clang-format, docs, report error

robertpfeiffer · robertpfeiffer · commit b473f0ba8ae4 · 2024-05-05T11:34:24.000+02:00
diff --git a/docs/reST/ref/draw.rst b/docs/reST/ref/draw.rst
@@ -541,6 +541,33 @@ object around the draw calls (see :func:`pygame.Surface.lock` and
    .. versionchanged:: 2.5.0 ``blend`` argument readded for backcompat, but will always raise a deprecation exception when used
 
    .. ## pygame.draw.aalines ##
+      
+.. function:: flood_fill
+
+   | :sl:`fill in a connected area of same-color pixels`
+   | :sg:`flood_fill(surface, color, starting_point) -> Rect`
+   | :sg:`flood_fill(surface, pattern_surface, starting_point) -> Rect`
+
+   Replace the color of a cluster of connected same-color pixels, beginning
+   from the starting point, with a repeating pattern or solid single color
+   
+   :param Surface surface: surface to draw on
+   :param color: color to draw with, the alpha value is optional if using a
+      tuple ``(RGB[A])``
+   :type color: Color or string (for :doc:`color_list`) or int or tuple(int, int, int, [int])
+   :param pattern_surface: pattern to fill with, as a surface
+   :param starting_point: starting point as a sequence of 2 ints/floats,
+      e.g. ``(x, y)``
+   :type starting_point: tuple(int or float, int or float) or
+      list(int or float, int or float) or Vector2(int or float, int or float)
+
+   :returns: a rect bounding the changed pixels, if nothing is drawn the
+      bounding rect's position will be the position of the starting point
+      and its width and height will be 0
+   :rtype: Rect
+
+   .. versionadded:: 2.5.0
+   .. ## pygame.draw.flood_fill ##
 
 .. ## pygame.draw ##
 
diff --git a/src_c/doc/draw_doc.h b/src_c/doc/draw_doc.h
@@ -9,3 +9,4 @@
 #define DOC_DRAW_LINES "lines(surface, color, closed, points) -> Rect\nlines(surface, color, closed, points, width=1) -> Rect\ndraw multiple contiguous straight line segments"
 #define DOC_DRAW_AALINE "aaline(surface, color, start_pos, end_pos) -> Rect\ndraw a straight antialiased line"
 #define DOC_DRAW_AALINES "aalines(surface, color, closed, points) -> Rect\ndraw multiple contiguous straight antialiased line segments"
+#define DOC_DRAW_FLOODFILL "flood_fill(surface, color, starting_point) -> Rect\nflood_fill(surface, pattern_surface, starting_point) -> Rect\nfill in a connected area of same-color pixels"
diff --git a/src_c/draw.c b/src_c/draw.c
@@ -995,7 +995,8 @@ flood_fill(PyObject *self, PyObject *arg, PyObject *kwargs)
     int startx, starty;
     Uint32 color;
     SDL_Surface *pattern = NULL;
-    SDL_bool did_lock=SDL_FALSE;
+    SDL_bool did_lock = SDL_FALSE;
+    int flood_fill_result;
 
     int drawn_area[4] = {INT_MAX, INT_MAX, INT_MIN,
                          INT_MIN}; /* Used to store bounding box values */
@@ -1016,47 +1017,50 @@ flood_fill(PyObject *self, PyObject *arg, PyObject *kwargs)
                             PG_SURF_BytesPerPixel(surf));
     }
 
-    if (pgSurface_Check(colorobj)){
-        pat_surfobj = ((pgSurfaceObject *) colorobj);
+    if (pgSurface_Check(colorobj)) {
+        pat_surfobj = ((pgSurfaceObject *)colorobj);
 
-        pattern= SDL_ConvertSurface
-            (pat_surfobj->surf, surf->format, 0);
+        pattern = SDL_ConvertSurface(pat_surfobj->surf, surf->format, 0);
 
-        if(pattern==NULL){
+        if (pattern == NULL) {
             return RAISE(PyExc_RuntimeError, "error converting pattern surf");
         }
 
-        SDL_SetSurfaceRLE(pattern,
-                          SDL_FALSE);
+        SDL_SetSurfaceRLE(pattern, SDL_FALSE);
 
-        color=0;
-    } else {
+        color = 0;
+    }
+    else {
         CHECK_LOAD_COLOR(colorobj);
     }
 
     if (!pg_TwoIntsFromObj(start, &startx, &starty)) {
         return RAISE(PyExc_TypeError, "invalid start_pos argument");
     }
 
-    if(SDL_MUSTLOCK(surf)){
-        did_lock=SDL_TRUE;
+    if (SDL_MUSTLOCK(surf)) {
+        did_lock = SDL_TRUE;
         if (!pgSurface_Lock(surfobj)) {
             return RAISE(PyExc_RuntimeError, "error locking surface");
         }
     }
 
-    flood_fill_inner(surf, startx, starty, color, pattern, drawn_area);
+    flood_fill_result = flood_fill_inner(surf, startx, starty, color, pattern, drawn_area);
 
-    if(pattern!=NULL){
+    if (pattern != NULL) {
         SDL_FreeSurface(pattern);
     }
 
-    if(did_lock){
+    if (did_lock) {
         if (!pgSurface_Unlock(surfobj)) {
             return RAISE(PyExc_RuntimeError, "error unlocking surface");
         }
     }
 
+    if(flood_fill_result == -1){
+        return RAISE(PyExc_RuntimeError, "flood fill allocation fail");
+    }
+
     /* Compute return rect. */
     if (drawn_area[0] != INT_MAX && drawn_area[1] != INT_MAX &&
         drawn_area[2] != INT_MIN && drawn_area[3] != INT_MIN)
@@ -1079,20 +1083,25 @@ swap(float *a, float *b)
 
 #define WORD_BITS (8 * sizeof(unsigned int))
 
-struct point2d{
+struct point2d {
     Uint32 x;
     Uint32 y;
 };
 
-static inline void _bitarray_set(unsigned int * bitarray, size_t idx, SDL_bool value){
-    if(value){
+static inline void
+_bitarray_set(unsigned int *bitarray, size_t idx, SDL_bool value)
+{
+    if (value) {
         bitarray[idx / WORD_BITS] |= (1 << (idx % WORD_BITS));
-    } else {
+    }
+    else {
         bitarray[idx / WORD_BITS] &= (~(1) << (idx % WORD_BITS));
     }
 }
 
-static inline SDL_bool _bitarray_get(unsigned int * bitarray, size_t idx) {
+static inline SDL_bool
+_bitarray_get(unsigned int *bitarray, size_t idx)
+{
     if (bitarray[idx / WORD_BITS] & (1 << (idx % WORD_BITS)))
         return SDL_TRUE;
     else
@@ -1786,42 +1795,44 @@ draw_line(SDL_Surface *surf, int x1, int y1, int x2, int y2, Uint32 color,
 
 
 static int
-flood_fill_inner(SDL_Surface *surf, int x1, int y1, Uint32 new_color, SDL_Surface *pattern, int *drawn_area)
+flood_fill_inner(SDL_Surface *surf, int x1, int y1, Uint32 new_color,
+                 SDL_Surface *pattern, int *drawn_area)
 {
     SDL_Rect cliprect;
 
     SDL_GetClipRect(surf, &cliprect);
-    size_t frontier_bufsize=8, frontier_size=1, next_frontier_size=0;
+    size_t frontier_bufsize = 8, frontier_size = 1, next_frontier_size = 0;
 
-    struct point2d *frontier = malloc(frontier_bufsize * sizeof(struct point2d));
-    if(frontier==NULL){
+    struct point2d *frontier =
+        malloc(frontier_bufsize * sizeof(struct point2d));
+    if (frontier == NULL) {
         return -1;
     }
 
-    struct point2d *frontier_next = malloc(frontier_bufsize * sizeof(struct point2d));
+    struct point2d *frontier_next =
+        malloc(frontier_bufsize * sizeof(struct point2d));
 
-    if(frontier_next==NULL){
+    if (frontier_next == NULL) {
         free(frontier);
         return -1;
     }
-    size_t mask_size =  cliprect.w*cliprect.h;
+    size_t mask_size = cliprect.w * cliprect.h;
 
     unsigned int *mask = calloc((mask_size) / 8 + 1, sizeof(unsigned int));
-    if (mask==NULL){
+    if (mask == NULL) {
         free(frontier);
         free(frontier_next);
         free(mask);
         return -1;
     }
-    Uint32 old_color=0;
+    Uint32 old_color = 0;
     Uint8 *pix;
 
-    int VN_X[]= {0,0,1,-1};
-    int VN_Y[]= {1,-1,0,0};
+    int VN_X[] = {0, 0, 1, -1};
+    int VN_Y[] = {1, -1, 0, 0};
 
-
-    if (!(x1>=cliprect.x && x1<(cliprect.x+cliprect.w)
-          && y1>=cliprect.y && y1<(cliprect.y+cliprect.h))) {
+    if (!(x1 >= cliprect.x && x1 < (cliprect.x + cliprect.w) &&
+          y1 >= cliprect.y && y1 < (cliprect.y + cliprect.h))) {
         free(frontier);
         free(mask);
         return 0;
@@ -1830,99 +1841,99 @@ flood_fill_inner(SDL_Surface *surf, int x1, int y1, Uint32 new_color, SDL_Surfac
     SURF_GET_AT(old_color, surf, x1, y1, (Uint8 *)surf->pixels, surf->format,
                 pix);
 
-    if (pattern==NULL && old_color == new_color){
+    if (pattern == NULL && old_color == new_color) {
         free(frontier);
         free(mask);
         free(frontier_next);
         return 0;
     }
 
-    frontier[0].x=x1;
-    frontier[0].y=y1;
+    frontier[0].x = x1;
+    frontier[0].y = y1;
 
-    while (frontier_size!=0){
-        next_frontier_size=0;
+    while (frontier_size != 0) {
+        next_frontier_size = 0;
 
-        for (size_t i=0; i<frontier_size; i++){
-            unsigned int x=frontier[i].x;
-            unsigned int y=frontier[i].y;
-            size_t mask_idx = (y-cliprect.y)*cliprect.w+(x-cliprect.x);
+        for (size_t i = 0; i < frontier_size; i++) {
+            unsigned int x = frontier[i].x;
+            unsigned int y = frontier[i].y;
+            size_t mask_idx = (y - cliprect.y) * cliprect.w + (x - cliprect.x);
 
-            Uint32 current_color=0;
+            Uint32 current_color = 0;
 
             _bitarray_set(mask, mask_idx, SDL_TRUE);
 
-            SURF_GET_AT(current_color, surf, x, y,
-                        (Uint8 *)surf->pixels, surf->format,
-                        pix);
+            SURF_GET_AT(current_color, surf, x, y, (Uint8 *)surf->pixels,
+                        surf->format, pix);
 
-            if (current_color!=old_color){
+            if (current_color != old_color) {
                 continue;
             }
 
-            if (pattern!=NULL){
-                SURF_GET_AT(new_color, pattern, x%pattern->w, y%pattern->h,
-                            (Uint8 *)pattern->pixels, pattern->format,
-                            pix);
+            if (pattern != NULL) {
+                SURF_GET_AT(new_color, pattern, x % pattern->w, y % pattern->h,
+                            (Uint8 *)pattern->pixels, pattern->format, pix);
             }
 
             unsafe_set_at(surf, x, y, new_color);
             add_pixel_to_drawn_list(x, y, drawn_area);
 
-            for (int n=0; n<4; n++){
-                long nx=x+VN_X[n];
-                long ny=y+VN_Y[n];
+            for (int n = 0; n < 4; n++) {
+                long nx = x + VN_X[n];
+                long ny = y + VN_Y[n];
                 SDL_bool found_in_frontier = SDL_FALSE;
 
-                if (!(nx>=cliprect.x && nx<cliprect.x+cliprect.w
-                      && ny>=cliprect.y && ny<cliprect.y+cliprect.h)) {
+                if (!(nx >= cliprect.x && nx < cliprect.x + cliprect.w &&
+                      ny >= cliprect.y && ny < cliprect.y + cliprect.h)) {
                     continue;
                 }
 
-                mask_idx = (ny-cliprect.y)*cliprect.w+(nx-cliprect.x);
+                mask_idx = (ny - cliprect.y) * cliprect.w + (nx - cliprect.x);
                 if (_bitarray_get(mask, mask_idx))
                     continue;
 
                 _bitarray_set(mask, mask_idx, SDL_TRUE);
-                if(found_in_frontier){
+                if (found_in_frontier) {
                     continue;
                 }
 
-                if (next_frontier_size==frontier_bufsize){
+                if (next_frontier_size == frontier_bufsize) {
                     struct point2d *old_buf = frontier_next;
 
-                    frontier_bufsize*=4;
+                    frontier_bufsize *= 4;
 
-                    frontier_next = realloc(frontier_next, frontier_bufsize*sizeof(struct point2d));
-                    if(frontier_next==NULL){
+                    frontier_next =
+                        realloc(frontier_next,
+                                frontier_bufsize * sizeof(struct point2d));
+                    if (frontier_next == NULL) {
                         free(mask);
                         free(frontier);
                         free(old_buf);
                         return -1;
                     }
 
                     old_buf = frontier;
-                    frontier = realloc(frontier, frontier_bufsize*sizeof(struct point2d));
-                    if(frontier==NULL){
+                    frontier = realloc(
+                        frontier, frontier_bufsize * sizeof(struct point2d));
+                    if (frontier == NULL) {
                         free(old_buf);
                         free(mask);
                         free(frontier_next);
                         return -1;
                     }
                 }
 
-                frontier_next[next_frontier_size].x=nx;
-                frontier_next[next_frontier_size].y=ny;
+                frontier_next[next_frontier_size].x = nx;
+                frontier_next[next_frontier_size].y = ny;
                 next_frontier_size++;
-
             }
         }
         struct point2d *temp_buf;
-        temp_buf=frontier;
-        frontier=frontier_next;
-        frontier_next=temp_buf;
+        temp_buf = frontier;
+        frontier = frontier_next;
+        frontier_next = temp_buf;
 
-        frontier_size=next_frontier_size;
+        frontier_size = next_frontier_size;
     }
     free(frontier);
     free(mask);
@@ -3134,7 +3145,7 @@ static PyMethodDef _draw_methods[] = {
     {"ellipse", (PyCFunction)ellipse, METH_VARARGS | METH_KEYWORDS,
      DOC_DRAW_ELLIPSE},
     {"flood_fill", (PyCFunction)flood_fill, METH_VARARGS | METH_KEYWORDS,
-     ""},
+    DOC_DRAW_FLOODFILL},
     {"arc", (PyCFunction)arc, METH_VARARGS | METH_KEYWORDS, DOC_DRAW_ARC},
     {"circle", (PyCFunction)circle, METH_VARARGS | METH_KEYWORDS,
      DOC_DRAW_CIRCLE},
