Editing Spatial anti-aliasing (section)

==Simplest approach to anti-aliasing==
The most basic approach to anti-aliasing a pixel is determining what percentage of the pixel is occupied by a given region in the vector graphic - in this case a pixel-sized square, possibly transposed over several pixels - and using that percentage as the colour.

A very basic plot of a single, white-on-black anti-aliased point using that method can be done as follows:

<syntaxhighlight lang="python">
def plot_antialiased_point(x: float, y: float):
    """Plot a single, white-on-black anti-aliased point."""
    for rounded_x in floor(x) to ceil(x):
        for rounded_y in floor(y) to ceil(y):
            percent_x = 1 - abs(x - rounded_x)
            percent_y = 1 - abs(y - rounded_y)
            percent = percent_x * percent_y
            draw_pixel(coordinates=(rounded_x, rounded_y), color=percent (range 0-1))
</syntaxhighlight>

This method is generally best suited for simple graphics, such as basic lines or curves, and applications that would otherwise have to convert absolute coordinates to pixel-constrained coordinates, such as 3D graphics. It is a fairly fast function, but it is relatively low-quality, and gets slower as the complexity of the shape increases. For purposes requiring very high-quality graphics or very complex vector shapes, this will probably not be the best approach.

Note: The <code>draw_pixel</code> routine above cannot blindly set the colour value to the percent calculated.  It must '''add''' the new value to the existing value at that location up to a maximum of 1.  Otherwise, the brightness of each pixel will be equal to the darkest value calculated in time for that location which produces a very bad result.  For example, if one point sets a brightness level of 0.90 for a given pixel and another point calculated later barely touches that pixel and has a brightness of 0.05, the final value set for that pixel should be 0.95, not 0.05.

For more sophisticated shapes, the algorithm may be generalized as rendering the shape to a pixel grid with higher resolution than the target display surface (usually a multiple that is a power of 2 to reduce distortion), then using [[bicubic interpolation]] to determine the average intensity of each real pixel on the display surface.