What is the fastest way to draw circles in python and save as png? - performance

Question

Background
I'm optimizing a project.
Profiling the code I found that 50% of the time is spend on a function in which a set of circles (different radii, colors and locations) are drawn to a choosen sector of fixed size (white canvas) if their center corrdinates is within the sector bounds. Depending on the usage the function saves the figure as a png and returns the path or returns the image as an numpy array.
The build-in method matplotlib._png.write_png from savefig is the most expensive But there is also some overhead from creating the figures, etc.
Generally the code is used with multiprocessing / parallel programming.
Example output
Code
import matplotlib.pyplot as plt
import cv2
import os
def get_top_view(sector, circles, file_path, save_image_flag):
# get the sector bounds.
x_low, y_low, x_high, y_high = get_sector_bounds(sector)
# init figure
fig, ax = plt.subplots()
ax.set_xlim(y_low, y_high)
ax.set_ylim(x_low, x_high)
ax.set_yticklabels([])
ax.set_xticklabels([])
ax.set_yticks([])
ax.set_xticks([])
ax.set_aspect('equal')
ax.axis('off')
# c is a circle object with all relevant data (center coordinates,
# radius, RGB color tuple)
for c in circles:
if x_low <= c.x_coord <= x_high and y_low <= c.y_coord <= y_high:
shape = plt.Circle((c.x_coord, c.y_coord), c.radius, color=c.color)
shape_plot = ax.add_artist(shape)
shapes.append(shape_plot)
plt.gca().invert_yaxis()
if save_image_flag:
plt.savefig(file_path + '_cc.png', bbox_inches='tight', pad_inches=0.02)
plt.close()
return file_path
else:
ax.margins(0)
fig.tight_layout()
fig.canvas.draw()
image_from_plot = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)
image_from_plot = image_from_plot.reshape(
fig.canvas.get_width_height()[::-1] + (3,))
image_from_plot = image_from_plot[:, 13:-14]
resized = cv2.resize(image_from_plot, (499, 391))
cropped = resized[78:-78]
plt.close()
return cropped
Questions
There is the issue that the array version and the png image is slightly different. I think that relates to the DPI of the image. I want to fix that and I'm thinking about different options who to speedup this function.
Speedup the process and keeping matplotlib, similar to this example from Github.
Get rid of matplotlib and draw it with Pillow, e.g. some thing like:
from PIL import Image, ImageDraw
def get_top_view(sector, circles, file_path, save_image_flag):
# get the sector bounds.
x_low, y_low, x_high, y_high = get_sector_bounds(sector)
im = Image.new('RGB', (499, 235), (255, 255, 255))
draw = ImageDraw.Draw(im)
# there needs to be some rescaling that the corrdinates match which
# I don't account for at the moment.
for c in circles:
if x_low <= c.x_coord <= x_high and y_low <= c.y_coord <= y_high:
draw.ellipse((c.x_coord - c.radius, c.y_coord - c.radius,
c.x_coord + c.radius, c.y_coord + c.radius),
fill=c.color)
if save_image_flag:
im.save(file_path + '.png')
return file_path
else:
image_as_array = convert_to_array() # have to think about how I'll do that
return image_as_array
A different approach that is faster (and somehow convenient)...
I'd be glad for any feedback on the two issues.

Answer 1

I'll share my findings here. I'm calling the function 2200 times for each output type within the simulation framework. All computation is serial as the multiprocessing code is not part of the example.
There are 220 sectors with 200 circles randomly distributed amongst the sectors. The simulation runs for 10 steps, where the circles radii get updated and new figures are drawn. Hence, 2200 calls to the function.
To generate and save png images it took 293483ms previously.
To generate numpy arrays it took 92715ms previously.
Speedup with Matplotlib
Generating and saving images (save_image_flag = True) now takes 126485ms.
Generating numpy arrays now takes 57029ms.
import matplotlib.pyplot as plt
import os
def get_top_view(sector, circles, file_path, save_image_flag):
# get the sector bounds.
x_low, y_low, x_high, y_high = get_sector_bounds(sector)
# init figure
fig, ax = plt.subplots()
ax.set_xlim(y_low, y_high)
ax.set_ylim(x_low, x_high)
# These were unnecessary
# ax.set_yticklabels([])
# ax.set_xticklabels([])
# ax.set_yticks([])
# ax.set_xticks([])
ax.set_aspect('equal')
ax.axis('off')
# c is a circle object with all relevant data (center coordinates,
# radius, RGB color tuple)
for c in circles:
if x_low <= c.x_coord <= x_high and y_low <= c.y_coord <= y_high:
shape = plt.Circle((c.x_coord, c.y_coord), c.radius, color=c.color)
shape_plot = ax.add_artist(shape)
shapes.append(shape_plot)
plt.gca().invert_yaxis()
# I added this to get the discrepancies between the generated image and
# the numpy array, as bbox_inches='tight' only applies to the saved image.
bbox0 = fig.get_tightbbox(fig.canvas.get_renderer()).padded(0.02)
if save_image_flag:
plt.savefig(file_path + '_cc.png', bbox_inches=bbox0)
plt.close()
return file_path
else:
buf = io.BytesIO()
fig.savefig(buf, format="rgba", dpi=100, bbox_inches=bbox0)
buf.seek(0)
img = np.reshape(np.frombuffer(buf.getvalue(), dtype=np.uint8),
newshape=(235, 499, -1))
img = img[..., :3]
buf.close()
plt.close()
return image
Speedup without Matplotlib
Research is in progress...