Changeset 60667

Timestamp:

08/26/2025 08:55:24 PM (12 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',
+                        ),
+                );
+        }
 }