Merge pull request #2304 from ScriptLineStudios/transform.silhouette

transform.solid_overlay

Author: MyreMylar

buildconfig/stubs/pygame/transform.pyi

@@ -19,6 +19,12 @@ def rotate(surface: Surface, angle: float) -> Surface: ...
 def rotozoom(surface: Surface, angle: float, scale: float) -> Surface: ...
 def scale2x(surface: Surface, dest_surface: Optional[Surface] = None) -> Surface: ...
 def grayscale(surface: Surface, dest_surface: Optional[Surface] = None) -> Surface: ...
+def solid_overlay(
+    surface: Surface,
+    color: ColorLike,
+    dest_surface: Optional[Surface] = None,
+    keep_alpha: bool = False,
+) -> Surface: ...
 def smoothscale(
     surface: Surface,
     size: Point,

docs/reST/ref/transform.rst

@@ -350,6 +350,31 @@ Instead, always begin with the original image and scale to the desired size.)
 
    .. ## pygame.transform.grayscale ##
 
+.. function:: solid_overlay
+
+   | :sl:`replaces non transparent pixels with the provided color`
+   | :sg:`solid_overlay(surface, color, dest_surface=None, keep_alpha=False) -> Surface`
+
+   Returns a new version of the original surface with all non transparent pixels set to the color provided.
+
+   An optional destination surface can be passed which is faster than creating a new
+   Surface.
+   This destination surface must have the same dimensions (width, height) and
+   depth as the source Surface.
+
+   :param pygame.Surface surface: The target surface.
+
+   :param pygame.Color color: Color which all non transparent within the target surface must be set to.
+
+   :param dest_surface: Optional destination surface to which the changes will be applied.
+   :type dest_surface: pygame.Surface or None
+
+   :param bool keep_alpha: Optional parameter that controls whether to keep the surface alpha when replacing with the color.
+
+   .. versionadded:: 2.5.2
+
+   .. ## pygame.transform.solid_overlay ##
+
 .. function:: threshold
 
    | :sl:`finds which, and how many pixels in a surface are within a threshold of a 'search_color' or a 'search_surf'.`

src_c/doc/transform_doc.h

@@ -18,5 +18,6 @@
 #define DOC_TRANSFORM_AVERAGECOLOR "average_color(surface, rect=None, consider_alpha=False) -> tuple\nfinds the average color of a surface"
 #define DOC_TRANSFORM_INVERT "invert(surface, dest_surface=None) -> Surface\ninverts the RGB elements of a surface"
 #define DOC_TRANSFORM_GRAYSCALE "grayscale(surface, dest_surface=None) -> Surface\ngrayscale a surface"
+#define DOC_TRANSFORM_SOLIDOVERLAY "solid_overlay(surface, color, dest_surface=None, keep_alpha=False) -> Surface\nreplaces non transparent pixels with the provided color"
 #define DOC_TRANSFORM_THRESHOLD "threshold(dest_surface, surface, search_color, threshold=(0,0,0,0), set_color=(0,0,0,0), set_behavior=1, search_surf=None, inverse_set=False) -> num_threshold_pixels\nfinds which, and how many pixels in a surface are within a threshold of a 'search_color' or a 'search_surf'."
 #define DOC_TRANSFORM_HSL "hsl(surface, hue, saturation, lightness, dest_surface=None) -> Surface\nChange the hue, saturation, and lightness of a surface."

src_c/transform.c

@@ -2215,6 +2215,227 @@ surf_grayscale(PyObject *self, PyObject *args, PyObject *kwargs)
     }
 }
 
+SDL_Surface *
+solid_overlay(pgSurfaceObject *srcobj, Uint32 color, pgSurfaceObject *dstobj,
+              const int keep_alpha)
+{
+    SDL_Surface *src = pgSurface_AsSurface(srcobj);
+    SDL_Surface *newsurf;
+    SDL_PixelFormat *fmt = src->format;
+    Uint8 a;
+
+    if (!dstobj) {
+        newsurf = newsurf_fromsurf(src, srcobj->surf->w, srcobj->surf->h);
+        if (!newsurf)
+            return NULL;
+    }
+    else {
+        newsurf = pgSurface_AsSurface(dstobj);
+    }
+
+    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 (fmt->BytesPerPixel != newsurf->format->BytesPerPixel ||
+        fmt->format != newsurf->format->format) {
+        return (SDL_Surface *)(RAISE(
+            PyExc_ValueError,
+            "Source and destination surfaces need the same format."));
+    }
+
+    /* If the source surface has no alpha channel, we can't overlay with alpha
+     * blending. */
+    if (!SDL_ISPIXELFORMAT_ALPHA(fmt->format))
+        return newsurf;
+
+    /* If we are keeping the src alpha, then we need to remove the alpha from
+     * the color so it's easier to add the base pixel alpha back in */
+    if (keep_alpha) {
+        color &= ~fmt->Amask;
+    }
+
+    int src_lock = SDL_MUSTLOCK(src);
+    int dst_lock = src != newsurf && SDL_MUSTLOCK(newsurf);
+
+    if (src_lock && SDL_LockSurface(src) < 0) {
+        return NULL;
+    }
+    if (dst_lock && SDL_LockSurface(newsurf) < 0) {
+        if (src_lock) {
+            SDL_UnlockSurface(src);
+        }
+        return NULL;
+    }
+
+    /* optimized path for 32 bit surfaces */
+    if (fmt->BytesPerPixel == 4) {
+        /* This algorithm iterates over each pixel's alpha channel. If it's not
+         * zero, the pixel is set to the desired color. If the keep_alpha flag
+         * is set, the original alpha value is retained, allowing the overlay
+         * color to inherit the surface pixel's alpha value. */
+#if SDL_BYTEORDER == SDL_LIL_ENDIAN
+        const int dst_ashift = fmt->Ashift;
+        const char _a_off = fmt->Ashift >> 3;
+#else
+        const int dst_ashift = 24 - newsurf->format->Ashift;
+        const char _a_off = 3 - (newsurf->format->Ashift >> 3);
+#endif
+
+        Uint8 *srcp = (Uint8 *)src->pixels + _a_off;
+        Uint32 *dstp = (Uint32 *)newsurf->pixels;
+
+        const int src_skip = src->pitch - src->w * 4;
+        const int dst_skip = newsurf->pitch / 4 - newsurf->w;
+        int n, height = src->h;
+
+        if (srcobj == dstobj) {
+            if (!keep_alpha) {
+                while (height--) {
+                    LOOP_UNROLLED4(
+                        {
+                            if (*srcp)
+                                *dstp = color;
+                            srcp += 4;
+                            dstp++;
+                        },
+                        n, src->w);
+                    srcp += src_skip;
+                    dstp += dst_skip;
+                }
+            }
+            else {
+                while (height--) {
+                    LOOP_UNROLLED4(
+                        {
+                            if ((a = *srcp)) {
+                                *dstp = color | (a << dst_ashift);
+                            }
+                            srcp += 4;
+                            dstp++;
+                        },
+                        n, src->w);
+                    srcp += src_skip;
+                    dstp += dst_skip;
+                }
+            }
+        }
+        else {
+            if (!keep_alpha) {
+                while (height--) {
+                    LOOP_UNROLLED4(
+                        {
+                            if (*srcp)
+                                *dstp = color;
+                            srcp += 4;
+                            dstp++;
+                        },
+                        n, src->w);
+                    srcp += src_skip;
+                    dstp += dst_skip;
+                }
+            }
+            else {
+                while (height--) {
+                    LOOP_UNROLLED4(
+                        {
+                            if ((a = *srcp)) {
+                                *dstp = color | (a << dst_ashift);
+                            }
+                            srcp += 4;
+                            dstp++;
+                        },
+                        n, src->w);
+                    srcp += src_skip;
+                    dstp += dst_skip;
+                }
+            }
+        }
+    }
+    else /* path for 16 bit surfaces */
+    {
+        int x, y;
+        Uint8 r, g, b;
+        Uint16 *src_row = (Uint16 *)src->pixels;
+        Uint16 *dst_row = (Uint16 *)newsurf->pixels;
+        const int src_skip = src->pitch / 2 - src->w;
+        const int dst_skip = newsurf->pitch / 2 - newsurf->w;
+
+        Uint8 Cr, Cg, Cb, Ca;
+        SDL_GetRGBA(color, fmt, &Cr, &Cg, &Cb, &Ca);
+        const Uint16 color16 = (Uint16)SDL_MapRGBA(fmt, Cr, Cg, Cb, Ca);
+
+        for (y = 0; y < src->h; y++) {
+            for (x = 0; x < src->w; x++) {
+                SDL_GetRGBA((Uint32)*src_row, fmt, &r, &g, &b, &a);
+
+                if (a) {
+                    if (keep_alpha)
+                        *dst_row = (Uint16)SDL_MapRGBA(fmt, Cr, Cg, Cb, a);
+                    else
+                        *dst_row = color16;
+                }
+
+                src_row++;
+                dst_row++;
+            }
+            src_row += src_skip;
+            dst_row += dst_skip;
+        }
+    }
+
+    if (src_lock)
+        SDL_UnlockSurface(src);
+    if (dst_lock)
+        SDL_UnlockSurface(newsurf);
+
+    return newsurf;
+}
+
+static PyObject *
+surf_solid_overlay(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    pgSurfaceObject *surfobj;
+    PyObject *colorobj;
+    Uint32 color;
+
+    pgSurfaceObject *surfobj2 = NULL;
+    SDL_Surface *newsurf;
+    SDL_Surface *surf;
+    int keep_alpha = 0;
+
+    static char *keywords[] = {"surface", "color", "dest_surface",
+                               "keep_alpha", NULL};
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O!O|O!i", keywords,
+                                     &pgSurface_Type, &surfobj, &colorobj,
+                                     &pgSurface_Type, &surfobj2, &keep_alpha))
+        return NULL;
+
+    surf = pgSurface_AsSurface(surfobj);
+
+    if (!pg_MappedColorFromObj(colorobj, surf->format, &color,
+                               PG_COLOR_HANDLE_ALL)) {
+        return RAISE(PyExc_TypeError, "invalid color argument");
+    }
+
+    newsurf = solid_overlay(surfobj, color, surfobj2, keep_alpha);
+
+    if (!newsurf) {
+        return NULL;
+    }
+
+    if (surfobj2) {
+        Py_INCREF(surfobj2);
+        return (PyObject *)surfobj2;
+    }
+    else {
+        return (PyObject *)pgSurface_New(newsurf);
+    }
+}
+
 #define MIN3(a, b, c) MIN(MIN(a, b), c)
 #define MAX3(a, b, c) MAX(MAX(a, b), c)
 
@@ -3793,6 +4014,8 @@ static PyMethodDef _transform_methods[] = {
      DOC_TRANSFORM_INVERT},
     {"grayscale", (PyCFunction)surf_grayscale, METH_VARARGS | METH_KEYWORDS,
      DOC_TRANSFORM_GRAYSCALE},
+    {"solid_overlay", (PyCFunction)surf_solid_overlay,
+     METH_VARARGS | METH_KEYWORDS, DOC_TRANSFORM_SOLIDOVERLAY},
     {"hsl", (PyCFunction)surf_hsl, METH_VARARGS | METH_KEYWORDS,
      DOC_TRANSFORM_HSL},
     {NULL, NULL, 0, NULL}};

test/transform_test.py

@@ -494,6 +494,38 @@ def test_hsl(self):
                             self.assertAlmostEqual(v1, v2, delta=1)
                         self.assertEqual(c_a, actual_color.a)
 
+    def test_solid_overlay(self):
+        test_surface = pygame.Surface((20, 20), pygame.SRCALPHA)
+        test_surface.fill((0, 0, 0, 0))
+        pygame.draw.rect(test_surface, (0, 0, 0), (10, 10, 10, 10))
+
+        surface = pygame.Surface((20, 20), pygame.SRCALPHA)
+        surface.fill((0, 0, 0, 0))
+        pygame.draw.rect(surface, (255, 0, 0), (10, 10, 10, 10))
+
+        surface = pygame.transform.solid_overlay(surface, (0, 0, 0))
+
+        for x in range(20):
+            for y in range(20):
+                self.assertEqual(surface.get_at((x, y)), test_surface.get_at((x, y)))
+
+        pygame.transform.solid_overlay(surface, (0, 0, 0), surface)
+
+        for x in range(20):
+            for y in range(20):
+                self.assertEqual(surface.get_at((x, y)), test_surface.get_at((x, y)))
+
+        test_surface.fill((0, 0, 0, 0))
+        pygame.draw.polygon(test_surface, (200, 100, 50), [(0, 0), (4, 4), (4, 2)])
+
+        surface.fill((0, 0, 0, 0))
+        pygame.draw.polygon(surface, (255, 0, 0), [(0, 0), (4, 4), (4, 2)])
+        surface = pygame.transform.solid_overlay(surface, (200, 100, 50))
+
+        for x in range(20):
+            for y in range(20):
+                self.assertEqual(surface.get_at((x, y)), test_surface.get_at((x, y)))
+
     def test_grayscale_simd_assumptions(self):
         # The grayscale SIMD algorithm relies on the destination surface pitch
         # being exactly width * 4 (4 bytes per pixel), for maximum speed.