In May 2020, Alexandre Morin-Chassé published a blog post about the stellar chart. This type of chart is an (approximately) direct alternative to the radar chart (also known as web, spider, star, or cobweb chart) — you can read more about this chart here. In this tutorial, we will see how we can create a quick-and-dirty stellar chart. First of all, let's get the necessary modules/libraries, as well as prepare a dummy dataset (with just a single record).

from itertools import chain, zip_longest
from math import ceil, pi

import matplotlib.pyplot as plt

data = [
("V1", 8),
("V2", 10),
("V3", 9),
("V4", 12),
("V5", 6),
("V6", 14),
("V7", 15),
("V8", 25),
]


We will also need some helper functions, namely a function to round up to the nearest 10 (round_up()) and a function to join two sequences (even_odd_merge()). In the latter, the values of the first sequence (a list or a tuple, basically) will fill the even positions and the values of the second the odd ones.

def round_up(value):
"""

>>> round_up(25)

30

"""
return int(ceil(value / 10.0)) * 10

def even_odd_merge(even, odd, filter_none=True):
"""

>>> list(even_odd_merge([1,3], [2,4]))

[1, 2, 3, 4]

"""
if filter_none:
return filter(None.__ne__, chain.from_iterable(zip_longest(even, odd)))

return chain.from_iterable(zip_longest(even, odd))


That said, to plot data on a stellar chart, we need to apply some transformations, as well as calculate some auxiliary values. So, let's start by creating a function (prepare_angles()) to calculate the angle of each axis on the chart (N corresponds to the number of variables to be plotted).

def prepare_angles(N):
angles = [n / N * 2 * pi for n in range(N)]

# Repeat the first angle to close the circle

angles += angles[:1]

return angles


Next, we need a function (prepare_data()) responsible for adjusting the original data (data) and separating it into several easy-to-use objects.

def prepare_data(data):
labels = [d for d in data]  # Variable names

values = [d for d in data]

# Repeat the first value to close the circle

values += values[:1]

N = len(labels)
angles = prepare_angles(N)

return labels, values, angles, N


Lastly, for this specific type of chart, we require a function (prepare_stellar_aux_data()) that, from the previously calculated angles, prepares two lists of auxiliary values: a list of intermediate angles for each pair of angles (stellar_angles) and a list of small constant values (stellar_values), which will act as the values of the variables to be plotted in order to achieve the star-like shape intended for the stellar chart.

def prepare_stellar_aux_data(angles, ymax, N):
angle_midpoint = pi / N

stellar_angles = [angle + angle_midpoint for angle in angles[:-1]]
stellar_values = [0.05 * ymax] * N

return stellar_angles, stellar_values


At this point, we already have all the necessary ingredients for the stellar chart, so let's move on to the Matplotlib side of this tutorial. In terms of aesthetics, we can rely on a function (draw_peripherals()) designed for this specific purpose (feel free to customize it!).

def draw_peripherals(ax, labels, angles, ymax, outer_color, inner_color):
# X-axis

ax.set_xticks(angles[:-1])
ax.set_xticklabels(labels, color=outer_color, size=8)

# Y-axis

ax.set_yticks(range(10, ymax, 10))
ax.set_yticklabels(range(10, ymax, 10), color=inner_color, size=7)
ax.set_ylim(0, ymax)
ax.set_rlabel_position(0)

# Both axes

ax.set_axisbelow(True)

# Boundary line

ax.spines["polar"].set_color(outer_color)

# Grid lines

ax.xaxis.grid(True, color=inner_color, linestyle="-")
ax.yaxis.grid(True, color=inner_color, linestyle="-")


To plot the data and orchestrate (almost) all the steps necessary to have a stellar chart, we just need one last function: draw_stellar().

def draw_stellar(
ax,
labels,
values,
angles,
N,
shape_color="tab:blue",
outer_color="slategrey",
inner_color="lightgrey",
):
# Limit the Y-axis according to the data to be plotted

ymax = round_up(max(values))

# Get the lists of angles and variable values

# with the necessary auxiliary values injected

stellar_angles, stellar_values = prepare_stellar_aux_data(angles, ymax, N)
all_angles = list(even_odd_merge(angles, stellar_angles))
all_values = list(even_odd_merge(values, stellar_values))

# Apply the desired style to the figure elements

draw_peripherals(ax, labels, angles, ymax, outer_color, inner_color)

# Draw (and fill) the star-shaped outer line/area

ax.plot(
all_angles,
all_values,
linewidth=1,
linestyle="solid",
solid_joinstyle="round",
color=shape_color,
)

ax.fill(all_angles, all_values, shape_color)

# Add a small hole in the center of the chart

ax.plot(0, 0, marker="o", color="white", markersize=3)


Finally, let's get our chart on a blank canvas (figure).

fig = plt.figure(dpi=100)
ax = fig.add_subplot(111, polar=True)  # Don't forget the projection!

draw_stellar(ax, *prepare_data(data))

plt.show() It's done! Right now, you have an example of a stellar chart and the boilerplate code to add this type of chart to your repertoire. If you end up creating your own stellar charts, feel free to share them with the world (and me!). I hope this tutorial was useful and interesting for you!