mirror of
https://github.com/python-pillow/Pillow.git
synced 2024-11-11 04:07:21 +03:00
d50445ff30
Similar to the recent adoption of Black. isort is a Python utility to sort imports alphabetically and automatically separate into sections. By using isort, contributors can quickly and automatically conform to the projects style without thinking. Just let the tool do it. Uses the configuration recommended by the Black to avoid conflicts of style. Rewrite TestImageQt.test_deprecated to no rely on import order.
257 lines
9.3 KiB
Python
257 lines
9.3 KiB
Python
import io
|
|
import struct
|
|
|
|
from PIL import Image, TiffImagePlugin, TiffTags
|
|
from PIL.TiffImagePlugin import IFDRational, _limit_rational
|
|
|
|
from .helper import PillowTestCase, hopper
|
|
|
|
tag_ids = {info.name: info.value for info in TiffTags.TAGS_V2.values()}
|
|
|
|
|
|
class TestFileTiffMetadata(PillowTestCase):
|
|
def test_rt_metadata(self):
|
|
""" Test writing arbitrary metadata into the tiff image directory
|
|
Use case is ImageJ private tags, one numeric, one arbitrary
|
|
data. https://github.com/python-pillow/Pillow/issues/291
|
|
"""
|
|
|
|
img = hopper()
|
|
|
|
# Behaviour change: re #1416
|
|
# Pre ifd rewrite, ImageJMetaData was being written as a string(2),
|
|
# Post ifd rewrite, it's defined as arbitrary bytes(7). It should
|
|
# roundtrip with the actual bytes, rather than stripped text
|
|
# of the premerge tests.
|
|
#
|
|
# For text items, we still have to decode('ascii','replace') because
|
|
# the tiff file format can't take 8 bit bytes in that field.
|
|
|
|
basetextdata = "This is some arbitrary metadata for a text field"
|
|
bindata = basetextdata.encode("ascii") + b" \xff"
|
|
textdata = basetextdata + " " + chr(255)
|
|
reloaded_textdata = basetextdata + " ?"
|
|
floatdata = 12.345
|
|
doubledata = 67.89
|
|
info = TiffImagePlugin.ImageFileDirectory()
|
|
|
|
ImageJMetaData = tag_ids["ImageJMetaData"]
|
|
ImageJMetaDataByteCounts = tag_ids["ImageJMetaDataByteCounts"]
|
|
ImageDescription = tag_ids["ImageDescription"]
|
|
|
|
info[ImageJMetaDataByteCounts] = len(bindata)
|
|
info[ImageJMetaData] = bindata
|
|
info[tag_ids["RollAngle"]] = floatdata
|
|
info.tagtype[tag_ids["RollAngle"]] = 11
|
|
info[tag_ids["YawAngle"]] = doubledata
|
|
info.tagtype[tag_ids["YawAngle"]] = 12
|
|
|
|
info[ImageDescription] = textdata
|
|
|
|
f = self.tempfile("temp.tif")
|
|
|
|
img.save(f, tiffinfo=info)
|
|
|
|
loaded = Image.open(f)
|
|
|
|
self.assertEqual(loaded.tag[ImageJMetaDataByteCounts], (len(bindata),))
|
|
self.assertEqual(loaded.tag_v2[ImageJMetaDataByteCounts], (len(bindata),))
|
|
|
|
self.assertEqual(loaded.tag[ImageJMetaData], bindata)
|
|
self.assertEqual(loaded.tag_v2[ImageJMetaData], bindata)
|
|
|
|
self.assertEqual(loaded.tag[ImageDescription], (reloaded_textdata,))
|
|
self.assertEqual(loaded.tag_v2[ImageDescription], reloaded_textdata)
|
|
|
|
loaded_float = loaded.tag[tag_ids["RollAngle"]][0]
|
|
self.assertAlmostEqual(loaded_float, floatdata, places=5)
|
|
loaded_double = loaded.tag[tag_ids["YawAngle"]][0]
|
|
self.assertAlmostEqual(loaded_double, doubledata)
|
|
|
|
# check with 2 element ImageJMetaDataByteCounts, issue #2006
|
|
|
|
info[ImageJMetaDataByteCounts] = (8, len(bindata) - 8)
|
|
img.save(f, tiffinfo=info)
|
|
loaded = Image.open(f)
|
|
|
|
self.assertEqual(loaded.tag[ImageJMetaDataByteCounts], (8, len(bindata) - 8))
|
|
self.assertEqual(loaded.tag_v2[ImageJMetaDataByteCounts], (8, len(bindata) - 8))
|
|
|
|
def test_read_metadata(self):
|
|
img = Image.open("Tests/images/hopper_g4.tif")
|
|
|
|
self.assertEqual(
|
|
{
|
|
"YResolution": IFDRational(4294967295, 113653537),
|
|
"PlanarConfiguration": 1,
|
|
"BitsPerSample": (1,),
|
|
"ImageLength": 128,
|
|
"Compression": 4,
|
|
"FillOrder": 1,
|
|
"RowsPerStrip": 128,
|
|
"ResolutionUnit": 3,
|
|
"PhotometricInterpretation": 0,
|
|
"PageNumber": (0, 1),
|
|
"XResolution": IFDRational(4294967295, 113653537),
|
|
"ImageWidth": 128,
|
|
"Orientation": 1,
|
|
"StripByteCounts": (1968,),
|
|
"SamplesPerPixel": 1,
|
|
"StripOffsets": (8,),
|
|
},
|
|
img.tag_v2.named(),
|
|
)
|
|
|
|
self.assertEqual(
|
|
{
|
|
"YResolution": ((4294967295, 113653537),),
|
|
"PlanarConfiguration": (1,),
|
|
"BitsPerSample": (1,),
|
|
"ImageLength": (128,),
|
|
"Compression": (4,),
|
|
"FillOrder": (1,),
|
|
"RowsPerStrip": (128,),
|
|
"ResolutionUnit": (3,),
|
|
"PhotometricInterpretation": (0,),
|
|
"PageNumber": (0, 1),
|
|
"XResolution": ((4294967295, 113653537),),
|
|
"ImageWidth": (128,),
|
|
"Orientation": (1,),
|
|
"StripByteCounts": (1968,),
|
|
"SamplesPerPixel": (1,),
|
|
"StripOffsets": (8,),
|
|
},
|
|
img.tag.named(),
|
|
)
|
|
|
|
def test_write_metadata(self):
|
|
""" Test metadata writing through the python code """
|
|
img = Image.open("Tests/images/hopper.tif")
|
|
|
|
f = self.tempfile("temp.tiff")
|
|
img.save(f, tiffinfo=img.tag)
|
|
|
|
loaded = Image.open(f)
|
|
|
|
original = img.tag_v2.named()
|
|
reloaded = loaded.tag_v2.named()
|
|
|
|
for k, v in original.items():
|
|
if isinstance(v, IFDRational):
|
|
original[k] = IFDRational(*_limit_rational(v, 2 ** 31))
|
|
elif isinstance(v, tuple) and isinstance(v[0], IFDRational):
|
|
original[k] = tuple(
|
|
IFDRational(*_limit_rational(elt, 2 ** 31)) for elt in v
|
|
)
|
|
|
|
ignored = ["StripByteCounts", "RowsPerStrip", "PageNumber", "StripOffsets"]
|
|
|
|
for tag, value in reloaded.items():
|
|
if tag in ignored:
|
|
continue
|
|
if isinstance(original[tag], tuple) and isinstance(
|
|
original[tag][0], IFDRational
|
|
):
|
|
# Need to compare element by element in the tuple,
|
|
# not comparing tuples of object references
|
|
self.assert_deep_equal(
|
|
original[tag],
|
|
value,
|
|
"%s didn't roundtrip, %s, %s" % (tag, original[tag], value),
|
|
)
|
|
else:
|
|
self.assertEqual(
|
|
original[tag],
|
|
value,
|
|
"%s didn't roundtrip, %s, %s" % (tag, original[tag], value),
|
|
)
|
|
|
|
for tag, value in original.items():
|
|
if tag not in ignored:
|
|
self.assertEqual(value, reloaded[tag], "%s didn't roundtrip" % tag)
|
|
|
|
def test_no_duplicate_50741_tag(self):
|
|
self.assertEqual(tag_ids["MakerNoteSafety"], 50741)
|
|
self.assertEqual(tag_ids["BestQualityScale"], 50780)
|
|
|
|
def test_empty_metadata(self):
|
|
f = io.BytesIO(b"II*\x00\x08\x00\x00\x00")
|
|
head = f.read(8)
|
|
info = TiffImagePlugin.ImageFileDirectory(head)
|
|
# Should not raise struct.error.
|
|
self.assert_warning(UserWarning, info.load, f)
|
|
|
|
def test_iccprofile(self):
|
|
# https://github.com/python-pillow/Pillow/issues/1462
|
|
im = Image.open("Tests/images/hopper.iccprofile.tif")
|
|
out = self.tempfile("temp.tiff")
|
|
|
|
im.save(out)
|
|
reloaded = Image.open(out)
|
|
self.assertNotIsInstance(im.info["icc_profile"], tuple)
|
|
self.assertEqual(im.info["icc_profile"], reloaded.info["icc_profile"])
|
|
|
|
def test_iccprofile_binary(self):
|
|
# https://github.com/python-pillow/Pillow/issues/1526
|
|
# We should be able to load this,
|
|
# but probably won't be able to save it.
|
|
|
|
im = Image.open("Tests/images/hopper.iccprofile_binary.tif")
|
|
self.assertEqual(im.tag_v2.tagtype[34675], 1)
|
|
self.assertTrue(im.info["icc_profile"])
|
|
|
|
def test_iccprofile_save_png(self):
|
|
im = Image.open("Tests/images/hopper.iccprofile.tif")
|
|
outfile = self.tempfile("temp.png")
|
|
im.save(outfile)
|
|
|
|
def test_iccprofile_binary_save_png(self):
|
|
im = Image.open("Tests/images/hopper.iccprofile_binary.tif")
|
|
outfile = self.tempfile("temp.png")
|
|
im.save(outfile)
|
|
|
|
def test_exif_div_zero(self):
|
|
im = hopper()
|
|
info = TiffImagePlugin.ImageFileDirectory_v2()
|
|
info[41988] = TiffImagePlugin.IFDRational(0, 0)
|
|
|
|
out = self.tempfile("temp.tiff")
|
|
im.save(out, tiffinfo=info, compression="raw")
|
|
|
|
reloaded = Image.open(out)
|
|
self.assertEqual(0, reloaded.tag_v2[41988].numerator)
|
|
self.assertEqual(0, reloaded.tag_v2[41988].denominator)
|
|
|
|
def test_expty_values(self):
|
|
data = io.BytesIO(
|
|
b"II*\x00\x08\x00\x00\x00\x03\x00\x1a\x01\x05\x00\x00\x00\x00\x00"
|
|
b"\x00\x00\x00\x00\x1b\x01\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00"
|
|
b"\x98\x82\x02\x00\x07\x00\x00\x002\x00\x00\x00\x00\x00\x00\x00a "
|
|
b"text\x00\x00"
|
|
)
|
|
head = data.read(8)
|
|
info = TiffImagePlugin.ImageFileDirectory_v2(head)
|
|
info.load(data)
|
|
# Should not raise ValueError.
|
|
info = dict(info)
|
|
self.assertIn(33432, info)
|
|
|
|
def test_PhotoshopInfo(self):
|
|
im = Image.open("Tests/images/issue_2278.tif")
|
|
|
|
self.assertIsInstance(im.tag_v2[34377], bytes)
|
|
out = self.tempfile("temp.tiff")
|
|
im.save(out)
|
|
reloaded = Image.open(out)
|
|
self.assertIsInstance(reloaded.tag_v2[34377], bytes)
|
|
|
|
def test_too_many_entries(self):
|
|
ifd = TiffImagePlugin.ImageFileDirectory_v2()
|
|
|
|
# 277: ("SamplesPerPixel", SHORT, 1),
|
|
ifd._tagdata[277] = struct.pack("hh", 4, 4)
|
|
ifd.tagtype[277] = TiffTags.SHORT
|
|
|
|
# Should not raise ValueError.
|
|
self.assert_warning(UserWarning, lambda: ifd[277])
|