rewrote transform.pixelate and wrote tests

Author: oddbookworm

src_c/transform.c

@@ -32,6 +32,7 @@
 
 #include <math.h>
 #include <string.h>
+#include <limits.h>
 
 #include "simd_shared.h"
 #include "simd_transform.h"
@@ -4225,96 +4226,14 @@ surf_invert(PyObject *self, PyObject *args, PyObject *kwargs)
     return (PyObject *)pgSurface_New(newsurf);
 }
 
-SDL_Surface *
-pixelate(pgSurfaceObject *srcobj, pgSurfaceObject *dstobj, int pixel_size)
-{
-    SDL_Surface *src = pgSurface_AsSurface(srcobj);
-    SDL_Surface *newsurf;
-
-    if (!dstobj) {
-        newsurf = newsurf_fromsurf(src, srcobj->surf->w, srcobj->surf->h);
-        if (!newsurf)
-            return NULL;
-    }
-    else {
-        newsurf = pgSurface_AsSurface(dstobj);
-    }
-
-    if (pixel_size < 1) {
-        return (SDL_Surface *)(RAISE(PyExc_ValueError,
-                                     "pixel_size must be greater than 0."));
-    }
-
-    if (newsurf->w != src->w || newsurf->h != src->h) {
-        return (SDL_Surface *)(RAISE(
-            PyExc_ValueError,
-            "Destination surface must be the same size as source surface."));
-    }
-
-    if (src->format->BytesPerPixel != newsurf->format->BytesPerPixel) {
-        return (SDL_Surface *)(RAISE(
-            PyExc_ValueError,
-            "Source and destination surfaces need the same format."));
-    }
-
-    int x, y;
-    for (y = 0; y < src->h; y += pixel_size) {
-        for (x = 0; x < src->w; x += pixel_size) {
-            unsigned char r, g, b, a;  // current
-            Uint32 ra, ga, ba, aa;     // averages
-            Uint16 size;
-            Uint32 color, average;
-            Uint8 *pix;
-            int width = (pixel_size > (src->w - x)) ? src->w - x : pixel_size;
-            int height = (pixel_size > (src->h - y)) ? src->h - y : pixel_size;
-
-            ra = 0;
-            ga = 0;
-            ba = 0;
-            aa = 0;
-            for (int w = 0; w < width; w++) {
-                for (int h = 0; h < height; h++) {
-                    SURF_GET_AT(color, src, x + w, y + h, (Uint8 *)src->pixels,
-                                src->format, pix);
-                    SDL_GetRGBA(color, src->format, &r, &g, &b, &a);
-                    ra += r;
-                    ga += g;
-                    ba += b;
-                    aa += a;
-                }
-            }
-            size = width * height;
-
-            average = SDL_MapRGBA(newsurf->format, (Uint8)(ra / size),
-                                  (Uint8)(ga / size), (Uint8)(ba / size),
-                                  (Uint8)(aa / size));
-
-            for (int w = 0; w < width; w++) {
-                for (int h = 0; h < height; h++) {
-                    SURF_SET_AT(average, newsurf, x + w, y + h,
-                                (Uint8 *)newsurf->pixels, newsurf->format,
-                                pix);
-                }
-            }
-        }
-    }
-
-    SDL_UnlockSurface(newsurf);
-
-    return newsurf;
-}
-
-/*
- * anticipated API: pygame.transform.pixelate(surface, pixel_size, dest_surface
- * = None)
- */
 static PyObject *
 surf_pixelate(PyObject *self, PyObject *args, PyObject *kwargs)
 {
     pgSurfaceObject *src;
     pgSurfaceObject *dst = NULL;
     int pixel_size;
     SDL_Surface *new_surf;
+    pgSurfaceObject *intermediate;
 
     static char *kwds[] = {"surface", "pixel_size", "dest_surface", NULL};
 
@@ -4324,12 +4243,36 @@ surf_pixelate(PyObject *self, PyObject *args, PyObject *kwargs)
         return NULL;
     }
 
-    new_surf = pixelate(src, dst, pixel_size);
+    double testWidth = round((double)src->surf->w / pixel_size);
+    double testHeight = round((double)src->surf->h / pixel_size);
 
-    if (!new_surf) {
+    if (testWidth > INT_MAX || testWidth <= 0)
+    {
+        PyErr_SetString(PyExc_OverflowError, "Cannot scale width outside the range [0, INT_MAX]");
+        return NULL;
+    }
+
+    if (testHeight > INT_MAX || testHeight <= 0)
+    {
+        PyErr_SetString(PyExc_OverflowError, "Cannot scale height outside the range [0, INT_MAX]");
         return NULL;
     }
 
+    int width = (int)testWidth;
+    int height = (int)testHeight;
+
+    SDL_Surface* temp = scale_to(src, NULL, width, height);
+    intermediate = pgSurface_New(temp);
+    if (intermediate == NULL)
+    {
+        return NULL; /* Exception already set in scale_to */
+    }
+    new_surf = scale_to(intermediate, dst, src->surf->w, src->surf->h);
+    if (new_surf == NULL)
+    {
+        return NULL; /* Exception already set in scale_to */
+    }
+
     if (dst) {
         Py_INCREF(dst);
         return (PyObject *)dst;

test/transform_test.py

@@ -8,6 +8,16 @@
 from pygame.tests import test_utils
 from pygame.tests.test_utils import example_path
 
+def surfaces_have_same_pixels(surf1, surf2):
+    if surf1.get_size() != surf2.get_size():
+        return False
+    
+    for row in range(surf1.get_height()):
+        for col in range(surf1.get_width()):
+            if surf1.get_at((col, row)) != surf2.get_at((col, row)):
+                return False
+            
+    return True
 
 def show_image(s, images=[]):
     # pygame.display.init()
@@ -1759,7 +1769,28 @@ def smoothscale_invalid_scale():
                 smaller_surface.get_at(((k // 2), 0)), pygame.Color(127, 127, 127)
             )
             self.assertEqual(smaller_surface.get_size(), (k, 1))
+            
+    def test_pixelate(self):
+        """Test pygame.transform.pixelate"""
+        # test that pixelating the original with a pixel_size of 1 yields the original back
+        data_fname = example_path("data")
+        path = os.path.join(data_fname, "alien3.png")
+        image = pygame.image.load(path)  # Get an indexed surface.
+
+        no_change = pygame.transform.pixelate(image, 1)
+
+        self.assertTrue(surfaces_have_same_pixels(image, no_change))
+        
+        # test that pixelating a square image with a pixel_size equal to the side length
+        # yields a surface of a single color, which is the average of the surf
+        square = pygame.transform.scale(image, (50, 50))
+        square_pixelated = pygame.transform.pixelate(square, 50)
+        square_resized = pygame.transform.scale(
+            pygame.transform.scale(square, (1, 1)),
+            square.get_size()
+        )
 
+        self.assertTrue(surfaces_have_same_pixels(square_pixelated, square_resized))
 
 class TransformDisplayModuleTest(unittest.TestCase):
     def setUp(self):