Pixels and geometrical shapes - Python/PIL

I'm trying to build a basic heatmap based on points. Each point has a heat radius, and therefore is represented by a circle.

Problem is that the circle needs to be converted in a list of pixels colored based on the distance from the circle's cente开发者_JS百科r.

Finding it hard to find an optimal solution for many points, what I have for now is something similar to this:

for pixels in pixels:
    if (pixel.x - circle.x)**2 + (pixel.y - circle.y)**2 <= circle.radius:
        pixel.set_color(circle.color)

Edit:

data I have:

• pixel at the center of the circle
• circle radius (integer)

  ---

Any tips?

Instead of doing it pixel-by-pixel, use a higher level interface with anti-aliasing, like the aggdraw module and its ellipse(xy, pen, brush) function.

Loop over the number of color steps you want (lets say, radius/2) and use 255/number_of_steps*current_step as the alpha value for the fill color.

For plotting it is usually recommended to use the matplotlib library (e.g. using imshow for heatmaps). Of course matplotlib also supports color gradients.

However, I don't really understand what you are trying to accomplish. If you just want to draw a bunch of colored circles then pretty much any graphics library will do (e.g. using the ellipse function in PIL).

It sounds like you want to color the pixel according to their distance from the center, but your own example code suggests that the color is constant?

If you are handling your pixels by yourself and your point is to increase performances, you can just focus on the square [x - radius; x + radius] * [y - radius; y + radius] since the points of your circle live here. That will save you a lot of useless iterations, if of course you CAN focus on this region (i.e. your pixels are not just an array without index per line and column).

You can even be sure that the pixels in the square [x - radius*sqrt(2)/2; x + radius*sqrt(2)/2] * [y - radius*sqrt(2)/2; y + radius*sqrt(2)/2] must be colored, with basic trigonometry (maximum square inside the circle).

So you could do:

import math
half_sqrt = math.sqrt(2) / 2
x_max = x + half_sqrt
y_max = y + half_sqrt
for (i in range(x, x + radius + 1):
    for (j in range(y, y + radius + 1):
        if (x <= x_max and y <= y_max):
            colorize_4_parts(i, j)
        else:
            pixel = get_pixel(i, j)
            if (pixel.x - circle.x)**2 + (pixel.y - circle.y)**2 <= circle.radius:
                # Apply same colors as above, could be a function
                colorize_4_parts(i, j)

def colorize_4_parts(i, j):
    # Hoping you have access to such a function get_pixel !
    pixel_top_right = get_pixel(i, j)
    pixel_top_right.set_color(circle.color)
    pixel_top_left = get_pixel(2 * x - i, j)
    pixel_top_leftt.set_color(circle.color)
    pixel_bot_right = get_pixel(i, 2 * y - j)
    pixel_bot_right.set_color(circle.color)
    pixel_bot_left = get_pixel(2 * x - i,  2 * y - j)
    pixel_bot_leftt.set_color(circle.color)

This is optimized to reduce costly computations to the minimum.

EDIT: function updated to be more efficient again: I had forgotten that we had a double symetry horizontal and vertical, so we can compute only for the top right corner !

This is a very common operation, and here's how people do it...

summary: Represent the point density on a grid, smooth this using a 2D convolution if needed (this gives your points to circles), and plot this as a heatmap using matplotlib.

In more detail: First, make a 2D grid for your heatmap, and add your data points to the grid, incrementing by the cells by 1 when a data point lands in the cell. Second, make another grid to represents the shape you want to give each point (usually people use a cylinder or gaussian or something like this). Third, convolve these two together, using, say scipy.signal.convolve2d. Finally, use matplotlib's imshow function to plot the convolution, and this will be your heatmap.

If you can't use the tools suggested in the standard approach then you might find work-arounds, but it has advantages. For example, the convolution will deal well with cases when the circles overlap.