Pillow/Tests/test_image_access.py

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

458 lines
15 KiB
Python
Raw Normal View History

from __future__ import annotations
2024-01-20 14:23:03 +03:00
import os
import subprocess
import sys
2020-09-01 20:16:46 +03:00
import sysconfig
2024-02-12 01:28:53 +03:00
from types import ModuleType
2014-01-05 22:41:25 +04:00
import pytest
2020-09-01 20:16:46 +03:00
2014-06-10 13:10:47 +04:00
from PIL import Image
2024-05-12 14:20:46 +03:00
from .helper import assert_image_equal, hopper, is_win32
2014-01-05 22:41:25 +04:00
# CFFI imports pycparser which doesn't support PYTHONOPTIMIZE=2
# https://github.com/eliben/pycparser/pull/198#issuecomment-317001670
2024-03-02 05:12:17 +03:00
cffi: ModuleType | None
if os.environ.get("PYTHONOPTIMIZE") == "2":
cffi = None
else:
try:
import cffi
2020-09-01 20:16:46 +03:00
from PIL import PyAccess
except ImportError:
cffi = None
2024-02-12 01:28:53 +03:00
numpy: ModuleType | None
try:
import numpy
except ImportError:
numpy = None
2018-03-03 12:54:00 +03:00
2020-03-02 17:02:19 +03:00
class AccessTest:
# Initial value
_init_cffi_access = Image.USE_CFFI_ACCESS
_need_cffi_access = False
@classmethod
def setup_class(cls) -> None:
Image.USE_CFFI_ACCESS = cls._need_cffi_access
@classmethod
def teardown_class(cls) -> None:
Image.USE_CFFI_ACCESS = cls._init_cffi_access
class TestImagePutPixel(AccessTest):
def test_sanity(self) -> None:
im1 = hopper()
im2 = Image.new(im1.mode, im1.size, 0)
for y in range(im1.size[1]):
for x in range(im1.size[0]):
pos = x, y
im2.putpixel(pos, im1.getpixel(pos))
assert_image_equal(im1, im2)
im2 = Image.new(im1.mode, im1.size, 0)
im2.readonly = 1
for y in range(im1.size[1]):
for x in range(im1.size[0]):
pos = x, y
im2.putpixel(pos, im1.getpixel(pos))
assert not im2.readonly
assert_image_equal(im1, im2)
im2 = Image.new(im1.mode, im1.size, 0)
pix1 = im1.load()
pix2 = im2.load()
2024-02-12 01:28:53 +03:00
with pytest.raises(TypeError):
pix1[0, "0"]
with pytest.raises(TypeError):
pix1["0", 0]
for y in range(im1.size[1]):
for x in range(im1.size[0]):
pix2[x, y] = pix1[x, y]
assert_image_equal(im1, im2)
def test_sanity_negative_index(self) -> None:
im1 = hopper()
im2 = Image.new(im1.mode, im1.size, 0)
2018-10-15 14:06:08 +03:00
width, height = im1.size
assert im1.getpixel((0, 0)) == im1.getpixel((-width, -height))
assert im1.getpixel((-1, -1)) == im1.getpixel((width - 1, height - 1))
2019-06-13 18:54:24 +03:00
for y in range(-1, -im1.size[1] - 1, -1):
for x in range(-1, -im1.size[0] - 1, -1):
pos = x, y
im2.putpixel(pos, im1.getpixel(pos))
assert_image_equal(im1, im2)
im2 = Image.new(im1.mode, im1.size, 0)
im2.readonly = 1
2019-06-13 18:54:24 +03:00
for y in range(-1, -im1.size[1] - 1, -1):
for x in range(-1, -im1.size[0] - 1, -1):
pos = x, y
im2.putpixel(pos, im1.getpixel(pos))
assert not im2.readonly
assert_image_equal(im1, im2)
im2 = Image.new(im1.mode, im1.size, 0)
pix1 = im1.load()
pix2 = im2.load()
2019-06-13 18:54:24 +03:00
for y in range(-1, -im1.size[1] - 1, -1):
for x in range(-1, -im1.size[0] - 1, -1):
pix2[x, y] = pix1[x, y]
assert_image_equal(im1, im2)
@pytest.mark.skipif(numpy is None, reason="NumPy not installed")
def test_numpy(self) -> None:
im = hopper()
pix = im.load()
2024-02-12 01:28:53 +03:00
assert numpy is not None
assert pix[numpy.int32(1), numpy.int32(2)] == (18, 20, 59)
class TestImageGetPixel(AccessTest):
@staticmethod
2024-02-12 01:28:53 +03:00
def color(mode: str) -> int | tuple[int, ...]:
bands = Image.getmodebands(mode)
if bands == 1:
return 1
2023-07-26 05:25:54 +03:00
if mode in ("BGR;15", "BGR;16"):
# These modes have less than 8 bits per band,
# so (1, 2, 3) cannot be roundtripped.
2023-07-26 05:25:54 +03:00
return (16, 32, 49)
return tuple(range(1, bands + 1))
2024-02-12 01:28:53 +03:00
def check(self, mode: str, expected_color_int: int | None = None) -> None:
2023-07-26 05:25:54 +03:00
if self._need_cffi_access and mode.startswith("BGR;"):
pytest.skip("Support not added to deprecated module for BGR;* modes")
2024-02-12 01:28:53 +03:00
expected_color = (
self.color(mode) if expected_color_int is None else expected_color_int
2024-02-12 01:28:53 +03:00
)
# Check putpixel
im = Image.new(mode, (1, 1), None)
2023-01-16 16:46:11 +03:00
im.putpixel((0, 0), expected_color)
actual_color = im.getpixel((0, 0))
assert actual_color == expected_color, (
f"put/getpixel roundtrip failed for mode {mode}, "
f"expected {expected_color} got {actual_color}"
)
# Check putpixel negative index
2023-01-16 16:46:11 +03:00
im.putpixel((-1, -1), expected_color)
actual_color = im.getpixel((-1, -1))
assert actual_color == expected_color, (
f"put/getpixel roundtrip negative index failed for mode {mode}, "
2023-01-16 16:46:11 +03:00
f"expected {expected_color} got {actual_color}"
)
# Check 0x0 image with None initial color
im = Image.new(mode, (0, 0), None)
2022-03-03 14:10:19 +03:00
assert im.load() is not None
error = ValueError if self._need_cffi_access else IndexError
with pytest.raises(error):
2023-01-16 16:46:11 +03:00
im.putpixel((0, 0), expected_color)
2022-03-03 14:10:19 +03:00
with pytest.raises(error):
im.getpixel((0, 0))
# Check negative index
2022-03-03 14:10:19 +03:00
with pytest.raises(error):
2023-01-16 16:46:11 +03:00
im.putpixel((-1, -1), expected_color)
2022-03-03 14:10:19 +03:00
with pytest.raises(error):
im.getpixel((-1, -1))
2017-03-01 12:20:18 +03:00
# Check initial color
2023-01-16 16:46:11 +03:00
im = Image.new(mode, (1, 1), expected_color)
actual_color = im.getpixel((0, 0))
assert actual_color == expected_color, (
f"initial color failed for mode {mode}, "
f"expected {expected_color} got {actual_color}"
)
# Check initial color negative index
2023-01-16 16:46:11 +03:00
actual_color = im.getpixel((-1, -1))
assert actual_color == expected_color, (
f"initial color failed with negative index for mode {mode}, "
2023-01-16 16:46:11 +03:00
f"expected {expected_color} got {actual_color}"
)
# Check 0x0 image with initial color
2023-01-16 16:46:11 +03:00
im = Image.new(mode, (0, 0), expected_color)
2022-03-03 14:10:19 +03:00
with pytest.raises(error):
im.getpixel((0, 0))
# Check negative index
2022-03-03 14:10:19 +03:00
with pytest.raises(error):
im.getpixel((-1, -1))
2024-05-12 14:20:46 +03:00
@pytest.mark.parametrize("mode", Image.MODES)
2024-02-12 01:28:53 +03:00
def test_basic(self, mode: str) -> None:
2024-05-12 14:20:46 +03:00
self.check(mode)
@pytest.mark.parametrize("mode", ("BGR;15", "BGR;16", "BGR;24"))
def test_deprecated(self, mode: str) -> None:
with pytest.warns(DeprecationWarning):
2024-04-15 12:28:52 +03:00
self.check(mode)
def test_list(self) -> None:
2023-08-28 13:12:23 +03:00
im = hopper()
assert im.getpixel([0, 0]) == (20, 20, 70)
2022-08-23 14:41:32 +03:00
@pytest.mark.parametrize("mode", ("I;16", "I;16B"))
@pytest.mark.parametrize("expected_color", (2**15 - 1, 2**15, 2**15 + 1, 2**16 - 1))
2024-02-12 01:28:53 +03:00
def test_signedness(self, mode: str, expected_color: int) -> None:
# See https://github.com/python-pillow/Pillow/issues/452
# pixelaccess is using signed int* instead of uint*
self.check(mode, expected_color)
2014-01-05 22:41:25 +04:00
@pytest.mark.parametrize("mode", ("P", "PA"))
2022-08-23 14:41:32 +03:00
@pytest.mark.parametrize("color", ((255, 0, 0), (255, 0, 0, 255)))
2024-02-12 01:28:53 +03:00
def test_p_putpixel_rgb_rgba(self, mode: str, color: tuple[int, ...]) -> None:
2022-08-31 13:56:38 +03:00
im = Image.new(mode, (1, 1))
2022-08-23 14:41:32 +03:00
im.putpixel((0, 0), color)
2022-08-31 13:56:38 +03:00
alpha = color[3] if len(color) == 4 and mode == "PA" else 255
assert im.convert("RGBA").getpixel((0, 0)) == (255, 0, 0, alpha)
2018-12-31 03:35:15 +03:00
2014-06-10 13:10:47 +04:00
2023-06-28 13:10:10 +03:00
@pytest.mark.filterwarnings("ignore::DeprecationWarning")
2020-03-02 17:02:19 +03:00
@pytest.mark.skipif(cffi is None, reason="No CFFI")
2014-06-10 13:10:47 +04:00
class TestCffiPutPixel(TestImagePutPixel):
_need_cffi_access = True
2014-06-10 13:10:47 +04:00
2023-06-28 13:10:10 +03:00
@pytest.mark.filterwarnings("ignore::DeprecationWarning")
2020-03-02 17:02:19 +03:00
@pytest.mark.skipif(cffi is None, reason="No CFFI")
2014-06-10 13:10:47 +04:00
class TestCffiGetPixel(TestImageGetPixel):
_need_cffi_access = True
2014-06-10 13:10:47 +04:00
2020-03-02 17:02:19 +03:00
@pytest.mark.skipif(cffi is None, reason="No CFFI")
class TestCffi(AccessTest):
_need_cffi_access = True
2014-06-10 13:10:47 +04:00
2024-02-12 01:28:53 +03:00
def _test_get_access(self, im: Image.Image) -> None:
2015-04-02 11:57:24 +03:00
"""Do we get the same thing as the old pixel access
2014-06-10 13:10:47 +04:00
2015-04-02 11:57:24 +03:00
Using private interfaces, forcing a capi access and
a pyaccess for the same image"""
2014-06-10 13:10:47 +04:00
caccess = im.im.pixel_access(False)
2023-06-28 13:10:10 +03:00
with pytest.warns(DeprecationWarning):
access = PyAccess.new(im, False)
2014-06-10 13:10:47 +04:00
w, h = im.size
for x in range(0, w, 10):
for y in range(0, h, 10):
assert access[(x, y)] == caccess[(x, y)]
2014-06-10 13:10:47 +04:00
2015-07-03 08:03:25 +03:00
# Access an out-of-range pixel
2020-02-22 19:07:04 +03:00
with pytest.raises(ValueError):
access[(access.xsize + 1, access.ysize + 1)]
2015-07-03 08:03:25 +03:00
def test_get_vs_c(self) -> None:
2023-06-28 13:10:10 +03:00
with pytest.warns(DeprecationWarning):
rgb = hopper("RGB")
rgb.load()
self._test_get_access(rgb)
for mode in ("RGBA", "L", "LA", "1", "P", "F"):
self._test_get_access(hopper(mode))
2014-06-10 13:10:47 +04:00
2023-06-28 13:10:10 +03:00
for mode in ("I;16", "I;16L", "I;16B", "I;16N", "I"):
im = Image.new(mode, (10, 10), 40000)
self._test_get_access(im)
2022-12-28 08:55:59 +03:00
2024-02-12 01:28:53 +03:00
def _test_set_access(self, im: Image.Image, color: tuple[int, ...] | float) -> None:
2015-04-02 11:57:24 +03:00
"""Are we writing the correct bits into the image?
2014-06-10 13:10:47 +04:00
2015-04-02 11:57:24 +03:00
Using private interfaces, forcing a capi access and
a pyaccess for the same image"""
2014-06-10 13:10:47 +04:00
caccess = im.im.pixel_access(False)
2023-06-28 13:10:10 +03:00
with pytest.warns(DeprecationWarning):
access = PyAccess.new(im, False)
2014-06-10 13:10:47 +04:00
w, h = im.size
for x in range(0, w, 10):
for y in range(0, h, 10):
access[(x, y)] = color
assert color == caccess[(x, y)]
2014-06-10 13:10:47 +04:00
2015-07-03 08:03:25 +03:00
# Attempt to set the value on a read-only image
2023-06-28 13:10:10 +03:00
with pytest.warns(DeprecationWarning):
access = PyAccess.new(im, True)
with pytest.raises(ValueError):
2015-07-03 08:03:25 +03:00
access[(0, 0)] = color
def test_set_vs_c(self) -> None:
2019-06-13 18:54:24 +03:00
rgb = hopper("RGB")
2023-06-28 13:10:10 +03:00
with pytest.warns(DeprecationWarning):
rgb.load()
2014-06-10 13:10:47 +04:00
self._test_set_access(rgb, (255, 128, 0))
2019-06-13 18:54:24 +03:00
self._test_set_access(hopper("RGBA"), (255, 192, 128, 0))
self._test_set_access(hopper("L"), 128)
self._test_set_access(hopper("LA"), (128, 128))
self._test_set_access(hopper("1"), 255)
self._test_set_access(hopper("P"), 128)
self._test_set_access(hopper("PA"), (128, 128))
2019-06-13 18:54:24 +03:00
self._test_set_access(hopper("F"), 1024.0)
2014-06-10 13:10:47 +04:00
2022-12-28 08:55:59 +03:00
for mode in ("I;16", "I;16L", "I;16B", "I;16N", "I"):
im = Image.new(mode, (10, 10), 40000)
self._test_set_access(im, 45000)
2014-06-10 13:10:47 +04:00
2023-06-28 13:10:10 +03:00
@pytest.mark.filterwarnings("ignore::DeprecationWarning")
def test_not_implemented(self) -> None:
assert PyAccess.new(hopper("BGR;15")) is None
2017-03-01 12:20:18 +03:00
# Ref https://github.com/python-pillow/Pillow/pull/2009
def test_reference_counting(self) -> None:
2016-07-04 13:42:45 +03:00
size = 10
for _ in range(10):
# Do not save references to the image, only to the access object
2023-06-28 13:10:10 +03:00
with pytest.warns(DeprecationWarning):
px = Image.new("L", (size, 1), 0).load()
2016-07-04 13:42:45 +03:00
for i in range(size):
# Pixels can contain garbage if image is released
assert px[i, 0] == 0
2016-07-04 13:42:45 +03:00
@pytest.mark.parametrize("mode", ("P", "PA"))
2024-02-12 01:28:53 +03:00
def test_p_putpixel_rgb_rgba(self, mode: str) -> None:
2022-10-10 03:46:33 +03:00
for color in ((255, 0, 0), (255, 0, 0, 127 if mode == "PA" else 255)):
im = Image.new(mode, (1, 1))
2023-06-28 13:10:10 +03:00
with pytest.warns(DeprecationWarning):
access = PyAccess.new(im, False)
access.putpixel((0, 0), color)
2023-06-28 13:10:10 +03:00
if len(color) == 3:
color += (255,)
assert im.convert("RGBA").getpixel((0, 0)) == color
2018-12-31 03:35:15 +03:00
2014-06-10 13:10:47 +04:00
class TestImagePutPixelError(AccessTest):
IMAGE_MODES1 = ["LA", "RGB", "RGBA", "BGR;15"]
IMAGE_MODES2 = ["L", "I", "I;16"]
INVALID_TYPES = ["foo", 1.0, None]
2020-08-21 00:16:19 +03:00
2020-09-22 06:06:52 +03:00
@pytest.mark.parametrize("mode", IMAGE_MODES1)
2024-02-12 01:28:53 +03:00
def test_putpixel_type_error1(self, mode: str) -> None:
2020-08-21 00:16:19 +03:00
im = hopper(mode)
for v in self.INVALID_TYPES:
2020-08-21 00:16:19 +03:00
with pytest.raises(TypeError, match="color must be int or tuple"):
im.putpixel((0, 0), v)
@pytest.mark.parametrize(
("mode", "band_numbers", "match"),
(
("L", (0, 2), "color must be int or single-element tuple"),
("LA", (0, 3), "color must be int, or tuple of one or two elements"),
(
"BGR;15",
(0, 2),
"color must be int, or tuple of one or three elements",
),
(
"RGB",
(0, 2, 5),
"color must be int, or tuple of one, three or four elements",
),
),
)
2024-02-12 01:28:53 +03:00
def test_putpixel_invalid_number_of_bands(
self, mode: str, band_numbers: tuple[int, ...], match: str
) -> None:
im = hopper(mode)
for band_number in band_numbers:
with pytest.raises(TypeError, match=match):
im.putpixel((0, 0), (0,) * band_number)
2020-09-22 06:06:52 +03:00
@pytest.mark.parametrize("mode", IMAGE_MODES2)
2024-02-12 01:28:53 +03:00
def test_putpixel_type_error2(self, mode: str) -> None:
2020-09-22 06:06:52 +03:00
im = hopper(mode)
for v in self.INVALID_TYPES:
with pytest.raises(
TypeError, match="color must be int or single-element tuple"
):
im.putpixel((0, 0), v)
@pytest.mark.parametrize("mode", IMAGE_MODES1 + IMAGE_MODES2)
2024-02-12 01:28:53 +03:00
def test_putpixel_overflow_error(self, mode: str) -> None:
2020-08-21 00:16:19 +03:00
im = hopper(mode)
with pytest.raises(OverflowError):
2022-03-04 08:42:24 +03:00
im.putpixel((0, 0), 2**80)
2020-08-21 00:16:19 +03:00
2020-03-02 17:02:19 +03:00
class TestEmbeddable:
@pytest.mark.xfail(reason="failing test")
@pytest.mark.skipif(not is_win32(), reason="requires Windows")
def test_embeddable(self) -> None:
import ctypes
2024-02-12 01:28:53 +03:00
from setuptools.command import build_ext
with open("embed_pil.c", "w", encoding="utf-8") as fh:
2024-05-08 10:57:36 +03:00
home = sys.prefix.replace("\\", "\\\\")
2019-06-13 18:54:24 +03:00
fh.write(
2024-05-08 10:57:36 +03:00
f"""
#include "Python.h"
int main(int argc, char* argv[])
2024-05-08 10:57:36 +03:00
{{
char *home = "{home}";
2017-01-12 01:12:31 +03:00
wchar_t *whome = Py_DecodeLocale(home, NULL);
Py_SetPythonHome(whome);
Py_InitializeEx(0);
Py_DECREF(PyImport_ImportModule("PIL.Image"));
Py_Finalize();
2017-01-12 01:12:31 +03:00
Py_InitializeEx(0);
Py_DECREF(PyImport_ImportModule("PIL.Image"));
Py_Finalize();
2017-01-12 01:12:31 +03:00
PyMem_RawFree(whome);
return 0;
2024-05-08 10:57:36 +03:00
}}
2019-06-13 18:54:24 +03:00
"""
)
2024-02-12 01:28:53 +03:00
compiler = getattr(build_ext, "new_compiler")()
2020-09-01 20:16:46 +03:00
compiler.add_include_dir(sysconfig.get_config_var("INCLUDEPY"))
2020-09-01 20:16:46 +03:00
libdir = sysconfig.get_config_var("LIBDIR") or sysconfig.get_config_var(
"INCLUDEPY"
).replace("include", "libs")
2017-01-12 02:45:19 +03:00
compiler.add_library_dir(libdir)
2019-06-13 18:54:24 +03:00
objects = compiler.compile(["embed_pil.c"])
compiler.link_executable(objects, "embed_pil")
2017-01-12 02:45:19 +03:00
env = os.environ.copy()
2019-06-13 18:54:24 +03:00
env["PATH"] = sys.prefix + ";" + env["PATH"]
# Do not display the Windows Error Reporting dialog
2024-02-12 01:28:53 +03:00
getattr(ctypes, "windll").kernel32.SetErrorMode(0x0002)
2019-06-13 18:54:24 +03:00
process = subprocess.Popen(["embed_pil.exe"], env=env)
2017-01-12 01:12:31 +03:00
process.communicate()
assert process.returncode == 0