img2pdf/src/img2pdf_test.py

5100 lines
196 KiB
Python
Raw Normal View History

2020-06-05 23:18:39 +00:00
#!/usr/bin/env python3
import sys
import numpy
import scipy.signal
import zlib
import struct
import subprocess
import pytest
import re
import pikepdf
import hashlib
import img2pdf
import os
from io import BytesIO
from PIL import Image
import decimal
from packaging.version import parse as parse_version
import warnings
import json
HAVE_MUTOOL = True
try:
ver = subprocess.check_output(["mutool", "-v"], stderr=subprocess.STDOUT)
m = re.fullmatch(r"mutool version ([0-9.]+)\n", ver.decode("utf8"))
if m is None:
HAVE_MUTOOL = False
else:
if parse_version(m.group(1)) < parse_version("1.10.0"):
HAVE_MUTOOL = False
except FileNotFoundError:
HAVE_MUTOOL = False
2020-06-05 23:18:39 +00:00
if not HAVE_MUTOOL:
warnings.warn("mutool >= 1.10.0 not available, skipping checks...")
2020-06-05 23:18:39 +00:00
HAVE_PDFIMAGES_CMYK = True
try:
ver = subprocess.check_output(["pdfimages", "-v"], stderr=subprocess.STDOUT)
m = re.fullmatch(r"pdfimages version ([0-9.]+)", ver.split(b"\n")[0].decode("utf8"))
if m is None:
HAVE_PDFIMAGES_CMYK = False
else:
if parse_version(m.group(1)) < parse_version("0.42.0"):
HAVE_PDFIMAGES_CMYK = False
except FileNotFoundError:
HAVE_PDFIMAGES_CMYK = False
if not HAVE_PDFIMAGES_CMYK:
warnings.warn("pdfimages >= 0.42.0 not available, skipping CMYK checks...")
HAVE_IMAGEMAGICK_MODERN = True
try:
ver = subprocess.check_output(["convert", "-version"], stderr=subprocess.STDOUT)
m = re.fullmatch(
r"Version: ImageMagick ([0-9.]+-[0-9]+) .*", ver.split(b"\n")[0].decode("utf8")
)
if m is None:
HAVE_IMAGEMAGICK_MODERN = False
else:
if parse_version(m.group(1)) < parse_version("6.9.10-12"):
HAVE_IMAGEMAGICK_MODERN = False
except FileNotFoundError:
HAVE_IMAGEMAGICK_MODERN = False
except subprocess.CalledProcessError:
HAVE_IMAGEMAGICK_MODERN = False
if not HAVE_IMAGEMAGICK_MODERN:
warnings.warn("imagemagick >= 6.9.10-12 not available, skipping certain checks...")
2020-06-05 23:18:39 +00:00
###############################################################################
# HELPER FUNCTIONS #
###############################################################################
def find_closest_palette_color(color, palette):
if color.ndim == 0:
idx = (numpy.abs(palette - color)).argmin()
else:
# naive distance function by computing the euclidean distance in RGB space
idx = ((palette - color) ** 2).sum(axis=-1).argmin()
return palette[idx]
def floyd_steinberg(img, palette):
result = numpy.array(img, copy=True)
for y in range(result.shape[0]):
for x in range(result.shape[1]):
oldpixel = result[y, x]
newpixel = find_closest_palette_color(oldpixel, palette)
quant_error = oldpixel - newpixel
result[y, x] = newpixel
if x + 1 < result.shape[1]:
result[y, x + 1] += quant_error * 7 / 16
if y + 1 < result.shape[0]:
result[y + 1, x - 1] += quant_error * 3 / 16
result[y + 1, x] += quant_error * 5 / 16
if x + 1 < result.shape[1] and y + 1 < result.shape[0]:
result[y + 1, x + 1] += quant_error * 1 / 16
return result
def convolve_rgba(img, kernel):
return numpy.stack(
(
scipy.signal.convolve2d(img[:, :, 0], kernel, "same"),
scipy.signal.convolve2d(img[:, :, 1], kernel, "same"),
scipy.signal.convolve2d(img[:, :, 2], kernel, "same"),
scipy.signal.convolve2d(img[:, :, 3], kernel, "same"),
),
axis=-1,
)
def rgb2gray(img):
result = numpy.zeros((60, 60), dtype=numpy.dtype("int64"))
count = 0
for y in range(img.shape[0]):
for x in range(img.shape[1]):
clin = sum(img[y, x] * [0.2126, 0.7152, 0.0722]) / 0xFFFF
if clin <= 0.0031308:
csrgb = 12.92 * clin
else:
csrgb = 1.055 * clin ** (1 / 2.4) - 0.055
result[y, x] = csrgb * 0xFFFF
count += 1
# if count == 24:
# raise Exception(result[y, x])
return result
def palettize(img, pal):
result = numpy.zeros((img.shape[0], img.shape[1]), dtype=numpy.dtype("int64"))
for y in range(img.shape[0]):
for x in range(img.shape[1]):
for i, col in enumerate(pal):
if numpy.array_equal(img[y, x], col):
result[y, x] = i
break
else:
raise Exception()
return result
# we cannot use zlib.compress() because different compressors may compress the
# same data differently, for example by using different optimizations on
# different architectures:
# https://lists.fedoraproject.org/archives/list/devel@lists.fedoraproject.org/thread/R7GD4L5Z6HELCDAL2RDESWR2F3ZXHWVX/
#
# to make the compressed representation of the uncompressed data bit-by-bit
# identical on all platforms we make use of the compression method 0, that is,
# no compression at all :)
def compress(data):
# two-byte zlib header (rfc1950)
# common header for lowest compression level
# bits 0-3: Compression info, base-2 logarithm of the LZ77 window size,
# minus eight -- 7 indicates a 32K window size
# bits 4-7: Compression method -- 8 is deflate
# bits 8-9: Compression level -- 0 is fastest
# bit 10: preset dictionary -- 0 is none
# bits 11-15: check bits so that the 16-bit unsigned integer stored in MSB
# order is a multiple of 31
result = b"\x78\x01"
# content is stored in deflate format (rfc1951)
# maximum chunk size is the largest 16 bit unsigned integer
chunksize = 0xFFFF
for i in range(0, len(data), chunksize):
# bits 0-4 are unused
# bits 5-6 indicate compression method -- 0 is no compression
# bit 7 indicates the last chunk
if i * chunksize < len(data) - chunksize:
result += b"\x00"
else:
# last chunck
result += b"\x01"
chunk = data[i : i + chunksize]
# the chunk length as little endian 16 bit unsigned integer
result += struct.pack("<H", len(chunk))
# the one's complement of the chunk length
# one's complement is all bits inverted which is the result of
# xor with 0xffff for a 16 bit unsigned integer
result += struct.pack("<H", len(chunk) ^ 0xFFFF)
result += chunk
# adler32 checksum of the uncompressed data as big endian 32 bit unsigned
# integer
result += struct.pack(">I", zlib.adler32(data))
return result
def write_png(data, path, bitdepth, colortype, palette=None):
with open(str(path), "wb") as f:
2020-06-05 23:18:39 +00:00
f.write(b"\x89PNG\r\n\x1A\n")
# PNG image type Colour type Allowed bit depths
# Greyscale 0 1, 2, 4, 8, 16
# Truecolour 2 8, 16
# Indexed-colour 3 1, 2, 4, 8
# Greyscale with alpha 4 8, 16
# Truecolour with alpha 6 8, 16
block = b"IHDR" + struct.pack(
">IIBBBBB",
data.shape[1], # width
data.shape[0], # height
bitdepth, # bitdepth
colortype, # colortype
0, # compression
0, # filtertype
0, # interlaced
)
f.write(
struct.pack(">I", len(block) - 4)
+ block
+ struct.pack(">I", zlib.crc32(block))
)
if palette is not None:
block = b"PLTE"
for col in palette:
block += struct.pack(">BBB", col[0], col[1], col[2])
f.write(
struct.pack(">I", len(block) - 4)
+ block
+ struct.pack(">I", zlib.crc32(block))
)
raw = b""
for y in range(data.shape[0]):
raw += b"\0"
if bitdepth == 16:
raw += data[y].astype(">u2").tobytes()
elif bitdepth == 8:
raw += data[y].astype(">u1").tobytes()
elif bitdepth in [4, 2, 1]:
valsperbyte = 8 // bitdepth
for x in range(0, data.shape[1], valsperbyte):
val = 0
for j in range(valsperbyte):
if x + j >= data.shape[1]:
break
val |= (data[y, x + j].astype(">u2") & (2 ** bitdepth - 1)) << (
(valsperbyte - j - 1) * bitdepth
)
raw += struct.pack(">B", val)
else:
raise Exception()
compressed = compress(raw)
block = b"IDAT" + compressed
f.write(
struct.pack(">I", len(compressed))
+ block
+ struct.pack(">I", zlib.crc32(block))
)
block = b"IEND"
f.write(struct.pack(">I", 0) + block + struct.pack(">I", zlib.crc32(block)))
def compare_ghostscript(tmpdir, img, pdf, gsdevice="png16m", exact=True):
if gsdevice in ["png16m", "pnggray"]:
ext = "png"
elif gsdevice in ["tiff24nc", "tiff32nc", "tiff48nc"]:
ext = "tiff"
else:
raise Exception("unknown gsdevice: " + gsdevice)
subprocess.check_call(
[
"gs",
"-dQUIET",
"-dNOPAUSE",
"-dBATCH",
"-sDEVICE=" + gsdevice,
"-r96",
"-sOutputFile=" + str(tmpdir / "gs-") + "%00d." + ext,
str(pdf),
]
)
if exact:
subprocess.check_call(
["compare", "-metric", "AE", str(img), str(tmpdir / "gs-1.") + ext, "null:"]
)
else:
psnr = subprocess.run(
[
"compare",
"-metric",
"PSNR",
str(img),
str(tmpdir / "gs-1.") + ext,
"null:",
],
check=False,
stderr=subprocess.PIPE,
).stderr
assert psnr != b"0"
2020-06-05 23:18:39 +00:00
psnr = float(psnr.strip(b"0"))
assert psnr != 0 # or otherwise we would use the exact variant
assert psnr > 50
(tmpdir / ("gs-1." + ext)).unlink()
def compare_poppler(tmpdir, img, pdf, exact=True):
subprocess.check_call(
["pdftocairo", "-r", "96", "-png", str(pdf), str(tmpdir / "poppler")]
)
if exact:
subprocess.check_call(
[
"compare",
"-metric",
"AE",
str(img),
str(tmpdir / "poppler-1.png"),
"null:",
]
)
else:
psnr = subprocess.run(
[
"compare",
"-metric",
"PSNR",
str(img),
str(tmpdir / "poppler-1.png"),
"null:",
],
check=False,
stderr=subprocess.PIPE,
).stderr
assert psnr != b"0"
2020-06-05 23:18:39 +00:00
psnr = float(psnr.strip(b"0"))
assert psnr != 0 # or otherwise we would use the exact variant
assert psnr > 50
(tmpdir / "poppler-1.png").unlink()
def compare_mupdf(tmpdir, img, pdf, exact=True, cmyk=False):
if not HAVE_MUTOOL:
return
2020-06-05 23:18:39 +00:00
if cmyk:
out = tmpdir / "mupdf.pam"
subprocess.check_call(
["mutool", "draw", "-r", "96", "-c", "cmyk", "-o", str(out), str(pdf)]
)
else:
out = tmpdir / "mupdf.png"
subprocess.check_call(
["mutool", "draw", "-r", "96", "-png", "-o", str(out), str(pdf)]
)
if exact:
if cmyk:
raise Exception("cmyk cannot be exact")
subprocess.check_call(["compare", "-metric", "AE", str(img), str(out), "null:"])
else:
psnr = subprocess.run(
["compare", "-metric", "PSNR", str(img), str(out), "null:"],
check=False,
stderr=subprocess.PIPE,
).stderr
assert psnr != b"0"
2020-06-05 23:18:39 +00:00
psnr = float(psnr.strip(b"0"))
assert psnr != 0 # or otherwise we would use the exact variant
assert psnr > 50
out.unlink()
def compare_pdfimages_jpg(tmpdir, img, pdf):
subprocess.check_call(["pdfimages", "-j", str(pdf), str(tmpdir / "images")])
assert img.read_bytes() == (tmpdir / "images-000.jpg").read_bytes()
(tmpdir / "images-000.jpg").unlink()
def compare_pdfimages_cmyk(tmpdir, img, pdf):
if not HAVE_PDFIMAGES_CMYK:
return
subprocess.check_call(["pdfimages", "-j", str(pdf), str(tmpdir / "images")])
assert img.read_bytes() == (tmpdir / "images-000.jpg").read_bytes()
(tmpdir / "images-000.jpg").unlink()
2020-06-05 23:18:39 +00:00
def compare_pdfimages_jp2(tmpdir, img, pdf):
subprocess.check_call(["pdfimages", "-jp2", str(pdf), str(tmpdir / "images")])
assert img.read_bytes() == (tmpdir / "images-000.jp2").read_bytes()
(tmpdir / "images-000.jp2").unlink()
def compare_pdfimages_tiff(tmpdir, img, pdf):
subprocess.check_call(["pdfimages", "-tiff", str(pdf), str(tmpdir / "images")])
subprocess.check_call(
["compare", "-metric", "AE", str(img), str(tmpdir / "images-000.tif"), "null:"]
)
(tmpdir / "images-000.tif").unlink()
def compare_pdfimages_png(tmpdir, img, pdf, exact=True):
subprocess.check_call(["pdfimages", "-png", str(pdf), str(tmpdir / "images")])
if exact:
subprocess.check_call(
[
"compare",
"-metric",
"AE",
str(img),
str(tmpdir / "images-000.png"),
"null:",
]
)
else:
psnr = subprocess.run(
[
"compare",
"-metric",
"PSNR",
str(img),
str(tmpdir / "images-000.png"),
"null:",
],
check=False,
stderr=subprocess.PIPE,
).stderr
assert psnr != b"0"
2020-06-05 23:18:39 +00:00
psnr = float(psnr.strip(b"0"))
assert psnr != 0 # or otherwise we would use the exact variant
assert psnr > 50
(tmpdir / "images-000.png").unlink()
def tiff_header_for_ccitt(width, height, img_size, ccitt_group=4):
# Quick and dirty TIFF header builder from
# https://stackoverflow.com/questions/2641770
tiff_header_struct = "<" + "2s" + "h" + "l" + "h" + "hhll" * 8 + "h"
return struct.pack(
# fmt: off
tiff_header_struct,
b'II', # Byte order indication: Little indian
42, # Version number (always 42)
8, # Offset to first IFD
8, # Number of tags in IFD
256, 4, 1, width, # ImageWidth, LONG, 1, width
257, 4, 1, height, # ImageLength, LONG, 1, lenght
258, 3, 1, 1, # BitsPerSample, SHORT, 1, 1
259, 3, 1, ccitt_group, # Compression, SHORT, 1, 4 = CCITT Group 4
262, 3, 1, 1, # Threshholding, SHORT, 1, 0 = WhiteIsZero
273, 4, 1, struct.calcsize(
tiff_header_struct), # StripOffsets, LONG, 1, len of header
278, 4, 1, height, # RowsPerStrip, LONG, 1, lenght
279, 4, 1, img_size, # StripByteCounts, LONG, 1, size of image
0
# last IFD
# fmt: on
)
###############################################################################
# INPUT FIXTURES #
###############################################################################
@pytest.fixture(scope="session")
def alpha():
# gaussian kernel with sigma=3
kernel = numpy.array(
[
[0.011362, 0.014962, 0.017649, 0.018648, 0.017649, 0.014962, 0.011362],
[0.014962, 0.019703, 0.02324, 0.024556, 0.02324, 0.019703, 0.014962],
[0.017649, 0.02324, 0.027413, 0.028964, 0.027413, 0.02324, 0.017649],
[0.018648, 0.024556, 0.028964, 0.030603, 0.028964, 0.024556, 0.018648],
[0.017649, 0.02324, 0.027413, 0.028964, 0.027413, 0.02324, 0.017649],
[0.014962, 0.019703, 0.02324, 0.024556, 0.02324, 0.019703, 0.014962],
[0.011362, 0.014962, 0.017649, 0.018648, 0.017649, 0.014962, 0.011362],
],
numpy.float,
)
# constructs a 2D array of a circle with a width of 36
circle = list()
offsets_36 = [14, 11, 9, 7, 6, 5, 4, 3, 3, 2, 2, 1, 1, 1, 0, 0, 0, 0]
for offs in offsets_36 + offsets_36[::-1]:
circle.append([0] * offs + [1] * (len(offsets_36) - offs) * 2 + [0] * offs)
alpha = numpy.zeros((60, 60, 4), dtype=numpy.dtype("int64"))
# draw three circles
for (xpos, ypos, color) in [
(12, 3, [0xFFFF, 0, 0, 0xFFFF]),
(21, 21, [0, 0xFFFF, 0, 0xFFFF]),
(3, 21, [0, 0, 0xFFFF, 0xFFFF]),
]:
for x, row in enumerate(circle):
for y, pos in enumerate(row):
if pos:
alpha[y + ypos, x + xpos] += color
alpha = numpy.clip(alpha, 0, 0xFFFF)
alpha = convolve_rgba(alpha, kernel)
return alpha
@pytest.fixture(scope="session")
def tmp_alpha_png(tmp_path_factory, alpha):
tmp_alpha_png = tmp_path_factory.mktemp("alpha_png") / "alpha.png"
write_png(alpha, str(tmp_alpha_png), 16, 6)
assert (
hashlib.md5(tmp_alpha_png.read_bytes()).hexdigest()
== "cc611e80cde3b9b7adb7723801a4e5d4"
)
yield tmp_alpha_png
tmp_alpha_png.unlink()
@pytest.fixture(scope="session")
def tmp_gray1_png(tmp_path_factory, alpha):
normal16 = alpha[:, :, 0:3]
gray16 = rgb2gray(normal16)
tmp_gray1_png = tmp_path_factory.mktemp("gray1_png") / "gray1.png"
write_png(
floyd_steinberg(gray16, numpy.arange(2) / 0x1 * 0xFFFF) / 0xFFFF * 0x1,
str(tmp_gray1_png),
1,
0,
)
assert (
hashlib.md5(tmp_gray1_png.read_bytes()).hexdigest()
== "ff4d9f18de39be879926be2e65990167"
)
yield tmp_gray1_png
tmp_gray1_png.unlink()
@pytest.fixture(scope="session")
def tmp_gray2_png(tmp_path_factory, alpha):
normal16 = alpha[:, :, 0:3]
gray16 = rgb2gray(normal16)
tmp_gray2_png = tmp_path_factory.mktemp("gray2_png") / "gray2.png"
write_png(
floyd_steinberg(gray16, numpy.arange(4) / 0x3 * 0xFFFF) / 0xFFFF * 0x3,
str(tmp_gray2_png),
2,
0,
)
assert (
hashlib.md5(tmp_gray2_png.read_bytes()).hexdigest()
== "d51900476658a1c9dd26a7b27db8a21f"
)
yield tmp_gray2_png
tmp_gray2_png.unlink()
@pytest.fixture(scope="session")
def tmp_gray4_png(tmp_path_factory, alpha):
normal16 = alpha[:, :, 0:3]
gray16 = rgb2gray(normal16)
tmp_gray4_png = tmp_path_factory.mktemp("gray4_png") / "gray4.png"
write_png(
floyd_steinberg(gray16, numpy.arange(16) / 0xF * 0xFFFF) / 0xFFFF * 0xF,
str(tmp_gray4_png),
4,
0,
)
assert (
hashlib.md5(tmp_gray4_png.read_bytes()).hexdigest()
== "722223ba74be9cba1af4a549076b70d3"
)
yield tmp_gray4_png
tmp_gray4_png.unlink()
@pytest.fixture(scope="session")
def tmp_gray8_png(tmp_path_factory, alpha):
normal16 = alpha[:, :, 0:3]
gray16 = rgb2gray(normal16)
tmp_gray8_png = tmp_path_factory.mktemp("gray8_png") / "gray8.png"
write_png(gray16 / 0xFFFF * 0xFF, tmp_gray8_png, 8, 0)
assert (
hashlib.md5(tmp_gray8_png.read_bytes()).hexdigest()
== "2320216faa5a10bf0f5f04ebce07f8e1"
)
yield tmp_gray8_png
tmp_gray8_png.unlink()
@pytest.fixture(scope="session")
def tmp_gray16_png(tmp_path_factory, alpha):
normal16 = alpha[:, :, 0:3]
gray16 = rgb2gray(normal16)
tmp_gray16_png = tmp_path_factory.mktemp("gray16_png") / "gray16.png"
write_png(gray16, str(tmp_gray16_png), 16, 0)
assert (
hashlib.md5(tmp_gray16_png.read_bytes()).hexdigest()
== "706175887af8ca1a33cfd93449f970df"
)
yield tmp_gray16_png
tmp_gray16_png.unlink()
@pytest.fixture(scope="session")
def tmp_inverse_png(tmp_path_factory, alpha):
normal16 = alpha[:, :, 0:3]
tmp_inverse_png = tmp_path_factory.mktemp("inverse_png") / "inverse.png"
write_png(0xFF - normal16 / 0xFFFF * 0xFF, str(tmp_inverse_png), 8, 2)
assert (
hashlib.md5(tmp_inverse_png.read_bytes()).hexdigest()
== "35a47d6ae6de8c9d0b31aa0cda8648f3"
)
yield tmp_inverse_png
tmp_inverse_png.unlink()
@pytest.fixture(scope="session")
def tmp_normal16_png(tmp_path_factory, alpha):
normal16 = alpha[:, :, 0:3]
tmp_normal16_png = tmp_path_factory.mktemp("normal16_png") / "normal16.png"
write_png(normal16, str(tmp_normal16_png), 16, 2)
assert (
hashlib.md5(tmp_normal16_png.read_bytes()).hexdigest()
== "6ad810399058a87d8145d8d9a7734da5"
)
yield tmp_normal16_png
tmp_normal16_png.unlink()
@pytest.fixture(scope="session")
def tmp_normal_png(tmp_path_factory, alpha):
normal16 = alpha[:, :, 0:3]
tmp_normal_png = tmp_path_factory.mktemp("normal_png") / "normal.png"
write_png(normal16 / 0xFFFF * 0xFF, str(tmp_normal_png), 8, 2)
assert (
hashlib.md5(tmp_normal_png.read_bytes()).hexdigest()
== "c8d2e1f116f31ecdeae050524efca7b6"
)
yield tmp_normal_png
tmp_normal_png.unlink()
@pytest.fixture(scope="session")
def tmp_palette1_png(tmp_path_factory, alpha):
normal16 = alpha[:, :, 0:3]
tmp_palette1_png = tmp_path_factory.mktemp("palette1_png") / "palette1.png"
# don't choose black and white or otherwise imagemagick will classify the
# image as bilevel with 8/1-bit depth instead of palette with 8-bit color
# don't choose gray colors or otherwise imagemagick will classify the
# image as grayscale
pal1 = numpy.array(
[[0x01, 0x02, 0x03], [0xFE, 0xFD, 0xFC]], dtype=numpy.dtype("int64")
)
write_png(
palettize(
floyd_steinberg(normal16, pal1 * 0xFFFF / 0xFF) / 0xFFFF * 0xFF, pal1
),
str(tmp_palette1_png),
1,
3,
pal1,
)
assert (
hashlib.md5(tmp_palette1_png.read_bytes()).hexdigest()
== "18a3dfca369f976996ef93389ddfad61"
)
yield tmp_palette1_png
tmp_palette1_png.unlink()
@pytest.fixture(scope="session")
def tmp_palette2_png(tmp_path_factory, alpha):
normal16 = alpha[:, :, 0:3]
tmp_palette2_png = tmp_path_factory.mktemp("palette2_png") / "palette2.png"
# choose values slightly off red, lime and blue because otherwise
# imagemagick will classify the image as Depth: 8/1-bit
pal2 = numpy.array(
[[0, 0, 0], [0xFE, 0, 0], [0, 0xFE, 0], [0, 0, 0xFE]],
dtype=numpy.dtype("int64"),
)
write_png(
palettize(
floyd_steinberg(normal16, pal2 * 0xFFFF / 0xFF) / 0xFFFF * 0xFF, pal2
),
str(tmp_palette2_png),
2,
3,
pal2,
)
assert (
hashlib.md5(tmp_palette2_png.read_bytes()).hexdigest()
== "d38646afa6fa0714be9badef25ff9392"
)
yield tmp_palette2_png
tmp_palette2_png.unlink()
@pytest.fixture(scope="session")
def tmp_palette4_png(tmp_path_factory, alpha):
normal16 = alpha[:, :, 0:3]
tmp_palette4_png = tmp_path_factory.mktemp("palette4_png") / "palette4.png"
# windows 16 color palette
pal4 = numpy.array(
[
[0x00, 0x00, 0x00],
[0x80, 0x00, 0x00],
[0x00, 0x80, 0x00],
[0x80, 0x80, 0x00],
[0x00, 0x00, 0x80],
[0x80, 0x00, 0x80],
[0x00, 0x80, 0x80],
[0xC0, 0xC0, 0xC0],
[0x80, 0x80, 0x80],
[0xFF, 0x00, 0x00],
[0x00, 0xFF, 0x00],
[0xFF, 0x00, 0x00],
[0x00, 0xFF, 0x00],
[0xFF, 0x00, 0xFF],
[0x00, 0xFF, 0x00],
[0xFF, 0xFF, 0xFF],
],
dtype=numpy.dtype("int64"),
)
write_png(
palettize(
floyd_steinberg(normal16, pal4 * 0xFFFF / 0xFF) / 0xFFFF * 0xFF, pal4
),
str(tmp_palette4_png),
4,
3,
pal4,
)
assert (
hashlib.md5(tmp_palette4_png.read_bytes()).hexdigest()
== "e1c59e68a68fca3273b6dc164d526ed7"
)
yield tmp_palette4_png
tmp_palette4_png.unlink()
@pytest.fixture(scope="session")
def tmp_palette8_png(tmp_path_factory, alpha):
normal16 = alpha[:, :, 0:3]
tmp_palette8_png = tmp_path_factory.mktemp("palette8_png") / "palette8.png"
# create a 256 color palette by first writing 16 shades of gray
# and then writing an array of RGB colors with 6, 8 and 5 levels
# for red, green and blue, respectively
pal8 = numpy.zeros((256, 3), dtype=numpy.dtype("int64"))
i = 0
for gray in range(15, 255, 15):
pal8[i] = [gray, gray, gray]
i += 1
for red in 0, 0x33, 0x66, 0x99, 0xCC, 0xFF:
for green in 0, 0x24, 0x49, 0x6D, 0x92, 0xB6, 0xDB, 0xFF:
for blue in 0, 0x40, 0x80, 0xBF, 0xFF:
pal8[i] = [red, green, blue]
i += 1
assert i == 256
write_png(
palettize(
floyd_steinberg(normal16, pal8 * 0xFFFF / 0xFF) / 0xFFFF * 0xFF, pal8
),
str(tmp_palette8_png),
8,
3,
pal8,
)
assert (
hashlib.md5(tmp_palette8_png.read_bytes()).hexdigest()
== "50bf09eb3571901f0bf642b9a733038c"
)
yield tmp_palette8_png
tmp_palette8_png.unlink()
@pytest.fixture(scope="session")
def jpg_img(tmp_path_factory, tmp_normal_png):
in_img = tmp_path_factory.mktemp("jpg") / "in.jpg"
subprocess.check_call(["convert", str(tmp_normal_png), str(in_img)])
identify = subprocess.check_output(["identify", "-verbose", str(in_img)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Format: JPEG \(Joint Photographic Experts Group JFIF format\)$",
r"^ Mime type: image/jpeg$",
r"^ Geometry: 60x60\+0\+0$",
r"^ Colorspace: sRGB$",
r"^ Type: TrueColor$",
r"^ Depth: 8-bit$",
r"^ Page geometry: 60x60\+0\+0$",
r"^ Compression: JPEG$",
]
for e in expected:
assert re.search(e, identify.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
2020-06-05 23:18:39 +00:00
yield in_img
in_img.unlink()
@pytest.fixture(scope="session")
def jpg_rot_img(tmp_path_factory, tmp_normal_png):
in_img = tmp_path_factory.mktemp("jpg_rot") / "in.jpg"
subprocess.check_call(["convert", str(tmp_normal_png), str(in_img)])
subprocess.check_call(
["exiftool", "-overwrite_original", "-all=", str(in_img), "-n"]
)
subprocess.check_call(
[
"exiftool",
"-overwrite_original",
"-Orientation=6",
"-XResolution=96",
"-YResolution=96",
"-n",
str(in_img),
]
)
identify = subprocess.check_output(["identify", "-verbose", str(in_img)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Format: JPEG \(Joint Photographic Experts Group JFIF format\)$",
r"^ Mime type: image/jpeg$",
r"^ Geometry: 60x60\+0\+0$",
r"^ Resolution: 96x96$",
r"^ Units: PixelsPerInch$",
r"^ Colorspace: sRGB$",
r"^ Type: TrueColor$",
r"^ Depth: 8-bit$",
r"^ Page geometry: 60x60\+0\+0$",
r"^ Compression: JPEG$",
r"^ Orientation: RightTop$",
]
for e in expected:
assert re.search(e, identify.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
2020-06-05 23:18:39 +00:00
yield in_img
in_img.unlink()
@pytest.fixture(scope="session")
def jpg_cmyk_img(tmp_path_factory, tmp_normal_png):
in_img = tmp_path_factory.mktemp("jpg_cmyk") / "in.jpg"
subprocess.check_call(
["convert", str(tmp_normal_png), "-colorspace", "cmyk", str(in_img)]
)
identify = subprocess.check_output(["identify", "-verbose", str(in_img)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Format: JPEG \(Joint Photographic Experts Group JFIF format\)$",
r"^ Mime type: image/jpeg$",
r"^ Geometry: 60x60\+0\+0$",
r"^ Colorspace: CMYK$",
r"^ Type: ColorSeparation$",
r"^ Depth: 8-bit$",
r"^ Page geometry: 60x60\+0\+0$",
r"^ Compression: JPEG$",
]
for e in expected:
assert re.search(e, identify.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
2020-06-05 23:18:39 +00:00
yield in_img
in_img.unlink()
@pytest.fixture(scope="session")
def jpg_2000_img(tmp_path_factory, tmp_normal_png):
in_img = tmp_path_factory.mktemp("jpg_2000") / "in.jp2"
subprocess.check_call(["convert", str(tmp_normal_png), str(in_img)])
identify = subprocess.check_output(["identify", "-verbose", str(in_img)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Format: JP2 \(JPEG-2000 File Format Syntax\)$",
r"^ Mime type: image/jp2$",
r"^ Geometry: 60x60\+0\+0$",
r"^ Colorspace: sRGB$",
r"^ Type: TrueColor$",
r"^ Depth: 8-bit$",
r"^ Page geometry: 60x60\+0\+0$",
r"^ Compression: JPEG2000$",
]
for e in expected:
assert re.search(e, identify.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
2020-06-05 23:18:39 +00:00
yield in_img
in_img.unlink()
@pytest.fixture(scope="session")
def png_rgb8_img(tmp_normal_png):
in_img = tmp_normal_png
identify = subprocess.check_output(["identify", "-verbose", str(in_img)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Format: PNG \(Portable Network Graphics\)$",
r"^ Mime type: image/png$",
r"^ Geometry: 60x60\+0\+0$",
r"^ Colorspace: sRGB$",
r"^ Type: TrueColor$",
r"^ Depth: 8-bit$",
r"^ Page geometry: 60x60\+0\+0$",
r"^ Compression: Zip$",
r"^ png:IHDR.bit-depth-orig: 8$",
r"^ png:IHDR.bit_depth: 8$",
r"^ png:IHDR.color-type-orig: 2$",
r"^ png:IHDR.color_type: 2 \(Truecolor\)$",
r"^ png:IHDR.interlace_method: 0 \(Not interlaced\)$",
]
for e in expected:
assert re.search(e, identify.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
2020-06-05 23:18:39 +00:00
return in_img
@pytest.fixture(scope="session")
def png_rgb16_img(tmp_normal16_png):
in_img = tmp_normal16_png
identify = subprocess.check_output(["identify", "-verbose", str(in_img)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Format: PNG \(Portable Network Graphics\)$",
r"^ Mime type: image/png$",
r"^ Geometry: 60x60\+0\+0$",
r"^ Colorspace: sRGB$",
r"^ Type: TrueColor$",
r"^ Depth: 16-bit$",
r"^ Page geometry: 60x60\+0\+0$",
r"^ Compression: Zip$",
r"^ png:IHDR.bit-depth-orig: 16$",
r"^ png:IHDR.bit_depth: 16$",
r"^ png:IHDR.color-type-orig: 2$",
r"^ png:IHDR.color_type: 2 \(Truecolor\)$",
r"^ png:IHDR.interlace_method: 0 \(Not interlaced\)$",
]
for e in expected:
assert re.search(e, identify.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
2020-06-05 23:18:39 +00:00
return in_img
@pytest.fixture(scope="session")
def png_rgba8_img(tmp_path_factory, tmp_alpha_png):
in_img = tmp_path_factory.mktemp("png_rgba8") / "in.png"
subprocess.check_call(
["convert", str(tmp_alpha_png), "-depth", "8", "-strip", str(in_img)]
)
identify = subprocess.check_output(["identify", "-verbose", str(in_img)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Format: PNG \(Portable Network Graphics\)$",
r"^ Mime type: image/png$",
r"^ Geometry: 60x60\+0\+0$",
r"^ Colorspace: sRGB$",
r"^ Type: TrueColorAlpha$",
r"^ Depth: 8-bit$",
r"^ Page geometry: 60x60\+0\+0$",
r"^ Compression: Zip$",
r"^ png:IHDR.bit-depth-orig: 8$",
r"^ png:IHDR.bit_depth: 8$",
r"^ png:IHDR.color-type-orig: 6$",
r"^ png:IHDR.color_type: 6 \(RGBA\)$",
r"^ png:IHDR.interlace_method: 0 \(Not interlaced\)$",
]
for e in expected:
assert re.search(e, identify.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
2020-06-05 23:18:39 +00:00
yield in_img
in_img.unlink()
@pytest.fixture(scope="session")
def png_rgba16_img(tmp_alpha_png):
in_img = tmp_alpha_png
identify = subprocess.check_output(["identify", "-verbose", str(in_img)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Format: PNG \(Portable Network Graphics\)$",
r"^ Mime type: image/png$",
r"^ Geometry: 60x60\+0\+0$",
r"^ Colorspace: sRGB$",
r"^ Type: TrueColorAlpha$",
r"^ Depth: 16-bit$",
r"^ Page geometry: 60x60\+0\+0$",
r"^ Compression: Zip$",
r"^ png:IHDR.bit-depth-orig: 16$",
r"^ png:IHDR.bit_depth: 16$",
r"^ png:IHDR.color-type-orig: 6$",
r"^ png:IHDR.color_type: 6 \(RGBA\)$",
r"^ png:IHDR.interlace_method: 0 \(Not interlaced\)$",
]
for e in expected:
assert re.search(e, identify.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
2020-06-05 23:18:39 +00:00
return in_img
@pytest.fixture(scope="session")
def png_gray8a_img(tmp_path_factory, tmp_alpha_png):
in_img = tmp_path_factory.mktemp("png_gray8a") / "in.png"
subprocess.check_call(
[
"convert",
str(tmp_alpha_png),
"-colorspace",
"Gray",
"-dither",
"FloydSteinberg",
"-colors",
"256",
"-depth",
"8",
"-strip",
str(in_img),
]
)
identify = subprocess.check_output(["identify", "-verbose", str(in_img)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Format: PNG \(Portable Network Graphics\)$",
r"^ Mime type: image/png$",
r"^ Geometry: 60x60\+0\+0$",
r"^ Colorspace: Gray$",
r"^ Type: GrayscaleAlpha$",
r"^ Depth: 8-bit$",
r"^ Page geometry: 60x60\+0\+0$",
r"^ Compression: Zip$",
r"^ png:IHDR.bit-depth-orig: 8$",
r"^ png:IHDR.bit_depth: 8$",
r"^ png:IHDR.color-type-orig: 4$",
r"^ png:IHDR.color_type: 4 \(GrayAlpha\)$",
r"^ png:IHDR.interlace_method: 0 \(Not interlaced\)$",
]
for e in expected:
assert re.search(e, identify.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
2020-06-05 23:18:39 +00:00
yield in_img
in_img.unlink()
@pytest.fixture(scope="session")
def png_gray16a_img(tmp_path_factory, tmp_alpha_png):
in_img = tmp_path_factory.mktemp("png_gray16a") / "in.png"
subprocess.check_call(
[
"convert",
str(tmp_alpha_png),
"-colorspace",
"Gray",
"-depth",
"16",
"-strip",
str(in_img),
]
)
identify = subprocess.check_output(["identify", "-verbose", str(in_img)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Format: PNG \(Portable Network Graphics\)$",
r"^ Mime type: image/png$",
r"^ Geometry: 60x60\+0\+0$",
r"^ Colorspace: Gray$",
r"^ Type: GrayscaleAlpha$",
r"^ Depth: 16-bit$",
r"^ Page geometry: 60x60\+0\+0$",
r"^ Compression: Zip$",
r"^ png:IHDR.bit-depth-orig: 16$",
r"^ png:IHDR.bit_depth: 16$",
r"^ png:IHDR.color-type-orig: 4$",
r"^ png:IHDR.color_type: 4 \(GrayAlpha\)$",
r"^ png:IHDR.interlace_method: 0 \(Not interlaced\)$",
]
for e in expected:
assert re.search(e, identify.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
2020-06-05 23:18:39 +00:00
yield in_img
in_img.unlink()
@pytest.fixture(scope="session")
def png_interlaced_img(tmp_path_factory, tmp_normal_png):
in_img = tmp_path_factory.mktemp("png_interlaced") / "in.png"
subprocess.check_call(
["convert", str(tmp_normal_png), "-interlace", "PNG", "-strip", str(in_img)]
)
identify = subprocess.check_output(["identify", "-verbose", str(in_img)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Format: PNG \(Portable Network Graphics\)$",
r"^ Mime type: image/png$",
r"^ Geometry: 60x60\+0\+0$",
r"^ Colorspace: sRGB$",
r"^ Type: TrueColor$",
r"^ Depth: 8-bit$",
r"^ Page geometry: 60x60\+0\+0$",
r"^ Compression: Zip$",
r"^ png:IHDR.bit-depth-orig: 8$",
r"^ png:IHDR.bit_depth: 8$",
r"^ png:IHDR.color-type-orig: 2$",
r"^ png:IHDR.color_type: 2 \(Truecolor\)$",
r"^ png:IHDR.interlace_method: 1 \(Adam7 method\)$",
]
for e in expected:
assert re.search(e, identify.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
2020-06-05 23:18:39 +00:00
yield in_img
in_img.unlink()
@pytest.fixture(scope="session")
def png_gray1_img(tmp_path_factory, tmp_gray1_png):
identify = subprocess.check_output(["identify", "-verbose", str(tmp_gray1_png)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Format: PNG \(Portable Network Graphics\)$",
r"^ Mime type: image/png$",
r"^ Geometry: 60x60\+0\+0$",
r"^ Colorspace: Gray$",
r"^ Type: Bilevel$",
r"^ Depth: 8/1-bit$",
r"^ Page geometry: 60x60\+0\+0$",
r"^ Compression: Zip$",
r"^ png:IHDR.bit-depth-orig: 1$",
r"^ png:IHDR.bit_depth: 1$",
r"^ png:IHDR.color-type-orig: 0$",
r"^ png:IHDR.color_type: 0 \(Grayscale\)$",
r"^ png:IHDR.interlace_method: 0 \(Not interlaced\)$",
]
for e in expected:
assert re.search(e, identify.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
2020-06-05 23:18:39 +00:00
return tmp_gray1_png
@pytest.fixture(scope="session")
def png_gray2_img(tmp_path_factory, tmp_gray2_png):
identify = subprocess.check_output(["identify", "-verbose", str(tmp_gray2_png)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Format: PNG \(Portable Network Graphics\)$",
r"^ Mime type: image/png$",
r"^ Geometry: 60x60\+0\+0$",
r"^ Colorspace: Gray$",
r"^ Type: Grayscale$",
r"^ Depth: 8/2-bit$",
r"^ Page geometry: 60x60\+0\+0$",
r"^ Compression: Zip$",
r"^ png:IHDR.bit-depth-orig: 2$",
r"^ png:IHDR.bit_depth: 2$",
r"^ png:IHDR.color-type-orig: 0$",
r"^ png:IHDR.color_type: 0 \(Grayscale\)$",
r"^ png:IHDR.interlace_method: 0 \(Not interlaced\)$",
]
for e in expected:
assert re.search(e, identify.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
2020-06-05 23:18:39 +00:00
return tmp_gray2_png
@pytest.fixture(scope="session")
def png_gray4_img(tmp_path_factory, tmp_gray4_png):
identify = subprocess.check_output(["identify", "-verbose", str(tmp_gray4_png)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Format: PNG \(Portable Network Graphics\)$",
r"^ Mime type: image/png$",
r"^ Geometry: 60x60\+0\+0$",
r"^ Colorspace: Gray$",
r"^ Type: Grayscale$",
r"^ Depth: 8/4-bit$",
r"^ Page geometry: 60x60\+0\+0$",
r"^ Compression: Zip$",
r"^ png:IHDR.bit-depth-orig: 4$",
r"^ png:IHDR.bit_depth: 4$",
r"^ png:IHDR.color-type-orig: 0$",
r"^ png:IHDR.color_type: 0 \(Grayscale\)$",
r"^ png:IHDR.interlace_method: 0 \(Not interlaced\)$",
]
for e in expected:
assert re.search(e, identify.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
2020-06-05 23:18:39 +00:00
return tmp_gray4_png
@pytest.fixture(scope="session")
def png_gray8_img(tmp_path_factory, tmp_gray8_png):
identify = subprocess.check_output(["identify", "-verbose", str(tmp_gray8_png)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Format: PNG \(Portable Network Graphics\)$",
r"^ Mime type: image/png$",
r"^ Geometry: 60x60\+0\+0$",
r"^ Colorspace: Gray$",
r"^ Type: Grayscale$",
r"^ Depth: 8-bit$",
r"^ Page geometry: 60x60\+0\+0$",
r"^ Compression: Zip$",
r"^ png:IHDR.bit-depth-orig: 8$",
r"^ png:IHDR.bit_depth: 8$",
r"^ png:IHDR.color-type-orig: 0$",
r"^ png:IHDR.color_type: 0 \(Grayscale\)$",
r"^ png:IHDR.interlace_method: 0 \(Not interlaced\)$",
]
for e in expected:
assert re.search(e, identify.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
2020-06-05 23:18:39 +00:00
return tmp_gray8_png
@pytest.fixture(scope="session")
def png_gray16_img(tmp_path_factory, tmp_gray16_png):
identify = subprocess.check_output(["identify", "-verbose", str(tmp_gray16_png)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Format: PNG \(Portable Network Graphics\)$",
r"^ Mime type: image/png$",
r"^ Geometry: 60x60\+0\+0$",
r"^ Colorspace: Gray$",
r"^ Type: Grayscale$",
r"^ Depth: 16-bit$",
r"^ Page geometry: 60x60\+0\+0$",
r"^ Compression: Zip$",
r"^ png:IHDR.bit-depth-orig: 16$",
r"^ png:IHDR.bit_depth: 16$",
r"^ png:IHDR.color-type-orig: 0$",
r"^ png:IHDR.color_type: 0 \(Grayscale\)$",
r"^ png:IHDR.interlace_method: 0 \(Not interlaced\)$",
]
for e in expected:
assert re.search(e, identify.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
2020-06-05 23:18:39 +00:00
return tmp_gray16_png
@pytest.fixture(scope="session")
def png_palette1_img(tmp_path_factory, tmp_palette1_png):
identify = subprocess.check_output(["identify", "-verbose", str(tmp_palette1_png)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Format: PNG \(Portable Network Graphics\)$",
r"^ Mime type: image/png$",
r"^ Geometry: 60x60\+0\+0$",
r"^ Colorspace: sRGB$",
r"^ Type: Palette$",
r"^ Depth: 8-bit$",
r"^ Page geometry: 60x60\+0\+0$",
r"^ Compression: Zip$",
r"^ png:IHDR.bit-depth-orig: 1$",
r"^ png:IHDR.bit_depth: 1$",
r"^ png:IHDR.color-type-orig: 3$",
r"^ png:IHDR.color_type: 3 \(Indexed\)$",
r"^ png:IHDR.interlace_method: 0 \(Not interlaced\)$",
]
for e in expected:
assert re.search(e, identify.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
2020-06-05 23:18:39 +00:00
return tmp_palette1_png
@pytest.fixture(scope="session")
def png_palette2_img(tmp_path_factory, tmp_palette2_png):
identify = subprocess.check_output(["identify", "-verbose", str(tmp_palette2_png)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Format: PNG \(Portable Network Graphics\)$",
r"^ Mime type: image/png$",
r"^ Geometry: 60x60\+0\+0$",
r"^ Colorspace: sRGB$",
r"^ Type: Palette$",
r"^ Depth: 8-bit$",
r"^ Page geometry: 60x60\+0\+0$",
r"^ Compression: Zip$",
r"^ png:IHDR.bit-depth-orig: 2$",
r"^ png:IHDR.bit_depth: 2$",
r"^ png:IHDR.color-type-orig: 3$",
r"^ png:IHDR.color_type: 3 \(Indexed\)$",
r"^ png:IHDR.interlace_method: 0 \(Not interlaced\)$",
]
for e in expected:
assert re.search(e, identify.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
2020-06-05 23:18:39 +00:00
return tmp_palette2_png
@pytest.fixture(scope="session")
def png_palette4_img(tmp_path_factory, tmp_palette4_png):
identify = subprocess.check_output(["identify", "-verbose", str(tmp_palette4_png)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Format: PNG \(Portable Network Graphics\)$",
r"^ Mime type: image/png$",
r"^ Geometry: 60x60\+0\+0$",
r"^ Colorspace: sRGB$",
r"^ Type: Palette$",
r"^ Depth: 8-bit$",
r"^ Page geometry: 60x60\+0\+0$",
r"^ Compression: Zip$",
r"^ png:IHDR.bit-depth-orig: 4$",
r"^ png:IHDR.bit_depth: 4$",
r"^ png:IHDR.color-type-orig: 3$",
r"^ png:IHDR.color_type: 3 \(Indexed\)$",
r"^ png:IHDR.interlace_method: 0 \(Not interlaced\)$",
]
for e in expected:
assert re.search(e, identify.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
2020-06-05 23:18:39 +00:00
return tmp_palette4_png
@pytest.fixture(scope="session")
def png_palette8_img(tmp_path_factory, tmp_palette8_png):
identify = subprocess.check_output(["identify", "-verbose", str(tmp_palette8_png)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Format: PNG \(Portable Network Graphics\)$",
r"^ Mime type: image/png$",
r"^ Geometry: 60x60\+0\+0$",
r"^ Colorspace: sRGB$",
r"^ Type: Palette$",
r"^ Depth: 8-bit$",
r"^ Page geometry: 60x60\+0\+0$",
r"^ Compression: Zip$",
r"^ png:IHDR.bit-depth-orig: 8$",
r"^ png:IHDR.bit_depth: 8$",
r"^ png:IHDR.color-type-orig: 3$",
r"^ png:IHDR.color_type: 3 \(Indexed\)$",
r"^ png:IHDR.interlace_method: 0 \(Not interlaced\)$",
]
for e in expected:
assert re.search(e, identify.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
2020-06-05 23:18:39 +00:00
return tmp_palette8_png
@pytest.fixture(scope="session")
def gif_transparent_img(tmp_path_factory, tmp_alpha_png):
in_img = tmp_path_factory.mktemp("gif_transparent_img") / "in.gif"
subprocess.check_call(["convert", str(tmp_alpha_png), str(in_img)])
identify = subprocess.check_output(["identify", "-verbose", str(in_img)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Format: GIF \(CompuServe graphics interchange format\)$",
r"^ Mime type: image/gif$",
r"^ Geometry: 60x60\+0\+0$",
r"^ Colorspace: sRGB$",
r"^ Type: PaletteAlpha$",
r"^ Depth: 8-bit$",
r"^ Colormap entries: 256$",
r"^ Page geometry: 60x60\+0\+0$",
r"^ Compression: LZW$",
]
for e in expected:
assert re.search(e, identify.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
2020-06-05 23:18:39 +00:00
yield in_img
in_img.unlink()
@pytest.fixture(scope="session")
def gif_palette1_img(tmp_path_factory, tmp_palette1_png):
in_img = tmp_path_factory.mktemp("gif_palette1_img") / "in.gif"
subprocess.check_call(["convert", str(tmp_palette1_png), str(in_img)])
identify = subprocess.check_output(["identify", "-verbose", str(in_img)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Format: GIF \(CompuServe graphics interchange format\)$",
r"^ Mime type: image/gif$",
r"^ Geometry: 60x60\+0\+0$",
r"^ Colorspace: sRGB$",
r"^ Type: Palette$",
r"^ Depth: 8-bit$",
r"^ Colormap entries: 2$",
r"^ Page geometry: 60x60\+0\+0$",
r"^ Compression: LZW$",
]
for e in expected:
assert re.search(e, identify.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
2020-06-05 23:18:39 +00:00
yield in_img
in_img.unlink()
@pytest.fixture(scope="session")
def gif_palette2_img(tmp_path_factory, tmp_palette2_png):
in_img = tmp_path_factory.mktemp("gif_palette2_img") / "in.gif"
subprocess.check_call(["convert", str(tmp_palette2_png), str(in_img)])
identify = subprocess.check_output(["identify", "-verbose", str(in_img)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Format: GIF \(CompuServe graphics interchange format\)$",
r"^ Mime type: image/gif$",
r"^ Geometry: 60x60\+0\+0$",
r"^ Colorspace: sRGB$",
r"^ Type: Palette$",
r"^ Depth: 8-bit$",
r"^ Colormap entries: 4$",
r"^ Page geometry: 60x60\+0\+0$",
r"^ Compression: LZW$",
]
for e in expected:
assert re.search(e, identify.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
2020-06-05 23:18:39 +00:00
yield in_img
in_img.unlink()
@pytest.fixture(scope="session")
def gif_palette4_img(tmp_path_factory, tmp_palette4_png):
in_img = tmp_path_factory.mktemp("gif_palette4_img") / "in.gif"
subprocess.check_call(["convert", str(tmp_palette4_png), str(in_img)])
identify = subprocess.check_output(["identify", "-verbose", str(in_img)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Format: GIF \(CompuServe graphics interchange format\)$",
r"^ Mime type: image/gif$",
r"^ Geometry: 60x60\+0\+0$",
r"^ Colorspace: sRGB$",
r"^ Type: Palette$",
r"^ Depth: 8-bit$",
r"^ Colormap entries: 16$",
r"^ Page geometry: 60x60\+0\+0$",
r"^ Compression: LZW$",
]
for e in expected:
assert re.search(e, identify.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
2020-06-05 23:18:39 +00:00
yield in_img
in_img.unlink()
@pytest.fixture(scope="session")
def gif_palette8_img(tmp_path_factory, tmp_palette8_png):
in_img = tmp_path_factory.mktemp("gif_palette8_img") / "in.gif"
subprocess.check_call(["convert", str(tmp_palette8_png), str(in_img)])
identify = subprocess.check_output(["identify", "-verbose", str(in_img)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Format: GIF \(CompuServe graphics interchange format\)$",
r"^ Mime type: image/gif$",
r"^ Geometry: 60x60\+0\+0$",
r"^ Colorspace: sRGB$",
r"^ Type: Palette$",
r"^ Depth: 8-bit$",
r"^ Colormap entries: 256$",
r"^ Page geometry: 60x60\+0\+0$",
r"^ Compression: LZW$",
]
for e in expected:
assert re.search(e, identify.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
2020-06-05 23:18:39 +00:00
yield in_img
in_img.unlink()
@pytest.fixture(scope="session")
def gif_animation_img(tmp_path_factory, tmp_normal_png, tmp_inverse_png):
in_img = tmp_path_factory.mktemp("gif_animation_img") / "in.gif"
subprocess.check_call(
["convert", str(tmp_normal_png), str(tmp_inverse_png), "-strip", str(in_img)]
2020-06-05 23:18:39 +00:00
)
identify = subprocess.check_output(["identify", "-verbose", str(in_img) + "[0]"])
expected = [
r"^ Format: GIF \(CompuServe graphics interchange format\)$",
r"^ Mime type: image/gif$",
r"^ Geometry: 60x60\+0\+0$",
r"^ Colorspace: sRGB$",
r"^ Type: Palette$",
r"^ Depth: 8-bit$",
r"^ Colormap entries: 256$",
r"^ Page geometry: 60x60\+0\+0$",
r"^ Compression: LZW$",
]
for e in expected:
assert re.search(e, identify.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
2020-06-05 23:18:39 +00:00
identify = subprocess.check_output(["identify", "-verbose", str(in_img) + "[1]"])
expected = [
r"^ Format: GIF \(CompuServe graphics interchange format\)$",
r"^ Mime type: image/gif$",
r"^ Geometry: 60x60\+0\+0$",
r"^ Colorspace: sRGB$",
r"^ Type: Palette$",
r"^ Depth: 8-bit$",
r"^ Colormap entries: 256$",
r"^ Page geometry: 60x60\+0\+0$",
r"^ Compression: LZW$",
r"^ Scene: 1$",
]
for e in expected:
assert re.search(e, identify.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
2020-06-05 23:18:39 +00:00
yield in_img
in_img.unlink()
@pytest.fixture(scope="session")
def tiff_float_img(tmp_path_factory, tmp_normal_png):
in_img = tmp_path_factory.mktemp("tiff_float_img") / "in.tiff"
subprocess.check_call(
[
"convert",
str(tmp_normal_png),
"-depth",
"32",
"-define",
"quantum:format=floating-point",
str(in_img),
]
)
identify = subprocess.check_output(["identify", "-verbose", str(in_img)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Format: TIFF \(Tagged Image File Format\)$",
r"^ Mime type: image/tiff$",
r"^ Geometry: 60x60\+0\+0$",
r"^ Colorspace: sRGB$",
r"^ Type: TrueColor$",
r"^ Endiann?ess: LSB$",
r"^ Depth: 32/(8|16)-bit$", # imagemagick may produce a Depth: 32/8-bit or 32/16-bit image
r"^ Page geometry: 60x60\+0\+0$",
r"^ Compression: Zip$",
r"^ quantum:format: floating-point$",
r"^ tiff:alpha: unspecified$",
r"^ tiff:endian: lsb$",
r"^ tiff:photometric: RGB$",
]
for e in expected:
assert re.search(e, identify.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
2020-06-05 23:18:39 +00:00
yield in_img
in_img.unlink()
@pytest.fixture(scope="session")
def tiff_cmyk8_img(tmp_path_factory, tmp_normal_png):
in_img = tmp_path_factory.mktemp("tiff_cmyk8") / "in.tiff"
subprocess.check_call(
["convert", str(tmp_normal_png), "-colorspace", "cmyk", str(in_img)]
)
identify = subprocess.check_output(["identify", "-verbose", str(in_img)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Format: TIFF \(Tagged Image File Format\)$",
r"^ Mime type: image/tiff$",
r"^ Geometry: 60x60\+0\+0$",
r"^ Colorspace: CMYK$",
r"^ Type: ColorSeparation$",
r"^ Endiann?ess: LSB$",
r"^ Depth: 8-bit$",
r"^ Page geometry: 60x60\+0\+0$",
r"^ Compression: Zip$",
r"^ tiff:alpha: unspecified$",
r"^ tiff:endian: lsb$",
r"^ tiff:photometric: separated$",
]
for e in expected:
assert re.search(e, identify.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
2020-06-05 23:18:39 +00:00
yield in_img
in_img.unlink()
@pytest.fixture(scope="session")
def tiff_cmyk16_img(tmp_path_factory, tmp_normal_png):
in_img = tmp_path_factory.mktemp("tiff_cmyk16") / "in.tiff"
subprocess.check_call(
[
"convert",
str(tmp_normal_png),
"-depth",
"16",
"-colorspace",
"cmyk",
str(in_img),
]
)
identify = subprocess.check_output(["identify", "-verbose", str(in_img)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Format: TIFF \(Tagged Image File Format\)$",
r"^ Mime type: image/tiff$",
r"^ Geometry: 60x60\+0\+0$",
r"^ Colorspace: CMYK$",
r"^ Type: ColorSeparation$",
r"^ Endiann?ess: LSB$",
r"^ Depth: 16-bit$",
r"^ Page geometry: 60x60\+0\+0$",
r"^ Compression: Zip$",
r"^ tiff:alpha: unspecified$",
r"^ tiff:endian: lsb$",
r"^ tiff:photometric: separated$",
]
for e in expected:
assert re.search(e, identify.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
2020-06-05 23:18:39 +00:00
yield in_img
in_img.unlink()
@pytest.fixture(scope="session")
def tiff_rgb8_img(tmp_path_factory, tmp_normal_png):
in_img = tmp_path_factory.mktemp("tiff_rgb8") / "in.tiff"
subprocess.check_call(["convert", str(tmp_normal_png), str(in_img)])
identify = subprocess.check_output(["identify", "-verbose", str(in_img)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Format: TIFF \(Tagged Image File Format\)$",
r"^ Mime type: image/tiff$",
r"^ Geometry: 60x60\+0\+0$",
r"^ Colorspace: sRGB$",
r"^ Type: TrueColor$",
r"^ Endiann?ess: LSB$",
r"^ Depth: 8-bit$",
r"^ Page geometry: 60x60\+0\+0$",
r"^ Compression: Zip$",
r"^ tiff:alpha: unspecified$",
r"^ tiff:endian: lsb$",
r"^ tiff:photometric: RGB$",
]
for e in expected:
assert re.search(e, identify.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
2020-06-05 23:18:39 +00:00
yield in_img
in_img.unlink()
@pytest.fixture(scope="session")
def tiff_rgb12_img(tmp_path_factory, tmp_normal16_png):
in_img = tmp_path_factory.mktemp("tiff_rgb8") / "in.tiff"
subprocess.check_call(
["convert", str(tmp_normal16_png), "-depth", "12", str(in_img)]
)
identify = subprocess.check_output(["identify", "-verbose", str(in_img)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Format: TIFF \(Tagged Image File Format\)$",
r"^ Mime type: image/tiff$",
r"^ Geometry: 60x60\+0\+0$",
r"^ Colorspace: sRGB$",
r"^ Type: TrueColor$",
r"^ Endiann?ess: LSB$",
r"^ Depth: 12(/16)?-bit$",
r"^ Page geometry: 60x60\+0\+0$",
r"^ Compression: Zip$",
r"^ tiff:alpha: unspecified$",
r"^ tiff:endian: lsb$",
r"^ tiff:photometric: RGB$",
]
for e in expected:
assert re.search(e, identify.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
2020-06-05 23:18:39 +00:00
yield in_img
in_img.unlink()
@pytest.fixture(scope="session")
def tiff_rgb14_img(tmp_path_factory, tmp_normal16_png):
in_img = tmp_path_factory.mktemp("tiff_rgb8") / "in.tiff"
subprocess.check_call(
["convert", str(tmp_normal16_png), "-depth", "14", str(in_img)]
)
identify = subprocess.check_output(["identify", "-verbose", str(in_img)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Format: TIFF \(Tagged Image File Format\)$",
r"^ Mime type: image/tiff$",
r"^ Geometry: 60x60\+0\+0$",
r"^ Colorspace: sRGB$",
r"^ Type: TrueColor$",
r"^ Endiann?ess: LSB$",
r"^ Depth: 14(/16)?-bit$",
r"^ Page geometry: 60x60\+0\+0$",
r"^ Compression: Zip$",
r"^ tiff:alpha: unspecified$",
r"^ tiff:endian: lsb$",
r"^ tiff:photometric: RGB$",
]
for e in expected:
assert re.search(e, identify.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
2020-06-05 23:18:39 +00:00
yield in_img
in_img.unlink()
@pytest.fixture(scope="session")
def tiff_rgb16_img(tmp_path_factory, tmp_normal16_png):
in_img = tmp_path_factory.mktemp("tiff_rgb8") / "in.tiff"
subprocess.check_call(
["convert", str(tmp_normal16_png), "-depth", "16", str(in_img)]
)
identify = subprocess.check_output(["identify", "-verbose", str(in_img)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Format: TIFF \(Tagged Image File Format\)$",
r"^ Mime type: image/tiff$",
r"^ Geometry: 60x60\+0\+0$",
r"^ Colorspace: sRGB$",
r"^ Type: TrueColor$",
r"^ Endiann?ess: LSB$",
r"^ Depth: 16-bit$",
r"^ Page geometry: 60x60\+0\+0$",
r"^ Compression: Zip$",
r"^ tiff:alpha: unspecified$",
r"^ tiff:endian: lsb$",
r"^ tiff:photometric: RGB$",
]
for e in expected:
assert re.search(e, identify.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
2020-06-05 23:18:39 +00:00
yield in_img
in_img.unlink()
@pytest.fixture(scope="session")
def tiff_rgba8_img(tmp_path_factory, tmp_alpha_png):
in_img = tmp_path_factory.mktemp("tiff_rgba8") / "in.tiff"
subprocess.check_call(
["convert", str(tmp_alpha_png), "-depth", "8", "-strip", str(in_img)]
)
identify = subprocess.check_output(["identify", "-verbose", str(in_img)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Format: TIFF \(Tagged Image File Format\)$",
r"^ Mime type: image/tiff$",
r"^ Geometry: 60x60\+0\+0$",
r"^ Colorspace: sRGB$",
r"^ Type: TrueColorAlpha$",
r"^ Endiann?ess: LSB$",
r"^ Depth: 8-bit$",
r"^ Page geometry: 60x60\+0\+0$",
r"^ Compression: Zip$",
r"^ tiff:alpha: unassociated$",
r"^ tiff:endian: lsb$",
r"^ tiff:photometric: RGB$",
]
for e in expected:
assert re.search(e, identify.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
2020-06-05 23:18:39 +00:00
yield in_img
in_img.unlink()
@pytest.fixture(scope="session")
def tiff_rgba16_img(tmp_path_factory, tmp_alpha_png):
in_img = tmp_path_factory.mktemp("tiff_rgba16") / "in.tiff"
subprocess.check_call(
["convert", str(tmp_alpha_png), "-depth", "16", "-strip", str(in_img)]
)
identify = subprocess.check_output(["identify", "-verbose", str(in_img)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Format: TIFF \(Tagged Image File Format\)$",
r"^ Mime type: image/tiff$",
r"^ Geometry: 60x60\+0\+0$",
r"^ Colorspace: sRGB$",
r"^ Type: TrueColorAlpha$",
r"^ Endiann?ess: LSB$",
r"^ Depth: 16-bit$",
r"^ Page geometry: 60x60\+0\+0$",
r"^ Compression: Zip$",
r"^ tiff:alpha: unassociated$",
r"^ tiff:endian: lsb$",
r"^ tiff:photometric: RGB$",
]
for e in expected:
assert re.search(e, identify.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
2020-06-05 23:18:39 +00:00
yield in_img
in_img.unlink()
@pytest.fixture(scope="session")
def tiff_gray1_img(tmp_path_factory, tmp_gray1_png):
in_img = tmp_path_factory.mktemp("tiff_gray1") / "in.tiff"
subprocess.check_call(["convert", str(tmp_gray1_png), "-depth", "1", str(in_img)])
identify = subprocess.check_output(["identify", "-verbose", str(in_img)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Format: TIFF \(Tagged Image File Format\)$",
r"^ Mime type: image/tiff$",
r"^ Geometry: 60x60\+0\+0$",
r"^ Colorspace: Gray$",
r"^ Type: Bilevel$",
r"^ Endiann?ess: LSB$",
r"^ Depth: 1-bit$",
r"^ Page geometry: 60x60\+0\+0$",
r"^ Compression: Zip$",
r"^ tiff:alpha: unspecified$",
r"^ tiff:endian: lsb$",
r"^ tiff:photometric: min-is-black$",
]
for e in expected:
assert re.search(e, identify.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
2020-06-05 23:18:39 +00:00
yield in_img
in_img.unlink()
@pytest.fixture(scope="session")
def tiff_gray2_img(tmp_path_factory, tmp_gray2_png):
in_img = tmp_path_factory.mktemp("tiff_gray2") / "in.tiff"
subprocess.check_call(["convert", str(tmp_gray2_png), "-depth", "2", str(in_img)])
identify = subprocess.check_output(["identify", "-verbose", str(in_img)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Format: TIFF \(Tagged Image File Format\)$",
r"^ Mime type: image/tiff$",
r"^ Geometry: 60x60\+0\+0$",
r"^ Colorspace: Gray$",
r"^ Type: Grayscale$",
r"^ Endiann?ess: LSB$",
r"^ Depth: 2-bit$",
r"^ Page geometry: 60x60\+0\+0$",
r"^ Compression: Zip$",
r"^ tiff:alpha: unspecified$",
r"^ tiff:endian: lsb$",
r"^ tiff:photometric: min-is-black$",
]
for e in expected:
assert re.search(e, identify.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
2020-06-05 23:18:39 +00:00
yield in_img
in_img.unlink()
@pytest.fixture(scope="session")
def tiff_gray4_img(tmp_path_factory, tmp_gray4_png):
in_img = tmp_path_factory.mktemp("tiff_gray4") / "in.tiff"
subprocess.check_call(["convert", str(tmp_gray4_png), "-depth", "4", str(in_img)])
identify = subprocess.check_output(["identify", "-verbose", str(in_img)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Format: TIFF \(Tagged Image File Format\)$",
r"^ Mime type: image/tiff$",
r"^ Geometry: 60x60\+0\+0$",
r"^ Colorspace: Gray$",
r"^ Type: Grayscale$",
r"^ Endiann?ess: LSB$",
r"^ Depth: 4-bit$",
r"^ Page geometry: 60x60\+0\+0$",
r"^ Compression: Zip$",
r"^ tiff:alpha: unspecified$",
r"^ tiff:endian: lsb$",
r"^ tiff:photometric: min-is-black$",
]
for e in expected:
assert re.search(e, identify.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
2020-06-05 23:18:39 +00:00
yield in_img
in_img.unlink()
@pytest.fixture(scope="session")
def tiff_gray8_img(tmp_path_factory, tmp_gray8_png):
in_img = tmp_path_factory.mktemp("tiff_gray8") / "in.tiff"
subprocess.check_call(["convert", str(tmp_gray8_png), "-depth", "8", str(in_img)])
identify = subprocess.check_output(["identify", "-verbose", str(in_img)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Format: TIFF \(Tagged Image File Format\)$",
r"^ Mime type: image/tiff$",
r"^ Geometry: 60x60\+0\+0$",
r"^ Colorspace: Gray$",
r"^ Type: Grayscale$",
r"^ Endiann?ess: LSB$",
r"^ Depth: 8-bit$",
r"^ Page geometry: 60x60\+0\+0$",
r"^ Compression: Zip$",
r"^ tiff:alpha: unspecified$",
r"^ tiff:endian: lsb$",
r"^ tiff:photometric: min-is-black$",
]
for e in expected:
assert re.search(e, identify.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
2020-06-05 23:18:39 +00:00
yield in_img
in_img.unlink()
@pytest.fixture(scope="session")
def tiff_gray16_img(tmp_path_factory, tmp_gray16_png):
in_img = tmp_path_factory.mktemp("tiff_gray16") / "in.tiff"
subprocess.check_call(["convert", str(tmp_gray16_png), "-depth", "16", str(in_img)])
identify = subprocess.check_output(["identify", "-verbose", str(in_img)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Format: TIFF \(Tagged Image File Format\)$",
r"^ Mime type: image/tiff$",
r"^ Geometry: 60x60\+0\+0$",
r"^ Colorspace: Gray$",
r"^ Type: Grayscale$",
r"^ Endiann?ess: LSB$",
r"^ Depth: 16-bit$",
r"^ Page geometry: 60x60\+0\+0$",
r"^ Compression: Zip$",
r"^ tiff:alpha: unspecified$",
r"^ tiff:endian: lsb$",
r"^ tiff:photometric: min-is-black$",
]
for e in expected:
assert re.search(e, identify.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
2020-06-05 23:18:39 +00:00
yield in_img
in_img.unlink()
@pytest.fixture(scope="session")
def tiff_multipage_img(tmp_path_factory, tmp_normal_png, tmp_inverse_png):
in_img = tmp_path_factory.mktemp("tiff_multipage_img") / "in.tiff"
subprocess.check_call(
["convert", str(tmp_normal_png), str(tmp_inverse_png), "-strip", str(in_img)]
2020-06-05 23:18:39 +00:00
)
identify = subprocess.check_output(["identify", "-verbose", str(in_img) + "[0]"])
expected = [
r"^ Format: TIFF \(Tagged Image File Format\)$",
r"^ Mime type: image/tiff$",
r"^ Geometry: 60x60\+0\+0$",
r"^ Colorspace: sRGB$",
r"^ Type: TrueColor$",
r"^ Endiann?ess: LSB$",
r"^ Depth: 8-bit$",
r"^ Page geometry: 60x60\+0\+0$",
r"^ Compression: Zip$",
r"^ tiff:alpha: unspecified$",
r"^ tiff:endian: lsb$",
r"^ tiff:photometric: RGB$",
]
for e in expected:
assert re.search(e, identify.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
2020-06-05 23:18:39 +00:00
identify = subprocess.check_output(["identify", "-verbose", str(in_img) + "[1]"])
expected = [
r"^ Format: TIFF \(Tagged Image File Format\)$",
r"^ Mime type: image/tiff$",
r"^ Geometry: 60x60\+0\+0$",
r"^ Colorspace: sRGB$",
r"^ Type: TrueColor$",
r"^ Endiann?ess: LSB$",
r"^ Depth: 8-bit$",
r"^ Page geometry: 60x60\+0\+0$",
r"^ Compression: Zip$",
r"^ tiff:alpha: unspecified$",
r"^ tiff:endian: lsb$",
r"^ tiff:photometric: RGB$",
r"^ Scene: 1$",
]
for e in expected:
assert re.search(e, identify.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
2020-06-05 23:18:39 +00:00
yield in_img
in_img.unlink()
@pytest.fixture(scope="session")
def tiff_palette1_img(tmp_path_factory, tmp_palette1_png):
in_img = tmp_path_factory.mktemp("tiff_palette1_img") / "in.tiff"
subprocess.check_call(["convert", str(tmp_palette1_png), str(in_img)])
identify = subprocess.check_output(["identify", "-verbose", str(in_img)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Format: TIFF \(Tagged Image File Format\)$",
r"^ Mime type: image/tiff$",
r"^ Geometry: 60x60\+0\+0$",
r"^ Colorspace: sRGB$",
r"^ Type: Palette$",
r"^ Endiann?ess: LSB$",
r"^ Depth: 1/8-bit$",
r"^ Colormap entries: 2$",
r"^ Page geometry: 60x60\+0\+0$",
r"^ Compression: Zip$",
r"^ tiff:alpha: unspecified$",
r"^ tiff:endian: lsb$",
r"^ tiff:photometric: palette$",
]
for e in expected:
assert re.search(e, identify.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
2020-06-05 23:18:39 +00:00
yield in_img
in_img.unlink()
@pytest.fixture(scope="session")
def tiff_palette2_img(tmp_path_factory, tmp_palette2_png):
in_img = tmp_path_factory.mktemp("tiff_palette2_img") / "in.tiff"
subprocess.check_call(["convert", str(tmp_palette2_png), str(in_img)])
identify = subprocess.check_output(["identify", "-verbose", str(in_img)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Format: TIFF \(Tagged Image File Format\)$",
r"^ Mime type: image/tiff$",
r"^ Geometry: 60x60\+0\+0$",
r"^ Colorspace: sRGB$",
r"^ Type: Palette$",
r"^ Endiann?ess: LSB$",
r"^ Depth: 2/8-bit$",
r"^ Colormap entries: 4$",
r"^ Page geometry: 60x60\+0\+0$",
r"^ Compression: Zip$",
r"^ tiff:alpha: unspecified$",
r"^ tiff:endian: lsb$",
r"^ tiff:photometric: palette$",
]
for e in expected:
assert re.search(e, identify.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
2020-06-05 23:18:39 +00:00
yield in_img
in_img.unlink()
@pytest.fixture(scope="session")
def tiff_palette4_img(tmp_path_factory, tmp_palette4_png):
in_img = tmp_path_factory.mktemp("tiff_palette4_img") / "in.tiff"
subprocess.check_call(["convert", str(tmp_palette4_png), str(in_img)])
identify = subprocess.check_output(["identify", "-verbose", str(in_img)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Format: TIFF \(Tagged Image File Format\)$",
r"^ Mime type: image/tiff$",
r"^ Geometry: 60x60\+0\+0$",
r"^ Colorspace: sRGB$",
r"^ Type: Palette$",
r"^ Endiann?ess: LSB$",
r"^ Depth: 4/8-bit$",
r"^ Colormap entries: 16$",
r"^ Page geometry: 60x60\+0\+0$",
r"^ Compression: Zip$",
r"^ tiff:alpha: unspecified$",
r"^ tiff:endian: lsb$",
r"^ tiff:photometric: palette$",
]
for e in expected:
assert re.search(e, identify.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
2020-06-05 23:18:39 +00:00
yield in_img
in_img.unlink()
@pytest.fixture(scope="session")
def tiff_palette8_img(tmp_path_factory, tmp_palette8_png):
in_img = tmp_path_factory.mktemp("tiff_palette8_img") / "in.tiff"
subprocess.check_call(["convert", str(tmp_palette8_png), str(in_img)])
identify = subprocess.check_output(["identify", "-verbose", str(in_img)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Format: TIFF \(Tagged Image File Format\)$",
r"^ Mime type: image/tiff$",
r"^ Geometry: 60x60\+0\+0$",
r"^ Colorspace: sRGB$",
r"^ Type: Palette$",
r"^ Endiann?ess: LSB$",
r"^ Depth: 8-bit$",
r"^ Colormap entries: 256$",
r"^ Page geometry: 60x60\+0\+0$",
r"^ Compression: Zip$",
r"^ tiff:alpha: unspecified$",
r"^ tiff:endian: lsb$",
r"^ tiff:photometric: palette$",
]
for e in expected:
assert re.search(e, identify.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
2020-06-05 23:18:39 +00:00
yield in_img
in_img.unlink()
@pytest.fixture(scope="session")
def tiff_ccitt_lsb_m2l_white_img(tmp_path_factory, tmp_gray1_png):
in_img = tmp_path_factory.mktemp("tiff_ccitt_lsb_m2l_white_img") / "in.tiff"
subprocess.check_call(
[
"convert",
str(tmp_gray1_png),
"-compress",
"group4",
"-define",
"tiff:endian=lsb",
"-define",
"tiff:fill-order=msb",
"-define",
"quantum:polarity=min-is-white",
str(in_img),
]
)
identify = subprocess.check_output(["identify", "-verbose", str(in_img)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Format: TIFF \(Tagged Image File Format\)$",
r"^ Mime type: image/tiff$",
r"^ Geometry: 60x60\+0\+0$",
r"^ Colorspace: Gray$",
r"^ Type: Bilevel$",
r"^ Endiann?ess: LSB$",
r"^ Depth: 1-bit$",
r"^ Page geometry: 60x60\+0\+0$",
r"^ Compression: Group4$",
r"^ tiff:alpha: unspecified$",
r"^ tiff:endian: lsb$",
r"^ tiff:photometric: min-is-white$",
r"^ tiff:rows-per-strip: 60$",
]
for e in expected:
assert re.search(e, identify.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
tiffinfo = subprocess.check_output(["tiffinfo", str(in_img)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Image Width: 60 Image Length: 60",
r"^ Bits/Sample: 1",
r"^ Compression Scheme: CCITT Group 4",
r"^ Photometric Interpretation: min-is-white",
r"^ FillOrder: msb-to-lsb",
r"^ Samples/Pixel: 1",
r"^ Rows/Strip: 60",
]
for e in expected:
assert re.search(e, tiffinfo.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
2020-06-05 23:18:39 +00:00
yield in_img
in_img.unlink()
@pytest.fixture(scope="session")
def tiff_ccitt_msb_m2l_white_img(tmp_path_factory, tmp_gray1_png):
in_img = tmp_path_factory.mktemp("tiff_ccitt_msb_m2l_white_img") / "in.tiff"
subprocess.check_call(
[
"convert",
str(tmp_gray1_png),
"-compress",
"group4",
"-define",
"tiff:endian=msb",
"-define",
"tiff:fill-order=msb",
"-define",
"quantum:polarity=min-is-white",
str(in_img),
]
)
identify = subprocess.check_output(["identify", "-verbose", str(in_img)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Format: TIFF \(Tagged Image File Format\)$",
r"^ Mime type: image/tiff$",
r"^ Geometry: 60x60\+0\+0$",
r"^ Colorspace: Gray$",
r"^ Type: Bilevel$",
r"^ Endiann?ess: MSB$",
r"^ Depth: 1-bit$",
r"^ Page geometry: 60x60\+0\+0$",
r"^ Compression: Group4$",
r"^ tiff:alpha: unspecified$",
r"^ tiff:endian: msb$",
r"^ tiff:photometric: min-is-white$",
r"^ tiff:rows-per-strip: 60$",
]
for e in expected:
assert re.search(e, identify.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
tiffinfo = subprocess.check_output(["tiffinfo", str(in_img)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Image Width: 60 Image Length: 60",
r"^ Bits/Sample: 1",
r"^ Compression Scheme: CCITT Group 4",
r"^ Photometric Interpretation: min-is-white",
r"^ FillOrder: msb-to-lsb",
r"^ Samples/Pixel: 1",
r"^ Rows/Strip: 60",
]
for e in expected:
assert re.search(e, tiffinfo.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
2020-06-05 23:18:39 +00:00
yield in_img
in_img.unlink()
@pytest.fixture(scope="session")
def tiff_ccitt_msb_l2m_white_img(tmp_path_factory, tmp_gray1_png):
in_img = tmp_path_factory.mktemp("tiff_ccitt_msb_l2m_white_img") / "in.tiff"
subprocess.check_call(
[
"convert",
str(tmp_gray1_png),
"-compress",
"group4",
"-define",
"tiff:endian=msb",
"-define",
"tiff:fill-order=lsb",
"-define",
"quantum:polarity=min-is-white",
str(in_img),
]
)
identify = subprocess.check_output(["identify", "-verbose", str(in_img)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Format: TIFF \(Tagged Image File Format\)$",
r"^ Mime type: image/tiff$",
r"^ Geometry: 60x60\+0\+0$",
r"^ Colorspace: Gray$",
r"^ Type: Bilevel$",
r"^ Endiann?ess: MSB$",
r"^ Depth: 1-bit$",
r"^ Page geometry: 60x60\+0\+0$",
r"^ Compression: Group4$",
r"^ tiff:alpha: unspecified$",
r"^ tiff:endian: msb$",
r"^ tiff:photometric: min-is-white$",
r"^ tiff:rows-per-strip: 60$",
]
for e in expected:
assert re.search(e, identify.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
tiffinfo = subprocess.check_output(["tiffinfo", str(in_img)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Image Width: 60 Image Length: 60",
r"^ Bits/Sample: 1",
r"^ Compression Scheme: CCITT Group 4",
r"^ Photometric Interpretation: min-is-white",
r"^ FillOrder: lsb-to-msb",
r"^ Samples/Pixel: 1",
r"^ Rows/Strip: 60",
]
for e in expected:
assert re.search(e, tiffinfo.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
2020-06-05 23:18:39 +00:00
yield in_img
in_img.unlink()
@pytest.fixture(scope="session")
def tiff_ccitt_lsb_m2l_black_img(tmp_path_factory, tmp_gray1_png):
in_img = tmp_path_factory.mktemp("tiff_ccitt_lsb_m2l_black_img") / "in.tiff"
# "-define quantum:polarity=min-is-black" requires ImageMagick with:
# https://github.com/ImageMagick/ImageMagick/commit/00730551f0a34328685c59d0dde87dd9e366103a
# or at least 7.0.8-11 from Aug 29, 2018
# or at least 6.9.10-12 from Sep 7, 2018 (for the ImageMagick6 branch)
2020-06-05 23:18:39 +00:00
# also see: https://www.imagemagick.org/discourse-server/viewtopic.php?f=1&t=34605
subprocess.check_call(
[
"convert",
str(tmp_gray1_png),
"-compress",
"group4",
"-define",
"tiff:endian=lsb",
"-define",
"tiff:fill-order=msb",
"-define",
"quantum:polarity=min-is-black",
str(in_img),
]
)
identify = subprocess.check_output(["identify", "-verbose", str(in_img)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Format: TIFF \(Tagged Image File Format\)$",
r"^ Mime type: image/tiff$",
r"^ Geometry: 60x60\+0\+0$",
r"^ Colorspace: Gray$",
r"^ Type: Bilevel$",
r"^ Endiann?ess: LSB$",
r"^ Depth: 1-bit$",
r"^ Page geometry: 60x60\+0\+0$",
r"^ Compression: Group4$",
r"^ tiff:alpha: unspecified$",
r"^ tiff:endian: lsb$",
r"^ tiff:photometric: min-is-black$",
r"^ tiff:rows-per-strip: 60$",
]
for e in expected:
assert re.search(e, identify.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
tiffinfo = subprocess.check_output(["tiffinfo", str(in_img)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Image Width: 60 Image Length: 60",
r"^ Bits/Sample: 1",
r"^ Compression Scheme: CCITT Group 4",
r"^ Photometric Interpretation: min-is-black",
r"^ FillOrder: msb-to-lsb",
r"^ Samples/Pixel: 1",
r"^ Rows/Strip: 60",
]
for e in expected:
assert re.search(e, tiffinfo.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
2020-06-05 23:18:39 +00:00
yield in_img
in_img.unlink()
@pytest.fixture(scope="session")
def tiff_ccitt_nometa1_img(tmp_path_factory, tmp_gray1_png):
in_img = tmp_path_factory.mktemp("tiff_ccitt_nometa1_img") / "in.tiff"
subprocess.check_call(
[
"convert",
str(tmp_gray1_png),
"-compress",
"group4",
"-define",
"tiff:endian=lsb",
"-define",
"tiff:fill-order=msb",
"-define",
"quantum:polarity=min-is-white",
str(in_img),
]
)
subprocess.check_call(
["tiffset", "-u", "258", str(in_img)]
) # remove BitsPerSample (258)
subprocess.check_call(
["tiffset", "-u", "266", str(in_img)]
) # remove FillOrder (266)
subprocess.check_call(
["tiffset", "-u", "277", str(in_img)]
) # remove SamplesPerPixel (277)
identify = subprocess.check_output(["identify", "-verbose", str(in_img)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Format: TIFF \(Tagged Image File Format\)$",
r"^ Mime type: image/tiff$",
r"^ Geometry: 60x60\+0\+0$",
r"^ Colorspace: Gray$",
r"^ Type: Bilevel$",
r"^ Endiann?ess: LSB$",
r"^ Depth: 1-bit$",
r"^ Page geometry: 60x60\+0\+0$",
r"^ Compression: Group4$",
r"^ tiff:alpha: unspecified$",
r"^ tiff:endian: lsb$",
r"^ tiff:photometric: min-is-white$",
r"^ tiff:rows-per-strip: 60$",
]
for e in expected:
assert re.search(e, identify.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
tiffinfo = subprocess.check_output(["tiffinfo", str(in_img)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Image Width: 60 Image Length: 60",
r"^ Compression Scheme: CCITT Group 4",
r"^ Photometric Interpretation: min-is-white",
r"^ Rows/Strip: 60",
]
for e in expected:
assert re.search(e, tiffinfo.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
2020-06-05 23:18:39 +00:00
unexpected = [" Bits/Sample: ", " FillOrder: ", " Samples/Pixel: "]
for e in unexpected:
assert e not in tiffinfo.decode("utf8")
yield in_img
in_img.unlink()
@pytest.fixture(scope="session")
def tiff_ccitt_nometa2_img(tmp_path_factory, tmp_gray1_png):
in_img = tmp_path_factory.mktemp("tiff_ccitt_nometa2_img") / "in.tiff"
subprocess.check_call(
[
"convert",
str(tmp_gray1_png),
"-compress",
"group4",
"-define",
"tiff:endian=lsb",
"-define",
"tiff:fill-order=msb",
"-define",
"quantum:polarity=min-is-white",
str(in_img),
]
)
subprocess.check_call(
["tiffset", "-u", "278", str(in_img)]
) # remove RowsPerStrip (278)
identify = json.loads(subprocess.check_output(["convert", str(in_img), "json:"]))
assert len(identify) == 1
# somewhere between imagemagick 6.9.7.4 and 6.9.9.34, the json output was
# put into an array, here we cater for the older version containing just
# the bare dictionary
if "image" in identify:
identify = [identify]
assert "image" in identify[0]
assert identify[0]["image"]["format"] == "TIFF"
assert identify[0]["image"]["formatDescription"] == "Tagged Image File Format"
assert identify[0]["image"]["mimeType"] == "image/tiff"
assert identify[0]["image"]["geometry"] == {
"width": 60,
"height": 60,
"x": 0,
"y": 0,
}
assert identify[0]["image"]["units"] == "PixelsPerInch"
assert identify[0]["image"]["type"] == "Bilevel"
assert identify[0]["image"]["endianess"] == "Undefined" # FIXME: should be LSB
assert identify[0]["image"]["colorspace"] == "Gray"
assert identify[0]["image"]["depth"] == 1
assert identify[0]["image"]["compression"] == "Group4"
assert identify[0]["image"]["properties"]["tiff:alpha"] == "unspecified"
assert identify[0]["image"]["properties"]["tiff:endian"] == "lsb"
assert identify[0]["image"]["properties"]["tiff:photometric"] == "min-is-white"
assert "tiff:rows-per-strip" not in identify[0]["image"]["properties"]
tiffinfo = subprocess.check_output(["tiffinfo", str(in_img)])
2020-06-05 23:18:39 +00:00
expected = [
r"^ Image Width: 60 Image Length: 60",
r"^ Bits/Sample: 1",
r"^ Compression Scheme: CCITT Group 4",
r"^ Photometric Interpretation: min-is-white",
r"^ FillOrder: msb-to-lsb",
r"^ Samples/Pixel: 1",
]
for e in expected:
assert re.search(e, tiffinfo.decode("utf8"), re.MULTILINE), identify.decode(
"utf8"
)
2020-06-05 23:18:39 +00:00
unexpected = [" Rows/Strip: "]
for e in unexpected:
assert e not in tiffinfo.decode("utf8")
yield in_img
in_img.unlink()
###############################################################################
# OUTPUT FIXTURES #
###############################################################################
@pytest.fixture(scope="session", params=["internal", "pikepdf", "pdfrw"])
def jpg_pdf(tmp_path_factory, jpg_img, request):
out_pdf = tmp_path_factory.mktemp("jpg_pdf") / "out.pdf"
subprocess.check_call(
[
"src/img2pdf.py",
"--producer=",
"--nodate",
"--engine=" + request.param,
"--output=" + str(out_pdf),
str(jpg_img),
2020-06-05 23:18:39 +00:00
]
)
with pikepdf.open(str(out_pdf)) as p:
assert (
p.pages[0].Contents.read_bytes()
== b"q\n45.0000 0 0 45.0000 0.0000 0.0000 cm\n/Im0 Do\nQ"
)
assert p.pages[0].Resources.XObject.Im0.BitsPerComponent == 8
assert p.pages[0].Resources.XObject.Im0.ColorSpace == "/DeviceRGB"
assert p.pages[0].Resources.XObject.Im0.Filter == "/DCTDecode"
assert p.pages[0].Resources.XObject.Im0.Height == 60
assert p.pages[0].Resources.XObject.Im0.Width == 60
yield out_pdf
out_pdf.unlink()
@pytest.fixture(scope="session", params=["internal", "pikepdf", "pdfrw"])
def jpg_rot_pdf(tmp_path_factory, jpg_rot_img, request):
out_pdf = tmp_path_factory.mktemp("jpg_rot_pdf") / "out.pdf"
subprocess.check_call(
[
"src/img2pdf.py",
"--producer=",
"--nodate",
"--engine=" + request.param,
"--output=" + str(out_pdf),
str(jpg_rot_img),
2020-06-05 23:18:39 +00:00
]
)
with pikepdf.open(str(out_pdf)) as p:
assert (
p.pages[0].Contents.read_bytes()
== b"q\n45.0000 0 0 45.0000 0.0000 0.0000 cm\n/Im0 Do\nQ"
)
assert p.pages[0].Resources.XObject.Im0.BitsPerComponent == 8
assert p.pages[0].Resources.XObject.Im0.ColorSpace == "/DeviceRGB"
assert p.pages[0].Resources.XObject.Im0.Filter == "/DCTDecode"
assert p.pages[0].Resources.XObject.Im0.Height == 60
assert p.pages[0].Resources.XObject.Im0.Width == 60
assert p.pages[0].Rotate == 90
yield out_pdf
out_pdf.unlink()
@pytest.fixture(scope="session", params=["internal", "pikepdf", "pdfrw"])
def jpg_cmyk_pdf(tmp_path_factory, jpg_cmyk_img, request):
out_pdf = tmp_path_factory.mktemp("jpg_cmyk_pdf") / "out.pdf"
subprocess.check_call(
[
"src/img2pdf.py",
"--producer=",
"--nodate",
"--engine=" + request.param,
"--output=" + str(out_pdf),
str(jpg_cmyk_img),
2020-06-05 23:18:39 +00:00
]
)
with pikepdf.open(str(out_pdf)) as p:
assert (
p.pages[0].Contents.read_bytes()
== b"q\n45.0000 0 0 45.0000 0.0000 0.0000 cm\n/Im0 Do\nQ"
)
assert p.pages[0].Resources.XObject.Im0.BitsPerComponent == 8
assert p.pages[0].Resources.XObject.Im0.ColorSpace == "/DeviceCMYK"
assert p.pages[0].Resources.XObject.Im0.Decode == pikepdf.Array(
[1, 0, 1, 0, 1, 0, 1, 0]
)
assert p.pages[0].Resources.XObject.Im0.Filter == "/DCTDecode"
assert p.pages[0].Resources.XObject.Im0.Height == 60
assert p.pages[0].Resources.XObject.Im0.Width == 60
yield out_pdf
out_pdf.unlink()
@pytest.fixture(scope="session", params=["internal", "pikepdf", "pdfrw"])
def jpg_2000_pdf(tmp_path_factory, jpg_2000_img, request):
out_pdf = tmp_path_factory.mktemp("jpg_2000_pdf") / "out.pdf"
subprocess.check_call(
[
"src/img2pdf.py",
"--producer=",
"--nodate",
"--engine=" + request.param,
"--output=" + str(out_pdf),
jpg_2000_img,
]
)
with pikepdf.open(str(out_pdf)) as p:
assert (
p.pages[0].Contents.read_bytes()
== b"q\n45.0000 0 0 45.0000 0.0000 0.0000 cm\n/Im0 Do\nQ"
)
assert p.pages[0].Resources.XObject.Im0.BitsPerComponent == 8
assert p.pages[0].Resources.XObject.Im0.ColorSpace == "/DeviceRGB"
assert p.pages[0].Resources.XObject.Im0.Filter == "/JPXDecode"
assert p.pages[0].Resources.XObject.Im0.Height == 60
assert p.pages[0].Resources.XObject.Im0.Width == 60
yield out_pdf
out_pdf.unlink()
@pytest.fixture(scope="session", params=["internal", "pikepdf", "pdfrw"])
def png_rgb8_pdf(tmp_path_factory, png_rgb8_img, request):
out_pdf = tmp_path_factory.mktemp("png_rgb8_pdf") / "out.pdf"
subprocess.check_call(
[
"src/img2pdf.py",
"--producer=",
"--nodate",
"--engine=" + request.param,
"--output=" + str(out_pdf),
str(png_rgb8_img),
2020-06-05 23:18:39 +00:00
]
)
with pikepdf.open(str(out_pdf)) as p:
assert (
p.pages[0].Contents.read_bytes()
== b"q\n45.0000 0 0 45.0000 0.0000 0.0000 cm\n/Im0 Do\nQ"
)
assert p.pages[0].Resources.XObject.Im0.BitsPerComponent == 8
assert p.pages[0].Resources.XObject.Im0.ColorSpace == "/DeviceRGB"
assert p.pages[0].Resources.XObject.Im0.DecodeParms.BitsPerComponent == 8
assert p.pages[0].Resources.XObject.Im0.DecodeParms.Colors == 3
assert p.pages[0].Resources.XObject.Im0.DecodeParms.Predictor == 15
assert p.pages[0].Resources.XObject.Im0.Filter == "/FlateDecode"
assert p.pages[0].Resources.XObject.Im0.Height == 60
assert p.pages[0].Resources.XObject.Im0.Width == 60
yield out_pdf
out_pdf.unlink()
@pytest.fixture(scope="session", params=["internal", "pikepdf", "pdfrw"])
def png_rgb16_pdf(tmp_path_factory, png_rgb16_img, request):
out_pdf = tmp_path_factory.mktemp("png_rgb16_pdf") / "out.pdf"
subprocess.check_call(
[
"src/img2pdf.py",
"--producer=",
"--nodate",
"--engine=" + request.param,
"--output=" + str(out_pdf),
str(png_rgb16_img),
2020-06-05 23:18:39 +00:00
]
)
with pikepdf.open(str(out_pdf)) as p:
assert (
p.pages[0].Contents.read_bytes()
== b"q\n45.0000 0 0 45.0000 0.0000 0.0000 cm\n/Im0 Do\nQ"
)
assert p.pages[0].Resources.XObject.Im0.BitsPerComponent == 16
assert p.pages[0].Resources.XObject.Im0.ColorSpace == "/DeviceRGB"
assert p.pages[0].Resources.XObject.Im0.DecodeParms.BitsPerComponent == 16
assert p.pages[0].Resources.XObject.Im0.DecodeParms.Colors == 3
assert p.pages[0].Resources.XObject.Im0.DecodeParms.Predictor == 15
assert p.pages[0].Resources.XObject.Im0.Filter == "/FlateDecode"
assert p.pages[0].Resources.XObject.Im0.Height == 60
assert p.pages[0].Resources.XObject.Im0.Width == 60
yield out_pdf
out_pdf.unlink()
@pytest.fixture(scope="session", params=["internal", "pikepdf", "pdfrw"])
def png_interlaced_pdf(tmp_path_factory, png_interlaced_img, request):
out_pdf = tmp_path_factory.mktemp("png_interlaced_pdf") / "out.pdf"
subprocess.check_call(
[
"src/img2pdf.py",
"--producer=",
"--nodate",
"--engine=" + request.param,
"--output=" + str(out_pdf),
str(png_interlaced_img),
2020-06-05 23:18:39 +00:00
]
)
with pikepdf.open(str(out_pdf)) as p:
assert (
p.pages[0].Contents.read_bytes()
== b"q\n45.0000 0 0 45.0000 0.0000 0.0000 cm\n/Im0 Do\nQ"
)
assert p.pages[0].Resources.XObject.Im0.BitsPerComponent == 8
assert p.pages[0].Resources.XObject.Im0.ColorSpace == "/DeviceRGB"
assert p.pages[0].Resources.XObject.Im0.DecodeParms.BitsPerComponent == 8
assert p.pages[0].Resources.XObject.Im0.DecodeParms.Colors == 3
assert p.pages[0].Resources.XObject.Im0.DecodeParms.Predictor == 15
assert p.pages[0].Resources.XObject.Im0.Filter == "/FlateDecode"
assert p.pages[0].Resources.XObject.Im0.Height == 60
assert p.pages[0].Resources.XObject.Im0.Width == 60
yield out_pdf
out_pdf.unlink()
@pytest.fixture(scope="session", params=["internal", "pikepdf", "pdfrw"])
def png_gray1_pdf(tmp_path_factory, tmp_gray1_png, request):
out_pdf = tmp_path_factory.mktemp("png_gray1_pdf") / "out.pdf"
subprocess.check_call(
[
"src/img2pdf.py",
"--producer=",
"--nodate",
"--engine=" + request.param,
"--output=" + str(out_pdf),
str(tmp_gray1_png),
2020-06-05 23:18:39 +00:00
]
)
with pikepdf.open(str(out_pdf)) as p:
assert (
p.pages[0].Contents.read_bytes()
== b"q\n45.0000 0 0 45.0000 0.0000 0.0000 cm\n/Im0 Do\nQ"
)
assert p.pages[0].Resources.XObject.Im0.BitsPerComponent == 1
assert p.pages[0].Resources.XObject.Im0.ColorSpace == "/DeviceGray"
assert p.pages[0].Resources.XObject.Im0.DecodeParms.BitsPerComponent == 1
assert p.pages[0].Resources.XObject.Im0.DecodeParms.Colors == 1
assert p.pages[0].Resources.XObject.Im0.DecodeParms.Predictor == 15
assert p.pages[0].Resources.XObject.Im0.Filter == "/FlateDecode"
assert p.pages[0].Resources.XObject.Im0.Height == 60
assert p.pages[0].Resources.XObject.Im0.Width == 60
yield out_pdf
out_pdf.unlink()
@pytest.fixture(scope="session", params=["internal", "pikepdf", "pdfrw"])
def png_gray2_pdf(tmp_path_factory, tmp_gray2_png, request):
out_pdf = tmp_path_factory.mktemp("png_gray2_pdf") / "out.pdf"
subprocess.check_call(
[
"src/img2pdf.py",
"--producer=",
"--nodate",
"--engine=" + request.param,
"--output=" + str(out_pdf),
str(tmp_gray2_png),
2020-06-05 23:18:39 +00:00
]
)
with pikepdf.open(str(out_pdf)) as p:
assert (
p.pages[0].Contents.read_bytes()
== b"q\n45.0000 0 0 45.0000 0.0000 0.0000 cm\n/Im0 Do\nQ"
)
assert p.pages[0].Resources.XObject.Im0.BitsPerComponent == 2
assert p.pages[0].Resources.XObject.Im0.ColorSpace == "/DeviceGray"
assert p.pages[0].Resources.XObject.Im0.DecodeParms.BitsPerComponent == 2
assert p.pages[0].Resources.XObject.Im0.DecodeParms.Colors == 1
assert p.pages[0].Resources.XObject.Im0.DecodeParms.Predictor == 15
assert p.pages[0].Resources.XObject.Im0.Filter == "/FlateDecode"
assert p.pages[0].Resources.XObject.Im0.Height == 60
assert p.pages[0].Resources.XObject.Im0.Width == 60
yield out_pdf
out_pdf.unlink()
@pytest.fixture(scope="session", params=["internal", "pikepdf", "pdfrw"])
def png_gray4_pdf(tmp_path_factory, tmp_gray4_png, request):
out_pdf = tmp_path_factory.mktemp("png_gray4_pdf") / "out.pdf"
subprocess.check_call(
[
"src/img2pdf.py",
"--producer=",
"--nodate",
"--engine=" + request.param,
"--output=" + str(out_pdf),
str(tmp_gray4_png),
2020-06-05 23:18:39 +00:00
]
)
with pikepdf.open(str(out_pdf)) as p:
assert (
p.pages[0].Contents.read_bytes()
== b"q\n45.0000 0 0 45.0000 0.0000 0.0000 cm\n/Im0 Do\nQ"
)
assert p.pages[0].Resources.XObject.Im0.BitsPerComponent == 4
assert p.pages[0].Resources.XObject.Im0.ColorSpace == "/DeviceGray"
assert p.pages[0].Resources.XObject.Im0.DecodeParms.BitsPerComponent == 4
assert p.pages[0].Resources.XObject.Im0.DecodeParms.Colors == 1
assert p.pages[0].Resources.XObject.Im0.DecodeParms.Predictor == 15
assert p.pages[0].Resources.XObject.Im0.Filter == "/FlateDecode"
assert p.pages[0].Resources.XObject.Im0.Height == 60
assert p.pages[0].Resources.XObject.Im0.Width == 60
yield out_pdf
out_pdf.unlink()
@pytest.fixture(scope="session", params=["internal", "pikepdf", "pdfrw"])
def png_gray8_pdf(tmp_path_factory, tmp_gray8_png, request):
out_pdf = tmp_path_factory.mktemp("png_gray8_pdf") / "out.pdf"
subprocess.check_call(
[
"src/img2pdf.py",
"--producer=",
"--nodate",
"--engine=" + request.param,
"--output=" + str(out_pdf),
str(tmp_gray8_png),
2020-06-05 23:18:39 +00:00
]
)
with pikepdf.open(str(out_pdf)) as p:
assert (
p.pages[0].Contents.read_bytes()
== b"q\n45.0000 0 0 45.0000 0.0000 0.0000 cm\n/Im0 Do\nQ"
)
assert p.pages[0].Resources.XObject.Im0.BitsPerComponent == 8
assert p.pages[0].Resources.XObject.Im0.ColorSpace == "/DeviceGray"
assert p.pages[0].Resources.XObject.Im0.DecodeParms.BitsPerComponent == 8
assert p.pages[0].Resources.XObject.Im0.DecodeParms.Colors == 1
assert p.pages[0].Resources.XObject.Im0.DecodeParms.Predictor == 15
assert p.pages[0].Resources.XObject.Im0.Filter == "/FlateDecode"
assert p.pages[0].Resources.XObject.Im0.Height == 60
assert p.pages[0].Resources.XObject.Im0.Width == 60
yield out_pdf
out_pdf.unlink()
@pytest.fixture(scope="session", params=["internal", "pikepdf", "pdfrw"])
def png_gray16_pdf(tmp_path_factory, tmp_gray16_png, request):
out_pdf = tmp_path_factory.mktemp("png_gray16_pdf") / "out.pdf"
subprocess.check_call(
[
"src/img2pdf.py",
"--producer=",
"--nodate",
"--engine=" + request.param,
"--output=" + str(out_pdf),
str(tmp_gray16_png),
2020-06-05 23:18:39 +00:00
]
)
with pikepdf.open(str(out_pdf)) as p:
assert (
p.pages[0].Contents.read_bytes()
== b"q\n45.0000 0 0 45.0000 0.0000 0.0000 cm\n/Im0 Do\nQ"
)
assert p.pages[0].Resources.XObject.Im0.BitsPerComponent == 16
assert p.pages[0].Resources.XObject.Im0.ColorSpace == "/DeviceGray"
assert p.pages[0].Resources.XObject.Im0.DecodeParms.BitsPerComponent == 16
assert p.pages[0].Resources.XObject.Im0.DecodeParms.Colors == 1
assert p.pages[0].Resources.XObject.Im0.DecodeParms.Predictor == 15
assert p.pages[0].Resources.XObject.Im0.Filter == "/FlateDecode"
assert p.pages[0].Resources.XObject.Im0.Height == 60
assert p.pages[0].Resources.XObject.Im0.Width == 60
yield out_pdf
out_pdf.unlink()
@pytest.fixture(scope="session", params=["internal", "pikepdf"])
def png_palette1_pdf(tmp_path_factory, tmp_palette1_png, request):
out_pdf = tmp_path_factory.mktemp("png_palette1_pdf") / "out.pdf"
subprocess.check_call(
[
"src/img2pdf.py",
"--producer=",
"--nodate",
"--engine=" + request.param,
"--output=" + str(out_pdf),
str(tmp_palette1_png),
2020-06-05 23:18:39 +00:00
]
)
with pikepdf.open(str(out_pdf)) as p:
assert (
p.pages[0].Contents.read_bytes()
== b"q\n45.0000 0 0 45.0000 0.0000 0.0000 cm\n/Im0 Do\nQ"
)
assert p.pages[0].Resources.XObject.Im0.BitsPerComponent == 1
assert p.pages[0].Resources.XObject.Im0.ColorSpace[0] == "/Indexed"
assert p.pages[0].Resources.XObject.Im0.ColorSpace[1] == "/DeviceRGB"
assert p.pages[0].Resources.XObject.Im0.DecodeParms.BitsPerComponent == 1
assert p.pages[0].Resources.XObject.Im0.DecodeParms.Colors == 1
assert p.pages[0].Resources.XObject.Im0.DecodeParms.Predictor == 15
assert p.pages[0].Resources.XObject.Im0.Filter == "/FlateDecode"
assert p.pages[0].Resources.XObject.Im0.Height == 60
assert p.pages[0].Resources.XObject.Im0.Width == 60
yield out_pdf
out_pdf.unlink()
@pytest.fixture(scope="session", params=["internal", "pikepdf"])
def png_palette2_pdf(tmp_path_factory, tmp_palette2_png, request):
out_pdf = tmp_path_factory.mktemp("png_palette2_pdf") / "out.pdf"
subprocess.check_call(
[
"src/img2pdf.py",
"--producer=",
"--nodate",
"--engine=" + request.param,
"--output=" + str(out_pdf),
str(tmp_palette2_png),
2020-06-05 23:18:39 +00:00
]
)
with pikepdf.open(str(out_pdf)) as p:
assert (
p.pages[0].Contents.read_bytes()
== b"q\n45.0000 0 0 45.0000 0.0000 0.0000 cm\n/Im0 Do\nQ"
)
assert p.pages[0].Resources.XObject.Im0.BitsPerComponent == 2
assert p.pages[0].Resources.XObject.Im0.ColorSpace[0] == "/Indexed"
assert p.pages[0].Resources.XObject.Im0.ColorSpace[1] == "/DeviceRGB"
assert p.pages[0].Resources.XObject.Im0.DecodeParms.BitsPerComponent == 2
assert p.pages[0].Resources.XObject.Im0.DecodeParms.Colors == 1
assert p.pages[0].Resources.XObject.Im0.DecodeParms.Predictor == 15
assert p.pages[0].Resources.XObject.Im0.Filter == "/FlateDecode"
assert p.pages[0].Resources.XObject.Im0.Height == 60
assert p.pages[0].Resources.XObject.Im0.Width == 60
yield out_pdf
out_pdf.unlink()
@pytest.fixture(scope="session", params=["internal", "pikepdf"])
def png_palette4_pdf(tmp_path_factory, tmp_palette4_png, request):
out_pdf = tmp_path_factory.mktemp("png_palette4_pdf") / "out.pdf"
subprocess.check_call(
[
"src/img2pdf.py",
"--producer=",
"--nodate",
"--engine=" + request.param,
"--output=" + str(out_pdf),
str(tmp_palette4_png),
2020-06-05 23:18:39 +00:00
]
)
with pikepdf.open(str(out_pdf)) as p:
assert (
p.pages[0].Contents.read_bytes()
== b"q\n45.0000 0 0 45.0000 0.0000 0.0000 cm\n/Im0 Do\nQ"
)
assert p.pages[0].Resources.XObject.Im0.BitsPerComponent == 4
assert p.pages[0].Resources.XObject.Im0.ColorSpace[0] == "/Indexed"
assert p.pages[0].Resources.XObject.Im0.ColorSpace[1] == "/DeviceRGB"
assert p.pages[0].Resources.XObject.Im0.DecodeParms.BitsPerComponent == 4
assert p.pages[0].Resources.XObject.Im0.DecodeParms.Colors == 1
assert p.pages[0].Resources.XObject.Im0.DecodeParms.Predictor == 15
assert p.pages[0].Resources.XObject.Im0.Filter == "/FlateDecode"
assert p.pages[0].Resources.XObject.Im0.Height == 60
assert p.pages[0].Resources.XObject.Im0.Width == 60
yield out_pdf
out_pdf.unlink()
@pytest.fixture(scope="session", params=["internal", "pikepdf"])
def png_palette8_pdf(tmp_path_factory, tmp_palette8_png, request):
out_pdf = tmp_path_factory.mktemp("png_palette8_pdf") / "out.pdf"
subprocess.check_call(
[
"src/img2pdf.py",
"--producer=",
"--nodate",
"--engine=" + request.param,
"--output=" + str(out_pdf),
str(tmp_palette8_png),
2020-06-05 23:18:39 +00:00
]
)
with pikepdf.open(str(out_pdf)) as p:
assert (
p.pages[0].Contents.read_bytes()
== b"q\n45.0000 0 0 45.0000 0.0000 0.0000 cm\n/Im0 Do\nQ"
)
assert p.pages[0].Resources.XObject.Im0.BitsPerComponent == 8
assert p.pages[0].Resources.XObject.Im0.ColorSpace[0] == "/Indexed"
assert p.pages[0].Resources.XObject.Im0.ColorSpace[1] == "/DeviceRGB"
assert p.pages[0].Resources.XObject.Im0.DecodeParms.BitsPerComponent == 8
assert p.pages[0].Resources.XObject.Im0.DecodeParms.Colors == 1
assert p.pages[0].Resources.XObject.Im0.DecodeParms.Predictor == 15
assert p.pages[0].Resources.XObject.Im0.Filter == "/FlateDecode"
assert p.pages[0].Resources.XObject.Im0.Height == 60
assert p.pages[0].Resources.XObject.Im0.Width == 60
yield out_pdf
out_pdf.unlink()
@pytest.fixture(scope="session", params=["internal", "pikepdf"])
def gif_palette1_pdf(tmp_path_factory, gif_palette1_img, request):
out_pdf = tmp_path_factory.mktemp("gif_palette1_pdf") / "out.pdf"
subprocess.check_call(
[
"src/img2pdf.py",
"--producer=",
"--nodate",
"--engine=" + request.param,
"--output=" + str(out_pdf),
str(gif_palette1_img),
2020-06-05 23:18:39 +00:00
]
)
with pikepdf.open(str(out_pdf)) as p:
assert (
p.pages[0].Contents.read_bytes()
== b"q\n45.0000 0 0 45.0000 0.0000 0.0000 cm\n/Im0 Do\nQ"
)
assert p.pages[0].Resources.XObject.Im0.BitsPerComponent == 1
assert p.pages[0].Resources.XObject.Im0.ColorSpace[0] == "/Indexed"
assert p.pages[0].Resources.XObject.Im0.ColorSpace[1] == "/DeviceRGB"
assert p.pages[0].Resources.XObject.Im0.DecodeParms.BitsPerComponent == 1
assert p.pages[0].Resources.XObject.Im0.DecodeParms.Colors == 1
assert p.pages[0].Resources.XObject.Im0.DecodeParms.Predictor == 15
assert p.pages[0].Resources.XObject.Im0.Filter == "/FlateDecode"
assert p.pages[0].Resources.XObject.Im0.Height == 60
assert p.pages[0].Resources.XObject.Im0.Width == 60
yield out_pdf
out_pdf.unlink()
@pytest.fixture(scope="session", params=["internal", "pikepdf"])
def gif_palette2_pdf(tmp_path_factory, gif_palette2_img, request):
out_pdf = tmp_path_factory.mktemp("gif_palette2_pdf") / "out.pdf"
subprocess.check_call(
[
"src/img2pdf.py",
"--producer=",
"--nodate",
"--engine=" + request.param,
"--output=" + str(out_pdf),
str(gif_palette2_img),
2020-06-05 23:18:39 +00:00
]
)
with pikepdf.open(str(out_pdf)) as p:
assert (
p.pages[0].Contents.read_bytes()
== b"q\n45.0000 0 0 45.0000 0.0000 0.0000 cm\n/Im0 Do\nQ"
)
assert p.pages[0].Resources.XObject.Im0.BitsPerComponent == 2
assert p.pages[0].Resources.XObject.Im0.ColorSpace[0] == "/Indexed"
assert p.pages[0].Resources.XObject.Im0.ColorSpace[1] == "/DeviceRGB"
assert p.pages[0].Resources.XObject.Im0.DecodeParms.BitsPerComponent == 2
assert p.pages[0].Resources.XObject.Im0.DecodeParms.Colors == 1
assert p.pages[0].Resources.XObject.Im0.DecodeParms.Predictor == 15
assert p.pages[0].Resources.XObject.Im0.Filter == "/FlateDecode"
assert p.pages[0].Resources.XObject.Im0.Height == 60
assert p.pages[0].Resources.XObject.Im0.Width == 60
yield out_pdf
out_pdf.unlink()
@pytest.fixture(scope="session", params=["internal", "pikepdf"])
def gif_palette4_pdf(tmp_path_factory, gif_palette4_img, request):
out_pdf = tmp_path_factory.mktemp("gif_palette4_pdf") / "out.pdf"
subprocess.check_call(
[
"src/img2pdf.py",
"--producer=",
"--nodate",
"--engine=" + request.param,
"--output=" + str(out_pdf),
str(gif_palette4_img),
2020-06-05 23:18:39 +00:00
]
)
with pikepdf.open(str(out_pdf)) as p:
assert (
p.pages[0].Contents.read_bytes()
== b"q\n45.0000 0 0 45.0000 0.0000 0.0000 cm\n/Im0 Do\nQ"
)
assert p.pages[0].Resources.XObject.Im0.BitsPerComponent == 4
assert p.pages[0].Resources.XObject.Im0.ColorSpace[0] == "/Indexed"
assert p.pages[0].Resources.XObject.Im0.ColorSpace[1] == "/DeviceRGB"
assert p.pages[0].Resources.XObject.Im0.DecodeParms.BitsPerComponent == 4
assert p.pages[0].Resources.XObject.Im0.DecodeParms.Colors == 1
assert p.pages[0].Resources.XObject.Im0.DecodeParms.Predictor == 15
assert p.pages[0].Resources.XObject.Im0.Filter == "/FlateDecode"
assert p.pages[0].Resources.XObject.Im0.Height == 60
assert p.pages[0].Resources.XObject.Im0.Width == 60
yield out_pdf
out_pdf.unlink()
@pytest.fixture(scope="session", params=["internal", "pikepdf"])
def gif_palette8_pdf(tmp_path_factory, gif_palette8_img, request):
out_pdf = tmp_path_factory.mktemp("gif_palette8_pdf") / "out.pdf"
subprocess.check_call(
[
"src/img2pdf.py",
"--producer=",
"--nodate",
"--engine=" + request.param,
"--output=" + str(out_pdf),
str(gif_palette8_img),
2020-06-05 23:18:39 +00:00
]
)
with pikepdf.open(str(out_pdf)) as p:
assert (
p.pages[0].Contents.read_bytes()
== b"q\n45.0000 0 0 45.0000 0.0000 0.0000 cm\n/Im0 Do\nQ"
)
assert p.pages[0].Resources.XObject.Im0.BitsPerComponent == 8
assert p.pages[0].Resources.XObject.Im0.ColorSpace[0] == "/Indexed"
assert p.pages[0].Resources.XObject.Im0.ColorSpace[1] == "/DeviceRGB"
assert p.pages[0].Resources.XObject.Im0.DecodeParms.BitsPerComponent == 8
assert p.pages[0].Resources.XObject.Im0.DecodeParms.Colors == 1
assert p.pages[0].Resources.XObject.Im0.DecodeParms.Predictor == 15
assert p.pages[0].Resources.XObject.Im0.Filter == "/FlateDecode"
assert p.pages[0].Resources.XObject.Im0.Height == 60
assert p.pages[0].Resources.XObject.Im0.Width == 60
yield out_pdf
out_pdf.unlink()
@pytest.fixture(scope="session", params=["internal", "pikepdf"])
def gif_animation_pdf(tmp_path_factory, gif_animation_img, request):
tmpdir = tmp_path_factory.mktemp("gif_animation_pdf")
out_pdf = tmpdir / "out.pdf"
subprocess.check_call(
[
"src/img2pdf.py",
"--producer=",
"--nodate",
"--engine=" + request.param,
"--output=" + str(out_pdf),
str(gif_animation_img),
2020-06-05 23:18:39 +00:00
]
)
pdfinfo = subprocess.check_output(["pdfinfo", str(out_pdf)])
assert re.search(
"^Pages: +2$", pdfinfo.decode("utf8"), re.MULTILINE
), identify.decode("utf8")
subprocess.check_call(["pdfseparate", str(out_pdf), str(tmpdir / "page-%d.pdf")])
2020-06-05 23:18:39 +00:00
for page in [1, 2]:
gif_animation_pdf_nr = tmpdir / ("page-%d.pdf" % page)
with pikepdf.open(gif_animation_pdf_nr) as p:
assert (
p.pages[0].Contents.read_bytes()
== b"q\n45.0000 0 0 45.0000 0.0000 0.0000 cm\n/Im0 Do\nQ"
)
assert p.pages[0].Resources.XObject.Im0.BitsPerComponent == 8
assert p.pages[0].Resources.XObject.Im0.ColorSpace[0] == "/Indexed"
assert p.pages[0].Resources.XObject.Im0.ColorSpace[1] == "/DeviceRGB"
assert p.pages[0].Resources.XObject.Im0.DecodeParms.BitsPerComponent == 8
assert p.pages[0].Resources.XObject.Im0.DecodeParms.Colors == 1
assert p.pages[0].Resources.XObject.Im0.DecodeParms.Predictor == 15
assert p.pages[0].Resources.XObject.Im0.Filter == "/FlateDecode"
assert p.pages[0].Resources.XObject.Im0.Height == 60
assert p.pages[0].Resources.XObject.Im0.Width == 60
gif_animation_pdf_nr.unlink()
yield out_pdf
out_pdf.unlink()
@pytest.fixture(scope="session", params=["internal", "pikepdf", "pdfrw"])
def tiff_cmyk8_pdf(tmp_path_factory, tiff_cmyk8_img, request):
out_pdf = tmp_path_factory.mktemp("tiff_cmyk8_pdf") / "out.pdf"
subprocess.check_call(
[
"src/img2pdf.py",
"--producer=",
"--nodate",
"--engine=" + request.param,
"--output=" + str(out_pdf),
str(tiff_cmyk8_img),
2020-06-05 23:18:39 +00:00
]
)
with pikepdf.open(str(out_pdf)) as p:
assert (
p.pages[0].Contents.read_bytes()
== b"q\n45.0000 0 0 45.0000 0.0000 0.0000 cm\n/Im0 Do\nQ"
)
assert p.pages[0].Resources.XObject.Im0.BitsPerComponent == 8
assert p.pages[0].Resources.XObject.Im0.ColorSpace == "/DeviceCMYK"
assert p.pages[0].Resources.XObject.Im0.Filter == "/FlateDecode"
assert p.pages[0].Resources.XObject.Im0.Height == 60
assert p.pages[0].Resources.XObject.Im0.Width == 60
yield out_pdf
out_pdf.unlink()
@pytest.fixture(scope="session", params=["internal", "pikepdf", "pdfrw"])
def tiff_rgb8_pdf(tmp_path_factory, tiff_rgb8_img, request):
out_pdf = tmp_path_factory.mktemp("tiff_rgb8_pdf") / "out.pdf"
subprocess.check_call(
[
"src/img2pdf.py",
"--producer=",
"--nodate",
"--engine=" + request.param,
"--output=" + str(out_pdf),
str(tiff_rgb8_img),
2020-06-05 23:18:39 +00:00
]
)
with pikepdf.open(str(out_pdf)) as p:
assert (
p.pages[0].Contents.read_bytes()
== b"q\n45.0000 0 0 45.0000 0.0000 0.0000 cm\n/Im0 Do\nQ"
)
assert p.pages[0].Resources.XObject.Im0.BitsPerComponent == 8
assert p.pages[0].Resources.XObject.Im0.ColorSpace == "/DeviceRGB"
assert p.pages[0].Resources.XObject.Im0.DecodeParms.BitsPerComponent == 8
assert p.pages[0].Resources.XObject.Im0.DecodeParms.Colors == 3
assert p.pages[0].Resources.XObject.Im0.DecodeParms.Predictor == 15
assert p.pages[0].Resources.XObject.Im0.Filter == "/FlateDecode"
assert p.pages[0].Resources.XObject.Im0.Height == 60
assert p.pages[0].Resources.XObject.Im0.Width == 60
yield out_pdf
out_pdf.unlink()
@pytest.fixture(scope="session", params=["internal", "pikepdf", "pdfrw"])
def tiff_gray1_pdf(tmp_path_factory, tiff_gray1_img, request):
out_pdf = tmp_path_factory.mktemp("tiff_gray1_pdf") / "out.pdf"
subprocess.check_call(
[
"src/img2pdf.py",
"--producer=",
"--nodate",
"--engine=" + request.param,
"--output=" + str(out_pdf),
str(tiff_gray1_img),
2020-06-05 23:18:39 +00:00
]
)
with pikepdf.open(str(out_pdf)) as p:
assert (
p.pages[0].Contents.read_bytes()
== b"q\n45.0000 0 0 45.0000 0.0000 0.0000 cm\n/Im0 Do\nQ"
)
assert p.pages[0].Resources.XObject.Im0.BitsPerComponent == 1
assert p.pages[0].Resources.XObject.Im0.ColorSpace == "/DeviceGray"
assert p.pages[0].Resources.XObject.Im0.DecodeParms[0].BlackIs1 == True
assert p.pages[0].Resources.XObject.Im0.DecodeParms[0].Columns == 60
assert p.pages[0].Resources.XObject.Im0.DecodeParms[0].K == -1
assert p.pages[0].Resources.XObject.Im0.DecodeParms[0].Rows == 60
assert p.pages[0].Resources.XObject.Im0.Filter[0] == "/CCITTFaxDecode"
assert p.pages[0].Resources.XObject.Im0.Height == 60
assert p.pages[0].Resources.XObject.Im0.Width == 60
yield out_pdf
out_pdf.unlink()
@pytest.fixture(scope="session", params=["internal", "pikepdf", "pdfrw"])
def tiff_gray2_pdf(tmp_path_factory, tiff_gray2_img, request):
out_pdf = tmp_path_factory.mktemp("tiff_gray2_pdf") / "out.pdf"
subprocess.check_call(
[
"src/img2pdf.py",
"--producer=",
"--nodate",
"--engine=" + request.param,
"--output=" + str(out_pdf),
str(tiff_gray2_img),
2020-06-05 23:18:39 +00:00
]
)
with pikepdf.open(str(out_pdf)) as p:
assert (
p.pages[0].Contents.read_bytes()
== b"q\n45.0000 0 0 45.0000 0.0000 0.0000 cm\n/Im0 Do\nQ"
)
assert p.pages[0].Resources.XObject.Im0.BitsPerComponent == 8
assert p.pages[0].Resources.XObject.Im0.ColorSpace == "/DeviceGray"
assert p.pages[0].Resources.XObject.Im0.DecodeParms.BitsPerComponent == 8
assert p.pages[0].Resources.XObject.Im0.DecodeParms.Colors == 1
assert p.pages[0].Resources.XObject.Im0.DecodeParms.Predictor == 15
assert p.pages[0].Resources.XObject.Im0.Filter == "/FlateDecode"
assert p.pages[0].Resources.XObject.Im0.Height == 60
assert p.pages[0].Resources.XObject.Im0.Width == 60
yield out_pdf
out_pdf.unlink()
@pytest.fixture(scope="session", params=["internal", "pikepdf", "pdfrw"])
def tiff_gray4_pdf(tmp_path_factory, tiff_gray4_img, request):
out_pdf = tmp_path_factory.mktemp("tiff_gray4_pdf") / "out.pdf"
subprocess.check_call(
[
"src/img2pdf.py",
"--producer=",
"--nodate",
"--engine=" + request.param,
"--output=" + str(out_pdf),
str(tiff_gray4_img),
2020-06-05 23:18:39 +00:00
]
)
with pikepdf.open(str(out_pdf)) as p:
assert (
p.pages[0].Contents.read_bytes()
== b"q\n45.0000 0 0 45.0000 0.0000 0.0000 cm\n/Im0 Do\nQ"
)
assert p.pages[0].Resources.XObject.Im0.BitsPerComponent == 8
assert p.pages[0].Resources.XObject.Im0.ColorSpace == "/DeviceGray"
assert p.pages[0].Resources.XObject.Im0.DecodeParms.BitsPerComponent == 8
assert p.pages[0].Resources.XObject.Im0.DecodeParms.Colors == 1
assert p.pages[0].Resources.XObject.Im0.DecodeParms.Predictor == 15
assert p.pages[0].Resources.XObject.Im0.Filter == "/FlateDecode"
assert p.pages[0].Resources.XObject.Im0.Height == 60
assert p.pages[0].Resources.XObject.Im0.Width == 60
yield out_pdf
out_pdf.unlink()
@pytest.fixture(scope="session", params=["internal", "pikepdf", "pdfrw"])
def tiff_gray8_pdf(tmp_path_factory, tiff_gray8_img, request):
out_pdf = tmp_path_factory.mktemp("tiff_gray8_pdf") / "out.pdf"
subprocess.check_call(
[
"src/img2pdf.py",
"--producer=",
"--nodate",
"--engine=" + request.param,
"--output=" + str(out_pdf),
str(tiff_gray8_img),
2020-06-05 23:18:39 +00:00
]
)
with pikepdf.open(str(out_pdf)) as p:
assert (
p.pages[0].Contents.read_bytes()
== b"q\n45.0000 0 0 45.0000 0.0000 0.0000 cm\n/Im0 Do\nQ"
)
assert p.pages[0].Resources.XObject.Im0.BitsPerComponent == 8
assert p.pages[0].Resources.XObject.Im0.ColorSpace == "/DeviceGray"
assert p.pages[0].Resources.XObject.Im0.DecodeParms.BitsPerComponent == 8
assert p.pages[0].Resources.XObject.Im0.DecodeParms.Colors == 1
assert p.pages[0].Resources.XObject.Im0.DecodeParms.Predictor == 15
assert p.pages[0].Resources.XObject.Im0.Filter == "/FlateDecode"
assert p.pages[0].Resources.XObject.Im0.Height == 60
assert p.pages[0].Resources.XObject.Im0.Width == 60
yield out_pdf
out_pdf.unlink()
@pytest.fixture(scope="session", params=["internal", "pikepdf", "pdfrw"])
def tiff_multipage_pdf(tmp_path_factory, tiff_multipage_img, request):
tmpdir = tmp_path_factory.mktemp("tiff_multipage_pdf")
out_pdf = tmpdir / "out.pdf"
subprocess.check_call(
[
"src/img2pdf.py",
"--producer=",
"--nodate",
"--engine=" + request.param,
"--output=" + str(out_pdf),
str(tiff_multipage_img),
2020-06-05 23:18:39 +00:00
]
)
pdfinfo = subprocess.check_output(["pdfinfo", str(out_pdf)])
assert re.search(
"^Pages: +2$", pdfinfo.decode("utf8"), re.MULTILINE
), identify.decode("utf8")
subprocess.check_call(["pdfseparate", str(out_pdf), str(tmpdir / "page-%d.pdf")])
2020-06-05 23:18:39 +00:00
for page in [1, 2]:
tiff_multipage_pdf_nr = tmpdir / ("page-%d.pdf" % page)
with pikepdf.open(tiff_multipage_pdf_nr) as p:
assert (
p.pages[0].Contents.read_bytes()
== b"q\n45.0000 0 0 45.0000 0.0000 0.0000 cm\n/Im0 Do\nQ"
)
assert p.pages[0].Resources.XObject.Im0.BitsPerComponent == 8
assert p.pages[0].Resources.XObject.Im0.ColorSpace == "/DeviceRGB"
assert p.pages[0].Resources.XObject.Im0.DecodeParms.BitsPerComponent == 8
assert p.pages[0].Resources.XObject.Im0.DecodeParms.Colors == 3
assert p.pages[0].Resources.XObject.Im0.DecodeParms.Predictor == 15
assert p.pages[0].Resources.XObject.Im0.Filter == "/FlateDecode"
assert p.pages[0].Resources.XObject.Im0.Height == 60
assert p.pages[0].Resources.XObject.Im0.Width == 60
tiff_multipage_pdf_nr.unlink()
yield out_pdf
out_pdf.unlink()
@pytest.fixture(scope="session", params=["internal", "pikepdf"])
def tiff_palette1_pdf(tmp_path_factory, tiff_palette1_img, request):
out_pdf = tmp_path_factory.mktemp("tiff_palette1_pdf") / "out.pdf"
subprocess.check_call(
[
"src/img2pdf.py",
"--producer=",
"--nodate",
"--engine=" + request.param,
"--output=" + str(out_pdf),
str(tiff_palette1_img),
2020-06-05 23:18:39 +00:00
]
)
with pikepdf.open(str(out_pdf)) as p:
assert (
p.pages[0].Contents.read_bytes()
== b"q\n45.0000 0 0 45.0000 0.0000 0.0000 cm\n/Im0 Do\nQ"
)
assert p.pages[0].Resources.XObject.Im0.BitsPerComponent == 1
assert p.pages[0].Resources.XObject.Im0.ColorSpace[0] == "/Indexed"
assert p.pages[0].Resources.XObject.Im0.ColorSpace[1] == "/DeviceRGB"
assert p.pages[0].Resources.XObject.Im0.DecodeParms.BitsPerComponent == 1
assert p.pages[0].Resources.XObject.Im0.DecodeParms.Colors == 1
assert p.pages[0].Resources.XObject.Im0.DecodeParms.Predictor == 15
assert p.pages[0].Resources.XObject.Im0.Filter == "/FlateDecode"
assert p.pages[0].Resources.XObject.Im0.Height == 60
assert p.pages[0].Resources.XObject.Im0.Width == 60
yield out_pdf
out_pdf.unlink()
@pytest.fixture(scope="session", params=["internal", "pikepdf"])
def tiff_palette2_pdf(tmp_path_factory, tiff_palette2_img, request):
out_pdf = tmp_path_factory.mktemp("tiff_palette2_pdf") / "out.pdf"
subprocess.check_call(
[
"src/img2pdf.py",
"--producer=",
"--nodate",
"--engine=" + request.param,
"--output=" + str(out_pdf),
str(tiff_palette2_img),
2020-06-05 23:18:39 +00:00
]
)
with pikepdf.open(str(out_pdf)) as p:
assert (
p.pages[0].Contents.read_bytes()
== b"q\n45.0000 0 0 45.0000 0.0000 0.0000 cm\n/Im0 Do\nQ"
)
assert p.pages[0].Resources.XObject.Im0.BitsPerComponent == 2
assert p.pages[0].Resources.XObject.Im0.ColorSpace[0] == "/Indexed"
assert p.pages[0].Resources.XObject.Im0.ColorSpace[1] == "/DeviceRGB"
assert p.pages[0].Resources.XObject.Im0.DecodeParms.BitsPerComponent == 2
assert p.pages[0].Resources.XObject.Im0.DecodeParms.Colors == 1
assert p.pages[0].Resources.XObject.Im0.DecodeParms.Predictor == 15
assert p.pages[0].Resources.XObject.Im0.Filter == "/FlateDecode"
assert p.pages[0].Resources.XObject.Im0.Height == 60
assert p.pages[0].Resources.XObject.Im0.Width == 60
yield out_pdf
out_pdf.unlink()
@pytest.fixture(scope="session", params=["internal", "pikepdf"])
def tiff_palette4_pdf(tmp_path_factory, tiff_palette4_img, request):
out_pdf = tmp_path_factory.mktemp("tiff_palette4_pdf") / "out.pdf"
subprocess.check_call(
[
"src/img2pdf.py",
"--producer=",
"--nodate",
"--engine=" + request.param,
"--output=" + str(out_pdf),
str(tiff_palette4_img),
2020-06-05 23:18:39 +00:00
]
)
with pikepdf.open(str(out_pdf)) as p:
assert (
p.pages[0].Contents.read_bytes()
== b"q\n45.0000 0 0 45.0000 0.0000 0.0000 cm\n/Im0 Do\nQ"
)
assert p.pages[0].Resources.XObject.Im0.BitsPerComponent == 4
assert p.pages[0].Resources.XObject.Im0.ColorSpace[0] == "/Indexed"
assert p.pages[0].Resources.XObject.Im0.ColorSpace[1] == "/DeviceRGB"
assert p.pages[0].Resources.XObject.Im0.DecodeParms.BitsPerComponent == 4
assert p.pages[0].Resources.XObject.Im0.DecodeParms.Colors == 1
assert p.pages[0].Resources.XObject.Im0.DecodeParms.Predictor == 15
assert p.pages[0].Resources.XObject.Im0.Filter == "/FlateDecode"
assert p.pages[0].Resources.XObject.Im0.Height == 60
assert p.pages[0].Resources.XObject.Im0.Width == 60
yield out_pdf
out_pdf.unlink()
@pytest.fixture(scope="session", params=["internal", "pikepdf"])
def tiff_palette8_pdf(tmp_path_factory, tiff_palette8_img, request):
out_pdf = tmp_path_factory.mktemp("tiff_palette8_pdf") / "out.pdf"
subprocess.check_call(
[
"src/img2pdf.py",
"--producer=",
"--nodate",
"--engine=" + request.param,
"--output=" + str(out_pdf),
str(tiff_palette8_img),
2020-06-05 23:18:39 +00:00
]
)
with pikepdf.open(str(out_pdf)) as p:
assert (
p.pages[0].Contents.read_bytes()
== b"q\n45.0000 0 0 45.0000 0.0000 0.0000 cm\n/Im0 Do\nQ"
)
assert p.pages[0].Resources.XObject.Im0.BitsPerComponent == 8
assert p.pages[0].Resources.XObject.Im0.ColorSpace[0] == "/Indexed"
assert p.pages[0].Resources.XObject.Im0.ColorSpace[1] == "/DeviceRGB"
assert p.pages[0].Resources.XObject.Im0.DecodeParms.BitsPerComponent == 8
assert p.pages[0].Resources.XObject.Im0.DecodeParms.Colors == 1
assert p.pages[0].Resources.XObject.Im0.DecodeParms.Predictor == 15
assert p.pages[0].Resources.XObject.Im0.Filter == "/FlateDecode"
assert p.pages[0].Resources.XObject.Im0.Height == 60
assert p.pages[0].Resources.XObject.Im0.Width == 60
yield out_pdf
out_pdf.unlink()
@pytest.fixture(scope="session", params=["internal", "pikepdf", "pdfrw"])
def tiff_ccitt_lsb_m2l_white_pdf(
tmp_path_factory, tiff_ccitt_lsb_m2l_white_img, request
):
out_pdf = tmp_path_factory.mktemp("tiff_ccitt_lsb_m2l_white_pdf") / "out.pdf"
subprocess.check_call(
[
"src/img2pdf.py",
"--producer=",
"--nodate",
"--engine=" + request.param,
"--output=" + str(out_pdf),
str(tiff_ccitt_lsb_m2l_white_img),
2020-06-05 23:18:39 +00:00
]
)
with pikepdf.open(str(out_pdf)) as p:
assert (
p.pages[0].Contents.read_bytes()
== b"q\n45.0000 0 0 45.0000 0.0000 0.0000 cm\n/Im0 Do\nQ"
)
assert p.pages[0].Resources.XObject.Im0.BitsPerComponent == 1
assert p.pages[0].Resources.XObject.Im0.ColorSpace == "/DeviceGray"
assert p.pages[0].Resources.XObject.Im0.DecodeParms[0].BlackIs1 == False
assert p.pages[0].Resources.XObject.Im0.DecodeParms[0].Columns == 60
assert p.pages[0].Resources.XObject.Im0.DecodeParms[0].K == -1
assert p.pages[0].Resources.XObject.Im0.DecodeParms[0].Rows == 60
assert p.pages[0].Resources.XObject.Im0.Filter[0] == "/CCITTFaxDecode"
assert p.pages[0].Resources.XObject.Im0.Height == 60
assert p.pages[0].Resources.XObject.Im0.Width == 60
yield out_pdf
out_pdf.unlink()
@pytest.fixture(scope="session", params=["internal", "pikepdf", "pdfrw"])
def tiff_ccitt_msb_m2l_white_pdf(
tmp_path_factory, tiff_ccitt_msb_m2l_white_img, request
):
out_pdf = tmp_path_factory.mktemp("tiff_ccitt_msb_m2l_white_pdf") / "out.pdf"
subprocess.check_call(
[
"src/img2pdf.py",
"--producer=",
"--nodate",
"--engine=" + request.param,
"--output=" + str(out_pdf),
str(tiff_ccitt_msb_m2l_white_img),
2020-06-05 23:18:39 +00:00
]
)
with pikepdf.open(str(out_pdf)) as p:
assert (
p.pages[0].Contents.read_bytes()
== b"q\n45.0000 0 0 45.0000 0.0000 0.0000 cm\n/Im0 Do\nQ"
)
assert p.pages[0].Resources.XObject.Im0.BitsPerComponent == 1
assert p.pages[0].Resources.XObject.Im0.ColorSpace == "/DeviceGray"
assert p.pages[0].Resources.XObject.Im0.DecodeParms[0].BlackIs1 == False
assert p.pages[0].Resources.XObject.Im0.DecodeParms[0].Columns == 60
assert p.pages[0].Resources.XObject.Im0.DecodeParms[0].K == -1
assert p.pages[0].Resources.XObject.Im0.DecodeParms[0].Rows == 60
assert p.pages[0].Resources.XObject.Im0.Filter[0] == "/CCITTFaxDecode"
assert p.pages[0].Resources.XObject.Im0.Height == 60
assert p.pages[0].Resources.XObject.Im0.Width == 60
yield out_pdf
out_pdf.unlink()
@pytest.fixture(scope="session", params=["internal", "pikepdf", "pdfrw"])
def tiff_ccitt_msb_l2m_white_pdf(
tmp_path_factory, tiff_ccitt_msb_l2m_white_img, request
):
out_pdf = tmp_path_factory.mktemp("tiff_ccitt_msb_l2m_white_pdf") / "out.pdf"
subprocess.check_call(
[
"src/img2pdf.py",
"--producer=",
"--nodate",
"--engine=" + request.param,
"--output=" + str(out_pdf),
str(tiff_ccitt_msb_l2m_white_img),
2020-06-05 23:18:39 +00:00
]
)
with pikepdf.open(str(out_pdf)) as p:
assert (
p.pages[0].Contents.read_bytes()
== b"q\n45.0000 0 0 45.0000 0.0000 0.0000 cm\n/Im0 Do\nQ"
)
assert p.pages[0].Resources.XObject.Im0.BitsPerComponent == 1
assert p.pages[0].Resources.XObject.Im0.ColorSpace == "/DeviceGray"
assert p.pages[0].Resources.XObject.Im0.DecodeParms[0].BlackIs1 == False
assert p.pages[0].Resources.XObject.Im0.DecodeParms[0].Columns == 60
assert p.pages[0].Resources.XObject.Im0.DecodeParms[0].K == -1
assert p.pages[0].Resources.XObject.Im0.DecodeParms[0].Rows == 60
assert p.pages[0].Resources.XObject.Im0.Filter[0] == "/CCITTFaxDecode"
assert p.pages[0].Resources.XObject.Im0.Height == 60
assert p.pages[0].Resources.XObject.Im0.Width == 60
yield out_pdf
out_pdf.unlink()
@pytest.fixture(scope="session", params=["internal", "pikepdf", "pdfrw"])
def tiff_ccitt_lsb_m2l_black_pdf(
tmp_path_factory, tiff_ccitt_lsb_m2l_black_img, request
):
out_pdf = tmp_path_factory.mktemp("tiff_ccitt_lsb_m2l_black_pdf") / "out.pdf"
subprocess.check_call(
[
"src/img2pdf.py",
"--producer=",
"--nodate",
"--engine=" + request.param,
"--output=" + str(out_pdf),
str(tiff_ccitt_lsb_m2l_black_img),
2020-06-05 23:18:39 +00:00
]
)
with pikepdf.open(str(out_pdf)) as p:
assert (
p.pages[0].Contents.read_bytes()
== b"q\n45.0000 0 0 45.0000 0.0000 0.0000 cm\n/Im0 Do\nQ"
)
assert p.pages[0].Resources.XObject.Im0.BitsPerComponent == 1
assert p.pages[0].Resources.XObject.Im0.ColorSpace == "/DeviceGray"
assert p.pages[0].Resources.XObject.Im0.DecodeParms[0].BlackIs1 == True
assert p.pages[0].Resources.XObject.Im0.DecodeParms[0].Columns == 60
assert p.pages[0].Resources.XObject.Im0.DecodeParms[0].K == -1
assert p.pages[0].Resources.XObject.Im0.DecodeParms[0].Rows == 60
assert p.pages[0].Resources.XObject.Im0.Filter[0] == "/CCITTFaxDecode"
assert p.pages[0].Resources.XObject.Im0.Height == 60
assert p.pages[0].Resources.XObject.Im0.Width == 60
yield out_pdf
out_pdf.unlink()
@pytest.fixture(scope="session", params=["internal", "pikepdf", "pdfrw"])
def tiff_ccitt_nometa1_pdf(tmp_path_factory, tiff_ccitt_nometa1_img, request):
out_pdf = tmp_path_factory.mktemp("tiff_ccitt_nometa1_pdf") / "out.pdf"
subprocess.check_call(
[
"src/img2pdf.py",
"--producer=",
"--nodate",
"--engine=" + request.param,
"--output=" + str(out_pdf),
str(tiff_ccitt_nometa1_img),
2020-06-05 23:18:39 +00:00
]
)
with pikepdf.open(str(out_pdf)) as p:
assert (
p.pages[0].Contents.read_bytes()
== b"q\n45.0000 0 0 45.0000 0.0000 0.0000 cm\n/Im0 Do\nQ"
)
assert p.pages[0].Resources.XObject.Im0.BitsPerComponent == 1
assert p.pages[0].Resources.XObject.Im0.ColorSpace == "/DeviceGray"
assert p.pages[0].Resources.XObject.Im0.DecodeParms[0].BlackIs1 == False
assert p.pages[0].Resources.XObject.Im0.DecodeParms[0].Columns == 60
assert p.pages[0].Resources.XObject.Im0.DecodeParms[0].K == -1
assert p.pages[0].Resources.XObject.Im0.DecodeParms[0].Rows == 60
assert p.pages[0].Resources.XObject.Im0.Filter[0] == "/CCITTFaxDecode"
assert p.pages[0].Resources.XObject.Im0.Height == 60
assert p.pages[0].Resources.XObject.Im0.Width == 60
yield out_pdf
out_pdf.unlink()
@pytest.fixture(scope="session", params=["internal", "pikepdf", "pdfrw"])
def tiff_ccitt_nometa2_pdf(tmp_path_factory, tiff_ccitt_nometa2_img, request):
out_pdf = tmp_path_factory.mktemp("tiff_ccitt_nometa2_pdf") / "out.pdf"
subprocess.check_call(
[
"src/img2pdf.py",
"--producer=",
"--nodate",
"--engine=" + request.param,
"--output=" + str(out_pdf),
str(tiff_ccitt_nometa2_img),
2020-06-05 23:18:39 +00:00
]
)
with pikepdf.open(str(out_pdf)) as p:
assert (
p.pages[0].Contents.read_bytes()
== b"q\n45.0000 0 0 45.0000 0.0000 0.0000 cm\n/Im0 Do\nQ"
)
assert p.pages[0].Resources.XObject.Im0.BitsPerComponent == 1
assert p.pages[0].Resources.XObject.Im0.ColorSpace == "/DeviceGray"
assert p.pages[0].Resources.XObject.Im0.DecodeParms[0].BlackIs1 == False
assert p.pages[0].Resources.XObject.Im0.DecodeParms[0].Columns == 60
assert p.pages[0].Resources.XObject.Im0.DecodeParms[0].K == -1
assert p.pages[0].Resources.XObject.Im0.DecodeParms[0].Rows == 60
assert p.pages[0].Resources.XObject.Im0.Filter[0] == "/CCITTFaxDecode"
assert p.pages[0].Resources.XObject.Im0.Height == 60
assert p.pages[0].Resources.XObject.Im0.Width == 60
yield out_pdf
out_pdf.unlink()
###############################################################################
# TEST CASES #
###############################################################################
@pytest.mark.skipif(
sys.platform in ["darwin", "win32"],
reason="test utilities not available on Windows and MacOS",
)
2020-06-05 23:18:39 +00:00
def test_jpg(tmp_path_factory, jpg_img, jpg_pdf):
tmpdir = tmp_path_factory.mktemp("jpg")
pnm = tmpdir / "jpg.pnm"
# We have to use jpegtopnm with the original JPG before being able to compare
# it with imagemagick because imagemagick will decode the JPG slightly
# differently than ghostscript, poppler and mupdf do it.
# We have to use jpegtopnm and cannot use djpeg because the latter produces
# slightly different results as well when called like this:
# djpeg -dct int -pnm "$tempdir/normal.jpg" > "$tempdir/normal.pnm"
# An alternative way to compare the JPG would be to require a different DCT
# method when decoding by setting -define jpeg:dct-method=ifast in the
# compare command.
pnm.write_bytes(subprocess.check_output(["jpegtopnm", "-dct", "int", str(jpg_img)]))
compare_ghostscript(tmpdir, pnm, jpg_pdf)
compare_poppler(tmpdir, pnm, jpg_pdf)
compare_mupdf(tmpdir, pnm, jpg_pdf)
pnm.unlink()
compare_pdfimages_jpg(tmpdir, jpg_img, jpg_pdf)
@pytest.mark.skipif(
sys.platform in ["darwin", "win32"],
reason="test utilities not available on Windows and MacOS",
)
2020-06-05 23:18:39 +00:00
def test_jpg_rot(tmp_path_factory, jpg_rot_img, jpg_rot_pdf):
tmpdir = tmp_path_factory.mktemp("jpg_rot")
# We have to use jpegtopnm with the original JPG before being able to compare
# it with imagemagick because imagemagick will decode the JPG slightly
# differently than ghostscript, poppler and mupdf do it.
# We have to use jpegtopnm and cannot use djpeg because the latter produces
# slightly different results as well when called like this:
# djpeg -dct int -pnm "$tempdir/normal.jpg" > "$tempdir/normal.pnm"
# An alternative way to compare the JPG would be to require a different DCT
# method when decoding by setting -define jpeg:dct-method=ifast in the
# compare command.
jpg_rot_pnm = tmpdir / "jpg_rot.pnm"
jpg_rot_pnm.write_bytes(
subprocess.check_output(["jpegtopnm", "-dct", "int", str(jpg_rot_img)])
)
jpg_rot_png = tmpdir / "jpg_rot.png"
subprocess.check_call(
["convert", "-rotate", "90", str(jpg_rot_pnm), str(jpg_rot_png)]
)
jpg_rot_pnm.unlink()
compare_ghostscript(tmpdir, jpg_rot_png, jpg_rot_pdf)
compare_poppler(tmpdir, jpg_rot_png, jpg_rot_pdf)
compare_mupdf(tmpdir, jpg_rot_png, jpg_rot_pdf)
jpg_rot_png.unlink()
compare_pdfimages_jpg(tmpdir, jpg_rot_img, jpg_rot_pdf)
@pytest.mark.skipif(
sys.platform in ["darwin", "win32"],
reason="test utilities not available on Windows and MacOS",
)
2020-06-05 23:18:39 +00:00
def test_jpg_cmyk(tmp_path_factory, jpg_cmyk_img, jpg_cmyk_pdf):
tmpdir = tmp_path_factory.mktemp("jpg_cmyk")
compare_ghostscript(
tmpdir, jpg_cmyk_img, jpg_cmyk_pdf, gsdevice="tiff32nc", exact=False
)
# not testing with poppler as it cannot write CMYK images
compare_mupdf(tmpdir, jpg_cmyk_img, jpg_cmyk_pdf, exact=False, cmyk=True)
compare_pdfimages_cmyk(tmpdir, jpg_cmyk_img, jpg_cmyk_pdf)
2020-06-05 23:18:39 +00:00
@pytest.mark.skipif(
not HAVE_IMAGEMAGICK_MODERN, reason="requires imagemagick with support for jpeg2000"
)
@pytest.mark.skipif(
sys.platform in ["darwin", "win32"],
reason="test utilities not available on Windows and MacOS",
)
2020-06-05 23:18:39 +00:00
def test_jpg_2000(tmp_path_factory, jpg_2000_img, jpg_2000_pdf):
tmpdir = tmp_path_factory.mktemp("jpg_2000")
compare_ghostscript(tmpdir, jpg_2000_img, jpg_2000_pdf)
compare_poppler(tmpdir, jpg_2000_img, jpg_2000_pdf)
compare_mupdf(tmpdir, jpg_2000_img, jpg_2000_pdf)
compare_pdfimages_jp2(tmpdir, jpg_2000_img, jpg_2000_pdf)
@pytest.mark.skipif(
sys.platform in ["darwin", "win32"],
reason="test utilities not available on Windows and MacOS",
)
2020-06-05 23:18:39 +00:00
def test_png_rgb8(tmp_path_factory, png_rgb8_img, png_rgb8_pdf):
tmpdir = tmp_path_factory.mktemp("png_rgb8")
compare_ghostscript(tmpdir, png_rgb8_img, png_rgb8_pdf)
compare_poppler(tmpdir, png_rgb8_img, png_rgb8_pdf)
compare_mupdf(tmpdir, png_rgb8_img, png_rgb8_pdf)
compare_pdfimages_png(tmpdir, png_rgb8_img, png_rgb8_pdf)
@pytest.mark.skipif(
sys.platform in ["darwin", "win32"],
reason="test utilities not available on Windows and MacOS",
)
2020-06-05 23:18:39 +00:00
def test_png_rgb16(tmp_path_factory, png_rgb16_img, png_rgb16_pdf):
tmpdir = tmp_path_factory.mktemp("png_rgb16")
compare_ghostscript(tmpdir, png_rgb16_img, png_rgb16_pdf, gsdevice="tiff48nc")
# poppler outputs 8-bit RGB so the comparison will not be exact
compare_poppler(tmpdir, png_rgb16_img, png_rgb16_pdf, exact=False)
# pdfimages is unable to write 16 bit output
@pytest.mark.skipif(
sys.platform in ["darwin", "win32"],
reason="test utilities not available on Windows and MacOS",
)
2020-06-05 23:18:39 +00:00
@pytest.mark.parametrize("engine", ["internal", "pikepdf", "pdfrw"])
def test_png_rgba8(tmp_path_factory, png_rgba8_img, engine):
out_pdf = tmp_path_factory.mktemp("png_rgba8") / "out.pdf"
assert (
0
!= subprocess.run(
[
"src/img2pdf.py",
"--producer=",
"--nodate",
"--engine=" + engine,
"--output=" + str(out_pdf),
str(png_rgba8_img),
2020-06-05 23:18:39 +00:00
]
).returncode
)
out_pdf.unlink()
@pytest.mark.skipif(
sys.platform in ["darwin", "win32"],
reason="test utilities not available on Windows and MacOS",
)
2020-06-05 23:18:39 +00:00
@pytest.mark.parametrize("engine", ["internal", "pikepdf", "pdfrw"])
def test_png_rgba16(tmp_path_factory, png_rgba16_img, engine):
out_pdf = tmp_path_factory.mktemp("png_rgba16") / "out.pdf"
assert (
0
!= subprocess.run(
[
"src/img2pdf.py",
"--producer=",
"--nodate",
"--engine=" + engine,
"--output=" + str(out_pdf),
str(png_rgba16_img),
2020-06-05 23:18:39 +00:00
]
).returncode
)
out_pdf.unlink()
@pytest.mark.skipif(
sys.platform in ["darwin", "win32"],
reason="test utilities not available on Windows and MacOS",
)
2020-06-05 23:18:39 +00:00
@pytest.mark.parametrize("engine", ["internal", "pikepdf", "pdfrw"])
def test_png_gray8a(tmp_path_factory, png_gray8a_img, engine):
out_pdf = tmp_path_factory.mktemp("png_gray8a") / "out.pdf"
assert (
0
!= subprocess.run(
[
"src/img2pdf.py",
"--producer=",
"--nodate",
"--engine=" + engine,
"--output=" + str(out_pdf),
str(png_gray8a_img),
2020-06-05 23:18:39 +00:00
]
).returncode
)
out_pdf.unlink()
@pytest.mark.skipif(
sys.platform in ["darwin", "win32"],
reason="test utilities not available on Windows and MacOS",
)
2020-06-05 23:18:39 +00:00
@pytest.mark.parametrize("engine", ["internal", "pikepdf", "pdfrw"])
def test_png_gray16a(tmp_path_factory, png_gray16a_img, engine):
out_pdf = tmp_path_factory.mktemp("png_gray16a") / "out.pdf"
assert (
0
!= subprocess.run(
[
"src/img2pdf.py",
"--producer=",
"--nodate",
"--engine=" + engine,
"--output=" + str(out_pdf),
str(png_gray16a_img),
2020-06-05 23:18:39 +00:00
]
).returncode
)
out_pdf.unlink()
@pytest.mark.skipif(
sys.platform in ["darwin", "win32"],
reason="test utilities not available on Windows and MacOS",
)
2020-06-05 23:18:39 +00:00
def test_png_interlaced(tmp_path_factory, png_interlaced_img, png_interlaced_pdf):
tmpdir = tmp_path_factory.mktemp("png_interlaced")
compare_ghostscript(tmpdir, png_interlaced_img, png_interlaced_pdf)
compare_poppler(tmpdir, png_interlaced_img, png_interlaced_pdf)
compare_mupdf(tmpdir, png_interlaced_img, png_interlaced_pdf)
compare_pdfimages_png(tmpdir, png_interlaced_img, png_interlaced_pdf)
@pytest.mark.skipif(
sys.platform in ["darwin", "win32"],
reason="test utilities not available on Windows and MacOS",
)
2020-06-05 23:18:39 +00:00
def test_png_gray1(tmp_path_factory, png_gray1_img, png_gray1_pdf):
tmpdir = tmp_path_factory.mktemp("png_gray1")
compare_ghostscript(tmpdir, png_gray1_img, png_gray1_pdf, gsdevice="pnggray")
compare_poppler(tmpdir, png_gray1_img, png_gray1_pdf)
compare_mupdf(tmpdir, png_gray1_img, png_gray1_pdf)
compare_pdfimages_png(tmpdir, png_gray1_img, png_gray1_pdf)
@pytest.mark.skipif(
sys.platform in ["darwin", "win32"],
reason="test utilities not available on Windows and MacOS",
)
2020-06-05 23:18:39 +00:00
def test_png_gray2(tmp_path_factory, png_gray2_img, png_gray2_pdf):
tmpdir = tmp_path_factory.mktemp("png_gray2")
compare_ghostscript(tmpdir, png_gray2_img, png_gray2_pdf, gsdevice="pnggray")
compare_poppler(tmpdir, png_gray2_img, png_gray2_pdf)
compare_mupdf(tmpdir, png_gray2_img, png_gray2_pdf)
compare_pdfimages_png(tmpdir, png_gray2_img, png_gray2_pdf)
@pytest.mark.skipif(
sys.platform in ["darwin", "win32"],
reason="test utilities not available on Windows and MacOS",
)
2020-06-05 23:18:39 +00:00
def test_png_gray4(tmp_path_factory, png_gray4_img, png_gray4_pdf):
tmpdir = tmp_path_factory.mktemp("png_gray4")
compare_ghostscript(tmpdir, png_gray4_img, png_gray4_pdf, gsdevice="pnggray")
compare_poppler(tmpdir, png_gray4_img, png_gray4_pdf)
compare_mupdf(tmpdir, png_gray4_img, png_gray4_pdf)
compare_pdfimages_png(tmpdir, png_gray4_img, png_gray4_pdf)
@pytest.mark.skipif(
sys.platform in ["darwin", "win32"],
reason="test utilities not available on Windows and MacOS",
)
2020-06-05 23:18:39 +00:00
def test_png_gray8(tmp_path_factory, png_gray8_img, png_gray8_pdf):
tmpdir = tmp_path_factory.mktemp("png_gray8")
compare_ghostscript(tmpdir, png_gray8_img, png_gray8_pdf, gsdevice="pnggray")
compare_poppler(tmpdir, png_gray8_img, png_gray8_pdf)
compare_mupdf(tmpdir, png_gray8_img, png_gray8_pdf)
compare_pdfimages_png(tmpdir, png_gray8_img, png_gray8_pdf)
@pytest.mark.skipif(
sys.platform in ["darwin", "win32"],
reason="test utilities not available on Windows and MacOS",
)
2020-06-05 23:18:39 +00:00
def test_png_gray16(tmp_path_factory, png_gray16_img, png_gray16_pdf):
tmpdir = tmp_path_factory.mktemp("png_gray16")
# ghostscript outputs 8-bit grayscale, so the comparison will not be exact
compare_ghostscript(
tmpdir, png_gray16_img, png_gray16_pdf, gsdevice="pnggray", exact=False
)
# poppler outputs 8-bit grayscale so the comparison will not be exact
compare_poppler(tmpdir, png_gray16_img, png_gray16_pdf, exact=False)
# pdfimages outputs 8-bit grayscale so the comparison will not be exact
compare_pdfimages_png(tmpdir, png_gray16_img, png_gray16_pdf, exact=False)
@pytest.mark.skipif(
sys.platform in ["darwin", "win32"],
reason="test utilities not available on Windows and MacOS",
)
2020-06-05 23:18:39 +00:00
def test_png_palette1(tmp_path_factory, png_palette1_img, png_palette1_pdf):
tmpdir = tmp_path_factory.mktemp("png_palette1")
compare_ghostscript(tmpdir, png_palette1_img, png_palette1_pdf)
compare_poppler(tmpdir, png_palette1_img, png_palette1_pdf)
compare_mupdf(tmpdir, png_palette1_img, png_palette1_pdf)
# pdfimages cannot export palette based images
@pytest.mark.skipif(
sys.platform in ["darwin", "win32"],
reason="test utilities not available on Windows and MacOS",
)
2020-06-05 23:18:39 +00:00
def test_png_palette2(tmp_path_factory, png_palette2_img, png_palette2_pdf):
tmpdir = tmp_path_factory.mktemp("png_palette2")
compare_ghostscript(tmpdir, png_palette2_img, png_palette2_pdf)
compare_poppler(tmpdir, png_palette2_img, png_palette2_pdf)
compare_mupdf(tmpdir, png_palette2_img, png_palette2_pdf)
# pdfimages cannot export palette based images
@pytest.mark.skipif(
sys.platform in ["darwin", "win32"],
reason="test utilities not available on Windows and MacOS",
)
2020-06-05 23:18:39 +00:00
def test_png_palette4(tmp_path_factory, png_palette4_img, png_palette4_pdf):
tmpdir = tmp_path_factory.mktemp("png_palette4")
compare_ghostscript(tmpdir, png_palette4_img, png_palette4_pdf)
compare_poppler(tmpdir, png_palette4_img, png_palette4_pdf)
compare_mupdf(tmpdir, png_palette4_img, png_palette4_pdf)
# pdfimages cannot export palette based images
@pytest.mark.skipif(
sys.platform in ["darwin", "win32"],
reason="test utilities not available on Windows and MacOS",
)
2020-06-05 23:18:39 +00:00
def test_png_palette8(tmp_path_factory, png_palette8_img, png_palette8_pdf):
tmpdir = tmp_path_factory.mktemp("png_palette8")
compare_ghostscript(tmpdir, png_palette8_img, png_palette8_pdf)
compare_poppler(tmpdir, png_palette8_img, png_palette8_pdf)
compare_mupdf(tmpdir, png_palette8_img, png_palette8_pdf)
# pdfimages cannot export palette based images
@pytest.mark.skipif(
sys.platform in ["darwin", "win32"],
reason="test utilities not available on Windows and MacOS",
)
2020-06-05 23:18:39 +00:00
@pytest.mark.parametrize("engine", ["internal", "pikepdf", "pdfrw"])
def test_gif_transparent(tmp_path_factory, gif_transparent_img, engine):
out_pdf = tmp_path_factory.mktemp("gif_transparent") / "out.pdf"
assert (
0
!= subprocess.run(
[
"src/img2pdf.py",
"--producer=",
"--nodate",
"--engine=" + engine,
"--output=" + str(out_pdf),
str(gif_transparent_img),
2020-06-05 23:18:39 +00:00
]
).returncode
)
out_pdf.unlink()
@pytest.mark.skipif(
sys.platform in ["darwin", "win32"],
reason="test utilities not available on Windows and MacOS",
)
2020-06-05 23:18:39 +00:00
def test_gif_palette1(tmp_path_factory, gif_palette1_img, gif_palette1_pdf):
tmpdir = tmp_path_factory.mktemp("gif_palette1")
compare_ghostscript(tmpdir, gif_palette1_img, gif_palette1_pdf)
compare_poppler(tmpdir, gif_palette1_img, gif_palette1_pdf)
compare_mupdf(tmpdir, gif_palette1_img, gif_palette1_pdf)
# pdfimages cannot export palette based images
@pytest.mark.skipif(
sys.platform in ["darwin", "win32"],
reason="test utilities not available on Windows and MacOS",
)
2020-06-05 23:18:39 +00:00
def test_gif_palette2(tmp_path_factory, gif_palette2_img, gif_palette2_pdf):
tmpdir = tmp_path_factory.mktemp("gif_palette2")
compare_ghostscript(tmpdir, gif_palette2_img, gif_palette2_pdf)
compare_poppler(tmpdir, gif_palette2_img, gif_palette2_pdf)
compare_mupdf(tmpdir, gif_palette2_img, gif_palette2_pdf)
# pdfimages cannot export palette based images
@pytest.mark.skipif(
sys.platform in ["darwin", "win32"],
reason="test utilities not available on Windows and MacOS",
)
2020-06-05 23:18:39 +00:00
def test_gif_palette4(tmp_path_factory, gif_palette4_img, gif_palette4_pdf):
tmpdir = tmp_path_factory.mktemp("gif_palette4")
compare_ghostscript(tmpdir, gif_palette4_img, gif_palette4_pdf)
compare_poppler(tmpdir, gif_palette4_img, gif_palette4_pdf)
compare_mupdf(tmpdir, gif_palette4_img, gif_palette4_pdf)
# pdfimages cannot export palette based images
@pytest.mark.skipif(
sys.platform in ["darwin", "win32"],
reason="test utilities not available on Windows and MacOS",
)
2020-06-05 23:18:39 +00:00
def test_gif_palette8(tmp_path_factory, gif_palette8_img, gif_palette8_pdf):
tmpdir = tmp_path_factory.mktemp("gif_palette8")
compare_ghostscript(tmpdir, gif_palette8_img, gif_palette8_pdf)
compare_poppler(tmpdir, gif_palette8_img, gif_palette8_pdf)
compare_mupdf(tmpdir, gif_palette8_img, gif_palette8_pdf)
# pdfimages cannot export palette based images
@pytest.mark.skipif(
sys.platform in ["darwin", "win32"],
reason="test utilities not available on Windows and MacOS",
)
2020-06-05 23:18:39 +00:00
def test_gif_animation(tmp_path_factory, gif_animation_img, gif_animation_pdf):
tmpdir = tmp_path_factory.mktemp("gif_animation")
subprocess.check_call(
["pdfseparate", str(gif_animation_pdf), str(tmpdir / "page-%d.pdf")]
2020-06-05 23:18:39 +00:00
)
for page in [1, 2]:
gif_animation_pdf_nr = tmpdir / ("page-%d.pdf" % page)
compare_ghostscript(
tmpdir, str(gif_animation_img) + "[%d]" % (page - 1), gif_animation_pdf_nr
)
compare_poppler(
tmpdir, str(gif_animation_img) + "[%d]" % (page - 1), gif_animation_pdf_nr
)
compare_mupdf(
tmpdir, str(gif_animation_img) + "[%d]" % (page - 1), gif_animation_pdf_nr
)
# pdfimages cannot export palette based images
gif_animation_pdf_nr.unlink()
@pytest.mark.skipif(
sys.platform in ["darwin", "win32"],
reason="test utilities not available on Windows and MacOS",
)
2020-06-05 23:18:39 +00:00
@pytest.mark.parametrize("engine", ["internal", "pikepdf", "pdfrw"])
def test_tiff_float(tmp_path_factory, tiff_float_img, engine):
out_pdf = tmp_path_factory.mktemp("tiff_float") / "out.pdf"
assert (
0
!= subprocess.run(
[
"src/img2pdf.py",
"--producer=",
"--nodate",
"--engine=" + engine,
"--output=" + str(out_pdf),
str(tiff_float_img),
2020-06-05 23:18:39 +00:00
]
).returncode
)
out_pdf.unlink()
@pytest.mark.skipif(
sys.platform in ["darwin", "win32"],
reason="test utilities not available on Windows and MacOS",
)
2020-06-05 23:18:39 +00:00
def test_tiff_cmyk8(tmp_path_factory, tiff_cmyk8_img, tiff_cmyk8_pdf):
tmpdir = tmp_path_factory.mktemp("tiff_cmyk8")
compare_ghostscript(
2020-08-04 22:47:50 +00:00
tmpdir, tiff_cmyk8_img, tiff_cmyk8_pdf, gsdevice="tiff32nc", exact=False
2020-06-05 23:18:39 +00:00
)
# not testing with poppler as it cannot write CMYK images
compare_mupdf(tmpdir, tiff_cmyk8_img, tiff_cmyk8_pdf, exact=False, cmyk=True)
compare_pdfimages_tiff(tmpdir, tiff_cmyk8_img, tiff_cmyk8_pdf)
@pytest.mark.skipif(
sys.platform in ["darwin", "win32"],
reason="test utilities not available on Windows and MacOS",
)
2020-06-05 23:18:39 +00:00
@pytest.mark.parametrize("engine", ["internal", "pikepdf", "pdfrw"])
def test_tiff_cmyk16(tmp_path_factory, tiff_cmyk16_img, engine):
out_pdf = tmp_path_factory.mktemp("tiff_cmyk16") / "out.pdf"
# PIL is unable to read 16 bit CMYK images
assert (
0
!= subprocess.run(
[
"src/img2pdf.py",
"--producer=",
"--nodate",
"--engine=" + engine,
"--output=" + str(out_pdf),
str(tiff_cmyk16_img),
2020-06-05 23:18:39 +00:00
]
).returncode
)
out_pdf.unlink()
@pytest.mark.skipif(
sys.platform in ["darwin", "win32"],
reason="test utilities not available on Windows and MacOS",
)
2020-06-05 23:18:39 +00:00
def test_tiff_rgb8(tmp_path_factory, tiff_rgb8_img, tiff_rgb8_pdf):
tmpdir = tmp_path_factory.mktemp("tiff_rgb8")
compare_ghostscript(tmpdir, tiff_rgb8_img, tiff_rgb8_pdf, gsdevice="tiff24nc")
compare_poppler(tmpdir, tiff_rgb8_img, tiff_rgb8_pdf)
compare_mupdf(tmpdir, tiff_rgb8_img, tiff_rgb8_pdf)
compare_pdfimages_tiff(tmpdir, tiff_rgb8_img, tiff_rgb8_pdf)
@pytest.mark.skipif(
sys.platform in ["darwin", "win32"],
reason="test utilities not available on Windows and MacOS",
)
2020-06-05 23:18:39 +00:00
@pytest.mark.parametrize("engine", ["internal", "pikepdf", "pdfrw"])
def test_tiff_rgb12(tmp_path_factory, tiff_rgb12_img, engine):
out_pdf = tmp_path_factory.mktemp("tiff_rgb12") / "out.pdf"
# PIL is unable to preserve more than 8 bits per sample
assert (
0
!= subprocess.run(
[
"src/img2pdf.py",
"--producer=",
"--nodate",
"--engine=" + engine,
"--output=" + str(out_pdf),
str(tiff_rgb12_img),
2020-06-05 23:18:39 +00:00
]
).returncode
)
out_pdf.unlink()
@pytest.mark.skipif(
sys.platform in ["darwin", "win32"],
reason="test utilities not available on Windows and MacOS",
)
2020-06-05 23:18:39 +00:00
@pytest.mark.parametrize("engine", ["internal", "pikepdf", "pdfrw"])
def test_tiff_rgb14(tmp_path_factory, tiff_rgb14_img, engine):
out_pdf = tmp_path_factory.mktemp("tiff_rgb14") / "out.pdf"
# PIL is unable to preserve more than 8 bits per sample
assert (
0
!= subprocess.run(
[
"src/img2pdf.py",
"--producer=",
"--nodate",
"--engine=" + engine,
"--output=" + str(out_pdf),
str(tiff_rgb14_img),
2020-06-05 23:18:39 +00:00
]
).returncode
)
out_pdf.unlink()
@pytest.mark.skipif(
sys.platform in ["darwin", "win32"],
reason="test utilities not available on Windows and MacOS",
)
2020-06-05 23:18:39 +00:00
@pytest.mark.parametrize("engine", ["internal", "pikepdf", "pdfrw"])
def test_tiff_rgb16(tmp_path_factory, tiff_rgb16_img, engine):
out_pdf = tmp_path_factory.mktemp("tiff_rgb16") / "out.pdf"
# PIL is unable to preserve more than 8 bits per sample
assert (
0
!= subprocess.run(
[
"src/img2pdf.py",
"--producer=",
"--nodate",
"--engine=" + engine,
"--output=" + str(out_pdf),
str(tiff_rgb16_img),
2020-06-05 23:18:39 +00:00
]
).returncode
)
out_pdf.unlink()
@pytest.mark.skipif(
sys.platform in ["darwin", "win32"],
reason="test utilities not available on Windows and MacOS",
)
2020-06-05 23:18:39 +00:00
@pytest.mark.parametrize("engine", ["internal", "pikepdf", "pdfrw"])
def test_tiff_rgba8(tmp_path_factory, tiff_rgba8_img, engine):
out_pdf = tmp_path_factory.mktemp("tiff_rgba8") / "out.pdf"
assert (
0
!= subprocess.run(
[
"src/img2pdf.py",
"--producer=",
"--nodate",
"--engine=" + engine,
"--output=" + str(out_pdf),
str(tiff_rgba8_img),
2020-06-05 23:18:39 +00:00
]
).returncode
)
out_pdf.unlink()
@pytest.mark.skipif(
sys.platform in ["darwin", "win32"],
reason="test utilities not available on Windows and MacOS",
)
2020-06-05 23:18:39 +00:00
@pytest.mark.parametrize("engine", ["internal", "pikepdf", "pdfrw"])
def test_tiff_rgba16(tmp_path_factory, tiff_rgba16_img, engine):
out_pdf = tmp_path_factory.mktemp("tiff_rgba16") / "out.pdf"
assert (
0
!= subprocess.run(
[
"src/img2pdf.py",
"--producer=",
"--nodate",
"--engine=" + engine,
"--output=" + str(out_pdf),
str(tiff_rgba16_img),
2020-06-05 23:18:39 +00:00
]
).returncode
)
out_pdf.unlink()
@pytest.mark.skipif(
sys.platform in ["darwin", "win32"],
reason="test utilities not available on Windows and MacOS",
)
2020-06-05 23:18:39 +00:00
def test_tiff_gray1(tmp_path_factory, tiff_gray1_img, tiff_gray1_pdf):
tmpdir = tmp_path_factory.mktemp("tiff_gray1")
compare_ghostscript(tmpdir, tiff_gray1_img, tiff_gray1_pdf, gsdevice="pnggray")
compare_poppler(tmpdir, tiff_gray1_img, tiff_gray1_pdf)
compare_mupdf(tmpdir, tiff_gray1_img, tiff_gray1_pdf)
compare_pdfimages_tiff(tmpdir, tiff_gray1_img, tiff_gray1_pdf)
@pytest.mark.skipif(
sys.platform in ["darwin", "win32"],
reason="test utilities not available on Windows and MacOS",
)
2020-06-05 23:18:39 +00:00
def test_tiff_gray2(tmp_path_factory, tiff_gray2_img, tiff_gray2_pdf):
tmpdir = tmp_path_factory.mktemp("tiff_gray2")
compare_ghostscript(tmpdir, tiff_gray2_img, tiff_gray2_pdf, gsdevice="pnggray")
compare_poppler(tmpdir, tiff_gray2_img, tiff_gray2_pdf)
compare_mupdf(tmpdir, tiff_gray2_img, tiff_gray2_pdf)
compare_pdfimages_tiff(tmpdir, tiff_gray2_img, tiff_gray2_pdf)
@pytest.mark.skipif(
sys.platform in ["darwin", "win32"],
reason="test utilities not available on Windows and MacOS",
)
2020-06-05 23:18:39 +00:00
def test_tiff_gray4(tmp_path_factory, tiff_gray4_img, tiff_gray4_pdf):
tmpdir = tmp_path_factory.mktemp("tiff_gray4")
compare_ghostscript(tmpdir, tiff_gray4_img, tiff_gray4_pdf, gsdevice="pnggray")
compare_poppler(tmpdir, tiff_gray4_img, tiff_gray4_pdf)
compare_mupdf(tmpdir, tiff_gray4_img, tiff_gray4_pdf)
compare_pdfimages_tiff(tmpdir, tiff_gray4_img, tiff_gray4_pdf)
@pytest.mark.skipif(
sys.platform in ["darwin", "win32"],
reason="test utilities not available on Windows and MacOS",
)
2020-06-05 23:18:39 +00:00
def test_tiff_gray8(tmp_path_factory, tiff_gray8_img, tiff_gray8_pdf):
tmpdir = tmp_path_factory.mktemp("tiff_gray8")
compare_ghostscript(tmpdir, tiff_gray8_img, tiff_gray8_pdf, gsdevice="pnggray")
compare_poppler(tmpdir, tiff_gray8_img, tiff_gray8_pdf)
compare_mupdf(tmpdir, tiff_gray8_img, tiff_gray8_pdf)
compare_pdfimages_tiff(tmpdir, tiff_gray8_img, tiff_gray8_pdf)
@pytest.mark.skipif(
sys.platform in ["darwin", "win32"],
reason="test utilities not available on Windows and MacOS",
)
2020-06-05 23:18:39 +00:00
@pytest.mark.parametrize("engine", ["internal", "pikepdf", "pdfrw"])
def test_tiff_gray16(tmp_path_factory, tiff_gray16_img, engine):
out_pdf = tmp_path_factory.mktemp("tiff_gray16") / "out.pdf"
assert (
0
!= subprocess.run(
[
"src/img2pdf.py",
"--producer=",
"--nodate",
"--engine=" + engine,
"--output=" + str(out_pdf),
str(tiff_gray16_img),
2020-06-05 23:18:39 +00:00
]
).returncode
)
out_pdf.unlink()
@pytest.mark.skipif(
sys.platform in ["darwin", "win32"],
reason="test utilities not available on Windows and MacOS",
)
2020-06-05 23:18:39 +00:00
def test_tiff_multipage(tmp_path_factory, tiff_multipage_img, tiff_multipage_pdf):
tmpdir = tmp_path_factory.mktemp("tiff_multipage")
subprocess.check_call(
["pdfseparate", str(tiff_multipage_pdf), str(tmpdir / "page-%d.pdf")]
2020-06-05 23:18:39 +00:00
)
for page in [1, 2]:
tiff_multipage_pdf_nr = tmpdir / ("page-%d.pdf" % page)
compare_ghostscript(
tmpdir, str(tiff_multipage_img) + "[%d]" % (page - 1), tiff_multipage_pdf_nr
)
compare_poppler(
tmpdir, str(tiff_multipage_img) + "[%d]" % (page - 1), tiff_multipage_pdf_nr
)
compare_mupdf(
tmpdir, str(tiff_multipage_img) + "[%d]" % (page - 1), tiff_multipage_pdf_nr
)
compare_pdfimages_tiff(
tmpdir, str(tiff_multipage_img) + "[%d]" % (page - 1), tiff_multipage_pdf_nr
)
tiff_multipage_pdf_nr.unlink()
@pytest.mark.skipif(
not HAVE_IMAGEMAGICK_MODERN,
reason="requires imagemagick with support for keeping the palette depth",
)
@pytest.mark.skipif(
sys.platform in ["darwin", "win32"],
reason="test utilities not available on Windows and MacOS",
)
2020-06-05 23:18:39 +00:00
def test_tiff_palette1(tmp_path_factory, tiff_palette1_img, tiff_palette1_pdf):
tmpdir = tmp_path_factory.mktemp("tiff_palette1")
compare_ghostscript(tmpdir, tiff_palette1_img, tiff_palette1_pdf)
compare_poppler(tmpdir, tiff_palette1_img, tiff_palette1_pdf)
compare_mupdf(tmpdir, tiff_palette1_img, tiff_palette1_pdf)
# pdfimages cannot export palette based images
@pytest.mark.skipif(
not HAVE_IMAGEMAGICK_MODERN,
reason="requires imagemagick with support for keeping the palette depth",
)
@pytest.mark.skipif(
sys.platform in ["darwin", "win32"],
reason="test utilities not available on Windows and MacOS",
)
2020-06-05 23:18:39 +00:00
def test_tiff_palette2(tmp_path_factory, tiff_palette2_img, tiff_palette2_pdf):
tmpdir = tmp_path_factory.mktemp("tiff_palette2")
compare_ghostscript(tmpdir, tiff_palette2_img, tiff_palette2_pdf)
compare_poppler(tmpdir, tiff_palette2_img, tiff_palette2_pdf)
compare_mupdf(tmpdir, tiff_palette2_img, tiff_palette2_pdf)
# pdfimages cannot export palette based images
@pytest.mark.skipif(
not HAVE_IMAGEMAGICK_MODERN,
reason="requires imagemagick with support for keeping the palette depth",
)
@pytest.mark.skipif(
sys.platform in ["darwin", "win32"],
reason="test utilities not available on Windows and MacOS",
)
2020-06-05 23:18:39 +00:00
def test_tiff_palette4(tmp_path_factory, tiff_palette4_img, tiff_palette4_pdf):
tmpdir = tmp_path_factory.mktemp("tiff_palette4")
compare_ghostscript(tmpdir, tiff_palette4_img, tiff_palette4_pdf)
compare_poppler(tmpdir, tiff_palette4_img, tiff_palette4_pdf)
compare_mupdf(tmpdir, tiff_palette4_img, tiff_palette4_pdf)
# pdfimages cannot export palette based images
@pytest.mark.skipif(
sys.platform in ["darwin", "win32"],
reason="test utilities not available on Windows and MacOS",
)
2020-06-05 23:18:39 +00:00
def test_tiff_palette8(tmp_path_factory, tiff_palette8_img, tiff_palette8_pdf):
tmpdir = tmp_path_factory.mktemp("tiff_palette8")
compare_ghostscript(tmpdir, tiff_palette8_img, tiff_palette8_pdf)
compare_poppler(tmpdir, tiff_palette8_img, tiff_palette8_pdf)
compare_mupdf(tmpdir, tiff_palette8_img, tiff_palette8_pdf)
# pdfimages cannot export palette based images
@pytest.mark.skipif(
sys.platform in ["darwin", "win32"],
reason="test utilities not available on Windows and MacOS",
)
2020-06-05 23:18:39 +00:00
def test_tiff_ccitt_lsb_m2l_white(
tmp_path_factory, tiff_ccitt_lsb_m2l_white_img, tiff_ccitt_lsb_m2l_white_pdf
):
tmpdir = tmp_path_factory.mktemp("tiff_ccitt_lsb_m2l_white")
compare_ghostscript(
tmpdir,
tiff_ccitt_lsb_m2l_white_img,
tiff_ccitt_lsb_m2l_white_pdf,
gsdevice="pnggray",
)
compare_poppler(tmpdir, tiff_ccitt_lsb_m2l_white_img, tiff_ccitt_lsb_m2l_white_pdf)
compare_mupdf(tmpdir, tiff_ccitt_lsb_m2l_white_img, tiff_ccitt_lsb_m2l_white_pdf)
compare_pdfimages_tiff(
tmpdir, tiff_ccitt_lsb_m2l_white_img, tiff_ccitt_lsb_m2l_white_pdf
)
@pytest.mark.skipif(
sys.platform in ["darwin", "win32"],
reason="test utilities not available on Windows and MacOS",
)
2020-06-05 23:18:39 +00:00
def test_tiff_ccitt_msb_m2l_white(
tmp_path_factory, tiff_ccitt_msb_m2l_white_img, tiff_ccitt_msb_m2l_white_pdf
):
tmpdir = tmp_path_factory.mktemp("tiff_ccitt_msb_m2l_white")
compare_ghostscript(
tmpdir,
tiff_ccitt_msb_m2l_white_img,
tiff_ccitt_msb_m2l_white_pdf,
gsdevice="pnggray",
)
compare_poppler(tmpdir, tiff_ccitt_msb_m2l_white_img, tiff_ccitt_msb_m2l_white_pdf)
compare_mupdf(tmpdir, tiff_ccitt_msb_m2l_white_img, tiff_ccitt_msb_m2l_white_pdf)
compare_pdfimages_tiff(
tmpdir, tiff_ccitt_msb_m2l_white_img, tiff_ccitt_msb_m2l_white_pdf
)
@pytest.mark.skipif(
sys.platform in ["darwin", "win32"],
reason="test utilities not available on Windows and MacOS",
)
2020-06-05 23:18:39 +00:00
def test_tiff_ccitt_msb_l2m_white(
tmp_path_factory, tiff_ccitt_msb_l2m_white_img, tiff_ccitt_msb_l2m_white_pdf
):
tmpdir = tmp_path_factory.mktemp("tiff_ccitt_msb_l2m_white")
compare_ghostscript(
tmpdir,
tiff_ccitt_msb_l2m_white_img,
tiff_ccitt_msb_l2m_white_pdf,
gsdevice="pnggray",
)
compare_poppler(tmpdir, tiff_ccitt_msb_l2m_white_img, tiff_ccitt_msb_l2m_white_pdf)
compare_mupdf(tmpdir, tiff_ccitt_msb_l2m_white_img, tiff_ccitt_msb_l2m_white_pdf)
compare_pdfimages_tiff(
tmpdir, tiff_ccitt_msb_l2m_white_img, tiff_ccitt_msb_l2m_white_pdf
)
@pytest.mark.skipif(
not HAVE_IMAGEMAGICK_MODERN,
reason="requires imagemagick with support for min-is-black",
)
@pytest.mark.skipif(
sys.platform in ["darwin", "win32"],
reason="test utilities not available on Windows and MacOS",
)
2020-06-05 23:18:39 +00:00
def test_tiff_ccitt_lsb_m2l_black(
tmp_path_factory, tiff_ccitt_lsb_m2l_black_img, tiff_ccitt_lsb_m2l_black_pdf
):
tmpdir = tmp_path_factory.mktemp("tiff_ccitt_lsb_m2l_black")
compare_ghostscript(
tmpdir,
tiff_ccitt_lsb_m2l_black_img,
tiff_ccitt_lsb_m2l_black_pdf,
gsdevice="pnggray",
)
compare_poppler(tmpdir, tiff_ccitt_lsb_m2l_black_img, tiff_ccitt_lsb_m2l_black_pdf)
compare_mupdf(tmpdir, tiff_ccitt_lsb_m2l_black_img, tiff_ccitt_lsb_m2l_black_pdf)
compare_pdfimages_tiff(
tmpdir, tiff_ccitt_lsb_m2l_black_img, tiff_ccitt_lsb_m2l_black_pdf
)
@pytest.mark.skipif(
sys.platform in ["darwin", "win32"],
reason="test utilities not available on Windows and MacOS",
)
2020-06-05 23:18:39 +00:00
def test_tiff_ccitt_nometa1(
tmp_path_factory, tiff_ccitt_nometa1_img, tiff_ccitt_nometa1_pdf
):
tmpdir = tmp_path_factory.mktemp("tiff_ccitt_nometa1")
compare_ghostscript(
tmpdir, tiff_ccitt_nometa1_img, tiff_ccitt_nometa1_pdf, gsdevice="pnggray"
)
compare_poppler(tmpdir, tiff_ccitt_nometa1_img, tiff_ccitt_nometa1_pdf)
compare_mupdf(tmpdir, tiff_ccitt_nometa1_img, tiff_ccitt_nometa1_pdf)
compare_pdfimages_tiff(tmpdir, tiff_ccitt_nometa1_img, tiff_ccitt_nometa1_pdf)
@pytest.mark.skipif(
sys.platform in ["darwin", "win32"],
reason="test utilities not available on Windows and MacOS",
)
2020-06-05 23:18:39 +00:00
def test_tiff_ccitt_nometa2(
tmp_path_factory, tiff_ccitt_nometa2_img, tiff_ccitt_nometa2_pdf
):
tmpdir = tmp_path_factory.mktemp("tiff_ccitt_nometa2")
compare_ghostscript(
2020-08-04 22:47:50 +00:00
tmpdir, tiff_ccitt_nometa2_img, tiff_ccitt_nometa2_pdf, gsdevice="pnggray"
2020-06-05 23:18:39 +00:00
)
compare_poppler(tmpdir, tiff_ccitt_nometa2_img, tiff_ccitt_nometa2_pdf)
compare_mupdf(tmpdir, tiff_ccitt_nometa2_img, tiff_ccitt_nometa2_pdf)
compare_pdfimages_tiff(tmpdir, tiff_ccitt_nometa2_img, tiff_ccitt_nometa2_pdf)
# we define some variables so that the table below can be narrower
psl = (972, 504) # --pagesize landscape
psp = (504, 972) # --pagesize portrait
isl = (756, 324) # --imgsize landscape
isp = (324, 756) # --imgsize portrait
border = (162, 270) # --border
poster = (97200, 50400)
# shortcuts for fit modes
f_into = img2pdf.FitMode.into
f_fill = img2pdf.FitMode.fill
f_exact = img2pdf.FitMode.exact
f_shrink = img2pdf.FitMode.shrink
f_enlarge = img2pdf.FitMode.enlarge
@pytest.mark.parametrize(
"layout_test_cases",
[
# fmt: off
# psp=972x504, psl=504x972, isl=756x324, isp=324x756, border=162:270
# --pagesize --border -a pagepdf imgpdf
# --imgsize --fit
(None, None, None, f_into, 0, (648, 216), (648, 216), # 000
(864, 432), (864, 432)),
(None, None, None, f_into, 1, (648, 216), (648, 216), # 001
(864, 432), (864, 432)),
(None, None, None, f_fill, 0, (648, 216), (648, 216), # 002
(864, 432), (864, 432)),
(None, None, None, f_fill, 1, (648, 216), (648, 216), # 003
(864, 432), (864, 432)),
(None, None, None, f_exact, 0, (648, 216), (648, 216), # 004
(864, 432), (864, 432)),
(None, None, None, f_exact, 1, (648, 216), (648, 216), # 005
(864, 432), (864, 432)),
(None, None, None, f_shrink, 0, (648, 216), (648, 216), # 006
(864, 432), (864, 432)),
(None, None, None, f_shrink, 1, (648, 216), (648, 216), # 007
(864, 432), (864, 432)),
(None, None, None, f_enlarge, 0, (648, 216), (648, 216), # 008
(864, 432), (864, 432)),
(None, None, None, f_enlarge, 1, (648, 216), (648, 216), # 009
(864, 432), (864, 432)),
(None, None, border, f_into, 0, (1188, 540), (648, 216), # 010
(1404, 756), (864, 432)),
(None, None, border, f_into, 1, (1188, 540), (648, 216), # 011
(1404, 756), (864, 432)),
(None, None, border, f_fill, 0, (1188, 540), (648, 216), # 012
(1404, 756), (864, 432)),
(None, None, border, f_fill, 1, (1188, 540), (648, 216), # 013
(1404, 756), (864, 432)),
(None, None, border, f_exact, 0, (1188, 540), (648, 216), # 014
(1404, 756), (864, 432)),
(None, None, border, f_exact, 1, (1188, 540), (648, 216), # 015
(1404, 756), (864, 432)),
(None, None, border, f_shrink, 0, (1188, 540), (648, 216), # 016
(1404, 756), (864, 432)),
(None, None, border, f_shrink, 1, (1188, 540), (648, 216), # 017
(1404, 756), (864, 432)),
(None, None, border, f_enlarge, 0, (1188, 540), (648, 216), # 018
(1404, 756), (864, 432)),
(None, None, border, f_enlarge, 1, (1188, 540), (648, 216), # 019
(1404, 756), (864, 432)),
(None, isp, None, f_into, 0, (324, 108), (324, 108), # 020
(324, 162), (324, 162)),
(None, isp, None, f_into, 1, (324, 108), (324, 108), # 021
(324, 162), (324, 162)),
(None, isp, None, f_fill, 0, (2268, 756), (2268, 756), # 022
(1512, 756), (1512, 756)),
(None, isp, None, f_fill, 1, (2268, 756), (2268, 756), # 023
(1512, 756), (1512, 756)),
(None, isp, None, f_exact, 0, (324, 756), (324, 756), # 024
(324, 756), (324, 756)),
(None, isp, None, f_exact, 1, (324, 756), (324, 756), # 025
(324, 756), (324, 756)),
(None, isp, None, f_shrink, 0, (324, 108), (324, 108), # 026
(324, 162), (324, 162)),
(None, isp, None, f_shrink, 1, (324, 108), (324, 108), # 027
(324, 162), (324, 162)),
(None, isp, None, f_enlarge, 0, (648, 216), (648, 216), # 028
(864, 432), (864, 432)),
(None, isp, None, f_enlarge, 1, (648, 216), (648, 216), # 029
(864, 432), (864, 432)),
(None, isp, border, f_into, 0, (864, 432), (324, 108), # 030
(864, 486), (324, 162)),
(None, isp, border, f_into, 1, (864, 432), (324, 108), # 031
(864, 486), (324, 162)),
(None, isp, border, f_fill, 0, (2808, 1080), (2268, 756), # 032
(2052, 1080), (1512, 756)),
(None, isp, border, f_fill, 1, (2808, 1080), (2268, 756), # 033
(2052, 1080), (1512, 756)),
(None, isp, border, f_exact, 0, (864, 1080), (324, 756), # 034
(864, 1080), (324, 756)),
(None, isp, border, f_exact, 1, (864, 1080), (324, 756), # 035
(864, 1080), (324, 756)),
(None, isp, border, f_shrink, 0, (864, 432), (324, 108), # 036
(864, 486), (324, 162)),
(None, isp, border, f_shrink, 1, (864, 432), (324, 108), # 037
(864, 486), (324, 162)),
(None, isp, border, f_enlarge, 0, (1188, 540), (648, 216), # 038
(1404, 756), (864, 432)),
(None, isp, border, f_enlarge, 1, (1188, 540), (648, 216), # 039
(1404, 756), (864, 432)),
(None, isl, None, f_into, 0, (756, 252), (756, 252), # 040
(648, 324), (648, 324)),
(None, isl, None, f_into, 1, (756, 252), (756, 252), # 041
(648, 324), (648, 324)),
(None, isl, None, f_fill, 0, (972, 324), (972, 324), # 042
(756, 378), (756, 378)),
(None, isl, None, f_fill, 1, (972, 324), (972, 324), # 043
(756, 378), (756, 378)),
(None, isl, None, f_exact, 0, (756, 324), (756, 324), # 044
(756, 324), (756, 324)),
(None, isl, None, f_exact, 1, (756, 324), (756, 324), # 045
(756, 324), (756, 324)),
(None, isl, None, f_shrink, 0, (648, 216), (648, 216), # 046
(648, 324), (648, 324)),
(None, isl, None, f_shrink, 1, (648, 216), (648, 216), # 047
(648, 324), (648, 324)),
(None, isl, None, f_enlarge, 0, (756, 252), (756, 252), # 048
(864, 432), (864, 432)),
(None, isl, None, f_enlarge, 1, (756, 252), (756, 252), # 049
(864, 432), (864, 432)),
# psp=972x504, psp=504x972, isl=756x324, isp=324x756, border=162:270
# --pagesize --border -a pagepdf imgpdf
# --imgsize --fit imgpx
(None, isl, border, f_into, 0, (1296, 576), (756, 252), # 050
(1188, 648), (648, 324)),
(None, isl, border, f_into, 1, (1296, 576), (756, 252), # 051
(1188, 648), (648, 324)),
(None, isl, border, f_fill, 0, (1512, 648), (972, 324), # 052
(1296, 702), (756, 378)),
(None, isl, border, f_fill, 1, (1512, 648), (972, 324), # 053
(1296, 702), (756, 378)),
(None, isl, border, f_exact, 0, (1296, 648), (756, 324), # 054
(1296, 648), (756, 324)),
(None, isl, border, f_exact, 1, (1296, 648), (756, 324), # 055
(1296, 648), (756, 324)),
(None, isl, border, f_shrink, 0, (1188, 540), (648, 216), # 056
(1188, 648), (648, 324)),
(None, isl, border, f_shrink, 1, (1188, 540), (648, 216), # 057
(1188, 648), (648, 324)),
(None, isl, border, f_enlarge, 0, (1296, 576), (756, 252), # 058
(1404, 756), (864, 432)),
(None, isl, border, f_enlarge, 1, (1296, 576), (756, 252), # 059
(1404, 756), (864, 432)),
(psp, None, None, f_into, 0, (504, 972), (504, 168), # 060
(504, 972), (504, 252)),
(psp, None, None, f_into, 1, (972, 504), (972, 324), # 061
(972, 504), (972, 486)),
(psp, None, None, f_fill, 0, (504, 972), (2916, 972), # 062
(504, 972), (1944, 972)),
(psp, None, None, f_fill, 1, (972, 504), (1512, 504), # 063
(972, 504), (1008, 504)),
(psp, None, None, f_exact, 0, (504, 972), (504, 972), # 064
(504, 972), (504, 972)),
(psp, None, None, f_exact, 1, (972, 504), (972, 504), # 065
(972, 504), (972, 504)),
(psp, None, None, f_shrink, 0, (504, 972), (504, 168), # 066
(504, 972), (504, 252)),
(psp, None, None, f_shrink, 1, (972, 504), (648, 216), # 067
(972, 504), (864, 432)),
(psp, None, None, f_enlarge, 0, (504, 972), (648, 216), # 068
(504, 972), (864, 432)),
(psp, None, None, f_enlarge, 1, (972, 504), (972, 324), # 069
(972, 504), (972, 486)),
(psp, None, border, f_into, 0, None, None, None, None), # 070
(psp, None, border, f_into, 1, None, None, None, None), # 071
(psp, None, border, f_fill, 0, (504, 972), (1944, 648), # 072
(504, 972), (1296, 648)),
(psp, None, border, f_fill, 1, (972, 504), (648, 216), # 073
(972, 504), (648, 324)),
(psp, None, border, f_exact, 0, None, None, None, None), # 074
(psp, None, border, f_exact, 1, None, None, None, None), # 075
(psp, None, border, f_shrink, 0, None, None, None, None), # 076
(psp, None, border, f_shrink, 1, None, None, None, None), # 077
(psp, None, border, f_enlarge, 0, (504, 972), (648, 216), # 078
(504, 972), (864, 432)),
(psp, None, border, f_enlarge, 1, (972, 504), (648, 216), # 079
(972, 504), (864, 432)),
(psp, isp, None, f_into, 0, (504, 972), (324, 108), # 080
(504, 972), (324, 162)),
(psp, isp, None, f_into, 1, (972, 504), (324, 108), # 081
(972, 504), (324, 162)),
(psp, isp, None, f_fill, 0, (504, 972), (2268, 756), # 082
(504, 972), (1512, 756)),
(psp, isp, None, f_fill, 1, (972, 504), (2268, 756), # 083
(972, 504), (1512, 756)),
(psp, isp, None, f_exact, 0, (504, 972), (324, 756), # 084
(504, 972), (324, 756)),
(psp, isp, None, f_exact, 1, (972, 504), (324, 756), # 085
(972, 504), (324, 756)),
(psp, isp, None, f_shrink, 0, (504, 972), (324, 108), # 086
(504, 972), (324, 162)),
(psp, isp, None, f_shrink, 1, (972, 504), (324, 108), # 087
(972, 504), (324, 162)),
(psp, isp, None, f_enlarge, 0, (504, 972), (648, 216), # 088
(504, 972), (864, 432)),
(psp, isp, None, f_enlarge, 1, (972, 504), (648, 216), # 089
(972, 504), (864, 432)),
(psp, isp, border, f_into, 0, (504, 972), (324, 108), # 090
(504, 972), (324, 162)),
(psp, isp, border, f_into, 1, (972, 504), (324, 108), # 091
(972, 504), (324, 162)),
(psp, isp, border, f_fill, 0, (504, 972), (2268, 756), # 092
(504, 972), (1512, 756)),
(psp, isp, border, f_fill, 1, (972, 504), (2268, 756), # 093
(972, 504), (1512, 756)),
(psp, isp, border, f_exact, 0, (504, 972), (324, 756), # 094
(504, 972), (324, 756)),
(psp, isp, border, f_exact, 1, (972, 504), (324, 756), # 095
(972, 504), (324, 756)),
(psp, isp, border, f_shrink, 0, (504, 972), (324, 108), # 096
(504, 972), (324, 162)),
(psp, isp, border, f_shrink, 1, (972, 504), (324, 108), # 097
(972, 504), (324, 162)),
(psp, isp, border, f_enlarge, 0, (504, 972), (648, 216), # 098
(504, 972), (864, 432)),
(psp, isp, border, f_enlarge, 1, (972, 504), (648, 216), # 099
(972, 504), (864, 432)),
# psp=972x504, psp=504x972, isl=756x324, isp=324x756, border=162:270
# --pagesize --border -a pagepdf imgpdf
# --imgsize --fit imgpx
(psp, isl, None, f_into, 0, (504, 972), (756, 252), # 100
(504, 972), (648, 324)),
(psp, isl, None, f_into, 1, (972, 504), (756, 252), # 101
(972, 504), (648, 324)),
(psp, isl, None, f_fill, 0, (504, 972), (972, 324), # 102
(504, 972), (756, 378)),
(psp, isl, None, f_fill, 1, (972, 504), (972, 324), # 103
(972, 504), (756, 378)),
(psp, isl, None, f_exact, 0, (504, 972), (756, 324), # 104
(504, 972), (756, 324)),
(psp, isl, None, f_exact, 1, (972, 504), (756, 324), # 105
(972, 504), (756, 324)),
(psp, isl, None, f_shrink, 0, (504, 972), (648, 216), # 106
(504, 972), (648, 324)),
(psp, isl, None, f_shrink, 1, (972, 504), (648, 216), # 107
(972, 504), (648, 324)),
(psp, isl, None, f_enlarge, 0, (504, 972), (756, 252), # 108
(504, 972), (864, 432)),
(psp, isl, None, f_enlarge, 1, (972, 504), (756, 252), # 109
(972, 504), (864, 432)),
(psp, isl, border, f_into, 0, (504, 972), (756, 252), # 110
(504, 972), (648, 324)),
(psp, isl, border, f_into, 1, (972, 504), (756, 252), # 111
(972, 504), (648, 324)),
(psp, isl, border, f_fill, 0, (504, 972), (972, 324), # 112
(504, 972), (756, 378)),
(psp, isl, border, f_fill, 1, (972, 504), (972, 324), # 113
(972, 504), (756, 378)),
(psp, isl, border, f_exact, 0, (504, 972), (756, 324), # 114
(504, 972), (756, 324)),
(psp, isl, border, f_exact, 1, (972, 504), (756, 324), # 115
(972, 504), (756, 324)),
(psp, isl, border, f_shrink, 0, (504, 972), (648, 216), # 116
(504, 972), (648, 324)),
(psp, isl, border, f_shrink, 1, (972, 504), (648, 216), # 117
(972, 504), (648, 324)),
(psp, isl, border, f_enlarge, 0, (504, 972), (756, 252), # 118
(504, 972), (864, 432)),
(psp, isl, border, f_enlarge, 1, (972, 504), (756, 252), # 119
(972, 504), (864, 432)),
(psl, None, None, f_into, 0, (972, 504), (972, 324), # 120
(972, 504), (972, 486)),
(psl, None, None, f_into, 1, (972, 504), (972, 324), # 121
(972, 504), (972, 486)),
(psl, None, None, f_fill, 0, (972, 504), (1512, 504), # 122
(972, 504), (1008, 504)),
(psl, None, None, f_fill, 1, (972, 504), (1512, 504), # 123
(972, 504), (1008, 504)),
(psl, None, None, f_exact, 0, (972, 504), (972, 504), # 124
(972, 504), (972, 504)),
(psl, None, None, f_exact, 1, (972, 504), (972, 504), # 125
(972, 504), (972, 504)),
(psl, None, None, f_shrink, 0, (972, 504), (648, 216), # 126
(972, 504), (864, 432)),
(psl, None, None, f_shrink, 1, (972, 504), (648, 216), # 127
(972, 504), (864, 432)),
(psl, None, None, f_enlarge, 0, (972, 504), (972, 324), # 128
(972, 504), (972, 486)),
(psl, None, None, f_enlarge, 1, (972, 504), (972, 324), # 129
(972, 504), (972, 486)),
(psl, None, border, f_into, 0, (972, 504), (432, 144), # 130
(972, 504), (360, 180)),
(psl, None, border, f_into, 1, (972, 504), (432, 144), # 131
(972, 504), (360, 180)),
(psl, None, border, f_fill, 0, (972, 504), (540, 180), # 132
(972, 504), (432, 216)),
(psl, None, border, f_fill, 1, (972, 504), (540, 180), # 133
(972, 504), (432, 216)),
(psl, None, border, f_exact, 0, (972, 504), (432, 180), # 134
(972, 504), (432, 180)),
(psl, None, border, f_exact, 1, (972, 504), (432, 180), # 135
(972, 504), (432, 180)),
(psl, None, border, f_shrink, 0, (972, 504), (432, 144), # 136
(972, 504), (360, 180)),
(psl, None, border, f_shrink, 1, (972, 504), (432, 144), # 137
(972, 504), (360, 180)),
(psl, None, border, f_enlarge, 0, (972, 504), (648, 216), # 138
(972, 504), (864, 432)),
(psl, None, border, f_enlarge, 1, (972, 504), (648, 216), # 139
(972, 504), (864, 432)),
(psl, isp, None, f_into, 0, (972, 504), (324, 108), # 140
(972, 504), (324, 162)),
(psl, isp, None, f_into, 1, (972, 504), (324, 108), # 141
(972, 504), (324, 162)),
(psl, isp, None, f_fill, 0, (972, 504), (2268, 756), # 142
(972, 504), (1512, 756)),
(psl, isp, None, f_fill, 1, (972, 504), (2268, 756), # 143
(972, 504), (1512, 756)),
(psl, isp, None, f_exact, 0, (972, 504), (324, 756), # 144
(972, 504), (324, 756)),
(psl, isp, None, f_exact, 1, (972, 504), (324, 756), # 145
(972, 504), (324, 756)),
(psl, isp, None, f_shrink, 0, (972, 504), (324, 108), # 146
(972, 504), (324, 162)),
(psl, isp, None, f_shrink, 1, (972, 504), (324, 108), # 147
(972, 504), (324, 162)),
(psl, isp, None, f_enlarge, 0, (972, 504), (648, 216), # 148
(972, 504), (864, 432)),
(psl, isp, None, f_enlarge, 1, (972, 504), (648, 216), # 149
(972, 504), (864, 432)),
# psp=972x504, psl=504x972, isl=756x324, isp=324x756, border=162:270
# --pagesize --border -a pagepdf imgpdf
# --imgsize --fit imgpx
(psl, isp, border, f_into, 0, (972, 504), (324, 108), # 150
(972, 504), (324, 162)),
(psl, isp, border, f_into, 1, (972, 504), (324, 108), # 151
(972, 504), (324, 162)),
(psl, isp, border, f_fill, 0, (972, 504), (2268, 756), # 152
(972, 504), (1512, 756)),
(psl, isp, border, f_fill, 1, (972, 504), (2268, 756), # 153
(972, 504), (1512, 756)),
(psl, isp, border, f_exact, 0, (972, 504), (324, 756), # 154
(972, 504), (324, 756)),
(psl, isp, border, f_exact, 1, (972, 504), (324, 756), # 155
(972, 504), (324, 756)),
(psl, isp, border, f_shrink, 0, (972, 504), (324, 108), # 156
(972, 504), (324, 162)),
(psl, isp, border, f_shrink, 1, (972, 504), (324, 108), # 157
(972, 504), (324, 162)),
(psl, isp, border, f_enlarge, 0, (972, 504), (648, 216), # 158
(972, 504), (864, 432)),
(psl, isp, border, f_enlarge, 1, (972, 504), (648, 216), # 159
(972, 504), (864, 432)),
(psl, isl, None, f_into, 0, (972, 504), (756, 252), # 160
(972, 504), (648, 324)),
(psl, isl, None, f_into, 1, (972, 504), (756, 252), # 161
(972, 504), (648, 324)),
(psl, isl, None, f_fill, 0, (972, 504), (972, 324), # 162
(972, 504), (756, 378)),
(psl, isl, None, f_fill, 1, (972, 504), (972, 324), # 163
(972, 504), (756, 378)),
(psl, isl, None, f_exact, 0, (972, 504), (756, 324), # 164
(972, 504), (756, 324)),
(psl, isl, None, f_exact, 1, (972, 504), (756, 324), # 165
(972, 504), (756, 324)),
(psl, isl, None, f_shrink, 0, (972, 504), (648, 216), # 166
(972, 504), (648, 324)),
(psl, isl, None, f_shrink, 1, (972, 504), (648, 216), # 167
(972, 504), (648, 324)),
(psl, isl, None, f_enlarge, 0, (972, 504), (756, 252), # 168
(972, 504), (864, 432)),
(psl, isl, None, f_enlarge, 1, (972, 504), (756, 252), # 169
(972, 504), (864, 432)),
(psl, isl, border, f_into, 0, (972, 504), (756, 252), # 170
(972, 504), (648, 324)),
(psl, isl, border, f_into, 1, (972, 504), (756, 252), # 171
(972, 504), (648, 324)),
(psl, isl, border, f_fill, 0, (972, 504), (972, 324), # 172
(972, 504), (756, 378)),
(psl, isl, border, f_fill, 1, (972, 504), (972, 324), # 173
(972, 504), (756, 378)),
(psl, isl, border, f_exact, 0, (972, 504), (756, 324), # 174
(972, 504), (756, 324)),
(psl, isl, border, f_exact, 1, (972, 504), (756, 324), # 175
(972, 504), (756, 324)),
(psl, isl, border, f_shrink, 0, (972, 504), (648, 216), # 176
(972, 504), (648, 324)),
(psl, isl, border, f_shrink, 1, (972, 504), (648, 216), # 177
(972, 504), (648, 324)),
(psl, isl, border, f_enlarge, 0, (972, 504), (756, 252), # 178
(972, 504), (864, 432)),
(psl, isl, border, f_enlarge, 1, (972, 504), (756, 252), # 179
(972, 504), (864, 432)),
(poster, None, None, f_fill, 0, (97200, 50400), (151200, 50400),
(97200, 50400), (100800, 50400)),
]
# fmt: on
)
def test_layout(layout_test_cases):
# there is no need to have test cases with the same images with inverted
# orientation (landscape/portrait) because --pagesize and --imgsize are
# already inverted
im1 = (864, 288) # imgpx #1 => 648x216
im2 = (1152, 576) # imgpx #2 => 864x432
psopt, isopt, border, fit, ao, pspdf1, ispdf1, pspdf2, ispdf2 = layout_test_cases
if isopt is not None:
isopt = ((img2pdf.ImgSize.abs, isopt[0]), (img2pdf.ImgSize.abs, isopt[1]))
layout_fun = img2pdf.get_layout_fun(psopt, isopt, border, fit, ao)
try:
pwpdf, phpdf, iwpdf, ihpdf = layout_fun(
im1[0], im1[1], (img2pdf.default_dpi, img2pdf.default_dpi)
)
assert (pwpdf, phpdf) == pspdf1
assert (iwpdf, ihpdf) == ispdf1
except img2pdf.NegativeDimensionError:
assert pspdf1 is None
assert ispdf1 is None
try:
pwpdf, phpdf, iwpdf, ihpdf = layout_fun(
im2[0], im2[1], (img2pdf.default_dpi, img2pdf.default_dpi)
)
assert (pwpdf, phpdf) == pspdf2
assert (iwpdf, ihpdf) == ispdf2
except img2pdf.NegativeDimensionError:
assert pspdf2 is None
assert ispdf2 is None
@pytest.fixture(
scope="session",
2020-08-03 10:34:02 +00:00
params=os.listdir(os.path.join(os.path.dirname(__file__), "tests", "input")),
2020-06-05 23:18:39 +00:00
)
def general_input(request):
assert os.path.isfile(
2020-08-03 10:34:02 +00:00
os.path.join(os.path.dirname(__file__), "tests", "input", request.param)
2020-06-05 23:18:39 +00:00
)
return request.param
@pytest.mark.parametrize("engine", ["internal", "pikepdf", "pdfrw"])
def test_general(general_input, engine):
inputf = os.path.join(os.path.dirname(__file__), "tests", "input", general_input)
2020-06-05 23:18:39 +00:00
outputf = os.path.join(
2020-08-03 10:34:02 +00:00
os.path.dirname(__file__), "tests", "output", general_input + ".pdf"
2020-06-05 23:18:39 +00:00
)
assert os.path.isfile(outputf)
f = inputf
out = outputf
engine = getattr(img2pdf.Engine, engine)
# we do not test animation.gif with pdfrw because it doesn't support
# saving hexadecimal palette data
if f.endswith(os.path.sep + "animation.gif") and engine == img2pdf.Engine.pdfrw:
return
with open(f, "rb") as inf:
orig_imgdata = inf.read()
output = img2pdf.convert(orig_imgdata, nodate=True, engine=engine)
x = pikepdf.open(BytesIO(output))
assert x.Root.Pages.Count in (1, 2)
if len(x.Root.Pages.Kids) == "1":
assert x.Size == "7"
assert len(x.Root.Pages.Kids) == 1
elif len(x.Root.Pages.Kids) == "2":
assert x.Size == "10"
assert len(x.Root.Pages.Kids) == 2
assert sorted(x.Root.keys()) == ["/Pages", "/Type"]
assert x.Root.Type == "/Catalog"
assert sorted(x.Root.Pages.keys()) == ["/Count", "/Kids", "/Type"]
assert x.Root.Pages.Type == "/Pages"
orig_img = Image.open(f)
for pagenum in range(len(x.Root.Pages.Kids)):
# retrieve the original image frame that this page was
# generated from
orig_img.seek(pagenum)
cur_page = x.Root.Pages.Kids[pagenum]
ndpi = orig_img.info.get("dpi", (96.0, 96.0))
# In python3, the returned dpi value for some tiff images will
# not be an integer but a float. To make the behaviour of
# img2pdf the same between python2 and python3, we convert that
# float into an integer by rounding.
# Search online for the 72.009 dpi problem for more info.
ndpi = (int(round(ndpi[0])), int(round(ndpi[1])))
imgwidthpx, imgheightpx = orig_img.size
pagewidth = 72.0 * imgwidthpx / ndpi[0]
pageheight = 72.0 * imgheightpx / ndpi[1]
def format_float(f):
if int(f) == f:
return int(f)
else:
return decimal.Decimal("%.4f" % f)
assert sorted(cur_page.keys()) == [
"/Contents",
"/MediaBox",
"/Parent",
"/Resources",
"/Type",
]
assert cur_page.MediaBox == pikepdf.Array(
[0, 0, format_float(pagewidth), format_float(pageheight)]
)
assert cur_page.Parent == x.Root.Pages
assert cur_page.Type == "/Page"
assert cur_page.Resources.keys() == {"/XObject"}
assert cur_page.Resources.XObject.keys() == {"/Im0"}
if engine != img2pdf.Engine.pikepdf:
assert cur_page.Contents.Length == len(cur_page.Contents.read_bytes())
assert cur_page.Contents.read_bytes() == b"q\n%.4f 0 0 %.4f 0.0000 0.0000 cm\n/Im0 Do\nQ" % (
pagewidth,
pageheight,
)
imgprops = cur_page.Resources.XObject.Im0
# test if the filter is valid:
assert imgprops.Filter in [
"/DCTDecode",
"/JPXDecode",
"/FlateDecode",
pikepdf.Array([pikepdf.Name.CCITTFaxDecode]),
]
# test if the image has correct size
assert imgprops.Width == orig_img.size[0]
assert imgprops.Height == orig_img.size[1]
# if the input file is a jpeg then it should've been copied
# verbatim into the PDF
if imgprops.Filter in ["/DCTDecode", "/JPXDecode"]:
assert cur_page.Resources.XObject.Im0.read_raw_bytes() == orig_imgdata
elif imgprops.Filter == pikepdf.Array([pikepdf.Name.CCITTFaxDecode]):
tiff_header = tiff_header_for_ccitt(
int(imgprops.Width), int(imgprops.Height), int(imgprops.Length), 4
)
imgio = BytesIO()
imgio.write(tiff_header)
imgio.write(cur_page.Resources.XObject.Im0.read_raw_bytes())
imgio.seek(0)
im = Image.open(imgio)
assert im.tobytes() == orig_img.tobytes()
try:
im.close()
except AttributeError:
pass
elif imgprops.Filter == "/FlateDecode":
# otherwise, the data is flate encoded and has to be equal
# to the pixel data of the input image
imgdata = zlib.decompress(cur_page.Resources.XObject.Im0.read_raw_bytes())
if hasattr(imgprops, "DecodeParms"):
if orig_img.format == "PNG":
pngidat, palette = img2pdf.parse_png(orig_imgdata)
elif (
orig_img.format == "TIFF"
and orig_img.info["compression"] == "group4"
):
offset, length = img2pdf.ccitt_payload_location_from_pil(orig_img)
pngidat = orig_imgdata[offset : offset + length]
else:
pngbuffer = BytesIO()
orig_img.save(pngbuffer, format="png")
pngidat, palette = img2pdf.parse_png(pngbuffer.getvalue())
assert zlib.decompress(pngidat) == imgdata
else:
colorspace = imgprops.ColorSpace
if colorspace == "/DeviceGray":
colorspace = "L"
elif colorspace == "/DeviceRGB":
colorspace = "RGB"
elif colorspace == "/DeviceCMYK":
colorspace = "CMYK"
else:
raise Exception("invalid colorspace")
im = Image.frombytes(
colorspace, (int(imgprops.Width), int(imgprops.Height)), imgdata
)
if orig_img.mode == "1":
assert im.tobytes() == orig_img.convert("L").tobytes()
elif orig_img.mode not in ("RGB", "L", "CMYK", "CMYK;I"):
assert im.tobytes() == orig_img.convert("RGB").tobytes()
# the python-pil version 2.3.0-1ubuntu3 in Ubuntu does
# not have the close() method
try:
im.close()
except AttributeError:
pass
else:
raise Exception("unknown filter")
def rec(obj):
if isinstance(obj, pikepdf.Dictionary):
return {k: rec(v) for k, v in obj.items() if k != "/Parent"}
elif isinstance(obj, pikepdf.Array):
return [rec(v) for v in obj]
elif isinstance(obj, pikepdf.Stream):
ret = rec(obj.stream_dict)
stream = obj.read_raw_bytes()
assert len(stream) == ret["/Length"]
del ret["/Length"]
if ret.get("/Filter") == "/FlateDecode":
stream = obj.read_bytes()
del ret["/Filter"]
ret["stream"] = stream
return ret
elif isinstance(obj, pikepdf.Name) or isinstance(obj, pikepdf.String):
return str(obj)
elif isinstance(obj, decimal.Decimal) or isinstance(obj, str):
return obj
elif isinstance(obj, int):
return decimal.Decimal(obj)
raise Exception("unhandled: %s" % (type(obj)))
y = pikepdf.open(out)
assert rec(x.Root) == rec(y.Root)
# the python-pil version 2.3.0-1ubuntu3 in Ubuntu does not have the
# close() method
try:
orig_img.close()
except AttributeError:
pass