Gaussian Blur inconsistency with PIL

[Sjmarf]

I've noticed that performing a gaussian blur with pygame.transform.gaussian_blur makes a less blurry image than PIL's gaussian blur when the same radius is used. If the radius of the pygame blur is doubled, then they match up correctly.

I assume this isn't intended behaviour? Is it possible that the radius was not doubled by Pygame CE when it should have been, or something like that?

Blurring a pygame surface with PIL:

img = Image.frombytes(
    "RGBA", surface.get_size(), pygame.image.tostring(surface "RGBA", False)
)
img = img.filter(ImageFilter.GaussianBlur(radius=10))
blurred_surface = pygame.image.frombuffer(
    img.tobytes(), img.size, "RGBA"
)

With Pygame CE:

blurred_surface = pygame.transform.gaussian_blur(surface, 10)

Side-by-side comparison, with both radii set to 10:

Both radii set to 10:

PIL with a radius of 10, and Pygame with a radius of 20:

[yunline]

radius = 20px

So yes, I think this is a bug of pygame.

[Isoheptane]

It's noticeable that gaussian blur (Gaussian distribution) doesn't have a radius, instead it has a standard deviation (sigma).

In the gaussian blur implementation of pygame-ce, sigma is half the radius instead of radium. This may be the problem.

/src_c/transform.c

float *lut = malloc((radius + 1) * sizeof(float));
float lut_sum = 0.0;

for (i = 0; i <= radius; i++) {  // init gaussian lut
    // Gaussian function, radius=2*sigma
    lut[i] = (float)radius / 2.0f *
             expf(-powf((float)i, 2.0f) /
                  (2.0f * powf((float)radius / 2.0f, 2.0f))) *
             0.3989422804014327f;
    lut_sum += lut[i] * 2;
}

Probably sigma should be equal to radius and LUT size should be 2*radius+1.

[Isoheptane]

I have rewritten the algorithm using Rust. Compared with Rust's implementation, it turns out that sigma should be equal to radius.