# 5 Best Ways to Add Different Graphs as Insets in Another Python Graph

1/5 - (1 vote)

π‘ Problem Formulation: When visualizing complex datasets, it becomes necessary to examine detailed subsets of data. One approach is adding insets: small graphs placed within a larger graph, allowing for simultaneous macro and micro analysis. This article demonstrates how to insert various types of graphs as insets into bigger Python graphs, enabling a multi-faceted view of data relationships. For instance, input may be a set of x-y coordinate data, and the desired output is a main scatter plot with a smaller line graph inset illustrating a trend within a specific data segment.

## Method 1: Using Matplotlib’s Axes Class

One efficient way to insert graphs is by using the Matplotlib library’s `Axes` class. This class provides an inset_axes method which can be used to add an inset plot directly to an existing axes. The method allows you to specify the size and position of the inset, making it a flexible option for adding insets.

Here’s an example:

```import matplotlib.pyplot as plt
from mpl_toolkits.axes_grid1.inset_locator import inset_axes

# Main plot
fig, ax = plt.subplots()
ax.plot(range(10), range(10))

# Inset plot
ax_inset = inset_axes(ax, width="30%", height="30%", loc=2)
ax_inset.plot(range(8), range(0, -8, -1))

plt.show()```

The output is a main plot ranging from 0-9 on both axes with an inset in the top-left corner showing a descending line plot.

This code snippet starts by importing the required libraries and functions. A figure and a set of main axes `ax` are created using `subplots()`. The main plot is drawn on `ax`. An inset axes is created using `inset_axes()` and a line plot is drawn on this set of inset axes. Finally, `plt.show()` displays the plot with the inset.

## Method 2: Utilizing Matplotlib’s zoomed_inset_axes Function

The zoomed_inset_axes function from Matplotlib’s mpl_toolkits.axes_grid1.inset_locator module allows for creating an inset that zooms into a particular region of the main plot. This is particularly useful for highlighting details within a specific data region.

Here’s an example:

```import matplotlib.pyplot as plt
from mpl_toolkits.axes_grid1.inset_locator import zoomed_inset_axes

# Main plot
fig, ax = plt.subplots()
ax.plot(range(10), [x**2 for x in range(10)])

# Inset plot (zooming into the range 2-3 on x-axis)
axins = zoomed_inset_axes(ax, zoom=3, loc=4)
axins.plot(range(10), [x**2 for x in range(10)])
axins.set_xlim(2, 3)
axins.set_ylim(4, 9)

plt.show()```

The output is a main plot displaying a quadratic function with an inset in the bottom-right, zoomed in on the x-axis from 2 to 3 and y-axis from 4 to 9.

After setting up the main plot, zoomed_inset_axes function is called to create the inset axes `axins` with a specific zoom level. The same plot is drawn in this inset, and `set_xlim()` and `set_ylim()` methods define the zoom area in inset. This highlights a specific region of the main plot within the inset.

The add_axes method is a flexible and straightforward approach to adding insets. By specifying the dimensions [left, bottom, width, height] of the inset axes in figure coordinate space, this method allows full control over the location and size of the inset relative to the figure.

Here’s an example:

```import matplotlib.pyplot as plt

# Main plot
fig = plt.figure()
ax.plot(range(10), range(10))

# Inset plot
ax_inset = fig.add_axes([0.5, 0.5, 0.4, 0.4])
ax_inset.plot(range(10), [x**3 for x in range(10)])

plt.show()```

The output displays a linear main plot and a cubic function as an inset graph, located at the center-right of the main plot.

After creating the figure and main axes, the `add_axes()` method is used to specify the inset’s position and size. The inset plot is then drawn onto this new set of axes, allowing for a completely customized inset graph within the main figure.

## Method 4: Embedding a Plot Within a Plot Using Subplots

Creating an inset graph can also be achieved by nesting subplots within a larger grid. By defining a subplot grid with `plt.subplots()`, smaller subplots can be placed within this grid, effectively acting as insets.

Here’s an example:

```import matplotlib.pyplot as plt

# Subplot grid
fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(5, 5))
ax1.plot(range(10), range(10))

# Inset plot in the grid
ax2.plot(range(10), [x**2 for x in range(10)])

plt.show()```

The output depicts a grid with two subplots: a linear plot on the top and a quadratic plot on the bottom.

This snippet uses `plt.subplots()` to create a 2×1 grid of subplots, with `figsize` determining the overall size of the figure. Each subplot in the grid can be treated as a stand-alone plot, enabling one to act as an inset for the other.

## Bonus One-Liner Method 5: Quick Inset with Pyplot’s text Method

A simplistic and less common approach to insets involves using the `text` method within Pyplot, which can embed a text box that contains a graph-like representation using ASCII characters. This method is quick but offers low precision and customization.

Here’s an example:

```import matplotlib.pyplot as plt

# Main plot
fig, ax = plt.subplots()
ax.plot(range(10), range(10))

# Inset text 'plot'
ax.text(0.5, 0.5, 'x1\n|\nx2', size=12, va='center', ha='center')

plt.show()```

The output is a main plot with a text box containing a simplistic representation of an inset ‘plot’ at the center.

The `text()` method demonstrates a non-traditional inset where a text ‘plot’ is added onto the main axes at the specified coordinates, using ASCII characters to mimic a graph-like visual. This method is mostly for demonstration or humor, providing only a symbolic inset representation.

## Summary/Discussion

• Method 1: Matplotlib’s Axes Class. High flexibility with size and location. Requires initialization of an axes object.
• Method 2: zoomed_inset_axes Function. Ideal for zooming into data. Limited to zooming into existing plots rather than adding diverse graph types.
• Method 3: add_axes Method. Direct control over positioning. Requires manual adjustments to prevent overlapping.
• Method 4: Nested Subplots. Straightforward for grid layouts. Less intuitive for unconventional graph positioning.
• Method 5: Pyplot’s text Method. Quick for simple representations. Not viable for detailed or accurate graph insets.