Merge pull request #1907 from ScriptLineStudios/grayscale

transform.grayscale and Color.grayscale

Author: Starbuck5

buildconfig/stubs/pygame/color.pyi

@@ -49,6 +49,7 @@ class Color(Collection[int]):
     def set_length(self, length: int) -> None: ...
     def lerp(self, color: ColorValue, amount: float) -> Color: ...
     def premul_alpha(self) -> Color: ...
+    def grayscale(self) -> Color: ...
     @overload
     def update(self, r: int, g: int, b: int, a: int = 255) -> None: ...
     @overload

buildconfig/stubs/pygame/transform.pyi

@@ -19,6 +19,7 @@ def scale_by(
 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 smoothscale(
     surface: Surface,
     size: Coordinate,

docs/reST/ref/color.rst

@@ -226,6 +226,18 @@
 
       .. ## Color.set_length ##
 
+   .. method:: grayscale
+
+      | :sl:`returns the grayscale of a Color`
+      | :sg:`grayscale() -> Color`
+      
+      Returns a new Color object which represents the grayscaled version of self, using the luminosity formula, 
+      which weights red, green, and blue according to their relative contribution to perceived brightness.
+
+      .. versionadded:: 2.1.4
+
+      .. ## Color.grayscale ##
+
    .. method:: lerp
 
       | :sl:`returns a linear interpolation to the given Color.`

docs/reST/ref/transform.rst

@@ -237,6 +237,20 @@ Instead, always begin with the original image and scale to the desired size.)
 
    .. ## pygame.transform.average_color ##
 
+.. function:: grayscale
+
+   | :sl:`grayscale a surface`
+   | :sg:`grayscale(surface, dest_surface=None) -> Surface`
+
+   Returns a grayscaled version of the original surface using the luminosity formula which weights red, green and blue according to their wavelengths.
+
+   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.
+   
+   .. versionadded:: 2.1.4
+
+   .. ## pygame.transform.grayscale ##
+
 .. 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/color.c

@@ -93,6 +93,8 @@ _color_set_length(pgColorObject *, PyObject *);
 static PyObject *
 _color_lerp(pgColorObject *, PyObject *, PyObject *);
 static PyObject *
+_color_grayscale(pgColorObject *);
+static PyObject *
 _premul_alpha(pgColorObject *, PyObject *);
 static PyObject *
 _color_update(pgColorObject *self, PyObject *const *args, Py_ssize_t nargs);
@@ -200,6 +202,8 @@ static PyMethodDef _color_methods[] = {
      DOC_COLORSETLENGTH},
     {"lerp", (PyCFunction)_color_lerp, METH_VARARGS | METH_KEYWORDS,
      DOC_COLORLERP},
+    {"grayscale", (PyCFunction)_color_grayscale, METH_NOARGS,
+     DOC_COLORGRAYSCALE},
     {"premul_alpha", (PyCFunction)_premul_alpha, METH_NOARGS,
      DOC_COLORPREMULALPHA},
     {"update", (PyCFunction)_color_update, METH_FASTCALL, DOC_COLORUPDATE},
@@ -782,6 +786,25 @@ _color_correct_gamma(pgColorObject *color, PyObject *args)
     return (PyObject *)_color_new_internal(Py_TYPE(color), rgba);
 }
 
+/**
+ * color.grayscale()
+ */
+static PyObject *
+_color_grayscale(pgColorObject *self)
+{
+    // RGBA to GRAY formula used by OpenCV
+    Uint8 grayscale_pixel =
+        (Uint8)(0.299 * self->data[0] + 0.587 * self->data[1] +
+                0.114 * self->data[2]);
+
+    Uint8 new_rgba[4];
+    new_rgba[0] = grayscale_pixel;
+    new_rgba[1] = grayscale_pixel;
+    new_rgba[2] = grayscale_pixel;
+    new_rgba[3] = self->data[3];
+    return (PyObject *)_color_new_internal(Py_TYPE(self), new_rgba);
+}
+
 /**
  * color.lerp(other, x)
  */

src_c/doc/color_doc.h

@@ -11,6 +11,7 @@
 #define DOC_COLORNORMALIZE "normalize() -> tuple\nReturns the normalized RGBA values of the Color."
 #define DOC_COLORCORRECTGAMMA "correct_gamma (gamma) -> Color\nApplies a certain gamma value to the Color."
 #define DOC_COLORSETLENGTH "set_length(len) -> None\nSet the number of elements in the Color to 1,2,3, or 4."
+#define DOC_COLORGRAYSCALE "grayscale() -> Color\nreturns the grayscale of a Color"
 #define DOC_COLORLERP "lerp(Color, float) -> Color\nreturns a linear interpolation to the given Color."
 #define DOC_COLORPREMULALPHA "premul_alpha() -> Color\nreturns a Color where the r,g,b components have been multiplied by the alpha."
 #define DOC_COLORUPDATE "update(r, g, b) -> None\nupdate(r, g, b, a=255) -> None\nupdate(color_value) -> None\nSets the elements of the color"
@@ -70,6 +71,10 @@ pygame.Color.set_length
  set_length(len) -> None
 Set the number of elements in the Color to 1,2,3, or 4.
 
+pygame.Color.grayscale
+ grayscale() -> Color
+returns the grayscale of a Color
+
 pygame.Color.lerp
  lerp(Color, float) -> Color
 returns a linear interpolation to the given Color.

src_c/doc/transform_doc.h

@@ -14,6 +14,7 @@
 #define DOC_PYGAMETRANSFORMLAPLACIAN "laplacian(surface, dest_surface=None) -> Surface\nfind edges in a surface"
 #define DOC_PYGAMETRANSFORMAVERAGESURFACES "average_surfaces(surfaces, dest_surface=None, palette_colors=1) -> Surface\nfind the average surface from many surfaces."
 #define DOC_PYGAMETRANSFORMAVERAGECOLOR "average_color(surface, rect=None, consider_alpha=False) -> Color\nfinds the average color of a surface"
+#define DOC_PYGAMETRANSFORMGRAYSCALE "grayscale(surface, dest_surface=None) -> Surface\ngrayscale a surface"
 #define DOC_PYGAMETRANSFORMTHRESHOLD "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'."
 
 
@@ -80,6 +81,10 @@ pygame.transform.average_color
  average_color(surface, rect=None, consider_alpha=False) -> Color
 finds the average color of a surface
 
+pygame.transform.grayscale
+ grayscale(surface, dest_surface=None) -> Surface
+grayscale a surface
+
 pygame.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
 finds which, and how many pixels in a surface are within a threshold of a 'search_color' or a 'search_surf'.

src_c/transform.c

@@ -2110,6 +2110,87 @@ clamp_4
 
 #endif
 
+SDL_Surface *
+grayscale(pgSurfaceObject *srcobj, pgSurfaceObject *dstobj)
+{
+    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 (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++) {
+        for (x = 0; x < src->w; x++) {
+            Uint32 pixel;
+            Uint8 *pix;
+            SURF_GET_AT(pixel, src, x, y, (Uint8 *)src->pixels, src->format,
+                        pix);
+            Uint8 r, g, b, a;
+            SDL_GetRGBA(pixel, src->format, &r, &g, &b, &a);
+
+            // RGBA to GRAY formula used by OpenCV
+            Uint8 grayscale_pixel = (Uint8)(0.299 * r + 0.587 * g + 0.114 * b);
+            Uint32 new_pixel =
+                SDL_MapRGBA(newsurf->format, grayscale_pixel, grayscale_pixel,
+                            grayscale_pixel, a);
+            SURF_SET_AT(new_pixel, newsurf, x, y, (Uint8 *)newsurf->pixels,
+                        newsurf->format, pix);
+        }
+    }
+
+    SDL_UnlockSurface(newsurf);
+
+    return newsurf;
+}
+
+static PyObject *
+surf_grayscale(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    pgSurfaceObject *surfobj;
+    pgSurfaceObject *surfobj2 = NULL;
+    SDL_Surface *newsurf;
+
+    static char *keywords[] = {"surface", "dest_surface", NULL};
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O!|O!", keywords,
+                                     &pgSurface_Type, &surfobj,
+                                     &pgSurface_Type, &surfobj2))
+        return NULL;
+
+    newsurf = grayscale(surfobj, surfobj2);
+
+    if (!newsurf) {
+        return NULL;
+    }
+
+    if (surfobj2) {
+        Py_INCREF(surfobj2);
+        return (PyObject *)surfobj2;
+    }
+    else {
+        return (PyObject *)pgSurface_New(newsurf);
+    }
+}
+
 /*
 number to use for missing samples
 */
@@ -2997,6 +3078,8 @@ static PyMethodDef _transform_methods[] = {
      METH_VARARGS | METH_KEYWORDS, DOC_PYGAMETRANSFORMAVERAGESURFACES},
     {"average_color", (PyCFunction)surf_average_color,
      METH_VARARGS | METH_KEYWORDS, DOC_PYGAMETRANSFORMAVERAGECOLOR},
+    {"grayscale", (PyCFunction)surf_grayscale, METH_VARARGS | METH_KEYWORDS,
+     DOC_PYGAMETRANSFORMGRAYSCALE},
     {NULL, NULL, 0, NULL}};
 
 MODINIT_DEFINE(transform)

test/color_test.py

@@ -1110,6 +1110,31 @@ def test_color_contains(self):
         self.assertRaises(TypeError, lambda: "string" in c)
         self.assertRaises(TypeError, lambda: 3.14159 in c)
 
+    def test_grayscale(self):
+        Color = pygame.color.Color
+
+        color = Color(255, 0, 0, 255)
+        self.assertEqual(color.grayscale(), Color(76, 76, 76, 255))
+        color = Color(3, 5, 7, 255)
+        self.assertEqual(color.grayscale(), Color(4, 4, 4, 255))
+        color = Color(3, 5, 70, 255)
+        self.assertEqual(color.grayscale(), Color(11, 11, 11, 255))
+        color = Color(3, 50, 70, 255)
+        self.assertEqual(color.grayscale(), Color(38, 38, 38, 255))
+        color = Color(30, 50, 70, 255)
+        self.assertEqual(color.grayscale(), Color(46, 46, 46, 255))
+
+        color = Color(255, 0, 0, 144)
+        self.assertEqual(color.grayscale(), Color(76, 76, 76, 144))
+        color = Color(3, 5, 7, 144)
+        self.assertEqual(color.grayscale(), Color(4, 4, 4, 144))
+        color = Color(3, 5, 70, 144)
+        self.assertEqual(color.grayscale(), Color(11, 11, 11, 144))
+        color = Color(3, 50, 70, 144)
+        self.assertEqual(color.grayscale(), Color(38, 38, 38, 144))
+        color = Color(30, 50, 70, 144)
+        self.assertEqual(color.grayscale(), Color(46, 46, 46, 144))
+
     def test_lerp(self):
         # setup
         Color = pygame.color.Color

test/transform_test.py

@@ -158,6 +158,51 @@ def test_smoothscale_by(self):
         dest = pygame.Surface((64, 48))
         pygame.transform.smoothscale_by(s, (2.0, 1.5), dest_surface=dest)
 
+    def test_grayscale(self):
+        s = pygame.Surface((32, 32))
+        s.fill((255, 0, 0))
+
+        s2 = pygame.transform.grayscale(s)
+        self.assertEqual(pygame.transform.average_color(s2)[0], 76)
+        self.assertEqual(pygame.transform.average_color(s2)[1], 76)
+        self.assertEqual(pygame.transform.average_color(s2)[2], 76)
+
+        dest = pygame.Surface((32, 32), depth=32)
+        pygame.transform.grayscale(s, dest)
+        self.assertEqual(pygame.transform.average_color(dest)[0], 76)
+        self.assertEqual(pygame.transform.average_color(dest)[1], 76)
+        self.assertEqual(pygame.transform.average_color(dest)[2], 76)
+
+        dest = pygame.Surface((32, 32), depth=32)
+        s.fill((34, 12, 65))
+        pygame.transform.grayscale(s, dest)
+        self.assertEqual(pygame.transform.average_color(dest)[0], 24)
+        self.assertEqual(pygame.transform.average_color(dest)[1], 24)
+        self.assertEqual(pygame.transform.average_color(dest)[2], 24)
+
+        dest = pygame.Surface((32, 32), depth=32)
+        s.fill((123, 123, 123))
+        pygame.transform.grayscale(s, dest)
+        self.assertIn(pygame.transform.average_color(dest)[0], [123, 122])
+        self.assertIn(pygame.transform.average_color(dest)[1], [123, 122])
+        self.assertIn(pygame.transform.average_color(dest)[2], [123, 122])
+
+        s = pygame.Surface((32, 32), depth=24)
+        s.fill((255, 0, 0))
+        dest = pygame.Surface((32, 32), depth=24)
+        pygame.transform.grayscale(s, dest)
+        self.assertEqual(pygame.transform.average_color(dest)[0], 76)
+        self.assertEqual(pygame.transform.average_color(dest)[1], 76)
+        self.assertEqual(pygame.transform.average_color(dest)[2], 76)
+
+        s = pygame.Surface((32, 32), depth=16)
+        s.fill((255, 0, 0))
+        dest = pygame.Surface((32, 32), depth=16)
+        pygame.transform.grayscale(s, dest)
+        self.assertEqual(pygame.transform.average_color(dest)[0], 72)
+        self.assertEqual(pygame.transform.average_color(dest)[1], 76)
+        self.assertEqual(pygame.transform.average_color(dest)[2], 72)
+
     def test_threshold__honors_third_surface(self):
         # __doc__ for threshold as of Tue 07/15/2008