def createTextbox(textfile, textboxRect, page, path):
fontSize = 12
linecounter = 0
# Extracts text from file and eliminates blank lines
# Counts the number of lines in the file
with open(textfile) as input_txt:
lineString = ""
lineArray = []
for line in input_txt:
if not line.isspace():
lineString = lineString + line
lineArray.append(line)
linecounter = linecounter + 1
lineLength = fitz.getTextlength(line, "Times-Roman", fontSize)
while (lineLength > textboxRect.width):
linecounter = linecounter + 1
lineLength = lineLength - textboxRect.width
# At font size 12, textbox can hold up to 10 lines of text
# Decreases font size by increments of 4 while line capacity is exceeded
lineCapacity = 10
while (linecounter > lineCapacity):
# Line capacity of textbox increases by the percent increase from each font size decrement
# Ex: 12 --> 8 makes for a 50% increase in line capacity
percentIncrease = calculatePercentIncrease(fontSize, fontSize - 2)
lineCapacity = lineCapacity + (lineCapacity * percentIncrease)
# Decrement font size by increment of 2
fontSize = fontSize - 2
linecounter = 0
# Recalculate the number of lines
# This is necessary since decreasing font size may decrease the number of lines
# When text exceeds horizontal boundaries, a new line is started
for line in lineArray:
linecounter = linecounter + 1
lineLength = fitz.getTextlength(line, "Times-Roman", fontSize)
while (lineLength > textboxRect.width):
linecounter = linecounter + 1
lineLength = lineLength - textboxRect.width
# Generate textbox with text
textboxShape = page.new_shape()
textboxShape.draw_rect(textboxRect)
textboxShape.finish(color=getColor("dodgerblue4"),
fill_opacity=1,
closePath=False)
textboxShape.commit()
page.insertTextbox(textboxRect,
lineString,
fontsize=fontSize,
fontname="Times-Roman",
align=0)
return
def dontenter(img, r, morph = None):
"""Draw the "Do Not Enter" traffic symbol.
"""
red = getColor("red3")
white = (1,1,1)
img.drawOval(r) # draw red circle w/ thick white border
img.finish(fill = red, color = white, width = r.width * 0.04)
img.drawOval(r) # draw empty circle, thin black border
img.finish(width = r.width * 0.001)
deltah = r.width * 0.13
deltav = r.height * 0.45
rs = r + (deltah, deltav, -deltah, -deltav)
img.drawRect(rs) # draw white horizontal rectangle
img.finish(color = white, fill = white, width = r.width * 0.06,
roundCap = False, morph = morph)
return
#==============================================================================
# Pie Chart program
#==============================================================================
doc = fitz.open() # new empty PDF
page = doc.newPage() # without parms, this is an ISO-A4 format page
# title line
title = "Sitzverteilung nach der Bundestagswahl 2013"
# pie chart center and point of 1st data pie
center = fitz.Point(200, 250)
point = fitz.Point(200, 150) # this will cycle through table data
# this is the radius
radius = abs(point - center)
blue = getColor("blue") # we need some colors
white = getColor("white")
lineheight = 20 # legend line height
ts_v = 200 # vertical start of legend block
ts_h = center.x + radius + 50 # horizontal coord of legend block
# these are the data to visualize:
# number of seats of political parties in German parliament since 2013
table = (
(253, "black", "CDU"), # seats, party color & party name
(56, "dodgerblue", "CSU"),
(193, "red", "SPD"),
(64, "violetred", "Die Linke"),
(63, "green", "Die Grünen"),
(1, "gray", "fraktionslos"),
def pencil(img, penciltip, pb_height, left, morph = None):
"""Draw a pencil image. Parameters:
img - Shape object
penciltip - fitz.Point, coordinates of the pencil tip
pb_height - the thickness of the pencil. This controls the dimension of the
picture: it will be contained in a rectangle of 100 x 345 pixels
if this parameter is 100.
left - bool, indicates whether the pencil points left (True) or right.
morph - a tuple (point, matrix) to achieve image torsion.
"""
from fitz.utils import getColor
from functools import partial
# define some colors
yellow = getColor("darkgoldenrod")
black = getColor("black")
white = getColor("white")
red = getColor("red")
wood = getColor("wheat2")
wood2 = getColor("wheat3")
#---------------------------------------------------------------------------
# some adjustments depending on pencil tip is left or right:
# for choosing between a left point (lp) or a right point (rb),
# we specify oneof(lp, rp), delivering either lp or rp. Likewise,
# variable 's' is used as a sign and is either +1 or -1.
#---------------------------------------------------------------------------
w = pb_height * 0.01 # standard line thickness
pb_width = 2 * pb_height # pencil body width
myfinish = partial(img.finish, width = w, morph = morph, closePath = False)
oneof = lambda l, r: l if left else r # choose an alternative
s = oneof(1,-1)
tipendtop = penciltip + fitz.Point(s, -0.5) * pb_height
tipendbot = penciltip + fitz.Point(s, 0.5) * pb_height
r = fitz.Rect(tipendtop,
tipendbot + (pb_width * s, 0)) # pencil body
r.normalize() # force r to be finite
# topline / botline indicate the pencil edges
topline0 = fitz.Point(r.x0 + r.width*0.1,
r.y0 + pb_height/5.) # upper pencil edge - left
topline1 = fitz.Point(r.x0 + r.width*0.9,
topline0.y) # upper epncil edge - right
botline0 = fitz.Point(r.x0 + r.width*0.1,
r.y1 - pb_height/5.) # lower pencil edge - left
botline1 = fitz.Point(r.x0 + r.width*0.9,
botline0.y) # lower pencil edge - right
# control point 1 for pencil rubber
hp1 = oneof(r.tr, r.tl) + (pb_height*0.6*s, 0)
# control point 2 for pencil rubber
hp2 = oneof(r.br, r.bl) + (pb_height*0.6*s, 0)
# pencil body is some type of yellow
img.drawRect(r)
myfinish(fill = yellow, color = wood)
img.drawPolyline((r.tl, topline0, botline0, r.bl))
img.drawPolyline((r.tr, topline1, botline1, r.br))
myfinish(fill = wood, color = wood)
# draw pencil edge lines
img.drawLine(topline0, topline1)
img.drawLine(botline0, botline1)
myfinish(color = wood2)
#===========================================================================
# black rectangle near pencil rubber
#===========================================================================
blackrect = fitz.Rect(oneof((r.tr - (pb_height/2., 0)), r.tl),
oneof(r.br, (r.bl + (pb_height/2., 0))))
img.drawRect(blackrect)
myfinish(fill = black)
#===========================================================================
# draw the pencil rubber
#===========================================================================
img.drawBezier(oneof(r.tr, r.tl), hp1, hp2, oneof(r.br, r.bl))
myfinish(fill = red)
#===========================================================================
# draw pencil tip and curves indicating pencil sharpening traces
#===========================================================================
img.drawPolyline((tipendtop, penciltip, tipendbot))
myfinish(fill = wood) # pencil tip
p1 = tipendtop # either left or right
p2 = oneof(topline0, topline1)
p3 = oneof(botline0, botline1)
p4 = tipendbot
p0 = -fitz.Point(pb_height/5., 0)*s # horiz. displacment of ctrl points
cp1 = p1 + (p2-p1)*0.5 + p0 # ctrl point upper rounding
cp2 = p2 + (p3-p2)*0.5 + p0*2.9 # ctrl point middle rounding
cp3 = p3 + (p4-p3)*0.5 + p0 # ctrl point lower rounding
img.drawCurve(p1, cp1, p2)
myfinish(fill = yellow, color=yellow, closePath = True)
img.drawCurve(p2, cp2, p3)
myfinish(fill = yellow, color=yellow, closePath = True)
img.drawCurve(p3, cp3, p4)
myfinish(fill = yellow, color=yellow, closePath = True)
#===========================================================================
# draw the pencil tip lead
#===========================================================================
img.drawPolyline((penciltip + (tipendtop - penciltip)*0.4,
penciltip,
penciltip + (tipendbot - penciltip)*0.4))
#===========================================================================
# add a curve to indicate lead is round
#===========================================================================
img.drawCurve(penciltip + (tipendtop - penciltip)*0.4,
penciltip + (pb_height * 0.6 * s, 0),
penciltip + (tipendbot - penciltip)*0.4)
myfinish(fill = black)
#===========================================================================
# re-border pencil body to get rid of some pesky pixels
#===========================================================================
img.drawPolyline((p1, p2, p3, p4))
myfinish(color = yellow)
br_tl = oneof(blackrect.tl, blackrect.tr)
br_bl = oneof(blackrect.bl, blackrect.br)
img.drawPolyline((br_tl, tipendtop, penciltip, tipendbot, br_bl))
myfinish()
#===========================================================================
# draw pencil label - first a rounded rectangle
#===========================================================================
p1 = fitz.Point(0.65, 0.15) * pb_height
p2 = fitz.Point(0.45, 0.15) * pb_height
lblrect = fitz.Rect(topline0 + oneof(p1, p2),
botline1 - oneof(p2, p1))
img.drawRect(lblrect)
img.drawCurve(lblrect.tr,
fitz.Point(lblrect.x1+pb_height/4., penciltip.y),
lblrect.br)
img.drawCurve(lblrect.tl,
fitz.Point(lblrect.x0-pb_height/4., penciltip.y),
lblrect.bl)
myfinish(fill = black)
#===========================================================================
# finally the white vertical stripes - whatever they are good for
#===========================================================================
p1t = blackrect.tl + (blackrect.width/3., pb_height/20.)
p1b = blackrect.bl + (blackrect.width/3., -pb_height/20.)
p2t = blackrect.tl + (blackrect.width*2/3., pb_height/20.)
p2b = blackrect.bl + (blackrect.width*2/3., -pb_height/20.)
img.drawLine(p1t, p1b)
img.drawLine(p2t, p2b)
img.finish(color = white, width = pb_height*0.08, roundCap = False,
morph = morph)
# insert text to indicate a medium lead grade
if img.insertTextbox(lblrect, "HB", color = white,
fontname = "Helvetica", morph = morph,
fontsize = pb_height * 0.22, align = 1) < 0:
raise ValueError("not enough space to store 'HB' text")
return
def hand(img, rect, color = None, fill = None, morph = None):
"""Put a hand symbol inside a rectangle on a PDF page. Parameters:
img - an object of the Shape class (contains relevant page information)
rect - a rectangle. Its width must be at least 30% larger than its height.
color, fill - color triples for border and filling (optional).
morph - morphing parameters (point, matrix)
"""
if rect.width / rect.height < 1.25:
raise ValueError("rect width:height ratio must be at least 1.25")
if not color:
line = getColor("orange")
else:
line = color
if not fill:
skin = getColor("burlywood1")
else:
skin = fill
#--------------------------------------------------------------------------
# Define control points for the symbol, relative to a rect height of 3.
# This is the actual brainware of the whole thing ...
#--------------------------------------------------------------------------
points = ((0.0, 1.4), (1.4, 0.2), (1.4, 1.4), (2.2, 0.0), (1.4, 1.4),
(3.4, 1.4), (3.4, 1.8), (2.8, 1.8), (2.8, 2.2), (2.6, 2.2),
(2.6, 2.6), (2.5, 2.6), (2.5, 3.0),
)
# rescale points to the argument rectangle.
f = rect.height / 3
tl = rect.tl # need this as displacement
# function for rescaling the points in the list
rescale = lambda x: fitz.Point(points[x])*f + tl
p1 = rescale(0)
p2 = rescale(1)
p3 = rescale(2)
p4 = rescale(3)
p5 = rescale(4)
p6 = rescale(5)
p7 = rescale(6)
p8 = rescale(7)
p9 = rescale(8)
p10 = rescale(9)
p11 = rescale(10)
p12 = rescale(11)
p13 = rescale(12)
# some additional helper points for Bezier curves of the finger tips.
d1 = fitz.Point(0.4, 0) *f
d7 = p7 - fitz.Point(1.2, 0) * f
d9 = fitz.Point(d7.x, p9.y)
d11 = fitz.Point(d7.x, p11.y)
# now draw everything
# IMPORTANT: the end point of each draw method must equal the start point
# of the next one in order to create one connected path. Only then the
# "finish" parameters will apply to all individual draws.
img.drawCurve(p1, p3, p2)
img.drawCurve(p2, p4, p5)
img.drawLine(p5, p6)
img.drawBezier(p6, p6 + d1, p7 + d1, p7)
img.drawLine(p7, d7)
img.drawLine(d7, p8)
img.drawBezier(p8, p8 + d1, p9 + d1, p9)
img.drawLine(p9, d9)
img.drawLine(d9, p10)
img.drawBezier(p10, p10 + d1, p11 + d1, p11)
img.drawLine(p11, d11)
img.drawLine(d11, p12)
img.drawBezier(p12, p12 + d1, p13 + d1, p13)
img.drawLine(p13, rect.bl)
img.finish(color = line, fill = skin, closePath = False, morph = morph)
return
rect.tr + (-dx, 2 * dy))
img.drawOval(rl) # draw left eye
img.drawOval(rr) # draw right eye
img.finish(fill = color, morph = morph)
p0 = rl.bl + (0, dy) # left corner of mouth
p1 = rr.br + (0, dy) # right corner of mouth
c = rl.bl + (rr.br - rl.bl)*0.5
img.drawCurve(p0, c, p1) # draw mouth
img.finish(width = 4 * w, closePath = False, morph = morph)
#------------------------------------------------------------------------------
# Main program:
# Create PDF with one symbol per page which can be used by showPDFpage
#------------------------------------------------------------------------------
if __name__ == "__main__":
green = getColor("limegreen")
red = getColor("red2")
doc = fitz.open()
p = doc.newPage()
img = p.newShape()
r = fitz.Rect(100, 100, 200, 200)
heart(img, r, red)
img.commit()
p.setCropBox(r + (10, 10, -10, -15))
p = doc.newPage()
img = p.newShape()
pnt = r.tl + (r.br - r.tl)*0.5
clover(img, r, green, morph = (pnt, fitz.Matrix(45)))
img.commit()
p.setCropBox(r + (5, 5, -5, -5))
window = sg.Window('Inputs', layout)
event, value_list = window.Read()
input_path = value_list[0]
output_path = value_list[1]
line_one = value_list[2]
line_two = value_list[3]
line_three = value_list[4]
stampall = value_list[5]
maxstring = max((len(line_one)), (len(line_two)),(len(line_three) + 4))
leftwidth = maxstring*7+26
from fitz.utils import getColor
yellow = getColor("darkgoldenrod")
black = getColor("black")
white = getColor("white")
red = getColor("red")
wood = getColor("wheat2")
wood2 = getColor("wheat3")
print("Tamponner toutes le pages:", stampall)
print("Char. max.:", maxstring)
# stamps_path = input()
#print("\n Enter the full path to the OUTPUT folder:")
#output_path = input()
sat = delta / cmax
S = str(int(round(sat * 100))).zfill(3)
return H + S + V
# create color list sorted down by hue, value, saturation
mylist = sorted(getColorInfoList(), reverse=True, key=lambda x: sortkey(x))
w = 800 # page width
h = 600 # page height
rw = 80 # width of color rect
rh = 60 # height of color rect
num_colors = len(mylist) # number of color triples
black = getColor("black") # text color
white = getColor("white") # text color
fsize = 8 # fontsize
lheight = fsize * 1.2 # line height
idx = 0 # index in color database
doc = fitz.open() # empty PDF
while idx < num_colors:
doc.insertPage(-1, width=w, height=h) # new empty page
page = doc[-1] # load it
for i in range(10): # row index
if idx >= num_colors:
break
for j in range(10): # column index
rect = fitz.Rect(rw * j, rh * i, rw * j + rw,
rh * i + rh) # color rect
cname = mylist[idx][0].lower() # color name
def pencil(page, penciltip, pb_height, left):
"""Draws a pencil image.
"""
from fitz.utils import getColor
# define some colors
yellow = getColor("darkgoldenrod")
black = getColor("black")
white = getColor("white")
red = getColor("red")
wood = getColor("wheat2")
wood2 = getColor("wheat3")
#---------------------------------------------------------------------------
# some adjustments follow depending on pencil tip is left or right:
# when choices need be made between a left point (lp) or a right point (rb),
# we specify lp*a + rp*b, delivering either lp or rp.
# Variable 's' is used as a sign and is either +1 or -1.
#---------------------------------------------------------------------------
if left: # pencil tip is left
a = 1
b = 0
s = 1
else:
a = 0
b = 1
s = -1
def oneof(x, y):
return x * a + y * b
w = pb_height * 0.01 # standard line thickness
pb_width = 2 * pb_height # pencil body width
tipendtop = penciltip + fitz.Point(1, -0.5) * pb_height * s
tipendbot = penciltip + fitz.Point(1, 0.5) * pb_height * s
r = fitz.Rect(tipendtop, tipendbot + (pb_width * s, 0)) # pencil body
r.normalize() # force r to be finite
# topline / botline indicate the pencil edges
topline0 = fitz.Point(r.x0 + r.width * 0.1,
r.y0 + pb_height / 5.) # upper pencil edge - left
topline1 = fitz.Point(r.x0 + r.width * 0.9,
topline0.y) # upper epncil edge - right
botline0 = fitz.Point(r.x0 + r.width * 0.1,
r.y1 - pb_height / 5.) # lower pencil edge - left
botline1 = fitz.Point(r.x0 + r.width * 0.9,
botline0.y) # lower pencil edge - right
# control point 1 for pencil rubber
hp1 = oneof(r.top_right, r.top_left) + (pb_height * 0.6 * s, 0)
# control point 2 for pencil rubber
hp2 = oneof(r.bottom_right, r.bottom_left) + (pb_height * 0.6 * s, 0)
# pencil body is some type of yellow
page.drawRect(r, fill=yellow, color=wood, width=w)
page.drawPolyline((r.top_left, topline0, botline0, r.bottom_left),
fill=wood,
color=yellow,
width=w)
page.drawPolyline((r.top_right, topline1, botline1, r.bottom_right),
fill=wood,
color=yellow,
width=w)
# draw pencil edge lines
page.drawLine(topline0, topline1, width=w, color=wood2)
page.drawLine(botline0, botline1, width=w, color=wood2)
#===========================================================================
# draw the pencil rubber
#===========================================================================
page.drawBezier(oneof(r.top_right, r.top_left),
hp1,
hp2,
oneof(r.bottom_right, r.bottom_left),
fill=red,
width=w)
#===========================================================================
# black rectangle near pencil rubber
#===========================================================================
blackrect = fitz.Rect(
oneof((r.top_right - (pb_height / 2., 0)), r.top_left),
oneof(r.bottom_right, (r.bottom_left + (pb_height / 2., 0))))
page.drawRect(blackrect, fill=black, width=w)
#===========================================================================
# draw pencil tip and curves indicating pencil sharpening traces
#===========================================================================
page.drawPolyline((tipendtop, penciltip, tipendbot), width=w,
fill=wood) # pencil tip
p1 = oneof(r.top_left, r.top_right) # either left or right
p2 = oneof(topline0, topline1)
p3 = oneof(botline0, botline1)
p4 = oneof(r.bottom_left, r.bottom_right)
p0 = -fitz.Point(pb_height / 5.,
0) * s # horiz. displacment of ctrl points
cp1 = p1 + (p2 - p1) * 0.5 + p0 # ctrl point upper rounding
cp2 = p2 + (p3 - p2) * 0.5 + p0 * 2.9 # ctrl point middle rounding
cp3 = p3 + (p4 - p3) * 0.5 + p0 # ctrl point lower rounding
page.drawCurve(p1, cp1, p2, fill=yellow, width=w, color=wood)
page.drawCurve(p2, cp2, p3, fill=yellow, width=w, color=wood)
page.drawCurve(p3, cp3, p4, fill=yellow, width=w, color=wood)
#===========================================================================
# draw the pencil tip lead mine
#===========================================================================
page.drawPolyline(
(penciltip + (tipendtop - penciltip) * 0.4, penciltip, penciltip +
(tipendbot - penciltip) * 0.4),
fill=black,
width=w,
closePath=True)
#===========================================================================
# add a curve to indicate lead mine is round
#===========================================================================
page.drawCurve(penciltip + (tipendtop - penciltip) * 0.4,
fitz.Point(penciltip.x + pb_height * 0.6 * s, penciltip.y),
penciltip + (tipendbot - penciltip) * 0.4,
width=w,
fill=black)
#===========================================================================
# re-border pencil body getting rid of some pesky pixels
#===========================================================================
page.drawLine(r.top_left, r.top_right, width=w)
page.drawLine(r.bottom_left, r.bottom_right, width=w)
page.drawPolyline((tipendtop, penciltip, tipendbot), width=w)
#===========================================================================
# draw pencil label - first a rounded rectangle
#===========================================================================
p1 = fitz.Point(0.65, 0.15) * pb_height
p2 = fitz.Point(0.45, 0.15) * pb_height
lblrect = fitz.Rect(topline0 + oneof(p1, p2), botline1 - oneof(p2, p1))
page.drawRect(lblrect, width=w, fill=black)
page.drawCurve(lblrect.top_right,
fitz.Point(lblrect.x1 + pb_height / 4., penciltip.y),
lblrect.bottom_right,
width=w,
fill=black)
page.drawCurve(lblrect.top_left,
fitz.Point(lblrect.x0 - pb_height / 4., penciltip.y),
lblrect.bottom_left,
width=w,
fill=black)
# ... then text indicating it's a medium pencil
if page.insertTextbox(lblrect,
"No.2",
color=white,
fontname="Helvetica",
fontsize=pb_height * 0.22,
align=1) < 0:
raise ValueError("not enough space to store pencil text")
#===========================================================================
# finally the white vertical stripes - whatever they are good for
#===========================================================================
p1t = blackrect.top_left + fitz.Point(blackrect.width / 3.,
pb_height / 20.)
p1b = blackrect.bottom_left + fitz.Point(blackrect.width / 3.,
-pb_height / 20.)
p2t = blackrect.top_left + fitz.Point(blackrect.width * 2 / 3.,
pb_height / 20.)
p2b = blackrect.bottom_left + fitz.Point(blackrect.width * 2 / 3.,
-pb_height / 20.)
page.drawLine(p1t,
p1b,
color=white,
width=pb_height * 0.08,
roundCap=False)
page.drawLine(p2t,
p2b,
color=white,
width=pb_height * 0.08,
roundCap=False)
return
calfa = math.cos(alfa)
salfa = math.sin(alfa)
for p in pnts:
s = p - pb
r = abs(s)
if r > 0: s /= r
np = (s.x * calfa - s.y * salfa, s.y * calfa + s.x * salfa)
points.append(pb + fitz.Point(np)*r)
return points
if __name__ == "__main__":
from fitz.utils import getColor
doc = fitz.open() # a new PDF
page = doc.newPage() # a new page in it
img = page.newShape() # start a Shape
red = getColor("red") # line color for sine
blue = getColor("blue") # line color for cosine
yellow = getColor("py_color") # background color
w = 0.3 # line width
#--------------------------------------------------------------------------
# Define start / end points of x axis that we want to use as 0 and 2*pi.
# They may be positioned in any way.
#--------------------------------------------------------------------------
pb = fitz.Point(200, 200) # begin, treated as (0, 0)
pe = fitz.Point(400, 100) # end, treated as (2*pi, 0)
# compute auxiliary end point pe1 with same y coord. as pb
alfa = img.horizontal_angle(pb, pe) # connection angle towards x-axis
rad = abs(pe - pb) # distance of these points
pe1 = pb + (rad, 0) # make corresp. horizontal end point
# =============================================================================
from os.path import isdir, isfile, join
import PySimpleGUI as sg
print = sg.EasyPrint
help_lisc_input = "Ce logiciel est soumis à la licence GPL v2, (c) Jodobear 2019.\n\nMentionner uniquement le dossier comprenant les fichiers pdf."
help_num = "Pour tampons numérotés: Le numéro de tampon correspond au trois premiers caractères du nom de fichier.\nPar exemple, un fichier nommé <<A14-Défense>> aura pour tampon <<A14>>.\nMettre éventuellement <<Pièce n°>> en 3e ligne pour obtenir <<Pièce n° A14>>.\n"
help_thanks = "Merci d'utiliser ce logiciel. Si vous avez des problèmes ou voulez contribuer à son développement, voir\nhttps://github.com/jodobear/pdf-stamper"
help_donation = "Pour faire un don au développeur du projet, voir https://tallyco.in/jodobear \n"
fonts = ["Helvetica", "Helvetica-Oblique", "Helvetica-Bold",
"Helvetica-BoldOblique", "Courier", "Courier-Oblique",
"Courier-Bold", "Courier-BoldOblique", "Times-Roman",
"Times-Italic", "Times-Bold", "Times-BoldItalic"]
colors = {"Noir": getColor("black"), "Blanc": getColor("white"),
"Rouge": getColor("red"), "Bleu": getColor("blue")}
layout = [
[sg.T("Appuyer sur 'Aide' pour instructions.")],
[sg.T('Dossier à tamponner:',
size=(18, 1)), sg.In(), sg.FolderBrowse("Parcourir", size=(10, 1))],
[sg.T("Dossier d'enregistrement:", size=(18, 1)),
sg.InputText(), sg.FolderBrowse("Parcourir", size=(10, 1))],
[sg.T('1e ligne du tampon:', size=(18, 2)), sg.In()],
[sg.T('2e ligne du tampon:', size=(18, 2)), sg.In()],
[sg.T('3e ligne du tampon:', size=(18, 2)), sg.In()],
[sg.Frame(layout=[
[sg.Radio('Tamponner toutes les pages', "RADIO1", default=True, size=(24, 1)),
sg.Radio('Tamponner la page n°', "RADIO1"), sg.In(size=(3, 1))],
[sg.Checkbox('Numéroter les tampons', size=(18, 1), default=False),
We draw each sun ray after it has been reflected by the cup.
The resulting picture is save in three image formats: PDF, PNG and SVG / SVGZ
"""
def pvon(a):
"""Starting point of a reflected sun ray, given an angle a."""
return(math.cos(a), math.sin(a))
def pbis(a):
"""End point of a reflected sun ray, given an angle a."""
return(math.cos(3*a - math.pi), (math.sin(3*a - math.pi)))
fileprfx = "catacaustic" # filename prefix
coffee = getColor("coffee") # color: latte macchiato?
yellow = getColor("yellow") # color of sun rays
blue = getColor("blue") # color cup border
doc = fitz.open() # new empty PDF
page = doc.newPage(-1, width = 800, height = 800)# create square sized page
center = fitz.Point(page.rect.width / 2, # center of circle on page
page.rect.height / 2)
radius = page.rect.width / 2 - 20 # leave a border of 20 pixels
img = page.newShape()
img.drawCircle(center, radius)
img.finish(color = coffee, fill = coffee) # fill coffee into the cup
count = 200 # how many sun rays we draw
interval = math.pi / count # angle fraction
print = sg.EasyPrint
help_lisc_input = "This software is liscenced under GPL v2, (c) Jodobear 2019.\n\nNOTE: Input path to the folder containing only pdf files to be stamped. Do not provide path to the file itself."
help_num = "FOR STAMPS WITH NUMBERS: Stamp numbers correspond to first three characters of the document name.\nFor example, a document named <<A14-Defence>> will be stamped with number <<A14>>.\nOptionally, input label (e.g. 'Exhibit No.') in Line 3 to get <<Exhibit No. A14>>.\n"
help_thanks = "Thank you for using this software. If you have any issues or want to contribute to the development, visit\nhttps://github.com/jodobear/pdf-stamper"
help_donation = "Please consider buying us a coffee at https://tallyco.in/jodobear \n"
fonts = [
"Helvetica", "Helvetica-Oblique", "Helvetica-Bold",
"Helvetica-BoldOblique", "Courier", "Courier-Oblique", "Courier-Bold",
"Courier-BoldOblique", "Times-Roman", "Times-Italic", "Times-Bold",
"Times-BoldItalic"
]
colors = {
"Black": getColor("black"),
"White": getColor("white"),
"Red": getColor("red"),
"Blue": getColor("blue")
}
layout = [[sg.T("Please click 'Help' for instructions.")],
[
sg.T('Folder to be stamped:', size=(18, 1)),
sg.In(),
sg.FolderBrowse(size=(10, 1))
],
[
sg.T('Output folder:', size=(18, 1)),
sg.InputText(),
sg.FolderBrowse(size=(10, 1))
"""
print(fitz.__doc__)
def pvon(a):
"""Starting point of a reflected sun ray, given an angle a."""
return (math.cos(a), math.sin(a))
def pbis(a):
"""End point of a reflected sun ray, given an angle a."""
return (math.cos(3 * a - math.pi), (math.sin(3 * a - math.pi)))
fileprfx = "catacaustic" # filename prefix
coffee = getColor("coffee") # color: latte macchiato?
yellow = getColor("yellow") # color of sun rays
blue = getColor("blue") # color cup border
doc = fitz.open() # new empty PDF
page = doc.newPage(-1, width=800, height=800) # create square sized page
center = fitz.Point(
page.rect.width / 2,
page.rect.height / 2 # center of circle on page
)
radius = page.rect.width / 2 - 20 # leave a border of 20 pixels
img = page.newShape()
img.drawCircle(center, radius)
img.finish(color=coffee, fill=coffee) # fill coffee into the cup
else:
sat = delta / cmax
S = str(int(round(sat * 100))).zfill(3)
return H + S + V
# create color list sorted down by hue, value, saturation
mylist = sorted(getColorInfoList(), reverse = True, key=lambda x: sortkey(x))
w = 800 # page width
h = 600 # page height
rw = 80 # width of color rect
rh = 60 # height of color rect
num_colors = len(mylist) # number of color triples
black = getColor("black") # text color
white = getColor("white") # text color
fsize = 8 # fontsize
lheight = fsize *1.2 # line height
idx = 0 # index in color database
doc = fitz.open() # empty PDF
while idx < num_colors:
doc.insertPage(-1, width = w, height = h) # new empty page
page=doc[-1] # load it
for i in range(10): # row index
if idx >= num_colors:
break
for j in range(10): # column index
rect = fitz.Rect(rw*j, rh*i, rw*j + rw, rh*i + rh) # color rect
cname = mylist[idx][0].lower() # color name
col = mylist[idx][1:] # color tuple -> to floats
Demo for creating the "SPUMONI" drawing contained in ReportLab's Users Guide
on pp. 25 - 26
Dependencies:
PyMuPDF
License:
GNU GPL 3+
The only purpose of this ugly picture is to show that creating it with PyMuPDF
definitely is at least as easy and straightforward ...
"""
green, pink, brown = getColor("green"), getColor("pink"), getColor("brown")
clist = (pink, green, brown) # make a list of these colors
top = 72 # some convenience constants
left = right = top / 2
nrects = 14
fname = "Helvetica-Bold" # fontname
doc = fitz.open() # empty new document
cw = doc._getCharWidths(fname) # get glyph widths of the font
text = "SPUMONI" # the ominous text
textl = sum([cw[ord(c)] for c in text]) # get total glyph width of text
width, height = fitz.PaperSize("letter")
page = doc.newPage(-1, width = width, height = height) # insert new page
rwidth = (width - 2*left) / nrects # rect width, leaves borders of 36 px
fsize = (width - 2*left) / textl # optimum fontsize
rheight = 400 # rect height
for i in range(nrects-2): # draw colored rectangles (last 2 stay white)
# Pie Chart program - semi circle version
#==============================================================================
from fitz.utils import getColor # for getting RGB colors by name
doc = fitz.open() # new empty PDF
doc.insertPage() # creates an ISO-A4 page
page = doc[-1] # this is the page
img = page.newShape()
# title of the page
title = "Sitzverteilung nach der Bundestagswahl 2013"
# pie chart center and point of 1st data pie
center = fitz.Point(200, 250)
point = fitz.Point(100, 250) # will cycle through table data
# this is the radius
radius = abs(point - center)
blue = getColor("blue") # we need some colors
white = getColor("white")
lineheight = 20 # legend line height
ts_v = 150 # vertical start of legend block
ts_h = center.x + radius + 50 # horizontal coord of legend block
# these are the data to visualize:
# number of seats of political parties in German parliament since 2013
table = ( # seats, party color & name
(64, "violetred", "Die Linke"),
(193, "red", "SPD"),
(63, "green", "Die Grünen"),
(253, "black", "CDU"),
(56, "dodgerblue", "CSU"),
(1, "gray", "fraktionslos"),
salfa = math.sin(alfa)
for p in pnts:
s = p - pb
r = abs(s)
if r > 0: s /= r
np = (s.x * calfa - s.y * salfa, s.y * calfa + s.x * salfa)
points.append(pb + fitz.Point(np) * r)
return points
if __name__ == "__main__":
from fitz.utils import getColor
doc = fitz.open() # a new PDF
page = doc.newPage() # a new page in it
img = page.newShape() # start a Shape
red = getColor("red") # line color for sine
blue = getColor("blue") # line color for cosine
yellow = getColor("py_color") # background color
w = 0.3 # line width
#--------------------------------------------------------------------------
# Define start / end points of x axis that we want to use as 0 and 2*pi.
# They may be oriented in any way.
#--------------------------------------------------------------------------
pb = fitz.Point(200, 200) # begin, treated as (0, 0)
pe = fitz.Point(400, 100) # end, treated as (2*pi, 0)
alfa = img.horizontal_angle(pb, pe) # connection angle towards x-axis
rad = abs(pe - pb) # distance of these points
pe1 = pb + (rad, 0) # make corresp. horizontal end point
# =============================================================================
# first draw a rectangle in which the functions graphs will later appear
Demo for creating the "SPUMONI" drawing contained in ReportLab's Users Guide
on pp. 25 - 26
Dependencies:
PyMuPDF
License:
GNU GPL 3+
The only purpose of this ugly picture is to show, that creating it with PyMuPDF
is definitely at least as easy and straightforward ...
"""
green, pink, brown = getColor("green"), getColor("pink"), getColor("brown")
clist = (pink, green, brown) # make a list of these colors
top = 72 # some convenience constants
left = right = top / 2
nrects = 14
fname = "Helvetica-Bold" # fontname
doc = fitz.open() # empty new document
cw = doc._getCharWidths(fname) # get glyph widths of the font
text = "SPUMONI" # the ominous text
textl = sum([cw[ord(c)] for c in text]) # get total glyph width of text
width, height = fitz.PaperSize("letter")
page = doc.newPage(-1, width = width, height = height) # insert new page
rwidth = (width - 2*left) / nrects # rect width, leaves borders of 36 px
fsize = (width - 2*left) / textl # optimum fontsize
rheight = 400 # rect height
for i in range(nrects-2): # draw colored rectangles (last 2 stay white)
