Merge branch 'main' into fits

python-pillow · Feb 19, 2022 · 727d8c9 · 727d8c9
2 parents 2ac183b + af34535
commit 727d8c9
Show file tree

Hide file tree

Showing 61 changed files with 1,384 additions and 752 deletions.
diff --git a/CHANGES.rst b/CHANGES.rst
@@ -5,6 +5,18 @@ Changelog (Pillow)
 9.1.0 (unreleased)
 ------------------
 
+- Consider palette size when converting and in getpalette() #6060
+  [radarhere]
+
+- Added enums #5954
+  [radarhere]
+
+- Ensure image is opaque after converting P to PA with RGB palette #6052
+  [radarhere]
+
+- Attach RGBA palettes from putpalette() when suitable #6054
+  [radarhere]
+
 - Added get_photoshop_blocks() to parse Photoshop TIFF tag #6030
   [radarhere]
 

diff --git a/Tests/images/pillow3.icns b/Tests/images/pillow3.icns
diff --git a/Tests/test_color_lut.py b/Tests/test_color_lut.py
@@ -43,107 +43,158 @@ def test_wrong_args(self):
         im = Image.new("RGB", (10, 10), 0)
 
         with pytest.raises(ValueError, match="filter"):
-            im.im.color_lut_3d("RGB", Image.CUBIC, *self.generate_identity_table(3, 3))
+            im.im.color_lut_3d(
+                "RGB", Image.Resampling.BICUBIC, *self.generate_identity_table(3, 3)
+            )
 
         with pytest.raises(ValueError, match="image mode"):
             im.im.color_lut_3d(
-                "wrong", Image.LINEAR, *self.generate_identity_table(3, 3)
+                "wrong", Image.Resampling.BILINEAR, *self.generate_identity_table(3, 3)
             )
 
         with pytest.raises(ValueError, match="table_channels"):
-            im.im.color_lut_3d("RGB", Image.LINEAR, *self.generate_identity_table(5, 3))
+            im.im.color_lut_3d(
+                "RGB", Image.Resampling.BILINEAR, *self.generate_identity_table(5, 3)
+            )
 
         with pytest.raises(ValueError, match="table_channels"):
-            im.im.color_lut_3d("RGB", Image.LINEAR, *self.generate_identity_table(1, 3))
+            im.im.color_lut_3d(
+                "RGB", Image.Resampling.BILINEAR, *self.generate_identity_table(1, 3)
+            )
 
         with pytest.raises(ValueError, match="table_channels"):
-            im.im.color_lut_3d("RGB", Image.LINEAR, *self.generate_identity_table(2, 3))
+            im.im.color_lut_3d(
+                "RGB", Image.Resampling.BILINEAR, *self.generate_identity_table(2, 3)
+            )
 
         with pytest.raises(ValueError, match="Table size"):
             im.im.color_lut_3d(
-                "RGB", Image.LINEAR, *self.generate_identity_table(3, (1, 3, 3))
+                "RGB",
+                Image.Resampling.BILINEAR,
+                *self.generate_identity_table(3, (1, 3, 3)),
             )
 
         with pytest.raises(ValueError, match="Table size"):
             im.im.color_lut_3d(
-                "RGB", Image.LINEAR, *self.generate_identity_table(3, (66, 3, 3))
+                "RGB",
+                Image.Resampling.BILINEAR,
+                *self.generate_identity_table(3, (66, 3, 3)),
             )
 
         with pytest.raises(ValueError, match=r"size1D \* size2D \* size3D"):
-            im.im.color_lut_3d("RGB", Image.LINEAR, 3, 2, 2, 2, [0, 0, 0] * 7)
+            im.im.color_lut_3d(
+                "RGB", Image.Resampling.BILINEAR, 3, 2, 2, 2, [0, 0, 0] * 7
+            )
 
         with pytest.raises(ValueError, match=r"size1D \* size2D \* size3D"):
-            im.im.color_lut_3d("RGB", Image.LINEAR, 3, 2, 2, 2, [0, 0, 0] * 9)
+            im.im.color_lut_3d(
+                "RGB", Image.Resampling.BILINEAR, 3, 2, 2, 2, [0, 0, 0] * 9
+            )
 
         with pytest.raises(TypeError):
-            im.im.color_lut_3d("RGB", Image.LINEAR, 3, 2, 2, 2, [0, 0, "0"] * 8)
+            im.im.color_lut_3d(
+                "RGB", Image.Resampling.BILINEAR, 3, 2, 2, 2, [0, 0, "0"] * 8
+            )
 
         with pytest.raises(TypeError):
-            im.im.color_lut_3d("RGB", Image.LINEAR, 3, 2, 2, 2, 16)
+            im.im.color_lut_3d("RGB", Image.Resampling.BILINEAR, 3, 2, 2, 2, 16)
 
     def test_correct_args(self):
         im = Image.new("RGB", (10, 10), 0)
 
-        im.im.color_lut_3d("RGB", Image.LINEAR, *self.generate_identity_table(3, 3))
+        im.im.color_lut_3d(
+            "RGB", Image.Resampling.BILINEAR, *self.generate_identity_table(3, 3)
+        )
 
-        im.im.color_lut_3d("CMYK", Image.LINEAR, *self.generate_identity_table(4, 3))
+        im.im.color_lut_3d(
+            "CMYK", Image.Resampling.BILINEAR, *self.generate_identity_table(4, 3)
+        )
 
         im.im.color_lut_3d(
-            "RGB", Image.LINEAR, *self.generate_identity_table(3, (2, 3, 3))
+            "RGB",
+            Image.Resampling.BILINEAR,
+            *self.generate_identity_table(3, (2, 3, 3)),
         )
 
         im.im.color_lut_3d(
-            "RGB", Image.LINEAR, *self.generate_identity_table(3, (65, 3, 3))
+            "RGB",
+            Image.Resampling.BILINEAR,
+            *self.generate_identity_table(3, (65, 3, 3)),
         )
 
         im.im.color_lut_3d(
-            "RGB", Image.LINEAR, *self.generate_identity_table(3, (3, 65, 3))
+            "RGB",
+            Image.Resampling.BILINEAR,
+            *self.generate_identity_table(3, (3, 65, 3)),
         )
 
         im.im.color_lut_3d(
-            "RGB", Image.LINEAR, *self.generate_identity_table(3, (3, 3, 65))
+            "RGB",
+            Image.Resampling.BILINEAR,
+            *self.generate_identity_table(3, (3, 3, 65)),
         )
 
     def test_wrong_mode(self):
         with pytest.raises(ValueError, match="wrong mode"):
             im = Image.new("L", (10, 10), 0)
-            im.im.color_lut_3d("RGB", Image.LINEAR, *self.generate_identity_table(3, 3))
+            im.im.color_lut_3d(
+                "RGB", Image.Resampling.BILINEAR, *self.generate_identity_table(3, 3)
+            )
 
         with pytest.raises(ValueError, match="wrong mode"):
             im = Image.new("RGB", (10, 10), 0)
-            im.im.color_lut_3d("L", Image.LINEAR, *self.generate_identity_table(3, 3))
+            im.im.color_lut_3d(
+                "L", Image.Resampling.BILINEAR, *self.generate_identity_table(3, 3)
+            )
 
         with pytest.raises(ValueError, match="wrong mode"):
             im = Image.new("L", (10, 10), 0)
-            im.im.color_lut_3d("L", Image.LINEAR, *self.generate_identity_table(3, 3))
+            im.im.color_lut_3d(
+                "L", Image.Resampling.BILINEAR, *self.generate_identity_table(3, 3)
+            )
 
         with pytest.raises(ValueError, match="wrong mode"):
             im = Image.new("RGB", (10, 10), 0)
             im.im.color_lut_3d(
-                "RGBA", Image.LINEAR, *self.generate_identity_table(3, 3)
+                "RGBA", Image.Resampling.BILINEAR, *self.generate_identity_table(3, 3)
             )
 
         with pytest.raises(ValueError, match="wrong mode"):
             im = Image.new("RGB", (10, 10), 0)
-            im.im.color_lut_3d("RGB", Image.LINEAR, *self.generate_identity_table(4, 3))
+            im.im.color_lut_3d(
+                "RGB", Image.Resampling.BILINEAR, *self.generate_identity_table(4, 3)
+            )
 
     def test_correct_mode(self):
         im = Image.new("RGBA", (10, 10), 0)
-        im.im.color_lut_3d("RGBA", Image.LINEAR, *self.generate_identity_table(3, 3))
+        im.im.color_lut_3d(
+            "RGBA", Image.Resampling.BILINEAR, *self.generate_identity_table(3, 3)
+        )
 
         im = Image.new("RGBA", (10, 10), 0)
-        im.im.color_lut_3d("RGBA", Image.LINEAR, *self.generate_identity_table(4, 3))
+        im.im.color_lut_3d(
+            "RGBA", Image.Resampling.BILINEAR, *self.generate_identity_table(4, 3)
+        )
 
         im = Image.new("RGB", (10, 10), 0)
-        im.im.color_lut_3d("HSV", Image.LINEAR, *self.generate_identity_table(3, 3))
+        im.im.color_lut_3d(
+            "HSV", Image.Resampling.BILINEAR, *self.generate_identity_table(3, 3)
+        )
 
         im = Image.new("RGB", (10, 10), 0)
-        im.im.color_lut_3d("RGBA", Image.LINEAR, *self.generate_identity_table(4, 3))
+        im.im.color_lut_3d(
+            "RGBA", Image.Resampling.BILINEAR, *self.generate_identity_table(4, 3)
+        )
 
     def test_identities(self):
         g = Image.linear_gradient("L")
         im = Image.merge(
-            "RGB", [g, g.transpose(Image.ROTATE_90), g.transpose(Image.ROTATE_180)]
+            "RGB",
+            [
+                g,
+                g.transpose(Image.Transpose.ROTATE_90),
+                g.transpose(Image.Transpose.ROTATE_180),
+            ],
         )
 
         # Fast test with small cubes
@@ -152,7 +203,9 @@ def test_identities(self):
                 im,
                 im._new(
                     im.im.color_lut_3d(
-                        "RGB", Image.LINEAR, *self.generate_identity_table(3, size)
+                        "RGB",
+                        Image.Resampling.BILINEAR,
+                        *self.generate_identity_table(3, size),
                     )
                 ),
             )
@@ -162,23 +215,32 @@ def test_identities(self):
             im,
             im._new(
                 im.im.color_lut_3d(
-                    "RGB", Image.LINEAR, *self.generate_identity_table(3, (2, 2, 65))
+                    "RGB",
+                    Image.Resampling.BILINEAR,
+                    *self.generate_identity_table(3, (2, 2, 65)),
                 )
             ),
         )
 
     def test_identities_4_channels(self):
         g = Image.linear_gradient("L")
         im = Image.merge(
-            "RGB", [g, g.transpose(Image.ROTATE_90), g.transpose(Image.ROTATE_180)]
+            "RGB",
+            [
+                g,
+                g.transpose(Image.Transpose.ROTATE_90),
+                g.transpose(Image.Transpose.ROTATE_180),
+            ],
         )
 
         # Red channel copied to alpha
         assert_image_equal(
             Image.merge("RGBA", (im.split() * 2)[:4]),
             im._new(
                 im.im.color_lut_3d(
-                    "RGBA", Image.LINEAR, *self.generate_identity_table(4, 17)
+                    "RGBA",
+                    Image.Resampling.BILINEAR,
+                    *self.generate_identity_table(4, 17),
                 )
             ),
         )
@@ -189,32 +251,39 @@ def test_copy_alpha_channel(self):
             "RGBA",
             [
                 g,
-                g.transpose(Image.ROTATE_90),
-                g.transpose(Image.ROTATE_180),
-                g.transpose(Image.ROTATE_270),
+                g.transpose(Image.Transpose.ROTATE_90),
+                g.transpose(Image.Transpose.ROTATE_180),
+                g.transpose(Image.Transpose.ROTATE_270),
             ],
         )
 
         assert_image_equal(
             im,
             im._new(
                 im.im.color_lut_3d(
-                    "RGBA", Image.LINEAR, *self.generate_identity_table(3, 17)
+                    "RGBA",
+                    Image.Resampling.BILINEAR,
+                    *self.generate_identity_table(3, 17),
                 )
             ),
         )
 
     def test_channels_order(self):
         g = Image.linear_gradient("L")
         im = Image.merge(
-            "RGB", [g, g.transpose(Image.ROTATE_90), g.transpose(Image.ROTATE_180)]
+            "RGB",
+            [
+                g,
+                g.transpose(Image.Transpose.ROTATE_90),
+                g.transpose(Image.Transpose.ROTATE_180),
+            ],
         )
 
         # Reverse channels by splitting and using table
         # fmt: off
         assert_image_equal(
             Image.merge('RGB', im.split()[::-1]),
-            im._new(im.im.color_lut_3d('RGB', Image.LINEAR,
+            im._new(im.im.color_lut_3d('RGB', Image.Resampling.BILINEAR,
                     3, 2, 2, 2, [
                         0, 0, 0,  0, 0, 1,
                         0, 1, 0,  0, 1, 1,
@@ -227,11 +296,16 @@ def test_channels_order(self):
     def test_overflow(self):
         g = Image.linear_gradient("L")
         im = Image.merge(
-            "RGB", [g, g.transpose(Image.ROTATE_90), g.transpose(Image.ROTATE_180)]
+            "RGB",
+            [
+                g,
+                g.transpose(Image.Transpose.ROTATE_90),
+                g.transpose(Image.Transpose.ROTATE_180),
+            ],
         )
 
         # fmt: off
-        transformed = im._new(im.im.color_lut_3d('RGB', Image.LINEAR,
+        transformed = im._new(im.im.color_lut_3d('RGB', Image.Resampling.BILINEAR,
                               3, 2, 2, 2,
                               [
                                   -1, -1, -1,   2, -1, -1,
@@ -251,7 +325,7 @@ def test_overflow(self):
         assert transformed[205, 205] == (255, 255, 0)
 
         # fmt: off
-        transformed = im._new(im.im.color_lut_3d('RGB', Image.LINEAR,
+        transformed = im._new(im.im.color_lut_3d('RGB', Image.Resampling.BILINEAR,
                               3, 2, 2, 2,
                               [
                                   -3, -3, -3,   5, -3, -3,
@@ -354,7 +428,12 @@ def test_numpy_sources(self):
     def test_numpy_formats(self):
         g = Image.linear_gradient("L")
         im = Image.merge(
-            "RGB", [g, g.transpose(Image.ROTATE_90), g.transpose(Image.ROTATE_180)]
+            "RGB",
+            [
+                g,
+                g.transpose(Image.Transpose.ROTATE_90),
+                g.transpose(Image.Transpose.ROTATE_180),
+            ],
         )
 
         lut = ImageFilter.Color3DLUT.generate((7, 9, 11), lambda r, g, b: (r, g, b))
@@ -445,7 +524,12 @@ def test_apply(self):
 
         g = Image.linear_gradient("L")
         im = Image.merge(
-            "RGB", [g, g.transpose(Image.ROTATE_90), g.transpose(Image.ROTATE_180)]
+            "RGB",
+            [
+                g,
+                g.transpose(Image.Transpose.ROTATE_90),
+                g.transpose(Image.Transpose.ROTATE_180),
+            ],
         )
         assert im == im.filter(lut)