Pillow/Tests/test_file_tiff.py

638 lines
21 KiB
Python
Raw Normal View History

import logging
from io import BytesIO
import sys
from .helper import unittest, PillowTestCase, hopper
2019-06-30 06:25:12 +03:00
from PIL import Image, TiffImagePlugin, features
2018-04-20 02:19:13 +03:00
from PIL._util import py3
2017-05-27 23:55:14 +03:00
from PIL.TiffImagePlugin import X_RESOLUTION, Y_RESOLUTION, RESOLUTION_UNIT
logger = logging.getLogger(__name__)
2015-06-06 17:04:39 +03:00
2014-06-10 13:10:47 +04:00
class TestFileTiff(PillowTestCase):
def test_sanity(self):
filename = self.tempfile("temp.tif")
2014-06-10 13:10:47 +04:00
hopper("RGB").save(filename)
2014-06-10 13:10:47 +04:00
im = Image.open(filename)
2014-06-10 13:10:47 +04:00
im.load()
self.assertEqual(im.mode, "RGB")
self.assertEqual(im.size, (128, 128))
self.assertEqual(im.format, "TIFF")
hopper("1").save(filename)
2018-10-02 11:44:43 +03:00
Image.open(filename)
hopper("L").save(filename)
2018-10-02 11:44:43 +03:00
Image.open(filename)
2014-06-10 13:10:47 +04:00
hopper("P").save(filename)
2018-10-02 11:44:43 +03:00
Image.open(filename)
2014-06-10 13:10:47 +04:00
hopper("RGB").save(filename)
2018-10-02 11:44:43 +03:00
Image.open(filename)
2014-06-10 13:10:47 +04:00
hopper("I").save(filename)
2018-10-02 11:44:43 +03:00
Image.open(filename)
2014-06-10 13:10:47 +04:00
2018-11-17 13:56:06 +03:00
def test_unclosed_file(self):
def open():
im = Image.open("Tests/images/multipage.tiff")
im.load()
2019-06-13 18:54:11 +03:00
2018-11-17 13:56:06 +03:00
self.assert_warning(None, open)
2014-06-10 13:10:47 +04:00
def test_mac_tiff(self):
2016-09-23 14:12:03 +03:00
# Read RGBa images from macOS [@PIL136]
2014-06-10 13:10:47 +04:00
filename = "Tests/images/pil136.tiff"
im = Image.open(filename)
2014-06-10 13:10:47 +04:00
self.assertEqual(im.mode, "RGBA")
self.assertEqual(im.size, (55, 43))
2019-06-13 18:54:11 +03:00
self.assertEqual(im.tile, [("raw", (0, 0, 55, 43), 8, ("RGBa", 0, 1))])
2014-06-10 13:10:47 +04:00
im.load()
self.assert_image_similar_tofile(im, "Tests/images/pil136.png", 1)
2017-12-08 17:32:39 +03:00
def test_wrong_bits_per_sample(self):
im = Image.open("Tests/images/tiff_wrong_bits_per_sample.tiff")
self.assertEqual(im.mode, "RGBA")
self.assertEqual(im.size, (52, 53))
2019-06-13 18:54:11 +03:00
self.assertEqual(im.tile, [("raw", (0, 0, 52, 53), 160, ("RGBA", 0, 1))])
2017-12-08 17:32:39 +03:00
im.load()
2017-09-01 13:36:51 +03:00
def test_set_legacy_api(self):
2018-06-06 15:34:09 +03:00
ifd = TiffImagePlugin.ImageFileDirectory_v2()
with self.assertRaises(Exception) as e:
ifd.legacy_api = None
2019-06-13 18:54:11 +03:00
self.assertEqual(str(e.exception), "Not allowing setting of legacy api")
2017-09-01 13:36:51 +03:00
def test_size(self):
filename = "Tests/images/pil168.tif"
im = Image.open(filename)
def set_size():
im.size = (256, 256)
2019-06-13 18:54:11 +03:00
self.assert_warning(DeprecationWarning, set_size)
2014-06-10 13:10:47 +04:00
def test_xyres_tiff(self):
filename = "Tests/images/pil168.tif"
im = Image.open(filename)
2015-09-11 20:09:14 +03:00
2015-12-10 01:35:35 +03:00
# legacy api
2015-12-16 06:30:17 +03:00
self.assertIsInstance(im.tag[X_RESOLUTION][0], tuple)
self.assertIsInstance(im.tag[Y_RESOLUTION][0], tuple)
2015-09-11 20:09:14 +03:00
2016-02-05 01:57:13 +03:00
# v2 api
2019-06-13 18:54:11 +03:00
self.assertIsInstance(im.tag_v2[X_RESOLUTION], TiffImagePlugin.IFDRational)
self.assertIsInstance(im.tag_v2[Y_RESOLUTION], TiffImagePlugin.IFDRational)
2015-09-11 20:09:14 +03:00
2019-06-13 18:54:11 +03:00
self.assertEqual(im.info["dpi"], (72.0, 72.0))
2015-09-11 20:09:14 +03:00
def test_xyres_fallback_tiff(self):
filename = "Tests/images/compression.tif"
im = Image.open(filename)
# v2 api
2019-06-13 18:54:11 +03:00
self.assertIsInstance(im.tag_v2[X_RESOLUTION], TiffImagePlugin.IFDRational)
self.assertIsInstance(im.tag_v2[Y_RESOLUTION], TiffImagePlugin.IFDRational)
self.assertRaises(KeyError, lambda: im.tag_v2[RESOLUTION_UNIT])
# Legacy.
2019-06-13 18:54:11 +03:00
self.assertEqual(im.info["resolution"], (100.0, 100.0))
# Fallback "inch".
2019-06-13 18:54:11 +03:00
self.assertEqual(im.info["dpi"], (100.0, 100.0))
def test_int_resolution(self):
filename = "Tests/images/pil168.tif"
im = Image.open(filename)
2014-06-10 13:10:47 +04:00
# Try to read a file where X,Y_RESOLUTION are ints
im.tag_v2[X_RESOLUTION] = 71
im.tag_v2[Y_RESOLUTION] = 71
2014-06-10 13:10:47 +04:00
im._setup()
2019-06-13 18:54:11 +03:00
self.assertEqual(im.info["dpi"], (71.0, 71.0))
2014-06-10 13:10:47 +04:00
2019-03-30 07:03:57 +03:00
def test_load_dpi_rounding(self):
2019-06-13 18:54:11 +03:00
for resolutionUnit, dpi in ((None, (72, 73)), (2, (72, 73)), (3, (183, 185))):
2019-03-30 07:03:57 +03:00
im = Image.open(
2019-06-13 18:54:11 +03:00
"Tests/images/hopper_roundDown_" + str(resolutionUnit) + ".tif"
)
2019-03-30 07:03:57 +03:00
self.assertEqual(im.tag_v2.get(RESOLUTION_UNIT), resolutionUnit)
2019-06-13 18:54:11 +03:00
self.assertEqual(im.info["dpi"], (dpi[0], dpi[0]))
2019-03-30 07:03:57 +03:00
2019-06-13 18:54:11 +03:00
im = Image.open(
"Tests/images/hopper_roundUp_" + str(resolutionUnit) + ".tif"
)
2019-03-30 07:03:57 +03:00
self.assertEqual(im.tag_v2.get(RESOLUTION_UNIT), resolutionUnit)
2019-06-13 18:54:11 +03:00
self.assertEqual(im.info["dpi"], (dpi[1], dpi[1]))
2019-03-30 07:03:57 +03:00
def test_save_dpi_rounding(self):
outfile = self.tempfile("temp.tif")
im = Image.open("Tests/images/hopper.tif")
for dpi in (72.2, 72.8):
im.save(outfile, dpi=(dpi, dpi))
reloaded = Image.open(outfile)
reloaded.load()
2019-06-13 18:54:11 +03:00
self.assertEqual((round(dpi), round(dpi)), reloaded.info["dpi"])
2019-03-30 07:03:57 +03:00
def test_save_setting_missing_resolution(self):
b = BytesIO()
Image.open("Tests/images/10ct_32bit_128.tiff").save(
2019-06-13 18:54:11 +03:00
b, format="tiff", resolution=123.45
)
im = Image.open(b)
self.assertEqual(float(im.tag_v2[X_RESOLUTION]), 123.45)
self.assertEqual(float(im.tag_v2[Y_RESOLUTION]), 123.45)
def test_invalid_file(self):
invalid_file = "Tests/images/flower.jpg"
2019-06-13 18:54:11 +03:00
self.assertRaises(SyntaxError, TiffImagePlugin.TiffImageFile, invalid_file)
TiffImagePlugin.PREFIXES.append(b"\xff\xd8\xff\xe0")
2019-06-13 18:54:11 +03:00
self.assertRaises(SyntaxError, TiffImagePlugin.TiffImageFile, invalid_file)
2016-01-02 04:27:40 +03:00
TiffImagePlugin.PREFIXES.pop()
2014-06-10 13:10:47 +04:00
2015-06-06 17:04:39 +03:00
def test_bad_exif(self):
2019-06-13 18:54:11 +03:00
i = Image.open("Tests/images/hopper_bad_exif.jpg")
# Should not raise struct.error.
self.assert_warning(UserWarning, i._getexif)
2015-06-06 17:04:39 +03:00
2015-12-01 20:14:32 +03:00
def test_save_rgba(self):
im = hopper("RGBA")
outfile = self.tempfile("temp.tif")
im.save(outfile)
def test_save_unsupported_mode(self):
im = hopper("HSV")
outfile = self.tempfile("temp.tif")
2017-09-01 14:05:40 +03:00
self.assertRaises(IOError, im.save, outfile)
2015-06-06 17:04:39 +03:00
2014-06-10 13:10:47 +04:00
def test_little_endian(self):
2019-06-13 18:54:11 +03:00
im = Image.open("Tests/images/16bit.cropped.tif")
2014-06-10 13:10:47 +04:00
self.assertEqual(im.getpixel((0, 0)), 480)
2019-06-13 18:54:11 +03:00
self.assertEqual(im.mode, "I;16")
2014-06-10 13:10:47 +04:00
b = im.tobytes()
# Bytes are in image native order (little endian)
if py3:
2019-06-13 18:54:11 +03:00
self.assertEqual(b[0], ord(b"\xe0"))
self.assertEqual(b[1], ord(b"\x01"))
2014-06-10 13:10:47 +04:00
else:
2019-06-13 18:54:11 +03:00
self.assertEqual(b[0], b"\xe0")
self.assertEqual(b[1], b"\x01")
2014-06-10 13:10:47 +04:00
def test_big_endian(self):
2019-06-13 18:54:11 +03:00
im = Image.open("Tests/images/16bit.MM.cropped.tif")
2014-06-10 13:10:47 +04:00
self.assertEqual(im.getpixel((0, 0)), 480)
2019-06-13 18:54:11 +03:00
self.assertEqual(im.mode, "I;16B")
2014-06-10 13:10:47 +04:00
b = im.tobytes()
# Bytes are in image native order (big endian)
if py3:
2019-06-13 18:54:11 +03:00
self.assertEqual(b[0], ord(b"\x01"))
self.assertEqual(b[1], ord(b"\xe0"))
2014-06-10 13:10:47 +04:00
else:
2019-06-13 18:54:11 +03:00
self.assertEqual(b[0], b"\x01")
self.assertEqual(b[1], b"\xe0")
2014-06-10 13:10:47 +04:00
2015-09-19 03:12:00 +03:00
def test_16bit_s(self):
2019-06-13 18:54:11 +03:00
im = Image.open("Tests/images/16bit.s.tif")
2015-09-19 03:12:00 +03:00
im.load()
2019-06-13 18:54:11 +03:00
self.assertEqual(im.mode, "I")
2018-03-06 11:53:07 +03:00
self.assertEqual(im.getpixel((0, 0)), 32767)
self.assertEqual(im.getpixel((0, 1)), 0)
2015-09-19 03:12:00 +03:00
2014-06-10 13:10:47 +04:00
def test_12bit_rawmode(self):
""" Are we generating the same interpretation
of the image as Imagemagick is? """
2019-06-13 18:54:11 +03:00
im = Image.open("Tests/images/12bit.cropped.tif")
2014-06-10 13:10:47 +04:00
# to make the target --
# convert 12bit.cropped.tif -depth 16 tmp.tif
# convert tmp.tif -evaluate RightShift 4 12in16bit2.tif
# imagemagick will auto scale so that a 12bit FFF is 16bit FFF0,
# so we need to unshift so that the integer values are the same.
2019-06-13 18:54:11 +03:00
self.assert_image_equal_tofile(im, "Tests/images/12in16bit.tif")
2014-06-10 13:10:47 +04:00
def test_32bit_float(self):
# Issue 614, specific 32-bit float format
2019-06-13 18:54:11 +03:00
path = "Tests/images/10ct_32bit_128.tiff"
2014-06-10 13:10:47 +04:00
im = Image.open(path)
im.load()
self.assertEqual(im.getpixel((0, 0)), -0.4526388943195343)
2019-06-13 18:54:11 +03:00
self.assertEqual(im.getextrema(), (-3.140936851501465, 3.140684127807617))
2014-06-10 13:10:47 +04:00
2019-01-04 04:29:23 +03:00
def test_unknown_pixel_mode(self):
self.assertRaises(
2019-06-13 18:54:11 +03:00
IOError, Image.open, "Tests/images/hopper_unknown_pixel_mode.tif"
)
2019-01-04 04:29:23 +03:00
2015-06-07 18:01:34 +03:00
def test_n_frames(self):
for path, n_frames in [
2019-06-13 18:54:11 +03:00
["Tests/images/multipage-lastframe.tif", 1],
["Tests/images/multipage.tiff", 3],
]:
im = Image.open(path)
self.assertEqual(im.n_frames, n_frames)
self.assertEqual(im.is_animated, n_frames != 1)
2015-06-07 18:01:34 +03:00
def test_eoferror(self):
2019-06-13 18:54:11 +03:00
im = Image.open("Tests/images/multipage-lastframe.tif")
n_frames = im.n_frames
2017-09-06 06:19:33 +03:00
# Test seeking past the last frame
self.assertRaises(EOFError, im.seek, n_frames)
self.assertLess(im.tell(), n_frames)
# Test that seeking to the last frame does not raise an error
2019-06-13 18:54:11 +03:00
im.seek(n_frames - 1)
2015-06-07 18:01:34 +03:00
2014-08-21 08:43:46 +04:00
def test_multipage(self):
# issue #862
2019-06-13 18:54:11 +03:00
im = Image.open("Tests/images/multipage.tiff")
2014-10-02 11:45:41 +04:00
# file is a multipage tiff: 10x10 green, 10x10 red, 20x20 blue
2014-08-21 08:43:46 +04:00
im.seek(0)
2014-10-26 12:24:57 +03:00
self.assertEqual(im.size, (10, 10))
2019-06-13 18:54:11 +03:00
self.assertEqual(im.convert("RGB").getpixel((0, 0)), (0, 128, 0))
2014-08-21 08:43:46 +04:00
im.seek(1)
im.load()
2014-10-26 12:24:57 +03:00
self.assertEqual(im.size, (10, 10))
2019-06-13 18:54:11 +03:00
self.assertEqual(im.convert("RGB").getpixel((0, 0)), (255, 0, 0))
2014-08-21 08:43:46 +04:00
im.seek(0)
im.load()
self.assertEqual(im.size, (10, 10))
2019-06-13 18:54:11 +03:00
self.assertEqual(im.convert("RGB").getpixel((0, 0)), (0, 128, 0))
2014-08-21 08:43:46 +04:00
im.seek(2)
im.load()
2014-10-26 12:24:57 +03:00
self.assertEqual(im.size, (20, 20))
2019-06-13 18:54:11 +03:00
self.assertEqual(im.convert("RGB").getpixel((0, 0)), (0, 0, 255))
2014-08-21 08:43:46 +04:00
def test_multipage_last_frame(self):
2019-06-13 18:54:11 +03:00
im = Image.open("Tests/images/multipage-lastframe.tif")
2014-08-21 08:43:46 +04:00
im.load()
2014-10-26 12:24:57 +03:00
self.assertEqual(im.size, (20, 20))
2019-06-13 18:54:11 +03:00
self.assertEqual(im.convert("RGB").getpixel((0, 0)), (0, 0, 255))
2014-08-21 08:43:46 +04:00
2014-07-27 23:18:42 +04:00
def test___str__(self):
filename = "Tests/images/pil136.tiff"
im = Image.open(filename)
2014-07-27 23:18:42 +04:00
# Act
ret = str(im.ifd)
# Assert
self.assertIsInstance(ret, str)
def test_dict(self):
# Arrange
filename = "Tests/images/pil136.tiff"
im = Image.open(filename)
2015-09-11 20:09:14 +03:00
# v2 interface
2019-06-13 18:54:11 +03:00
v2_tags = {
256: 55,
257: 43,
258: (8, 8, 8, 8),
259: 1,
262: 2,
296: 2,
273: (8,),
338: (1,),
277: 4,
279: (9460,),
282: 72.0,
283: 72.0,
284: 1,
}
self.assertEqual(dict(im.tag_v2), v2_tags)
2015-12-10 01:35:35 +03:00
2015-09-11 20:09:14 +03:00
# legacy interface
2019-06-13 18:54:11 +03:00
legacy_tags = {
256: (55,),
257: (43,),
258: (8, 8, 8, 8),
259: (1,),
262: (2,),
296: (2,),
273: (8,),
338: (1,),
277: (4,),
279: (9460,),
282: ((720000, 10000),),
283: ((720000, 10000),),
284: (1,),
}
self.assertEqual(dict(im.tag), legacy_tags)
2014-07-27 23:18:42 +04:00
def test__delitem__(self):
filename = "Tests/images/pil136.tiff"
im = Image.open(filename)
len_before = len(dict(im.ifd))
2014-07-27 23:18:42 +04:00
del im.ifd[256]
len_after = len(dict(im.ifd))
2014-07-27 23:18:42 +04:00
self.assertEqual(len_before, len_after + 1)
def test_load_byte(self):
for legacy_api in [False, True]:
2015-09-11 20:09:14 +03:00
ifd = TiffImagePlugin.ImageFileDirectory_v2()
data = b"abc"
ret = ifd.load_byte(data, legacy_api)
self.assertEqual(ret, b"abc")
2014-07-27 23:18:42 +04:00
def test_load_string(self):
2015-09-11 20:09:14 +03:00
ifd = TiffImagePlugin.ImageFileDirectory_v2()
2014-07-27 23:18:42 +04:00
data = b"abc\0"
ret = ifd.load_string(data, False)
2014-07-27 23:18:42 +04:00
self.assertEqual(ret, "abc")
def test_load_float(self):
2015-09-11 20:09:14 +03:00
ifd = TiffImagePlugin.ImageFileDirectory_v2()
2014-07-27 23:18:42 +04:00
data = b"abcdabcd"
ret = ifd.load_float(data, False)
2019-06-13 18:54:11 +03:00
self.assertEqual(ret, (1.6777999408082104e22, 1.6777999408082104e22))
2014-07-27 23:18:42 +04:00
def test_load_double(self):
2015-09-11 20:09:14 +03:00
ifd = TiffImagePlugin.ImageFileDirectory_v2()
2014-07-27 23:18:42 +04:00
data = b"abcdefghabcdefgh"
ret = ifd.load_double(data, False)
2019-06-13 18:54:11 +03:00
self.assertEqual(ret, (8.540883223036124e194, 8.540883223036124e194))
2014-07-27 23:18:42 +04:00
def test_seek(self):
filename = "Tests/images/pil136.tiff"
im = Image.open(filename)
im.seek(0)
2014-07-27 23:18:42 +04:00
self.assertEqual(im.tell(), 0)
def test_seek_eof(self):
filename = "Tests/images/pil136.tiff"
im = Image.open(filename)
2014-07-27 23:18:42 +04:00
self.assertEqual(im.tell(), 0)
self.assertRaises(EOFError, im.seek, -1)
2017-09-01 14:05:40 +03:00
self.assertRaises(EOFError, im.seek, 1)
2014-07-27 23:18:42 +04:00
def test__limit_rational_int(self):
from PIL.TiffImagePlugin import _limit_rational
2019-06-13 18:54:11 +03:00
2014-07-27 23:18:42 +04:00
value = 34
ret = _limit_rational(value, 65536)
2014-07-27 23:18:42 +04:00
self.assertEqual(ret, (34, 1))
def test__limit_rational_float(self):
from PIL.TiffImagePlugin import _limit_rational
2019-06-13 18:54:11 +03:00
2014-07-27 23:18:42 +04:00
value = 22.3
ret = _limit_rational(value, 65536)
self.assertEqual(ret, (223, 10))
2014-07-27 23:18:42 +04:00
def test_4bit(self):
test_file = "Tests/images/hopper_gray_4bpp.tif"
2014-10-02 11:45:41 +04:00
original = hopper("L")
im = Image.open(test_file)
self.assertEqual(im.size, (128, 128))
self.assertEqual(im.mode, "L")
2014-10-02 11:45:41 +04:00
self.assert_image_similar(im, original, 7.3)
def test_gray_semibyte_per_pixel(self):
test_files = (
(
2016-04-21 23:13:10 +03:00
24.8, # epsilon
( # group
"Tests/images/tiff_gray_2_4_bpp/hopper2.tif",
"Tests/images/tiff_gray_2_4_bpp/hopper2I.tif",
"Tests/images/tiff_gray_2_4_bpp/hopper2R.tif",
"Tests/images/tiff_gray_2_4_bpp/hopper2IR.tif",
2019-06-13 18:54:11 +03:00
),
),
(
2016-04-21 23:13:10 +03:00
7.3, # epsilon
( # group
"Tests/images/tiff_gray_2_4_bpp/hopper4.tif",
"Tests/images/tiff_gray_2_4_bpp/hopper4I.tif",
"Tests/images/tiff_gray_2_4_bpp/hopper4R.tif",
"Tests/images/tiff_gray_2_4_bpp/hopper4IR.tif",
2019-06-13 18:54:11 +03:00
),
),
)
original = hopper("L")
for epsilon, group in test_files:
im = Image.open(group[0])
self.assertEqual(im.size, (128, 128))
self.assertEqual(im.mode, "L")
self.assert_image_similar(im, original, epsilon)
for file in group[1:]:
im2 = Image.open(file)
self.assertEqual(im2.size, (128, 128))
self.assertEqual(im2.mode, "L")
self.assert_image_equal(im, im2)
2014-12-28 17:30:12 +03:00
def test_with_underscores(self):
2019-06-13 18:54:11 +03:00
kwargs = {"resolution_unit": "inch", "x_resolution": 72, "y_resolution": 36}
2014-12-28 17:30:12 +03:00
filename = self.tempfile("temp.tif")
hopper("RGB").save(filename, **kwargs)
im = Image.open(filename)
2015-09-11 20:09:14 +03:00
# legacy interface
self.assertEqual(im.tag[X_RESOLUTION][0][0], 72)
self.assertEqual(im.tag[Y_RESOLUTION][0][0], 36)
# v2 interface
self.assertEqual(im.tag_v2[X_RESOLUTION], 72)
self.assertEqual(im.tag_v2[Y_RESOLUTION], 36)
2014-12-28 17:30:12 +03:00
def test_roundtrip_tiff_uint16(self):
# Test an image of all '0' values
pixel_value = 0x1234
2016-06-25 16:50:40 +03:00
infile = "Tests/images/uint16_1_4660.tif"
im = Image.open(infile)
self.assertEqual(im.getpixel((0, 0)), pixel_value)
tmpfile = self.tempfile("temp.tif")
im.save(tmpfile)
2016-09-03 05:23:42 +03:00
reloaded = Image.open(tmpfile)
2016-09-03 05:23:42 +03:00
self.assert_image_equal(im, reloaded)
2016-09-03 05:23:42 +03:00
2018-07-17 07:10:57 +03:00
def test_strip_raw(self):
infile = "Tests/images/tiff_strip_raw.tif"
im = Image.open(infile)
2019-06-13 18:54:11 +03:00
self.assert_image_equal_tofile(im, "Tests/images/tiff_adobe_deflate.png")
2018-07-17 07:10:57 +03:00
def test_strip_planar_raw(self):
2018-10-24 22:24:03 +03:00
# gdal_translate -of GTiff -co INTERLEAVE=BAND \
# tiff_strip_raw.tif tiff_strip_planar_raw.tiff
infile = "Tests/images/tiff_strip_planar_raw.tif"
im = Image.open(infile)
2019-06-13 18:54:11 +03:00
self.assert_image_equal_tofile(im, "Tests/images/tiff_adobe_deflate.png")
def test_strip_planar_raw_with_overviews(self):
# gdaladdo tiff_strip_planar_raw2.tif 2 4 8 16
infile = "Tests/images/tiff_strip_planar_raw_with_overviews.tif"
im = Image.open(infile)
2019-06-13 18:54:11 +03:00
self.assert_image_equal_tofile(im, "Tests/images/tiff_adobe_deflate.png")
def test_tiled_planar_raw(self):
2018-10-24 22:24:03 +03:00
# gdal_translate -of GTiff -co TILED=YES -co BLOCKXSIZE=32 \
# -co BLOCKYSIZE=32 -co INTERLEAVE=BAND \
# tiff_tiled_raw.tif tiff_tiled_planar_raw.tiff
infile = "Tests/images/tiff_tiled_planar_raw.tif"
2018-07-17 07:10:57 +03:00
im = Image.open(infile)
2019-06-13 18:54:11 +03:00
self.assert_image_equal_tofile(im, "Tests/images/tiff_adobe_deflate.png")
2018-07-17 07:10:57 +03:00
def test_palette(self):
for mode in ["P", "PA"]:
outfile = self.tempfile("temp.tif")
im = hopper(mode)
im.save(outfile)
reloaded = Image.open(outfile)
self.assert_image_equal(im.convert("RGB"), reloaded.convert("RGB"))
2016-09-29 04:16:04 +03:00
def test_tiff_save_all(self):
import io
import os
mp = io.BytesIO()
with Image.open("Tests/images/multipage.tiff") as im:
im.save(mp, format="tiff", save_all=True)
mp.seek(0, os.SEEK_SET)
with Image.open(mp) as im:
self.assertEqual(im.n_frames, 3)
2016-04-21 23:10:08 +03:00
# Test appending images
mp = io.BytesIO()
2019-06-13 18:54:11 +03:00
im = Image.new("RGB", (100, 100), "#f00")
ims = [Image.new("RGB", (100, 100), color) for color in ["#0f0", "#00f"]]
im.copy().save(mp, format="TIFF", save_all=True, append_images=ims)
mp.seek(0, os.SEEK_SET)
reread = Image.open(mp)
self.assertEqual(reread.n_frames, 3)
# Test appending using a generator
def imGenerator(ims):
for im in ims:
yield im
2019-06-13 18:54:11 +03:00
mp = io.BytesIO()
2019-06-13 18:54:11 +03:00
im.save(mp, format="TIFF", save_all=True, append_images=imGenerator(ims))
mp.seek(0, os.SEEK_SET)
reread = Image.open(mp)
self.assertEqual(reread.n_frames, 3)
def test_saving_icc_profile(self):
# Tests saving TIFF with icc_profile set.
# At the time of writing this will only work for non-compressed tiffs
2017-05-27 23:55:14 +03:00
# as libtiff does not support embedded ICC profiles,
# ImageFile._save(..) however does.
2019-06-13 18:54:11 +03:00
im = Image.new("RGB", (1, 1))
im.info["icc_profile"] = "Dummy value"
# Try save-load round trip to make sure both handle icc_profile.
2019-06-13 18:54:11 +03:00
tmpfile = self.tempfile("temp.tif")
im.save(tmpfile, "TIFF", compression="raw")
reloaded = Image.open(tmpfile)
2019-06-13 18:54:11 +03:00
self.assertEqual(b"Dummy value", reloaded.info["icc_profile"])
2017-04-04 10:27:20 +03:00
def test_close_on_load_exclusive(self):
# similar to test_fd_leak, but runs on unixlike os
2017-01-02 23:56:19 +03:00
tmpfile = self.tempfile("temp.tif")
with Image.open("Tests/images/uint16_1_4660.tif") as im:
im.save(tmpfile)
im = Image.open(tmpfile)
fp = im.fp
self.assertFalse(fp.closed)
im.load()
self.assertTrue(fp.closed)
2017-04-04 10:27:20 +03:00
def test_close_on_load_nonexclusive(self):
tmpfile = self.tempfile("temp.tif")
2017-04-04 10:27:20 +03:00
with Image.open("Tests/images/uint16_1_4660.tif") as im:
im.save(tmpfile)
2019-06-13 18:54:11 +03:00
with open(tmpfile, "rb") as f:
im = Image.open(f)
fp = im.fp
self.assertFalse(fp.closed)
im.load()
self.assertFalse(fp.closed)
2017-04-04 10:27:20 +03:00
2019-06-30 06:25:12 +03:00
@unittest.skipUnless(features.check("libtiff"), "libtiff not installed")
2019-06-30 02:09:53 +03:00
def test_sampleformat_not_corrupted(self):
# Assert that a TIFF image with SampleFormat=UINT tag is not corrupted
# when saving to a new file.
# Pillow 6.0 fails with "OSError: cannot identify image file".
import base64
2019-06-30 06:11:05 +03:00
2019-06-30 02:09:53 +03:00
tiff = BytesIO(
base64.b64decode(
2019-06-30 06:11:05 +03:00
b"SUkqAAgAAAAPAP4ABAABAAAAAAAAAAABBAABAAAAAQAAAAEBBAABAAAAAQAA"
b"AAIBAwADAAAAwgAAAAMBAwABAAAACAAAAAYBAwABAAAAAgAAABEBBAABAAAA"
b"4AAAABUBAwABAAAAAwAAABYBBAABAAAAAQAAABcBBAABAAAACwAAABoBBQAB"
b"AAAAyAAAABsBBQABAAAA0AAAABwBAwABAAAAAQAAACgBAwABAAAAAQAAAFMB"
b"AwADAAAA2AAAAAAAAAAIAAgACAABAAAAAQAAAAEAAAABAAAAAQABAAEAAAB4"
b"nGNgYAAAAAMAAQ=="
2019-06-30 02:09:53 +03:00
)
)
out = BytesIO()
with Image.open(tiff) as im:
2019-06-30 06:11:05 +03:00
im.save(out, format="tiff")
2019-06-30 02:09:53 +03:00
out.seek(0)
with Image.open(out) as im:
im.load()
2018-03-03 12:54:00 +03:00
2019-06-13 18:54:11 +03:00
@unittest.skipUnless(sys.platform.startswith("win32"), "Windows only")
class TestFileTiffW32(PillowTestCase):
def test_fd_leak(self):
tmpfile = self.tempfile("temp.tif")
import os
# this is an mmaped file.
with Image.open("Tests/images/uint16_1_4660.tif") as im:
im.save(tmpfile)
im = Image.open(tmpfile)
2017-01-02 23:56:19 +03:00
fp = im.fp
self.assertFalse(fp.closed)
self.assertRaises(WindowsError, os.remove, tmpfile)
im.load()
2017-01-02 23:56:19 +03:00
self.assertTrue(fp.closed)
# this closes the mmap
im.close()
# this should not fail, as load should have closed the file pointer,
# and close should have closed the mmap
os.remove(tmpfile)