Changeset 60667

Timestamp:

08/26/2025 08:55:24 PM (6 months ago)

Author:

adamsilverstein

Message:

Media: improve Imagick handling of indexed PNG images with transparency.

Fix an issue where certain transparent PNG images experienced noticeable quality degradation when resized by Imagick.

Follow up to [60246].

Props elvismdev, SirLouen, siliconforks, nosilver4u, iamshashank.

Fixes #63448.

Location:

trunk

Files:

• src/wp-includes/class-wp-image-editor-imagick.php (modified) (3 diffs)
• tests/phpunit/data/images/png-tests/oval-or8-grayscale-indexed.png (added)
• tests/phpunit/data/images/png-tests/oval-or8.png (added)
• tests/phpunit/tests/image/editorImagick.php (modified) (1 diff)

trunk/src/wp-includes/class-wp-image-editor-imagick.php

@@ -446 +446 @@
         try {
             /*
+             * We need to perform some special handling for certain types of images:
+             * 1. For PNG images, we need to specify compression settings and remove unneeded chunks.
+             * 2. For indexed PNG images, the number of colors must not exceed 256.
+             * 3. For indexed PNG images with an alpha channel, the tRNS chunk must be preserved.
+             * 4. For indexed PNG images with true alpha transparency (an alpha channel > 1 bit),
+             *    we need to avoid saving the image using ImageMagick's 'png8' format,
+             *    because that supports only binary (1 bit) transparency.
+             *
+             * For #4 we want to check whether the image has a 1-bit alpha channel before resizing,
+             * because resizing may cause the number of alpha values to multiply due to antialiasing.
+             * (We're assuming that, if the original image had only a 1-bit alpha channel,
+             * then a 1-bit alpha channel should be good enough for the resized images too.)
+             * So we're going to perform all the necessary checks before resizing the image
+             * and store the results in variables for later use.
+             */
+            $is_png                                      = false;
+            $is_indexed_png                              = false;
+            $is_indexed_png_with_alpha_channel           = false;
+            $is_indexed_png_with_true_alpha_transparency = false;
+
+            if ( 'image/png' === $this->mime_type ) {
+                $is_png = true;
+
+                if (
+                    is_callable( array( $this->image, 'getImageProperty' ) )
+                    && '3' === $this->image->getImageProperty( 'png:IHDR.color-type-orig' )
+                ) {
+                    $is_indexed_png = true;
+
+                    if (
+                        is_callable( array( $this->image, 'getImageAlphaChannel' ) )
+                        && $this->image->getImageAlphaChannel()
+                    ) {
+                        $is_indexed_png_with_alpha_channel = true;
+
+                        if (
+                            is_callable( array( $this->image, 'getImageChannelDepth' ) )
+                            && defined( 'Imagick::CHANNEL_ALPHA' )
+                            && 1 < $this->image->getImageChannelDepth( Imagick::CHANNEL_ALPHA )
+                        ) {
+                            $is_indexed_png_with_true_alpha_transparency = true;
+                        }
+                    }
+                }
+            }
+
+            /*
              * To be more efficient, resample large images to 5x the destination size before resizing
              * whenever the output size is less that 1/3 of the original image size (1/3^2 ~= .111),
@@ -481 +528 @@
             }
 
-            if ( 'image/png' === $this->mime_type ) {
+            if ( $is_png ) {
                 $this->image->setOption( 'png:compression-filter', '5' );
                 $this->image->setOption( 'png:compression-level', '9' );
@@ -488 +535 @@
                 // Indexed PNG files get some additional handling.
                 // See #63448 for details.
-                if (
-                    is_callable( array( $this->image, 'getImageProperty' ) )
-                    && '3' === $this->image->getImageProperty( 'png:IHDR.color-type-orig' )
-                ) {
+                if ( $is_indexed_png ) {
 
                     // Check for an alpha channel.
-                    if (
-                        is_callable( array( $this->image, 'getImageAlphaChannel' ) )
-                        && $this->image->getImageAlphaChannel()
-                    ) {
+                    if ( $is_indexed_png_with_alpha_channel ) {
                         $this->image->setOption( 'png:include-chunk', 'tRNS' );
                     } else {
                         $this->image->setOption( 'png:exclude-chunk', 'all' );
                     }
-                    // Set the image format to Indexed PNG.
-                    $this->image->setOption( 'png:format', 'png8' );
-
+
+                    $this->image->quantizeImage( 256, $this->image->getColorspace(), 0, false, false );
+
+                    /*
+                     * If the colorspace is 'gray', use the png8 format to ensure it stays indexed.
+                     * ImageMagick tends to save grayscale images as grayscale PNGs rather than indexed PNGs,
+                     * even though grayscale PNGs usually have considerably larger file sizes.
+                     * But we can force ImageMagick to save the image as an indexed PNG instead,
+                     * by telling it to use png8 format.
+                     *
+                     * Note that we need to first call quantizeImage() before checking getImageColorspace(),
+                     * because only after calling quantizeImage() will the colorspace be COLORSPACE_GRAY for grayscale images
+                     * (and we have not found any other way to identify grayscale images).
+                     *
+                     * We need to avoid forcing indexed format for images with true alpha transparency,
+                     * because ImageMagick does not support saving an image with true alpha transparency as an indexed PNG.
+                     */
+                    if ( Imagick::COLORSPACE_GRAY === $this->image->getImageColorspace() && ! $is_indexed_png_with_true_alpha_transparency ) {
+                        // Set the image format to Indexed PNG.
+                        $this->image->setOption( 'png:format', 'png8' );
+                    }
                 } else {
                     $this->image->setOption( 'png:exclude-chunk', 'all' );

trunk/tests/phpunit/tests/image/editorImagick.php

@@ -874 +874 @@
         );
     }
+
+    /**
+     * Tests that alpha transparency is preserved after resizing.
+     *
+     * @ticket 63448
+     * @dataProvider data_alpha_transparency_is_preserved_after_resize
+     *
+     * @param string $file_path Path to the image file.
+     */
+    public function test_alpha_transparency_is_preserved_after_resize( $file_path ) {
+
+        $temp_file = DIR_TESTDATA . '/images/test-temp.png';
+
+        $imagick_image_editor = new WP_Image_Editor_Imagick( $file_path );
+        $imagick_image_editor->load();
+
+        $size = $imagick_image_editor->get_size();
+        $imagick_image_editor->resize( $size['width'] * 0.5, $size['height'] * 0.5 );
+        $imagick_image_editor->save( $temp_file );
+
+        $imagick             = new Imagick( $temp_file );
+        $alpha_channel_depth = $imagick->getImageChannelDepth( Imagick::CHANNEL_ALPHA );
+
+        unlink( $temp_file );
+
+        $this->assertGreaterThan( 1, $alpha_channel_depth, "Alpha transparency should be preserved after resize for {$file_path}." );
+    }
+
+    public static function data_alpha_transparency_is_preserved_after_resize() {
+        return array(
+            'oval-or8'                   => array(
+                DIR_TESTDATA . '/images/png-tests/oval-or8.png',
+            ),
+            'oval-or8-grayscale-indexed' => array(
+                DIR_TESTDATA . '/images/png-tests/oval-or8-grayscale-indexed.png',
+            ),
+        );
+    }
 }