You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
plakativ/plakativ.py

2466 lines
95 KiB
Python

This file contains ambiguous Unicode characters!

This file contains ambiguous Unicode characters that may be confused with others in your current locale. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to highlight these characters.

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#
# Plakativ allows to create posters bigger than the page size one's own printer
# is able to print on by enlarging the input PDF, cutting it into smaller
# pieces and putting each of them onto a paper size that can be printed
# normally. The result can then be glued together into a bigger poster.
#
# Copyright (C) 2019 - 2021 Johannes Schauer Marin Rodrigues <josch@mister-muffin.de>
#
# This program is free software: you can redistribute it and/or modify it under
# the terms of the GNU General Public License version 3 as published by the
# Free Software Foundation.
from collections import OrderedDict
import math
import fitz
import sys
import argparse
import os.path
import platform
from enum import Enum
from io import BytesIO
import logging
have_img2pdf = True
try:
from PIL import Image
# ignore PIL limit because this software is meant to create posters which
# naturally can be very large in size
Image.MAX_IMAGE_PIXELS = None
import img2pdf
except ImportError:
have_img2pdf = False
have_tkinter = True
try:
import tkinter
import tkinter.filedialog
import tkinter.messagebox
except ImportError:
have_tkinter = False
class dummy:
def __init__(self, *args, **kwargs):
raise Exception("this functionality needs tkinter")
tkinter = type("", (), {})()
tkinter.Frame = dummy
tkinter.Menubutton = dummy
tkinter.LabelFrame = dummy
VERSION = "0.5.2"
PAGE_SIZES = OrderedDict(
[
("custom", (None, None)),
("A0 (841 mm × 1189 mm)", (841, 1189)),
("A1 (594 mm × 841 mm)", (594, 841)),
("A2 (420 mm × 594 mm)", (420, 594)),
("A3 (297 mm × 420 mm)", (297, 420)),
("A4 (210 mm × 297 mm)", (210, 297)),
("A5 (148 mm × 210 mm)", (148, 210)),
("Letter (8.5 in × 11 in)", (215.9, 279.4)),
("Legal (8.5 in × 14 in)", (215.9, 355.6)),
("Tabloid (11 in × 17 in)", (279.4, 431.8)),
]
)
papersizes = {
"letter": "8.5inx11in",
"a0": "841mmx1189mm",
"a1": "594mmx841mm",
"a2": "420mmx594mm",
"a3": "297mmx420mm",
"a4": "210mmx297mm",
"a5": "148mmx210mm",
"a6": "105mmx148mm",
"legal": "8.5inx14in",
"tabloid": "11inx17in",
}
papernames = {
"letter": "Letter",
"a0": "A0",
"a1": "A1",
"a2": "A2",
"a3": "A3",
"a4": "A4",
"a5": "A5",
"a6": "A6",
"legal": "Legal",
"tabloid": "Tabloid",
}
Unit = Enum("Unit", "pt cm mm inch")
def mm_to_pt(length):
return (72.0 * length) / 25.4
def cm_to_mm(length):
return length * 10.0
def in_to_mm(length):
return length * 25.4
def pt_to_mm(length):
return (25.4 * length) / 72.0
class PlakativException(Exception):
pass
class PageNrOutOfRangeException(PlakativException):
pass
class LayoutNotComputedException(PlakativException):
pass
def simple_cover(n, m, x, y):
pages_x_portrait = math.ceil(n / x)
pages_y_portrait = math.ceil(m / y)
pages_x_landscape = math.ceil(n / y)
pages_y_landscape = math.ceil(m / x)
if pages_x_portrait * pages_y_portrait <= pages_x_landscape * pages_y_landscape:
pages_x = pages_x_portrait
pages_y = pages_y_portrait
portrait = True
size = pages_x * x, pages_y * y
else:
pages_x = pages_x_landscape
pages_y = pages_y_landscape
portrait = False
size = pages_x * y, pages_y * x
config = list()
for py in range(pages_y):
for px in range(pages_x):
if portrait:
posx = px * x
posy = py * y
else:
posx = px * y
posy = py * x
config.append((posx, posy, portrait))
return config, size
# the function complex_cover() is based on a heuristic proposed by
# stackoverflow user m69 https://stackoverflow.com/users/4907604/m69 as a reply
# to this question https://stackoverflow.com/questions/39306507
#
# In addition to computing the number of required rectangles it also returns
# the position of the rectangles.
#
# In contrast to the solution by m69 this algorithm mandates at least one page
# in each corner of the result. This means that the minimum solution size is
# four. The advantage is, that the layout computed by this algorithm will
# always be completely be inside the poster without leaving the poster area.
# This in turn will make assembling the poster easier.
#
# This heuristic is not optimal. We always use a regular simple cover for the
# hole in the center (if it exists) but there are situations where the hole in
# the center should be covered by a complex cover instead. We do not consider
# this improvement because:
# - it's required very seldom
# - it makes the resulting layout more complicated to glue together
# - there is no proof that the improved version is optimal either
# - we save some cpu cycles
def complex_cover(n, m, x, y):
# each tuple-entry represents one of the corners of the poster
# upper-left, upper-right, lower-right, lower-left
portrait = (
(True, True, True, False),
(True, True, False, False),
(True, False, True, False),
(True, False, False, True),
(True, False, False, False),
)
X = lambda r, d: x if portrait[r][d] else y
Y = lambda r, d: y if portrait[r][d] else x
if x == y:
# if page sizes are square, only one rotation has to be checked
num_rotations = 1
elif n == m:
# if the poster size is a square, rotation 4 and 5 (which are itself
# just rotations of rotations 2 and 1, respectively) do not need to be
# checked
num_rotations = 3
else:
num_rotations = 5
minimum = math.ceil((n * m) / (x * y))
config, _ = simple_cover(n, m, x, y)
cover = len(config)
if cover == minimum:
return config
for r in range(num_rotations):
# w0 -> width of upper left corner pages
for w0 in range(1, math.ceil(n / X(r, 0))):
# w1 -> width of upper right corner pages
w1 = math.ceil((n - w0 * X(r, 0)) / X(r, 1))
if w1 < 0:
w1 = 0
# h0 -> height of upper left corner pages
for h0 in range(1, math.ceil(m / Y(r, 0))):
# h3 -> height of lower left corner pages
h3 = math.ceil((m - h0 * Y(r, 0)) / Y(r, 3))
if h3 < 0:
h3 = 0
# w2 -> width of lower right corner pages
for w2 in range(1, math.ceil(n / X(r, 2))):
# w3 -> width of lower left corner pages
w3 = math.ceil((n - w2 * X(r, 2)) / X(r, 3))
if w3 < 0:
w3 = 0
# h2 -> height of lower right corner pages
for h2 in range(1, math.ceil(m / Y(r, 2))):
# h1 -> height of upper right corner pages
h1 = math.ceil((m - h2 * Y(r, 2)) / Y(r, 1))
if h1 < 0:
h1 = 0
newconfig = list()
# upper-left (w0,h0)
for i in range(w0):
for j in range(h0):
newconfig.append(
(i * X(r, 0), j * Y(r, 0), portrait[r][0])
)
# upper-right (w1,h1)
for i in range(w1):
for j in range(h1):
newconfig.append(
(
n - w1 * X(r, 1) + i * X(r, 1),
j * Y(r, 1),
portrait[r][1],
)
)
# lower-right (w2,h2)
for i in range(w2):
for j in range(h2):
newconfig.append(
(
n - w2 * X(r, 2) + i * X(r, 2),
m - h2 * Y(r, 2) + j * Y(r, 2),
portrait[r][2],
)
)
# lower-left (w3,h3)
for i in range(w3):
for j in range(h3):
newconfig.append(
(
i * X(r, 3),
m - h3 * Y(r, 3) + j * Y(r, 3),
portrait[r][3],
)
)
# if neither rectangle 0 overlaps with rectangle 2 nor
# does rectangle 1 overlap with rectangle 3 in the center,
# then a center cover has to be added
X4 = n - w0 * X(r, 0) - w2 * X(r, 2)
Y4 = m - h1 * Y(r, 1) - h3 * Y(r, 3)
simple_config = []
if X4 > 0 and Y4 > 0:
simple_config, (sx, sy) = simple_cover(X4, Y4, x, y)
# shift the results such that they are in the center
for cx, cy, p in simple_config:
newconfig.append(
(
w0 * X(r, 0) + (X4 - sx) / 2 + cx,
h1 * Y(r, 1) + (Y4 - sy) / 2 + cy,
p,
)
)
else:
X4 = n - w1 * X(r, 1) - w3 * X(r, 3)
Y4 = m - h0 * Y(r, 0) - h2 * Y(r, 2)
if X4 > 0 and Y4 > 0:
simple_config, (sx, sy) = simple_cover(X4, Y4, x, y)
# shift the results such that they are in the center
for cx, cy, p in simple_config:
newconfig.append(
(
w3 * X(r, 3) + (X4 - sx) / 2 + cx,
h0 * Y(r, 0) + (Y4 - sy) / 2 + cy,
p,
)
)
total = len(newconfig)
# shortcut to cut computation short in case a
# solution with the minimal possible number of
# pages is found
if total == minimum:
return newconfig
if total < cover:
cover = total
config = newconfig
return config
class Plakativ:
def __init__(self, doc=None, pagenr=0):
self.doc = doc
if self.doc is None:
# either we didn't have img2pdf or opening the input with img2pdf
# failed
if hasattr(infile, "read"):
self.doc = fitz.open(stream=infile, filetype="application/pdf")
else:
self.doc = fitz.open(filename=infile)
self.pagenr = pagenr
# set page number -- first page is 0
def set_input_pagenr(self, pagenr):
if pagenr < 0 or pagenr >= len(self.doc):
raise PageNrOutOfRangeException(
"%d is not between 0 and %d (inclusive)" % (pagenr, len(self.doc))
)
self.pagenr = pagenr
def get_input_pagenums(self):
return len(self.doc)
def get_input_page_size(self):
# since pymupdf 1.19.0 a warning will be issued if the deprecated names are used
if hasattr(self.doc[self.pagenr], "get_displaylist"):
gdl = self.doc[self.pagenr].get_displaylist
else:
gdl = self.doc[self.pagenr].getDisplayList
rect = gdl().rect
return (rect.width, rect.height)
def get_image(self, zoom):
mat_0 = fitz.Matrix(zoom, zoom)
# since pymupdf 1.19.0 a warning will be issued if the deprecated names are used
if hasattr(self.doc[self.pagenr], "get_displaylist"):
gdl = self.doc[self.pagenr].get_displaylist()
else:
gdl = self.doc[self.pagenr].getDisplayList()
if hasattr(gdl, "get_pixmap"):
pix = gdl.get_pixmap(matrix=mat_0, alpha=False)
else:
pix = gdl.getPixmap(matrix=mat_0, alpha=False)
if hasattr(pix, "tobytes"):
# getImageData was deprecated in pymupdf 1.19.0
return pix.tobytes("ppm")
if hasattr(pix, "getImageData"):
# the getImageData() function was only introduced in pymupdf 1.14.5
return pix.getImageData("ppm")
else:
# this is essentially the same thing that the getImageData()
# function does
return pix._getImageData(2) # 2 stands for pgm/ppm/pbm
def compute_layout(
self,
mode,
postersize=None,
mult=None,
npages=None,
pagesize=(210, 297),
border=(0, 0, 0, 0),
strategy="simple",
):
border_top, border_right, border_bottom, border_left = border
self.layout = {
"output_pagesize": pagesize,
"border_top": border_top,
"border_right": border_right,
"border_bottom": border_bottom,
"border_left": border_left,
}
printable_width = self.layout["output_pagesize"][0] - (
border_left + border_right
)
printable_height = self.layout["output_pagesize"][1] - (
border_top + border_bottom
)
# since pymupdf 1.19.0 a warning will be issued if the deprecated names are used
if hasattr(self.doc[self.pagenr], "get_displaylist"):
gdl = self.doc[self.pagenr].get_displaylist
else:
gdl = self.doc[self.pagenr].getDisplayList
# this may fail with "RuntimeError: image is too wide"
# from pdf_load_image_imp() in pdf-image.c from mupdf for sizes larger
# than 1<<16 pixels:
# https://bugs.ghostscript.com/show_bug.cgi?id=703839
rect = gdl().rect
inpage_width = pt_to_mm(rect.width)
inpage_height = pt_to_mm(rect.height)
if mode in ["size", "mult"]:
if mode == "size":
# fit the input page size into the selected postersize
width_portrait = postersize[0]
height_portrait = (width_portrait * inpage_height) / inpage_width
if height_portrait > postersize[1]:
height_portrait = postersize[1]
width_portrait = (height_portrait * inpage_width) / inpage_height
area_portrait = width_portrait * height_portrait
width_landscape = postersize[1]
height_landscape = (width_landscape * inpage_height) / inpage_width
if height_landscape > postersize[0]:
height_landscape = postersize[0]
width_landscape = (height_landscape * inpage_width) / inpage_height
area_landscape = width_landscape * height_landscape
if area_portrait > area_landscape:
poster_width, poster_height = width_portrait, height_portrait
else:
poster_width, poster_height = width_landscape, height_landscape
elif mode == "mult":
area = inpage_width * inpage_height * mult
poster_width = math.sqrt(area * inpage_width / inpage_height)
poster_height = math.sqrt(area * inpage_height / inpage_width)
else:
raise Exception("unsupported mode: %s" % mode)
elif mode == "npages":
# stupid bruteforce algorithm to determine the largest printable
# postersize with N pages
best_area = 0
best = None
for x in range(1, npages + 1):
for y in range(1, npages + 1):
if x * y > npages:
continue
width_portrait = x * printable_width
height_portrait = y * printable_height
poster_width = width_portrait
poster_height = (poster_width * inpage_height) / inpage_width
if poster_height > height_portrait:
poster_height = height_portrait
poster_width = (poster_height * inpage_width) / inpage_height
area_portrait = poster_width * poster_height
if area_portrait > best_area:
best_area = area_portrait
best = (poster_width, poster_height)
width_landscape = x * printable_height
height_landscape = y * printable_width
poster_width = width_landscape
poster_height = (poster_width * inpage_height) / inpage_width
if poster_height > height_landscape:
poster_height = height_landscape
poster_width = (poster_height * inpage_width) / inpage_height
area_landscape = poster_width * poster_height
if area_landscape > best_area:
best_area = area_landscape
best = (poster_width, poster_height)
poster_width, poster_height = best
if strategy == "complex":
# bisect poster sizes until we find the largest size that can
# be printed given the available number of pages
# we already know the maximum size for a solution utilizing the
# simple cover algorithm, so this will be the minimum known
# poster size
min_area_mult = (poster_width * poster_height) / (
inpage_width * inpage_height
)
# to avoid floating point errors later
min_area_mult *= 0.9999
min_area_npages = len(
complex_cover(
poster_width, poster_height, printable_width, printable_height
)
)
# the maximum possible size is a poster of the area created by
# multiplying the individual page areas by the maximum number
# of pages available
max_area_mult = (npages * printable_width * printable_height) / (
inpage_width * inpage_height
)
max_area_npages = len(
complex_cover(
math.sqrt(max_area_mult) * inpage_width,
math.sqrt(max_area_mult) * inpage_height,
printable_width,
printable_height,
)
)
while True:
if abs(min_area_mult - max_area_mult) < 0.001:
break
new_area_mult = (min_area_mult + max_area_mult) / 2
new_area_npages = len(
complex_cover(
math.sqrt(new_area_mult) * inpage_width,
math.sqrt(new_area_mult) * inpage_height,
printable_width,
printable_height,
)
)
if new_area_npages > npages:
max_area_mult = new_area_mult
else:
min_area_mult = new_area_mult
poster_width = inpage_width * math.sqrt(min_area_mult)
poster_height = inpage_height * math.sqrt(min_area_mult)
else:
raise Exception("unsupported mode: %s" % mode)
pages_x_portrait = math.ceil(poster_width / printable_width)
pages_y_portrait = math.ceil(poster_height / printable_height)
pages_x_landscape = math.ceil(poster_width / printable_height)
pages_y_landscape = math.ceil(poster_height / printable_width)
portrait = True
if pages_x_portrait * pages_y_portrait > pages_x_landscape * pages_y_landscape:
portrait = False
if portrait:
pages_x = pages_x_portrait
pages_y = pages_y_portrait
else:
pages_x = pages_x_landscape
pages_y = pages_y_landscape
# size of the bounding box of all pages after they have been glued together
if portrait:
self.layout["overallsize"] = (
pages_x * printable_width + (border_right + border_left),
pages_y * printable_height + (border_top + border_bottom),
)
else:
self.layout["overallsize"] = (
pages_x * printable_height + (border_top + border_bottom),
pages_y * printable_width + (border_right + border_left),
)
# position of the poster relative to upper left corner of layout["overallsize"]
if portrait:
self.layout["posterpos"] = (
border_left + (pages_x * printable_width - poster_width) / 2,
border_top + (pages_y * printable_height - poster_height) / 2,
)
else:
self.layout["posterpos"] = (
border_bottom + (pages_x * printable_height - poster_width) / 2,
border_right + (pages_y * printable_width - poster_height) / 2,
)
# positions are relative to self.layout["posterpos"]
self.layout["positions"] = []
for y in range(pages_y):
for x in range(pages_x):
if portrait:
posx = (
x * printable_width
- (pages_x * printable_width - poster_width) / 2
)
posy = (
y * printable_height
- (pages_y * printable_height - poster_height) / 2
)
else:
posx = (
x * printable_height
- (pages_x * printable_height - poster_width) / 2
)
posy = (
y * printable_width
- (pages_y * printable_width - poster_height) / 2
)
self.layout["positions"].append((posx, posy, portrait))
if strategy == "complex":
positions_complex = complex_cover(
poster_width, poster_height, printable_width, printable_height
)
if len(positions_complex) < len(self.layout["positions"]):
self.layout["positions"] = positions_complex
# figure out the borders around the final poster by analyzing
# the computed positions and storing the largest border size in
# each dimension
poster_top = poster_right = poster_bottom = poster_left = 0
for posx, posy, p in self.layout["positions"]:
if p:
top = posy - border_top
if top < 0 and -top > poster_top:
poster_top = -top
right = posx + printable_width + border_right - poster_width
if right > 0 and right > poster_right:
poster_right = right
bottom = posy + printable_height + border_bottom - poster_height
if bottom > 0 and bottom > poster_bottom:
poster_bottom = bottom
left = posx - border_left
if left < 0 and -left > poster_left:
poster_left = -left
else:
top = posy - border_left
if top < 0 and -top > poster_top:
poster_top = -top
right = posx + printable_height + border_top - poster_width
if right > 0 and right > poster_right:
poster_right = right
bottom = posy + printable_width + border_right - poster_height
if bottom > 0 and bottom > poster_bottom:
poster_bottom = bottom
left = posx - border_bottom
if left < 0 and -left > poster_left:
poster_left = -left
self.layout["overallsize"] = (
poster_width + poster_left + poster_right,
poster_height + poster_top + poster_bottom,
)
self.layout["posterpos"] = (poster_left, poster_top)
# size of output poster is always proportional to size of input page
self.layout["postersize"] = poster_width, poster_height
if mode == "size":
mult = (poster_width * poster_height) / (inpage_width * inpage_height)
npages = len(self.layout["positions"])
elif mode == "mult":
postersize = poster_width, poster_height
npages = len(self.layout["positions"])
elif mode == "npages":
postersize = poster_width, poster_height
mult = (poster_width * poster_height) / (inpage_width * inpage_height)
else:
raise Exception("unsupported mode: %s" % mode)
return postersize, mult, npages
def render(self, outfile, cover=False, guides=False, numbers=False, border=False):
if not hasattr(self, "layout"):
raise LayoutNotComputedException()
# since pymupdf 1.19.0 a warning will be issued if the deprecated names are used
if hasattr(self.doc[self.pagenr], "get_displaylist"):
gdl = self.doc[self.pagenr].get_displaylist
else:
gdl = self.doc[self.pagenr].getDisplayList
inpage_width = pt_to_mm(gdl().rect.width)
outdoc = fitz.open()
if cover:
# factor to convert from output poster dimensions (given in mm) into
# pdf dimensions (given in pt)
zoom_1 = min(
mm_to_pt(
self.layout["output_pagesize"][0]
- 2 * max(self.layout["border_left"], self.layout["border_right"])
)
/ (self.layout["overallsize"][0]),
mm_to_pt(
self.layout["output_pagesize"][1]
- 2 * max(self.layout["border_top"], self.layout["border_bottom"])
)
/ (self.layout["overallsize"][1]),
)
# since pymupdf 1.19.0 a warning will be issued if the deprecated names are used
if hasattr(outdoc, "new_page"):
np = outdoc.new_page
else:
np = outdoc.newPage
page = np(
-1, # insert after last page
width=mm_to_pt(self.layout["output_pagesize"][0]),
height=mm_to_pt(self.layout["output_pagesize"][1]),
)
for i, (x, y, portrait) in enumerate(self.layout["positions"]):
x0 = (x + self.layout["posterpos"][0]) * zoom_1 + (
mm_to_pt(self.layout["output_pagesize"][0])
- zoom_1 * self.layout["overallsize"][0]
) / 2
y0 = (y + self.layout["posterpos"][1]) * zoom_1 + (
mm_to_pt(self.layout["output_pagesize"][1])
- zoom_1 * self.layout["overallsize"][1]
) / 2
if portrait:
page_width = self.layout["output_pagesize"][0] * zoom_1
page_height = self.layout["output_pagesize"][1] * zoom_1
top = self.layout["border_top"] * zoom_1
right = self.layout["border_right"] * zoom_1
bottom = self.layout["border_bottom"] * zoom_1
left = self.layout["border_left"] * zoom_1
else:
# page is rotated 90 degrees clockwise
page_width = self.layout["output_pagesize"][1] * zoom_1
page_height = self.layout["output_pagesize"][0] * zoom_1
top = self.layout["border_left"] * zoom_1
right = self.layout["border_top"] * zoom_1
bottom = self.layout["border_right"] * zoom_1
left = self.layout["border_bottom"] * zoom_1
# inner rectangle
if hasattr(page, "new_shape"):
shape = page.new_shape()
else:
shape = page.newShape()
if hasattr(shape, "draw_rect"):
dr = shape.draw_rect
else:
dr = shape.drawRect
dr(
fitz.Rect(
x0,
y0,
x0 + page_width - left - right,
y0 + page_height - top - bottom,
)
)
shape.finish(color=(0, 0, 1))
# outer rectangle
dr(
fitz.Rect(
x0 - left,
y0 - top,
x0 - left + page_width,
y0 - top + page_height,
)
)
shape.finish(color=(1, 0, 0))
shape.insertTextbox(
fitz.Rect(
x0 + 5,
y0 + 5,
x0 + page_width - left - right - 5,
y0 + page_height - top - bottom - 5,
),
"%d" % (i + 1),
fontsize=20,
color=(0, 0, 0),
)
shape.commit()
for i, (x, y, portrait) in enumerate(self.layout["positions"]):
if portrait:
page_width = mm_to_pt(self.layout["output_pagesize"][0])
page_height = mm_to_pt(self.layout["output_pagesize"][1])
else:
page_width = mm_to_pt(self.layout["output_pagesize"][1])
page_height = mm_to_pt(self.layout["output_pagesize"][0])
# since pymupdf 1.19.0 a warning will be issued if the deprecated names are used
if hasattr(outdoc, "new_page"):
np = outdoc.new_page
else:
np = outdoc.newPage
page = np(
-1, width=page_width, height=page_height # insert after last page
)
if portrait:
target_x = x - self.layout["border_left"]
target_y = y - self.layout["border_top"]
target_width = self.layout["output_pagesize"][0]
target_height = self.layout["output_pagesize"][1]
else:
target_x = x - self.layout["border_bottom"]
target_y = y - self.layout["border_left"]
target_width = self.layout["output_pagesize"][1]
target_height = self.layout["output_pagesize"][0]
target_xoffset = 0
target_yoffset = 0
if target_x < 0:
target_xoffset = -target_x
target_width += target_x
target_x = 0
if target_y < 0:
target_yoffset = -target_y
target_height += target_y
target_y = 0
if target_x + target_width > self.layout["postersize"][0]:
target_width = self.layout["postersize"][0] - target_x
if target_y + target_height > self.layout["postersize"][1]:
target_height = self.layout["postersize"][1] - target_y
targetrect = fitz.Rect(
mm_to_pt(target_xoffset),
mm_to_pt(target_yoffset),
mm_to_pt(target_xoffset + target_width),
mm_to_pt(target_yoffset + target_height),
)
factor = inpage_width / self.layout["postersize"][0]
sourcerect = fitz.Rect(
mm_to_pt(factor * target_x),
mm_to_pt(factor * target_y),
mm_to_pt(factor * (target_x + target_width)),
mm_to_pt(factor * (target_y + target_height)),
)
# since pymupdf 1.19.0 a warning will be issued if the deprecated names are used
if hasattr(page, "show_pdf_page"):
spp = page.show_pdf_page
else:
spp = page.showPDFpage
spp(
targetrect, # fill the whole page
self.doc, # input document
self.pagenr, # input page number
clip=sourcerect, # part of the input page to use
)
if hasattr(page, "new_shape"):
shape = page.new_shape()
else:
shape = page.newShape()
if hasattr(shape, "draw_rect"):
dr = shape.draw_rect
else:
dr = shape.drawRect
if guides:
if portrait:
dr(
fitz.Rect(
mm_to_pt(self.layout["border_left"]),
mm_to_pt(self.layout["border_top"]),
page_width - mm_to_pt(self.layout["border_right"]),
page_height - mm_to_pt(self.layout["border_bottom"]),
)
)
else:
dr(
fitz.Rect(
mm_to_pt(self.layout["border_bottom"]),
mm_to_pt(self.layout["border_left"]),
page_width - mm_to_pt(self.layout["border_top"]),
page_height - mm_to_pt(self.layout["border_right"]),
)
)
shape.finish(width=0.2, color=(0.5, 0.5, 0.5), dashes="[5 6 1 6] 0")
if numbers:
if portrait:
shape.insertTextbox(
fitz.Rect(
mm_to_pt(self.layout["border_left"]) + 5,
mm_to_pt(self.layout["border_top"]) + 5,
page_width - mm_to_pt(self.layout["border_right"]) - 5,
page_height - mm_to_pt(self.layout["border_bottom"]) - 5,
),
"%d" % (i + 1),
fontsize=8,
color=(0.5, 0.5, 0.5),
)
else:
shape.insertTextbox(
fitz.Rect(
mm_to_pt(self.layout["border_bottom"]) + 5,
mm_to_pt(self.layout["border_left"]) + 5,
page_width - mm_to_pt(self.layout["border_top"]) - 5,
page_height - mm_to_pt(self.layout["border_right"]) - 5,
),
"%d" % (i + 1),
fontsize=8,
color=(0.5, 0.5, 0.5),
)
if border:
if portrait:
dr(
fitz.Rect(
mm_to_pt(self.layout["border_left"] - x),
mm_to_pt(self.layout["border_top"] - y),
mm_to_pt(
self.layout["border_left"]
- x
+ self.layout["postersize"][0]
),
mm_to_pt(
self.layout["border_top"]
- y
+ self.layout["postersize"][1]
),
)
)
else:
dr(
fitz.Rect(
mm_to_pt(self.layout["border_bottom"] - x),
mm_to_pt(self.layout["border_left"] - y),
mm_to_pt(
self.layout["border_bottom"]
- x
+ self.layout["postersize"][0]
),
mm_to_pt(
self.layout["border_left"]
- y
+ self.layout["postersize"][1]
),
)
)
shape.finish(width=0.2, color=(0.5, 0.5, 0.5), dashes="[1 1] 0")
shape.commit()
if hasattr(outfile, "write"):
# outfile is an object with a write() method
outfile.write(outdoc.write(garbage=4, deflate=True))
else:
# outfile is used as a filename
outdoc.save(outfile, garbage=4, deflate=True)
# from Python 3.7 Lib/idlelib/configdialog.py
# Copyright 2015-2017 Terry Jan Reedy
# Python License
class VerticalScrolledFrame(tkinter.Frame):
"""A pure Tkinter vertically scrollable frame.
* Use the 'interior' attribute to place widgets inside the scrollable frame
* Construct and pack/place/grid normally
* This frame only allows vertical scrolling
"""
def __init__(self, parent, *args, **kw):
tkinter.Frame.__init__(self, parent, *args, **kw)
# Create a canvas object and a vertical scrollbar for scrolling it.
vscrollbar = tkinter.Scrollbar(self, orient=tkinter.VERTICAL)
vscrollbar.pack(fill=tkinter.Y, side=tkinter.RIGHT, expand=tkinter.FALSE)
canvas = tkinter.Canvas(
self,
borderwidth=0,
highlightthickness=0,
yscrollcommand=vscrollbar.set,
width=240 * parent.winfo_fpixels("1i") / 96.0,
)
canvas.pack(side=tkinter.LEFT, fill=tkinter.BOTH, expand=tkinter.TRUE)
vscrollbar.config(command=canvas.yview)
# Reset the view.
canvas.xview_moveto(0)
canvas.yview_moveto(0)
# Create a frame inside the canvas which will be scrolled with it.
self.interior = interior = tkinter.Frame(canvas)
interior_id = canvas.create_window(0, 0, window=interior, anchor=tkinter.NW)
# Track changes to the canvas and frame width and sync them,
# also updating the scrollbar.
def _configure_interior(event):
# Update the scrollbars to match the size of the inner frame.
size = (interior.winfo_reqwidth(), interior.winfo_reqheight())
canvas.config(scrollregion="0 0 %s %s" % size)
interior.bind("<Configure>", _configure_interior)
def _configure_canvas(event):
if interior.winfo_reqwidth() != canvas.winfo_width():
# Update the inner frame's width to fill the canvas.
canvas.itemconfigure(interior_id, width=canvas.winfo_width())
canvas.bind("<Configure>", _configure_canvas)
return
# From Python 3.7 Lib/tkinter/__init__.py
# Copyright 2000 Fredrik Lundh
# Python License
#
# add support for 'state' and 'name' kwargs
# add support for updating list of options
class OptionMenu(tkinter.Menubutton):
"""OptionMenu which allows the user to select a value from a menu."""
def __init__(self, master, variable, value, *values, **kwargs):
"""Construct an optionmenu widget with the parent MASTER, with
the resource textvariable set to VARIABLE, the initially selected
value VALUE, the other menu values VALUES and an additional
keyword argument command."""
kw = {
"borderwidth": 2,
"textvariable": variable,
"indicatoron": 1,
"relief": tkinter.RAISED,
"anchor": "c",
"highlightthickness": 2,
}
if "state" in kwargs:
kw["state"] = kwargs["state"]
del kwargs["state"]
if "name" in kwargs:
kw["name"] = kwargs["name"]
del kwargs["name"]
tkinter.Widget.__init__(self, master, "menubutton", kw)
self.widgetName = "tk_optionMenu"
self.callback = kwargs.get("command")
self.variable = variable
if "command" in kwargs:
del kwargs["command"]
if kwargs:
raise tkinter.TclError("unknown option -" + list(kwargs.keys())[0])
self.set_values([value] + list(values))
def __getitem__(self, name):
if name == "menu":
return self.__menu
return tkinter.Widget.__getitem__(self, name)
def set_values(self, values):
menu = self.__menu = tkinter.Menu(self, name="menu", tearoff=0)
self.menuname = menu._w
for v in values:
menu.add_command(
label=v, command=tkinter._setit(self.variable, v, self.callback)
)
self["menu"] = menu
def destroy(self):
"""Destroy this widget and the associated menu."""
tkinter.Menubutton.destroy(self)
self.__menu = None
class Application(tkinter.Frame):
def __init__(self, master=None):
super().__init__(master)
self.master = master
self.master.title("plakativ")
self.pack(fill=tkinter.BOTH, expand=tkinter.TRUE)
self.canvas = tkinter.Canvas(self, bg="black")
self.canvas.pack(fill=tkinter.BOTH, side=tkinter.LEFT, expand=tkinter.TRUE)
self.canvas_size = self.canvas.winfo_width(), self.canvas.winfo_height()
self.canvas.bind("<Configure>", self.on_resize)
frame_right = tkinter.Frame(self)
frame_right.pack(side=tkinter.TOP, expand=tkinter.TRUE, fill=tkinter.Y)
top_frame = tkinter.Frame(frame_right)
top_frame.pack(fill=tkinter.X)
button_text = "Open PDF"
if have_img2pdf:
button_text = "Open PDF, JPG, PNG, TIF"
tkinter.Button(top_frame, text=button_text, command=self.on_open_button).pack(
side=tkinter.LEFT, expand=tkinter.TRUE, fill=tkinter.X
)
tkinter.Button(top_frame, text="Help", state=tkinter.DISABLED).pack(
side=tkinter.RIGHT, expand=tkinter.TRUE, fill=tkinter.X
)
frame1 = VerticalScrolledFrame(frame_right)
frame1.pack(side=tkinter.TOP, expand=tkinter.TRUE, fill=tkinter.Y)
self.input = InputWidget(frame1.interior)
self.input.pack(fill=tkinter.X)
self.input.set(1, (0, 0))
if hasattr(self, "plakativ"):
self.input.callback = self.on_input
self.pagesize = PageSizeWidget(frame1.interior)
self.pagesize.pack(fill=tkinter.X)
self.pagesize.set(False, (210, 297))
if hasattr(self, "plakativ"):
self.pagesize.callback = self.on_pagesize
self.bordersize = BorderSizeWidget(frame1.interior)
self.bordersize.pack(fill=tkinter.X)
self.bordersize.set(15.0, 15.0, 15.0, 15.0)
if hasattr(self, "plakativ"):
self.bordersize.callback = self.on_bordersize
self.postersize = PostersizeWidget(frame1.interior)
self.postersize.pack(fill=tkinter.X)
self.postersize.set("size", (False, (594, 841)), 1.0, 1)
if hasattr(self, "plakativ"):
self.postersize.callback = self.on_postersize
self.layouter = LayouterWidget(frame1.interior)
self.layouter.pack(fill=tkinter.X)
self.layouter.set("simple")
if hasattr(self, "plakativ"):
self.layouter.callback = self.on_layouter
self.outopts = OutOptsWidget(frame1.interior)
self.outopts.pack(fill=tkinter.X)
option_group = tkinter.LabelFrame(frame1.interior, text="Program options")
option_group.pack(fill=tkinter.X)
tkinter.Label(option_group, text="Unit:", state=tkinter.DISABLED).grid(
row=0, column=0, sticky=tkinter.W
)
unit = tkinter.StringVar()
unit.set("mm")
OptionMenu(option_group, unit, ["mm"], state=tkinter.DISABLED).grid(
row=0, column=1, sticky=tkinter.W
)
tkinter.Label(option_group, text="Language:", state=tkinter.DISABLED).grid(
row=1, column=0, sticky=tkinter.W
)
language = tkinter.StringVar()
language.set("English")
OptionMenu(option_group, language, ["English"], state=tkinter.DISABLED).grid(
row=1, column=1, sticky=tkinter.W
)
bottom_frame = tkinter.Frame(frame_right)
bottom_frame.pack(fill=tkinter.X)
self.save_button = tkinter.Button(
bottom_frame,
text="Save PDF",
command=self.on_save_button,
state=tkinter.DISABLED,
)
self.save_button.pack(side=tkinter.LEFT, expand=tkinter.TRUE, fill=tkinter.X)
quit_button = tkinter.Button(
bottom_frame, text="Exit", command=self.master.destroy
)
quit_button.pack(side=tkinter.RIGHT, expand=tkinter.TRUE, fill=tkinter.X)
def on_input(self, value):
_, pagesize = self.pagesize.value
pagenum, _ = value
mode, (custom_size, size), mult, npages = self.postersize.value
bordersize = self.bordersize.value
strategy = self.layouter.value
self.plakativ.set_input_pagenr(pagenum - 1)
size, mult, npages = self.plakativ.compute_layout(
mode, size, mult, npages, pagesize, bordersize, strategy
)
self.postersize.set(mode, (custom_size, size), mult, npages)
self.draw()
width, height = self.plakativ.get_input_page_size()
return "%.02f" % pt_to_mm(width), "%.02f" % pt_to_mm(height)
def on_pagesize(self, value):
_, pagesize = value
pagenum, _ = self.input.value
mode, (custom_size, size), mult, npages = self.postersize.value
bordersize = self.bordersize.value
strategy = self.layouter.value
self.plakativ.set_input_pagenr(pagenum - 1)
size, mult, npages = self.plakativ.compute_layout(
mode, size, mult, npages, pagesize, bordersize, strategy
)
self.postersize.set(mode, (custom_size, size), mult, npages)
self.draw()
def on_bordersize(self, value):
_, pagesize = self.pagesize.value
pagenum, _ = self.input.value
mode, (custom_size, size), mult, npages = self.postersize.value
strategy = self.layouter.value
self.plakativ.set_input_pagenr(pagenum - 1)
size, mult, npages = self.plakativ.compute_layout(
mode, size, mult, npages, pagesize, value, strategy
)
self.postersize.set(mode, (custom_size, size), mult, npages)
self.draw()
def on_postersize(self, value):
mode, (custom_size, size), mult, npages = value
pagenum, _ = self.input.value
_, pagesize = self.pagesize.value
border = self.bordersize.value
strategy = self.layouter.value
self.plakativ.set_input_pagenr(pagenum - 1)
size, mult, npages = self.plakativ.compute_layout(
mode, size, mult, npages, pagesize, border, strategy
)
self.draw()
return (mode, (custom_size, size), mult, npages)
def on_layouter(self, value):
_, pagesize = self.pagesize.value
pagenum, _ = self.input.value
mode, (custom_size, size), mult, npages = self.postersize.value
border = self.bordersize.value
self.plakativ.set_input_pagenr(pagenum - 1)
size, mult, npages = self.plakativ.compute_layout(
mode, size, mult, npages, pagesize, border, value
)
self.postersize.set(mode, (custom_size, size), mult, npages)
self.draw()
def on_resize(self, event):
self.canvas_size = (event.width, event.height)
self.draw()
def draw(self):
# clean canvas
self.canvas.delete(tkinter.ALL)
if not hasattr(self, "plakativ"):
button_text = "Open PDF"
if have_img2pdf:
button_text = "Open PDF, JPG, PNG, TIF"
self.canvas.create_text(
self.canvas_size[0] / 2,
self.canvas_size[1] / 2,
text='Click on the "%s" button in the upper right.' % button_text,
fill="white",
)
return
canvas_padding = 10
width, height = self.plakativ.get_input_page_size()
# factor to convert from input page dimensions (given in pt) into
# canvas dimensions (given in pixels)
zoom_0 = min(
self.canvas_size[0]
/ width
* self.plakativ.layout["postersize"][0]
/ (self.plakativ.layout["overallsize"][0] + canvas_padding),
self.canvas_size[1]
/ height
* self.plakativ.layout["postersize"][1]
/ (self.plakativ.layout["overallsize"][1] + canvas_padding),
)
img = self.plakativ.get_image(zoom_0)
tkimg = tkinter.PhotoImage(data=img)
# factor to convert from output poster dimensions (given in mm) into
# canvas dimensions (given in pixels)
zoom_1 = min(
self.canvas_size[0]
/ (self.plakativ.layout["overallsize"][0] + canvas_padding),
self.canvas_size[1]
/ (self.plakativ.layout["overallsize"][1] + canvas_padding),
)
# draw image on canvas
self.canvas.create_image(
(self.canvas_size[0] - zoom_1 * self.plakativ.layout["overallsize"][0]) / 2
+ zoom_1 * self.plakativ.layout["posterpos"][0],
(self.canvas_size[1] - zoom_1 * self.plakativ.layout["overallsize"][1]) / 2
+ zoom_1 * self.plakativ.layout["posterpos"][1],
anchor=tkinter.NW,
image=tkimg,
)
self.canvas.image = tkimg
# self.canvas.create_text(
# self.canvas_size[0] / 2,
# self.canvas_size[1] / 2,
# text="%d" % len(self.plakativ.layout["positions"]),
# fill="grey",
# font=("TkDefaultFont", 40),
# anchor=tkinter.CENTER,
# )
# draw rectangles
# TODO: also draw numbers indicating the page number
for x, y, portrait in self.plakativ.layout["positions"]:
x0 = (x + self.plakativ.layout["posterpos"][0]) * zoom_1 + (
self.canvas_size[0] - zoom_1 * self.plakativ.layout["overallsize"][0]
) / 2
y0 = (y + self.plakativ.layout["posterpos"][1]) * zoom_1 + (
self.canvas_size[1] - zoom_1 * self.plakativ.layout["overallsize"][1]
) / 2
if portrait:
page_width = self.plakativ.layout["output_pagesize"][0] * zoom_1
page_height = self.plakativ.layout["output_pagesize"][1] * zoom_1
top = self.plakativ.layout["border_top"] * zoom_1
right = self.plakativ.layout["border_right"] * zoom_1
bottom = self.plakativ.layout["border_bottom"] * zoom_1
left = self.plakativ.layout["border_left"] * zoom_1
else:
# page is rotated 90 degrees clockwise
page_width = self.plakativ.layout["output_pagesize"][1] * zoom_1
page_height = self.plakativ.layout["output_pagesize"][0] * zoom_1
top = self.plakativ.layout["border_left"] * zoom_1
right = self.plakativ.layout["border_top"] * zoom_1
bottom = self.plakativ.layout["border_right"] * zoom_1
left = self.plakativ.layout["border_bottom"] * zoom_1
# inner rectangle
self.canvas.create_rectangle(
x0,
y0,
x0 + page_width - left - right,
y0 + page_height - top - bottom,
outline="blue",
)
# outer rectangle
self.canvas.create_rectangle(
x0 - left,
y0 - top,
x0 - left + page_width,
y0 - top + page_height,
outline="red",
)
# filename = "out_%03d.ps" % len(self.plakativ.layout["positions"])
# self.canvas.postscript(file=filename)
# print("saved ", filename)
def on_open_button(self):
if have_img2pdf:
filetypes = [
("all supported", "*.pdf *.png *.jpg *.jpeg *.gif *.tiff *.tif"),
("pdf documents", "*.pdf"),
("png images", "*.png"),
("jpg images", "*.jpg *.jpeg"),
("gif images", "*.gif"),
("tiff images", "*.tiff *.tif"),
("all files", "*"),
]
else:
filetypes = [
("pdf documents", "*.pdf"),
("all files", "*"),
]
filename = tkinter.filedialog.askopenfilename(
parent=self.master,
title="Open either a PDF or a raster image",
filetypes=filetypes
# initialdir="/home/josch/git/plakativ",
# initialfile="test.pdf",
)
if filename == ():
return
self.open_file(filename)
def open_file(self, filename):
self.filename = filename
doc = None
if have_img2pdf:
# if we have img2pdf available we can encapsulate a raster image
# into a PDF container
data = None
try:
data = img2pdf.convert(self.filename)
except img2pdf.AlphaChannelError:
remove_alpha = tkinter.messagebox.askyesno(
title="Removing Alpha Channel",
message="PDF does not support alpha channels. Should the "
"alpha channel be removed? The resulting PDF might not be "
"lossless anymore.",
)
# remove alpha channel
if remove_alpha:
img = Image.open(self.filename).convert("RGBA")
background = Image.new("RGBA", img.size, (255, 255, 255))
img = Image.alpha_composite(background, img)
with BytesIO() as output:
img.convert("RGB").save(output, format="PNG")
output.seek(0)
data = img2pdf.convert(output)
else:
return
except img2pdf.ImageOpenError:
# img2pdf cannot handle this
pass
if data is not None:
stream = BytesIO()
stream.write(data)
doc = fitz.open(stream=stream, filetype="application/pdf")
if doc is None:
# either we didn't have img2pdf or opening the input with img2pdf
# failed
doc = fitz.open(filename=self.filename)
self.plakativ = Plakativ(doc)
# compute the splitting with the current values
mode, (custom_size, size), mult, npages = self.postersize.value
_, pagesize = self.pagesize.value
border = self.bordersize.value
strategy = self.layouter.value
size, mult, npages = self.plakativ.compute_layout(
mode, size, mult, npages, pagesize, border, strategy
)
# update input widget
width, height = self.plakativ.get_input_page_size()
self.input.set(1, ("%.02f" % pt_to_mm(width), "%.02f" % pt_to_mm(height)))
self.input.nametowidget("spinbox_pagenum").configure(
to=self.plakativ.get_input_pagenums()
)
self.input.nametowidget("label_of_pagenum").configure(
text="of %d" % self.plakativ.get_input_pagenums()
)
# update postersize widget
self.postersize.set(mode, (custom_size, size), mult, npages)
# draw preview in canvas
self.draw()
# enable save button
self.save_button.configure(state=tkinter.NORMAL)
# set callback function
self.input.callback = self.on_input
self.pagesize.callback = self.on_pagesize
self.bordersize.callback = self.on_bordersize
self.postersize.callback = self.on_postersize
self.layouter.callback = self.on_layouter
def on_save_button(self):
base, ext = os.path.splitext(os.path.basename(self.filename))
filename = tkinter.filedialog.asksaveasfilename(
parent=self.master,
title="Save as PDF",
defaultextension=".pdf",
filetypes=[("pdf documents", "*.pdf"), ("all files", "*")],
initialdir=os.path.dirname(self.filename),
initialfile=base + "_poster" + ext,
)
if filename == "":
return
self.plakativ.render(
filename,
cover=self.outopts.variables["cover"].get(),
guides=self.outopts.variables["guides"].get(),
numbers=self.outopts.variables["numbers"].get(),
border=self.outopts.variables["border"].get(),
)
class LayouterWidget(tkinter.LabelFrame):
def __init__(self, parent, *args, **kw):
tkinter.LabelFrame.__init__(self, parent, text="Layouter", *args, **kw)
self.callback = None
self.variables = {"strategy": tkinter.StringVar()}
def callback(varname, idx, op):
assert op == "w"
self.on_strategy(self.variables["strategy"].get())
self.variables["strategy"].trace("w", callback)
layouter1 = tkinter.Radiobutton(
self, text="Simple", variable=self.variables["strategy"], value="simple"
)
layouter1.pack(anchor=tkinter.W)
layouter3 = tkinter.Radiobutton(
self, text="Complex", variable=self.variables["strategy"], value="complex"
)
layouter3.pack(anchor=tkinter.W)
def on_strategy(self, value):
if getattr(self, "value", None) is None:
return
strategy = self.value
self.set(value)
def set(self, strategy):
# before setting self.value, check if the effective value is different
# from before or otherwise we do not need to execute the callback in
# the end
state_changed = True
if getattr(self, "value", None) is not None:
state_changed = self.value != strategy
# execute callback if necessary
if state_changed and self.callback is not None:
pagesize = self.callback(strategy)
self.value = strategy
if self.variables["strategy"].get() != strategy:
self.variables["strategy"].set(strategy)
class OutOptsWidget(tkinter.LabelFrame):
def __init__(self, parent, *args, **kw):
tkinter.LabelFrame.__init__(self, parent, text="Output options", *args, **kw)
self.variables = {
"guides": tkinter.IntVar(),
"border": tkinter.IntVar(),
"numbers": tkinter.IntVar(),
"cover": tkinter.IntVar(),
}
tkinter.Checkbutton(
self, text="Print cutting guides", variable=self.variables["guides"]
).pack(anchor=tkinter.W)
tkinter.Checkbutton(
self, text="Print poster border", variable=self.variables["border"]
).pack(anchor=tkinter.W)
tkinter.Checkbutton(
self, text="Print page number", variable=self.variables["numbers"]
).pack(anchor=tkinter.W)
tkinter.Checkbutton(
self, text="Print layout cover page", variable=self.variables["cover"]
).pack(anchor=tkinter.W)
class InputWidget(tkinter.LabelFrame):
def __init__(self, parent, *args, **kw):
tkinter.LabelFrame.__init__(self, parent, text="Input properties", *args, **kw)
self.callback = None
self.variables = {
"pagenum": tkinter.IntVar(),
"width": tkinter.StringVar(),
"height": tkinter.StringVar(),
}
def callback(varname, idx, op):
assert op == "w"
self.on_pagenum(self.variables["pagenum"].get())
self.variables["pagenum"].trace("w", callback)
tkinter.Label(self, text="Use page").grid(row=0, column=0, sticky=tkinter.W)
tkinter.Spinbox(
self,
increment=1,
from_=1,
to=100,
width=3,
name="spinbox_pagenum",
textvariable=self.variables["pagenum"],
).grid(row=0, column=1, sticky=tkinter.W)
tkinter.Label(self, text="of 1", name="label_of_pagenum").grid(
row=0, column=2, sticky=tkinter.W
)
tkinter.Label(self, text="Width:").grid(row=1, column=0, sticky=tkinter.W)
tkinter.Label(self, textvariable=self.variables["width"]).grid(
row=1, column=1, sticky=tkinter.W
)
tkinter.Label(self, text="mm", name="size_label_width_mm").grid(
row=1, column=2, sticky=tkinter.W
)
tkinter.Label(self, text="Height:").grid(row=2, column=0, sticky=tkinter.W)
tkinter.Label(self, textvariable=self.variables["height"]).grid(
row=2, column=1, sticky=tkinter.W
)
tkinter.Label(self, text="mm", name="size_label_height_mm").grid(
row=2, column=2, sticky=tkinter.W
)
def on_pagenum(self, value):
if getattr(self, "value", None) is None:
return
_, size = self.value
self.set(value, size)
def set(self, pagenum, pagesize):
# before setting self.value, check if the effective value is different
# from before or otherwise we do not need to execute the callback in
# the end
state_changed = True
if getattr(self, "value", None) is not None:
state_changed = self.value != (pagenum, pagesize)
# execute callback if necessary
if state_changed and self.callback is not None:
pagesize = self.callback((pagenum, pagesize))
self.value = (pagenum, pagesize)
width, height = pagesize
if self.variables["pagenum"].get() != pagenum:
self.variables["pagenum"].set(pagenum)
if self.variables["width"].get() != width:
self.variables["width"].set(width)
if self.variables["height"].get() != height:
self.variables["height"].set(height)
class PageSizeWidget(tkinter.LabelFrame):
def __init__(self, parent, *args, **kw):
tkinter.LabelFrame.__init__(
self, parent, text="Size of output pages", *args, **kw
)
self.callback = None
self.variables = {
"dropdown": tkinter.StringVar(),
"width": tkinter.DoubleVar(),
"height": tkinter.DoubleVar(),
}
for k, v in self.variables.items():
# need to pass k and v as function arguments so that their value
# does not get overwritten each loop iteration
def callback(varname, idx, op, k_copy=k, v_copy=v):
assert op == "w"
getattr(self, "on_" + k_copy)(v_copy.get())
v.trace("w", callback)
OptionMenu(self, self.variables["dropdown"], *PAGE_SIZES.keys()).grid(
row=1, column=0, columnspan=3, sticky=tkinter.W
)
tkinter.Label(
self, text="Width:", state=tkinter.DISABLED, name="size_label_width"
).grid(row=2, column=0, sticky=tkinter.W)
tkinter.Spinbox(
self,
format="%.2f",
increment=0.01,
from_=0,
to=100,
width=5,
state=tkinter.DISABLED,
name="spinbox_width",
textvariable=self.variables["width"],
).grid(row=2, column=1, sticky=tkinter.W)
tkinter.Label(
self, text="mm", state=tkinter.DISABLED, name="size_label_width_mm"
).grid(row=2, column=2, sticky=tkinter.W)
tkinter.Label(
self, text="Height:", state=tkinter.DISABLED, name="size_label_height"
).grid(row=3, column=0, sticky=tkinter.W)
tkinter.Spinbox(
self,
format="%.2f",
increment=0.01,
from_=0,
to=100,
width=5,
state=tkinter.DISABLED,
name="spinbox_height",
textvariable=self.variables["height"],
).grid(row=3, column=1, sticky=tkinter.W)
tkinter.Label(
self, text="mm", state=tkinter.DISABLED, name="size_label_height_mm"
).grid(row=3, column=2, sticky=tkinter.W)
def on_dropdown(self, value):
custom_size, size = self.value
if value == "custom":
custom_size = True
else:
custom_size = False
size = PAGE_SIZES[value]
self.set(custom_size, size)
def on_width(self, value):
if getattr(self, "value", None) is None:
return
custom_size, (_, height) = self.value
self.set(custom_size, (value, height))
def on_height(self, value):
if getattr(self, "value", None) is None:
return
custom_size, (width, _) = self.value
self.set(custom_size, (width, value))
def set(self, custom_size, pagesize):
# before setting self.value, check if the effective value is different
# from before or otherwise we do not need to execute the callback in
# the end
state_changed = True
if getattr(self, "value", None) is not None:
state_changed = self.value != (custom_size, pagesize)
# execute callback if necessary
if state_changed and self.callback is not None:
self.callback((custom_size, pagesize))
self.value = (custom_size, pagesize)
width, height = pagesize
if custom_size:
self.nametowidget("size_label_width").configure(state=tkinter.NORMAL)
self.nametowidget("spinbox_width").configure(state=tkinter.NORMAL)
self.nametowidget("size_label_width_mm").configure(state=tkinter.NORMAL)
self.nametowidget("size_label_height").configure(state=tkinter.NORMAL)
self.nametowidget("spinbox_height").configure(state=tkinter.NORMAL)
self.nametowidget("size_label_height_mm").configure(state=tkinter.NORMAL)
else:
self.nametowidget("size_label_width").configure(state=tkinter.DISABLED)
self.nametowidget("spinbox_width").configure(state=tkinter.DISABLED)
self.nametowidget("size_label_width_mm").configure(state=tkinter.DISABLED)
self.nametowidget("size_label_height").configure(state=tkinter.DISABLED)
self.nametowidget("spinbox_height").configure(state=tkinter.DISABLED)
self.nametowidget("size_label_height_mm").configure(state=tkinter.DISABLED)
# only set variables that changed to not trigger multiple variable tracers
if custom_size:
if self.variables["dropdown"].get() != "custom":
self.variables["dropdown"].set("custom")
else:
val = dict(zip(PAGE_SIZES.values(), PAGE_SIZES.keys()))[(width, height)]
if self.variables["dropdown"].get() != val:
self.variables["dropdown"].set(val)
if self.variables["width"].get() != width:
self.variables["width"].set(width)
if self.variables["height"].get() != height:
self.variables["height"].set(height)
class BorderSizeWidget(tkinter.LabelFrame):
def __init__(self, parent, *args, **kw):
tkinter.LabelFrame.__init__(
self, parent, text="Output Borders/Overlap", *args, **kw
)
self.callback = None
self.variables = dict()
for i, (n, label) in enumerate(
[
("top", "Top:"),
("right", "Right:"),
("bottom", "Bottom:"),
("left", "Left:"),
]
):
self.variables[n] = tkinter.DoubleVar()
# need to pass k and v as function arguments so that their value
# does not get overwritten each loop iteration
def callback(varname, idx, op, k_copy=n, v_copy=self.variables[n]):
assert op == "w"
getattr(self, "on_" + k_copy)(v_copy.get())
self.variables[n].trace("w", callback)
tkinter.Label(self, text=label).grid(row=i, column=0, sticky=tkinter.W)
tkinter.Spinbox(
self,
format="%.2f",
increment=1.0,
from_=0,
to=100,
width=5,
textvariable=self.variables[n],
).grid(row=i, column=1)
tkinter.Label(self, text="mm").grid(row=i, column=2)
def on_top(self, value):
if getattr(self, "value", None) is None:
return
_, right, bottom, left = self.value
self.set(value, right, bottom, left)
def on_right(self, value):
if getattr(self, "value", None) is None:
return
top, _, bottom, left = self.value
self.set(top, value, bottom, left)
def on_bottom(self, value):
if getattr(self, "value", None) is None:
return
top, right, _, left = self.value
self.set(top, right, value, left)
def on_left(self, value):
if getattr(self, "value", None) is None:
return
top, right, bottom, _ = self.value
self.set(top, right, bottom, value)
def set(self, top, right, bottom, left):
# before setting self.value, check if the effective value is different
# from before or otherwise we do not need to execute the callback in
# the end
state_changed = True
if getattr(self, "value", None) is not None:
state_changed = self.value != (top, right, bottom, left)
# execute callback if necessary
if state_changed and self.callback is not None:
self.callback((top, right, bottom, left))
self.value = top, right, bottom, left
# only set variables that changed to not trigger multiple variable tracers
if self.variables["top"].get() != top:
self.variables["top"].set(top)
if self.variables["right"].get() != right:
self.variables["right"].set(right)
if self.variables["bottom"].get() != bottom:
self.variables["bottom"].set(bottom)
if self.variables["left"].get() != left:
self.variables["left"].set(left)
class PostersizeWidget(tkinter.LabelFrame):
def __init__(self, parent, *args, **kw):
tkinter.LabelFrame.__init__(self, parent, text="Poster Size", *args, **kw)
self.callback = None
self.variables = {
"radio": tkinter.StringVar(),
"dropdown": tkinter.StringVar(),
"width": tkinter.DoubleVar(),
"height": tkinter.DoubleVar(),
"multiplier": tkinter.DoubleVar(),
"pages": tkinter.IntVar(),
}
for k, v in self.variables.items():
# need to pass k and v as function arguments so that their value
# does not get overwritten each loop iteration
def callback(varname, idx, op, k_copy=k, v_copy=v):
assert op == "w"
getattr(self, "on_" + k_copy)(v_copy.get())
v.trace("w", callback)
tkinter.Radiobutton(
self,
text="Fit into width/height",
variable=self.variables["radio"],
value="size",
state=tkinter.DISABLED,
name="size_radio",
).grid(row=0, column=0, columnspan=3, sticky=tkinter.W)
OptionMenu(
self,
self.variables["dropdown"],
*PAGE_SIZES.keys(),
# state=tkinter.DISABLED,
name="size_dropdown",
).grid(row=1, column=0, columnspan=3, sticky=tkinter.W, padx=(27, 0))
tkinter.Label(
self, text="Width:", state=tkinter.DISABLED, name="size_label_width"
).grid(row=2, column=0, sticky=tkinter.W, padx=(27, 0))
tkinter.Spinbox(
self,
format="%.2f",
increment=0.1,
from_=0,
to=10000,
width=5,
textvariable=self.variables["width"],
state=tkinter.DISABLED,
name="size_spinbox_width",
).grid(row=2, column=1, sticky=tkinter.W)
tkinter.Label(
self, text="mm", state=tkinter.DISABLED, name="size_label_width_mm"
).grid(row=2, column=2, sticky=tkinter.W)
tkinter.Label(
self, text="Height:", state=tkinter.DISABLED, name="size_label_height"
).grid(row=3, column=0, sticky=tkinter.W, padx=(27, 0))
tkinter.Spinbox(
self,
format="%.2f",
increment=0.1,
from_=0,
to=10000,
width=5,
textvariable=self.variables["height"],
state=tkinter.DISABLED,
name="size_spinbox_height",
).grid(row=3, column=1, sticky=tkinter.W)
tkinter.Label(
self, text="mm", state=tkinter.DISABLED, name="size_label_height_mm"
).grid(row=3, column=2, sticky=tkinter.W)
tkinter.Radiobutton(
self,
text="Factor of input page area",
variable=self.variables["radio"],
value="mult",
state=tkinter.DISABLED,
name="mult_radio",
).grid(row=4, column=0, columnspan=3, sticky=tkinter.W)
tkinter.Label(
self,
text="Multiplier:",
state=tkinter.DISABLED,
name="mult_label_multiplier",
).grid(row=5, column=0, sticky=tkinter.W, padx=(27, 0))
tkinter.Spinbox(
self,
format="%.2f",
increment=0.01,
from_=0,
to=10000,
width=6,
textvariable=self.variables["multiplier"],
state=tkinter.DISABLED,
name="mult_spinbox_multiplier",
).grid(row=5, column=1, sticky=tkinter.W)
tkinter.Radiobutton(
self,
text="Fit into X output pages",
variable=self.variables["radio"],
value="npages",
state=tkinter.DISABLED,
name="npages_radio",
).grid(row=6, column=0, columnspan=3, sticky=tkinter.W)
tkinter.Label(
self, text="# of pages:", state=tkinter.DISABLED, name="npages_label"
).grid(row=7, column=0, sticky=tkinter.W, padx=(27, 0))
tkinter.Spinbox(
self,
increment=1,
from_=1,
to=10000,
width=6,
textvariable=self.variables["pages"],
state=tkinter.DISABLED,
name="npages_spinbox",
).grid(row=7, column=1, sticky=tkinter.W)
def on_radio(self, value):
_, size, mult, npages = self.value
self.set(value, size, mult, npages)
def on_dropdown(self, value):
mode, (custom_size, size), mult, npages = self.value
if value == "custom":
custom_size = True
else:
custom_size = False
size = PAGE_SIZES[value]
self.set(mode, (custom_size, size), mult, npages)
def on_width(self, value):
if getattr(self, "value", None) is None:
return
mode, (custom_size, (_, height)), mult, npages = self.value
self.set(mode, (custom_size, (value, height)), mult, npages)
def on_height(self, value):
if getattr(self, "value", None) is None:
return
mode, (custom_size, (width, _)), mult, npages = self.value
self.set(mode, (custom_size, (width, value)), mult, npages)
def on_multiplier(self, value):
if getattr(self, "value", None) is None:
return
mode, size, _, npages = self.value
self.set(mode, size, value, npages)
def on_pages(self, value):
if getattr(self, "value", None) is None:
return
mode, size, mult, _ = self.value
self.set(mode, size, mult, value)
def set(self, mode, size, mult, npages):
# before setting self.value, check if the effective value is different
# from before or otherwise we do not need to execute the callback in
# the end
state_changed = True
if getattr(self, "value", None) is not None:
if mode == self.value[0] == "size":
state_changed = self.value[1][1] != size[1]
elif mode == self.value[0] == "mult":
state_changed = self.value[2] != mult
elif mode == self.value[0] == "npages":
state_changed = self.value[3] != npages
# execute callback if necessary
if state_changed and self.callback is not None:
mode, size, mult, npages = self.callback((mode, size, mult, npages))
self.value = (mode, size, mult, npages)
custom_size, (width, height) = size
# cycle through all widgets and set the state accordingly
for k, v in self.children.items():
if k.endswith("_radio"):
v.configure(state=tkinter.NORMAL)
continue
if not k.startswith(mode + "_"):
v.configure(state=tkinter.DISABLED)
continue
if k in ["size_dropdown", "size_radio"]:
v.configure(state=tkinter.NORMAL)
continue
if mode != "size":
v.configure(state=tkinter.NORMAL)
continue
if custom_size:
v.configure(state=tkinter.NORMAL)
continue
v.configure(state=tkinter.DISABLED)
# only set variables that changed to not trigger multiple variable tracers
if custom_size or mode != "size":
if self.variables["dropdown"].get() != "custom":
self.variables["dropdown"].set("custom")
else:
val = dict(zip(PAGE_SIZES.values(), PAGE_SIZES.keys()))[(width, height)]
if self.variables["dropdown"].get() != val:
self.variables["dropdown"].set(val)
if self.variables["radio"].get() != mode:
self.variables["radio"].set(mode)
if self.variables["width"].get() != width:
self.variables["width"].set(width)
if self.variables["height"].get() != height:
self.variables["height"].set(height)
if self.variables["multiplier"].get() != mult:
self.variables["multiplier"].set(mult)
if self.variables["pages"].get() != npages:
self.variables["pages"].set(npages)
def compute_layout(
infile,
outfile,
mode,
size=None,
mult=None,
npages=None,
pagenr=0,
pagesize=(210, 297),
border=(0, 0, 0, 0),
strategy="simple",
remove_alpha=False,
cover=False,
guides=False,
numbers=False,
poster_border=False,
):
doc = None
if hasattr(infile, "read"):
# we have to slurp in the whole file because we potentially read it
# in multiple times in case img2pdf is installed
# also, mupdf needs to be able to seek(), so we need to slurp it in
# anyways
infile = BytesIO(infile.read())
if have_img2pdf:
# if we have img2pdf available we can encapsulate a raster image
# into a PDF container
data = None
try:
# FIXME: img2pdf should not use the root logger so that instead we
# can run logging.getLogger('img2pdf').setLevel(logging.CRITICAL)
logging.getLogger().setLevel(logging.CRITICAL)
data = img2pdf.convert(infile)
except img2pdf.AlphaChannelError:
if remove_alpha:
# remove alpha channel
from PIL import Image
img = Image.open(infile).convert("RGBA")
background = Image.new("RGBA", img.size, (255, 255, 255))
img = Image.alpha_composite(background, img)
with BytesIO() as output:
img.convert("RGB").save(output, format="PNG")
output.seek(0)
data = img2pdf.convert(output)
else:
print(
"""
Plakativ is lossless by default. To automatically remove the alpha channel from
the input and place the image on a white background, use the --remove-alpha
option""",
file=sys.stderr,
)
exit(1)
except img2pdf.ImageOpenError:
# img2pdf cannot handle this
pass
if data is not None:
stream = BytesIO()
stream.write(data)
doc = fitz.open(stream=stream, filetype="application/pdf")
if doc is None:
# either we didn't have img2pdf or opening the input with img2pdf
# failed
if hasattr(infile, "read"):
doc = fitz.open(stream=infile, filetype="application/pdf")
else:
doc = fitz.open(filename=infile)
plakativ = Plakativ(doc, pagenr)
plakativ.compute_layout(mode, size, mult, npages, pagesize, border, strategy)
plakativ.render(outfile, cover, guides, numbers, poster_border)
doc.close()
def gui(filename=None):
if not have_tkinter:
raise Exception("the GUI requires tkinter")
root = tkinter.Tk()
app = Application(master=root)
if filename is not None:
app.open_file(filename)
app.mainloop()
def parse_num(num, name):
if num == "":
raise argparse.ArgumentTypeError("%s is empty" % name)
unit = None
if num.endswith("pt"):
unit = Unit.pt
elif num.endswith("cm"):
unit = Unit.cm
elif num.endswith("mm"):
unit = Unit.mm
elif num.endswith("in"):
unit = Unit.inch
else:
try:
num = float(num)
except ValueError:
msg = (
"%s is not a floating point number and doesn't have a "
"valid unit: %s" % (name, num)
)
raise argparse.ArgumentTypeError(msg)
if unit is None:
unit = Unit.mm
else:
num = num[:-2]
try:
num = float(num)
except ValueError:
msg = "%s is not a floating point number: %s" % (name, num)
raise argparse.ArgumentTypeError(msg)
if num < 0:
msg = "%s must not be negative: %s" % (name, num)
raise argparse.ArgumentTypeError(msg)
if unit == Unit.cm:
num = cm_to_mm(num)
elif unit == Unit.pt:
num = pt_to_mm(num)
elif unit == Unit.inch:
num = in_to_mm(num)
return num
def parse_borderarg(string):
if ":" in string: