mirror of
https://github.com/python-pillow/Pillow.git
synced 2024-12-28 02:46:18 +03:00
329 lines
11 KiB
Python
329 lines
11 KiB
Python
"""
|
|
Tests for resize functionality.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
from collections.abc import Generator
|
|
from itertools import permutations
|
|
from pathlib import Path
|
|
|
|
import pytest
|
|
|
|
from PIL import Image
|
|
|
|
from .helper import (
|
|
assert_image_equal,
|
|
assert_image_equal_tofile,
|
|
assert_image_similar,
|
|
hopper,
|
|
skip_unless_feature,
|
|
)
|
|
|
|
|
|
class TestImagingCoreResize:
|
|
def resize(
|
|
self, im: Image.Image, size: tuple[int, int], f: Image.Resampling
|
|
) -> Image.Image:
|
|
# Image class independent version of resize.
|
|
im.load()
|
|
return im._new(im.im.resize(size, f))
|
|
|
|
@pytest.mark.parametrize(
|
|
"mode", ("1", "P", "L", "I", "F", "RGB", "RGBA", "CMYK", "YCbCr", "I;16")
|
|
)
|
|
def test_nearest_mode(self, mode: str) -> None:
|
|
im = hopper(mode)
|
|
r = self.resize(im, (15, 12), Image.Resampling.NEAREST)
|
|
assert r.mode == mode
|
|
assert r.size == (15, 12)
|
|
assert r.im.bands == im.im.bands
|
|
|
|
def test_convolution_modes(self) -> None:
|
|
with pytest.raises(ValueError):
|
|
self.resize(hopper("1"), (15, 12), Image.Resampling.BILINEAR)
|
|
with pytest.raises(ValueError):
|
|
self.resize(hopper("P"), (15, 12), Image.Resampling.BILINEAR)
|
|
for mode in [
|
|
"L",
|
|
"I",
|
|
"I;16",
|
|
"I;16L",
|
|
"I;16B",
|
|
"I;16N",
|
|
"F",
|
|
"RGB",
|
|
"RGBA",
|
|
"CMYK",
|
|
"YCbCr",
|
|
]:
|
|
im = hopper(mode)
|
|
r = self.resize(im, (15, 12), Image.Resampling.BILINEAR)
|
|
assert r.mode == mode
|
|
assert r.size == (15, 12)
|
|
assert r.im.bands == im.im.bands
|
|
|
|
@pytest.mark.parametrize(
|
|
"resample",
|
|
(
|
|
Image.Resampling.NEAREST,
|
|
Image.Resampling.BOX,
|
|
Image.Resampling.BILINEAR,
|
|
Image.Resampling.HAMMING,
|
|
Image.Resampling.BICUBIC,
|
|
Image.Resampling.LANCZOS,
|
|
),
|
|
)
|
|
def test_reduce_filters(self, resample: Image.Resampling) -> None:
|
|
r = self.resize(hopper("RGB"), (15, 12), resample)
|
|
assert r.mode == "RGB"
|
|
assert r.size == (15, 12)
|
|
|
|
@pytest.mark.parametrize(
|
|
"resample",
|
|
(
|
|
Image.Resampling.NEAREST,
|
|
Image.Resampling.BOX,
|
|
Image.Resampling.BILINEAR,
|
|
Image.Resampling.HAMMING,
|
|
Image.Resampling.BICUBIC,
|
|
Image.Resampling.LANCZOS,
|
|
),
|
|
)
|
|
def test_enlarge_filters(self, resample: Image.Resampling) -> None:
|
|
r = self.resize(hopper("RGB"), (212, 195), resample)
|
|
assert r.mode == "RGB"
|
|
assert r.size == (212, 195)
|
|
|
|
@pytest.mark.parametrize(
|
|
"resample",
|
|
(
|
|
Image.Resampling.NEAREST,
|
|
Image.Resampling.BOX,
|
|
Image.Resampling.BILINEAR,
|
|
Image.Resampling.HAMMING,
|
|
Image.Resampling.BICUBIC,
|
|
Image.Resampling.LANCZOS,
|
|
),
|
|
)
|
|
@pytest.mark.parametrize(
|
|
"mode, channels_set",
|
|
(
|
|
("RGB", ("blank", "filled", "dirty")),
|
|
("RGBA", ("blank", "blank", "filled", "dirty")),
|
|
("LA", ("filled", "dirty")),
|
|
),
|
|
)
|
|
def test_endianness(
|
|
self, resample: Image.Resampling, mode: str, channels_set: tuple[str, ...]
|
|
) -> None:
|
|
# Make an image with one colored pixel, in one channel.
|
|
# When resized, that channel should be the same as a GS image.
|
|
# Other channels should be unaffected.
|
|
# The R and A channels should not swap, which is indicative of
|
|
# an endianness issues.
|
|
|
|
samples = {
|
|
"blank": Image.new("L", (2, 2), 0),
|
|
"filled": Image.new("L", (2, 2), 255),
|
|
"dirty": Image.new("L", (2, 2), 0),
|
|
}
|
|
samples["dirty"].putpixel((1, 1), 128)
|
|
|
|
# samples resized with current filter
|
|
references = {
|
|
name: self.resize(ch, (4, 4), resample) for name, ch in samples.items()
|
|
}
|
|
|
|
for channels in set(permutations(channels_set)):
|
|
# compile image from different channels permutations
|
|
im = Image.merge(mode, [samples[ch] for ch in channels])
|
|
resized = self.resize(im, (4, 4), resample)
|
|
|
|
for i, ch in enumerate(resized.split()):
|
|
# check what resized channel in image is the same
|
|
# as separately resized channel
|
|
assert_image_equal(ch, references[channels[i]])
|
|
|
|
@pytest.mark.parametrize(
|
|
"resample",
|
|
(
|
|
Image.Resampling.NEAREST,
|
|
Image.Resampling.BOX,
|
|
Image.Resampling.BILINEAR,
|
|
Image.Resampling.HAMMING,
|
|
Image.Resampling.BICUBIC,
|
|
Image.Resampling.LANCZOS,
|
|
),
|
|
)
|
|
def test_enlarge_zero(self, resample: Image.Resampling) -> None:
|
|
r = self.resize(Image.new("RGB", (0, 0), "white"), (212, 195), resample)
|
|
assert r.mode == "RGB"
|
|
assert r.size == (212, 195)
|
|
assert r.getdata()[0] == (0, 0, 0)
|
|
|
|
def test_unknown_filter(self) -> None:
|
|
with pytest.raises(ValueError):
|
|
self.resize(hopper(), (10, 10), 9) # type: ignore[arg-type]
|
|
|
|
def test_cross_platform(self, tmp_path: Path) -> None:
|
|
# This test is intended for only check for consistent behaviour across
|
|
# platforms. So if a future Pillow change requires that the test file
|
|
# be updated, that is okay.
|
|
im = hopper().resize((64, 64))
|
|
temp_file = str(tmp_path / "temp.gif")
|
|
im.save(temp_file)
|
|
|
|
with Image.open(temp_file) as reloaded:
|
|
assert_image_equal_tofile(reloaded, "Tests/images/hopper_resized.gif")
|
|
|
|
|
|
@pytest.fixture
|
|
def gradients_image() -> Generator[Image.Image, None, None]:
|
|
with Image.open("Tests/images/radial_gradients.png") as im:
|
|
im.load()
|
|
try:
|
|
yield im
|
|
finally:
|
|
im.close()
|
|
|
|
|
|
class TestReducingGapResize:
|
|
def test_reducing_gap_values(self, gradients_image: Image.Image) -> None:
|
|
ref = gradients_image.resize(
|
|
(52, 34), Image.Resampling.BICUBIC, reducing_gap=None
|
|
)
|
|
im = gradients_image.resize((52, 34), Image.Resampling.BICUBIC)
|
|
assert_image_equal(ref, im)
|
|
|
|
with pytest.raises(ValueError):
|
|
gradients_image.resize((52, 34), Image.Resampling.BICUBIC, reducing_gap=0)
|
|
|
|
with pytest.raises(ValueError):
|
|
gradients_image.resize(
|
|
(52, 34), Image.Resampling.BICUBIC, reducing_gap=0.99
|
|
)
|
|
|
|
@pytest.mark.parametrize(
|
|
"box, epsilon",
|
|
((None, 4), ((1.1, 2.2, 510.8, 510.9), 4), ((3, 10, 410, 256), 10)),
|
|
)
|
|
def test_reducing_gap_1(
|
|
self,
|
|
gradients_image: Image.Image,
|
|
box: tuple[float, float, float, float],
|
|
epsilon: float,
|
|
) -> None:
|
|
ref = gradients_image.resize((52, 34), Image.Resampling.BICUBIC, box=box)
|
|
im = gradients_image.resize(
|
|
(52, 34), Image.Resampling.BICUBIC, box=box, reducing_gap=1.0
|
|
)
|
|
|
|
with pytest.raises(pytest.fail.Exception):
|
|
assert_image_equal(ref, im)
|
|
|
|
assert_image_similar(ref, im, epsilon)
|
|
|
|
@pytest.mark.parametrize(
|
|
"box, epsilon",
|
|
((None, 1.5), ((1.1, 2.2, 510.8, 510.9), 1.5), ((3, 10, 410, 256), 1)),
|
|
)
|
|
def test_reducing_gap_2(
|
|
self,
|
|
gradients_image: Image.Image,
|
|
box: tuple[float, float, float, float],
|
|
epsilon: float,
|
|
) -> None:
|
|
ref = gradients_image.resize((52, 34), Image.Resampling.BICUBIC, box=box)
|
|
im = gradients_image.resize(
|
|
(52, 34), Image.Resampling.BICUBIC, box=box, reducing_gap=2.0
|
|
)
|
|
|
|
with pytest.raises(pytest.fail.Exception):
|
|
assert_image_equal(ref, im)
|
|
|
|
assert_image_similar(ref, im, epsilon)
|
|
|
|
@pytest.mark.parametrize(
|
|
"box, epsilon",
|
|
((None, 1), ((1.1, 2.2, 510.8, 510.9), 1), ((3, 10, 410, 256), 0.5)),
|
|
)
|
|
def test_reducing_gap_3(
|
|
self,
|
|
gradients_image: Image.Image,
|
|
box: tuple[float, float, float, float],
|
|
epsilon: float,
|
|
) -> None:
|
|
ref = gradients_image.resize((52, 34), Image.Resampling.BICUBIC, box=box)
|
|
im = gradients_image.resize(
|
|
(52, 34), Image.Resampling.BICUBIC, box=box, reducing_gap=3.0
|
|
)
|
|
|
|
with pytest.raises(pytest.fail.Exception):
|
|
assert_image_equal(ref, im)
|
|
|
|
assert_image_similar(ref, im, epsilon)
|
|
|
|
@pytest.mark.parametrize("box", (None, (1.1, 2.2, 510.8, 510.9), (3, 10, 410, 256)))
|
|
def test_reducing_gap_8(
|
|
self, gradients_image: Image.Image, box: tuple[float, float, float, float]
|
|
) -> None:
|
|
ref = gradients_image.resize((52, 34), Image.Resampling.BICUBIC, box=box)
|
|
im = gradients_image.resize(
|
|
(52, 34), Image.Resampling.BICUBIC, box=box, reducing_gap=8.0
|
|
)
|
|
|
|
assert_image_equal(ref, im)
|
|
|
|
@pytest.mark.parametrize(
|
|
"box, epsilon",
|
|
(((0, 0, 512, 512), 5.5), ((0.9, 1.7, 128, 128), 9.5)),
|
|
)
|
|
def test_box_filter(
|
|
self,
|
|
gradients_image: Image.Image,
|
|
box: tuple[float, float, float, float],
|
|
epsilon: float,
|
|
) -> None:
|
|
ref = gradients_image.resize((52, 34), Image.Resampling.BOX, box=box)
|
|
im = gradients_image.resize(
|
|
(52, 34), Image.Resampling.BOX, box=box, reducing_gap=1.0
|
|
)
|
|
|
|
assert_image_similar(ref, im, epsilon)
|
|
|
|
|
|
class TestImageResize:
|
|
def test_resize(self) -> None:
|
|
def resize(mode: str, size: tuple[int, int] | list[int]) -> None:
|
|
out = hopper(mode).resize(size)
|
|
assert out.mode == mode
|
|
assert out.size == tuple(size)
|
|
|
|
for mode in "1", "P", "L", "RGB", "I", "F":
|
|
resize(mode, (112, 103))
|
|
resize(mode, [188, 214])
|
|
|
|
# Test unknown resampling filter
|
|
with hopper() as im:
|
|
with pytest.raises(ValueError):
|
|
im.resize((10, 10), -1)
|
|
|
|
@skip_unless_feature("libtiff")
|
|
def test_transposed(self) -> None:
|
|
with Image.open("Tests/images/g4_orientation_5.tif") as img:
|
|
im = img.resize((64, 64))
|
|
assert im.size == (64, 64)
|
|
|
|
@pytest.mark.parametrize(
|
|
"mode", ("L", "RGB", "I", "I;16", "I;16L", "I;16B", "I;16N", "F")
|
|
)
|
|
def test_default_filter_bicubic(self, mode: str) -> None:
|
|
im = hopper(mode)
|
|
assert im.resize((20, 20), Image.Resampling.BICUBIC) == im.resize((20, 20))
|
|
|
|
@pytest.mark.parametrize("mode", ("1", "P", "BGR;15", "BGR;16"))
|
|
def test_default_filter_nearest(self, mode: str) -> None:
|
|
im = hopper(mode)
|
|
assert im.resize((20, 20), Image.Resampling.NEAREST) == im.resize((20, 20))
|