def generate_employee_handout(name, home_address, office_address, home_map,
office_map, canvas):
# Add Generic Company logo for the lolz
company_logo = "generic-logo-hi.png"
canvas.drawImage(company_logo, 15, 750, width=100, height=30)
# header text
canvas.setFont("Helvetica-Bold", 20, leading=None)
canvas.drawCentredString(380, 755,
"Direct Debit Banking Services Locations")
# Add name
canvas.setFont("Helvetica-Bold", 20, leading=None)
canvas.drawString(25, 700, "Name: " + name)
# add office details and map image
canvas.setFont("Helvetica-Bold", 16, leading=None)
canvas.drawString(25, 630, "Office: " + office_address)
canvas.drawImage(office_map, 25, 425, width=200, height=200)
# add home details and map image
canvas.setFont("Helvetica-Bold", 16, leading=None)
canvas.drawString(25, 365, "Home: " + home_address)
canvas.drawImage(home_map, 25, 160, width=200, height=200)
# add footer with time
formatted_time = time.ctime()
canvas.setFont("Helvetica", 10, leading=None)
canvas.drawCentredString(520, 15, formatted_time)
# save pdf
canvas.showPage()
print("PDF completed")
def _imageDrawCanvas(self,
image,
canvas,
n,
page_size=DEFAULT_IMAGE_PAGE_SIZE):
"""
Вывести отсканированую страницу на PDF холст.
@param image: Объект образа отсканированной страницы.
@param canvas: Объект PDF холста.
@param n: Номер страницы.
@param page_size: Размер страницы в точках,
к которому будут приводиться все отсканированные страницы.
@return: True/False.
"""
if image:
img_filename = os.path.join(ic_file.getHomeDir(),
MULTISCAN_PAGE_FILENAME % n)
width, height = page_size
image = image.resize((int(width), int(height)))
image.save(img_filename)
canvas.drawImage(img_filename, 0, 0)
canvas.showPage()
return True
else:
log.warning(
u'Ошибка записи сканированой страницы [%d] в PDF файл' % n)
return False
def writepdf(number, effort, letter, p, canvas):
styles = getSampleStyleSheet()
styleN = styles['Normal']
styleN.spaceBefore = 10
styleN.spaceAfter = 10
styleH = styles['Heading1']
styleH.alignment = 1
styleN.alignment = 1
story = []
story.append(Paragraph('<font color="black">%s</font>' % letter, styleH))
canvas.saveState()
f = Frame(spacer + p[0] * inch * 0.5,
spacer + p[1] * inch + 0.3 * inch,
inch * 0.5,
inch,
showBoundary=1)
f.addFromList(story, canvas)
canvas.restoreState()
if p == (6, 9):
canvas.showPage()
p = (0, 0)
else:
if p[1] == 9:
p = (p[0] + 1, 0)
else:
p = (p[0], p[1] + 1)
return p
def addPage(self, pageRes):
streamBuffer, docObject = pageRes
mainPage = PdfFileReader(streamBuffer)
for i in range(0, mainPage.getNumPages()):
try:
if self.jumpFirst:
self.collector.addPage(mainPage.getPage(i))
self.jumpFirst = False
else:
page = mainPage.getPage(i)
numberPagerBuffer, canvas, doc_orientation = self.getNextPageNumber(
page.mediaBox, docObject)
try:
_orientation, paper = paperFormat(page.mediaBox)
self.poolObj.get(
'ir.attachment').advancedPlmReportEngine(
document=docObject,
canvas=canvas,
page_orientation=doc_orientation,
paper=paper,
page_obj=page)
except Exception as ex:
logging.warning(ex)
logging.warning(
'advancedPlmReportEngine function not implemented in plm.document object'
)
canvas.showPage()
canvas.save()
numberPageReader = PdfFileReader(numberPagerBuffer)
mainPage.getPage(i).mergePage(numberPageReader.getPage(0))
self.collector.addPage(mainPage.getPage(i))
except Exception as ex:
logging.error(ex)
logging.error('Something went wrong during pdf generation')
def write_tile(i, pos=None, canvas=None):
styles = getSampleStyleSheet()
styleN = styles['Normal']
styleN.spaceBefore = 10
styleN.spaceAfter = 10
styleN.textColor = white
styleH = styles['Heading1']
styleH.textColor = white
styleH.alignment = 1
styleN.alignment = 1
canvas.saveState()
canvas.setFillColor(red)
canvas.rect(spacer + pos[0] * 40 * mm, 5 * mm + pos[1] * 80 * mm, 40 * mm, 80 * mm, fill=1, stroke=1)
f = Frame(spacer + pos[0] * 40 * mm, pos[1] * 80 * mm - 5 * mm, 40 * mm, 40 * mm, showBoundary=0)
f.addFromList([Paragraph('%i' % i, styleH)], canvas)
f = Frame(spacer + pos[0] * 40 * mm, pos[1] * 80 * mm + 35 * mm, 40 * mm, 40 * mm, showBoundary=0)
f.addFromList([Paragraph('%i' % i, styleH)], canvas)
canvas.restoreState()
if pos == (3, 2):
canvas.showPage()
pos = (0, 0)
else:
if pos[1] == 2:
pos = (pos[0] + 1, 0)
else:
pos = (pos[0], pos[1] + 1)
return pos
def _imageDrawCanvas(self,
image,
canvas,
n,
page_size=DEFAULT_IMAGE_PAGE_SIZE):
"""
Output the scanned page to a PDF canvas.
:param image: Image object of the scanned page.
:param canvas: PDF canvas object.
:param n: Page number.
:param page_size: Page size in dots,
to which all scanned pages will be brought.
:return: True/False.
"""
if image:
img_filename = os.path.join(file_func.getHomePath(),
MULTISCAN_PAGE_FILENAME % n)
width, height = page_size
image = image.resize((int(width), int(height)))
image.save(img_filename)
canvas.drawImage(img_filename, 0, 0)
canvas.showPage()
return True
else:
log_func.warning(u'Error writing scanned page [%d] to PDF file' %
n)
return False
def print_cards():
#LETTER = (8.5, 11)
LETTER = (11, 8.5)
DPI = 72
# Set print margins
MARGIN = 0.5
x_offset = int(MARGIN * DPI)
y_offset = int(MARGIN * DPI)
CARDSIZE = (int(2.49 * DPI), int(3.48 * DPI))
#scale = CARDSIZE[0] / 375.0 # Default cardsize in px
cards = convert_to_cards(session['cardtext'])
byte_io = BytesIO()
from reportlab.pdfgen import canvas
canvas = canvas.Canvas(byte_io, pagesize=landscape(letter))
WIDTH, HEIGHT = landscape(letter)
#draw = ImageDraw.Draw(sheet)
for card in cards:
image = create_card_img(card,session["do_google"])
image_reader = ImageReader(image)
canvas.drawImage(image_reader,
x_offset,
y_offset,
width=CARDSIZE[0],
height=CARDSIZE[1])
x_offset += CARDSIZE[0] + 5 # 5 px border around cards
if x_offset + CARDSIZE[0] > LETTER[0] * DPI:
x_offset = int(MARGIN * DPI)
y_offset += CARDSIZE[1] + 5
if y_offset + CARDSIZE[1] > LETTER[1] * DPI:
x_offset = int(MARGIN * DPI)
y_offset = int(MARGIN * DPI)
canvas.showPage()
canvas.save()
byte_io.seek(0)
return send_file(byte_io, mimetype='application/pdf')
def print_band_list_pdf(band, canvas):
style = TableStyle([
('VALIGN', (0, 0), (-1, -1), "TOP"),
('FONT', (0, 0), (-1, 0), "Helvetica-Bold", 14),
('FONT', (0, 1), (-1, 1), "Helvetica", 14),
('ALIGN', (-1, 0), (-1, -1), "RIGHT"),
])
# split models in 2 columns
col = 1
col1 = []
col2 = []
for model in band.model_list:
if col == 1:
col1.append(create_model_table(model))
col = 2
else:
col2.append(create_model_table(model))
col = 1
# create table with header (2 rows) and the 2 columns of models
data = [[band.name, str(band.total_cost) + "pts"],
[
str(len(band.model_list)) + " models",
"Cost of personalities: " + str(band.personalities_cost) +
"pts"
], [col1, col2]]
table = Table(data,
colWidths=9 * cm,
rowHeights=[1 * cm, 1.5 * cm, 24 * cm])
table.setStyle(style)
# draw table
table.wrap(18 * cm, 26 * cm)
table.drawOn(canvas, 1.5 * cm, 2 * cm)
# pass page
canvas.showPage()
def make_page(canvas, config, page):
#print ' ', page
caption_height = place_caption(canvas, config, page['caption'])
if 'image' in page:
place_images(canvas, config, page, caption_height)
canvas.showPage()
def produce_pdf(self, input_file=None, out_directory=None):
out = os.path.join(out_directory, self.out_file_name)
self.data = self._parse_input_file(input_file)
canvas = reportlab.pdfgen.canvas.Canvas(out, pagesize=pagesizes.A4)
map(lambda p: self._process_page(canvas, p), self.pages)
canvas.showPage()
canvas.save()
def generate_report(_id, incoming_number, date_and_time, read, sent_replied,
body, seen, pdf_filename):
smsdata = _id, incoming_number, date_and_time, read, sent_replied, body, seen
canvas.drawString(50, 100, smsdata)
canvas.showPage()
import_Data(data_file)
def genBarcode(code, value, canvas, scale):
dr = createBarcodeDrawing(code, value=value, humanReadable=True)
dr.renderScale = scale
bounds = dr.getBounds()
width = bounds[2] - bounds[0]
height = bounds[3] - bounds[1]
dr.drawOn(canvas, (297*mm)/2-width*scale/2, (210*mm)/2-height*scale/2)
canvas.drawString(1*mm, 1*mm, "generated at "+str(datetime.now()) + " from "+request.url)
canvas.showPage()
def create_mug_pdf(image_name):
from reportlab.pdfgen import canvas
from reportlab.lib.units import inch
canvas = canvas.Canvas('mug.pdf')
canvas.setPageSize((8.58*inch, 3.7*inch))
canvas.drawImage(image_name, 0.1*inch, 0.1*inch, 5.9*inch, 3.9*inch)
canvas.showPage()
canvas.save()
def createPDF(file, title):
canvas = reportlab.pdfgen.canvas.Canvas(file)
canvas.setFont('Times-BoldItalic', 12)
canvas.drawString(inch, 10.5 * inch, title)
canvas.setFont('Times-Roman', 10)
canvas.drawCentredString(4.135 * inch, 0.75 * inch,
'Page %d' % canvas.getPageNumber())
canvas.showPage()
canvas.save()
def create_backpdf(image_name):
from reportlab.pdfgen import canvas
from reportlab.lib.units import inch
canvas = canvas.Canvas('PC_back.pdf')
canvas.setPageSize((6*inch, 4*inch))
canvas.drawImage(image_name, 0.1*inch, 0.1*inch, 5.9*inch, 3.9*inch)
canvas.showPage()
canvas.save()
def convert_pdf(image_name, width, height):
from reportlab.pdfgen import canvas
from reportlab.lib.units import inch
canvas = canvas.Canvas('output.pdf')
canvas.setPageSize((width*inch, height*inch))
canvas.drawImage(image_name, 0.1*inch, 0.1*inch, (width-0.1)*inch, (height-0.1)*inch)
canvas.showPage()
canvas.save()
def write_tile(values=None,
conversion_cost=None,
front_img=None,
back_img=None,
pos=None,
canvas=None):
styles = getSampleStyleSheet()
styleN = styles['Normal']
styleN.spaceBefore = 10
styleN.spaceAfter = 10
styleN.textColor = black
styleH = styles['Heading1']
styleH.textColor = black
styleH.alignment = 1
styleN.alignment = 1
canvas.saveState()
canvas.rect(spacer + pos[0] * 47 * mm,
5 * mm + pos[1] * 94 * mm,
47 * mm,
94 * mm,
fill=0,
stroke=1)
#canvas.drawImage(front_img, spacer + pos[0] * 47 * mm, 5 * mm + pos[1] * 94 * mm + 47 * mm, 47 * mm, 47 * mm)
#if back_img is not None:
#canvas.drawImage(back_img, spacer + pos[0] * 47 * mm, 5 * mm + pos[1] * 94 * mm, 47 * mm, 47 * mm)
f = Frame(spacer + pos[0] * 47 * mm,
pos[1] * 94 * mm - 5 * mm,
47 * mm,
47 * mm,
showBoundary=0)
if values is not None:
table = Table(values,
style=[('TEXTCOLOR', (0, 0), (1, 2), black),
('SIZE', (0, 0), (1, 2), 14)])
f.addFromList([table], canvas)
f = Frame(spacer + pos[0] * 47 * mm,
pos[1] * 94 * mm + 35 * mm,
47 * mm,
47 * mm,
showBoundary=0)
if conversion_cost is not None:
f.addFromList([Paragraph('%s' % conversion_cost, styleH)], canvas)
canvas.restoreState()
if pos == (2, 2):
canvas.showPage()
pos = (0, 0)
else:
if pos[1] == 2:
pos = (pos[0] + 1, 0)
else:
pos = (pos[0], pos[1] + 1)
return pos
def build_filled_pdf_page(page_data: PageData, values: Dict[str, Any]) -> PageObject:
packet = io.BytesIO()
canvas = reportlab.pdfgen.canvas.Canvas(
packet, reportlab.lib.pagesizes.letter, initialFontName="Times-Roman", initialFontSize=14
)
for position, emplacement_data in page_data.items():
canvas.drawString(*position, str(values.get(emplacement_data.name, ""))[: emplacement_data.line_size])
canvas.showPage()
canvas.save()
packet.seek(0)
return PyPDF2.PdfFileReader(packet).getPage(0)
def _finish_rendering(canvas):
canvas.showPage()
canvas.save()
print_ = getattr(args, 'print')
if sys.platform.startswith('linux'):
if print_:
os.system('lp "%s"' % default_output_file)
else:
os.system('xdg-open "%s"' % default_output_file)
else:
os.startfile(default_output_file, 'print' if print_ else 'open')
def genBarcode(code, value, canvas, scale):
dr = createBarcodeDrawing(code, value=value, humanReadable=True)
dr.renderScale = scale
bounds = dr.getBounds()
width = bounds[2] - bounds[0]
height = bounds[3] - bounds[1]
dr.drawOn(canvas, (297 * mm) / 2 - width * scale / 2,
(210 * mm) / 2 - height * scale / 2)
canvas.drawString(
1 * mm, 1 * mm,
"generated at " + str(datetime.now()) + " from " + request.url)
canvas.showPage()
def gen_label(sku, canvas, title):
# barcode128 = code39.Extended39(value = sku, barWidth = barWidth, barHeight = barHeight)
barcode128 = code128.Code128(value = sku, barWidth = barWidth, barHeight = barHeight)
canvas.scale(0.3, 1.0)
barcode128.drawOn(canvas, bar_x, bar_y)
canvas.setFont(font, fontsize)
canvas.drawString(bar_value_x, bar_value_y, sku)
canvas.showPage()
def genPdfNameTag(canvas, data):
while data:
if len(data) > 8:
# select first 8 elements
genSinglePageNameTag(canvas, data[:8])
# truncate data
data = data[8:len(data)]
# move to the next page
canvas.showPage()
else:
genSinglePageNameTag(canvas, data)
def generate_pdf(request):
from django.http import HttpResponse
from reportlab.pdfgen import canvas
response = HttpResponse(content_type="application/pdf")
response[
'Content-Disposition'] = 'attachment; filename = "somefilename.pdf"'
canvas = canvas.Canvas(response)
canvas.drawString(300, 800, "Hello World!")
canvas.showPage()
canvas.save()
return response
def draw(self, canvas):
for size, split in itertools.product(self.sizes, [False, True]):
try:
card_layout = size(*self._args, **self._kwargs)
card_layout.draw(canvas, split)
canvas.showPage()
break
except TemplateTooSmall:
# Reset the page
canvas._restartAccumulators()
canvas.init_graphics_state()
canvas.state_stack = []
else:
print("Could not fit {}".format(self._kwargs["title"]))
def print_image(canvas, image, name):
w, h = A4
canvas.drawImage(
pil_to_rl(image, name),
0,
0,
height=w * 0.95,
width=w * 0.95,
preserveAspectRatio=True,
anchor='sw'
)
canvas.drawCentredString(w / 2, 600, name)
canvas.showPage()
canvas.save()
def get2(self, request, *args, **kwargs):
buffer = io.BytesIO()
canvas = Canvas(buffer)
# 내용을 채운다
canvas.drawString(40, 40, "canvas.drawString")
canvas.drawAlignedString(40, 80, "canvas.drawAlignedString")
canvas.drawCentredString(40, 120, "canvas.drawCentredString")
canvas.showPage()
canvas.save()
file_name = "hello.pdf"
buffer.seek(0)
return FileResponse(buffer, as_attachment=True, filename=file_name)
def main():
output_path = "../../data/characters/templates_printout.pdf"
canvas = reportlab.pdfgen.canvas.Canvas(
output_path, bottomup=1, pagesize=reportlab.lib.pagesizes.A4)
canvas_size = reportlab.lib.pagesizes.A4
width, height = canvas_size
# Size of image and margin between images on a pdf page
image_size = int(width * 0.2)
margin = int(width * 0.06)
paths = glob.glob("../../data/characters/templates/*.jpg")
templates = [
cv2.cvtColor(cv2.imread(path), cv2.COLOR_BGR2GRAY) for path in paths
]
temporary_dir = "/tmp/templates/"
# Make directory for temporary images if it doesn't already exist
os.makedirs(temporary_dir, exist_ok=True)
# Write bordered images to temporary dir
for path, template in zip(paths, templates):
temporary_path = temporary_dir + os.path.basename(path)
cv2.imwrite(temporary_path, template)
paths_iterator = iter(glob.glob(temporary_dir + "/*.jpg"))
# Create pages until we run out of template paths
while True:
try:
create_page(canvas, canvas_size, paths_iterator, image_size,
margin)
canvas.showPage()
except StopIteration:
break
canvas.save()
# Clean up temporary images
shutil.rmtree(temporary_dir)
def draw_page(page, uid, survey_name, canvas: reportlab.pdfgen.canvas.Canvas):
draw_qr_data(canvas, 'survey:' + survey_name + ':' + page.name + ':' + uid,
64, (48, height - 64 - 48))
canvas.setFillColorRGB(0.2, 0.2, 0.2)
canvas.setStrokeColorRGB(0.2, 0.2, 0.2)
canvas.circle(32, 32, 4, stroke=1, fill=1)
canvas.circle(32 + 12, 32, 4, stroke=1, fill=1)
canvas.circle(32, 32 + 12, 4, stroke=1, fill=1)
canvas.circle(width - 32, height - 32, 4, stroke=1, fill=1)
canvas.circle(width - 32 - 12, height - 32, 4, stroke=1, fill=1)
canvas.circle(width - 32, height - 32 - 12, 4, stroke=1, fill=1)
canvas.circle(width - 32, 32, 4, stroke=1, fill=1)
canvas.circle(width - 32 - 12, 32, 4, stroke=1, fill=1)
canvas.circle(width - 32, 32 + 12, 4, stroke=1, fill=1)
canvas.circle(32, height - 32, 4, stroke=1, fill=1)
canvas.circle(32 + 12, height - 32, 4, stroke=1, fill=1)
canvas.circle(32, height - 32 - 12, 4, stroke=1, fill=1)
canvas.setFillColorRGB(0.3, 0.3, 0.3)
canvas.drawString(128, height - 67,
survey_name + ':' + page.name + ':' + uid)
canvas.setFillColorRGB(0.4, 0.4, 0.4)
canvas.setStrokeColorRGB(0.2, 0.2, 0.2)
canvas.setFont('Courier', 8)
for field in page.get_binary_fields():
canvas.circle(field.position[0],
height - field.position[1],
5,
stroke=1,
fill=0)
canvas.drawCentredString(field.position[0],
height - field.position[1] - 2, field.hint)
canvas.setFillColorRGB(0.1, 0.1, 0.1)
for text in page.get_text_areas():
if text.rotation != 0:
canvas.saveState()
canvas.rotate(text.rotation)
tobj = canvas.beginText(text.position[0], height - text.position[1])
tobj.setFont(text.fontname, text.fontsize)
for line in text.text.split():
tobj.textLine(line)
canvas.drawText(tobj)
if text.rotation != 0:
canvas.restoreState()
canvas.showPage()
def gentestlabels():
# ascertain edges
global gl_printer
(xwidth, yheight) = letter
margin = .3 * inch
xwidth -= margin * 2
yheight -= margin * 2
xorg = yorg = margin
canvas = canvas_init('tmp/kitlabels.pdf',
pagesize=letter,
bottomup=1,
verbosity=1)
canvas.setStrokeColorRGB(.33, .33, .33)
canvas.setFont('Helvetica', 10)
yrows = 3
xcols = 2
ystep = yheight / yrows
xstep = xwidth / xcols
v('xystep: %f %f' % (xstep, ystep))
x = xorg
i = 0
pages = 2
for page in range(pages):
if (page != 0):
canvas.showPage()
y = yheight - ystep + margin
for yrowcount in reversed(range(yrows)):
for xcolcount in reversed(range(xcols)):
genkitlabel(canvas, x, y, xstep, ystep, '', test=1)
i += 1
x += xstep
x = xorg
y -= ystep
finish_up(canvas)
exit()
def test5(self):
"List and display all named colors and their gray equivalents."
canvas = reportlab.pdfgen.canvas.Canvas(
outputfile('test_lib_colors.pdf'))
#do all named colors
framePage(canvas, 'Color Demo - page %d' % canvas.getPageNumber())
all_colors = list(reportlab.lib.colors.getAllNamedColors().items())
all_colors.sort() # alpha order by name
canvas.setFont('Times-Roman', 10)
text = 'This shows all the named colors in the HTML standard (plus their gray and CMYK equivalents).'
canvas.drawString(72, 740, text)
canvas.drawString(200, 725, 'Pure RGB')
canvas.drawString(300, 725, 'B&W Approx')
canvas.drawString(400, 725, 'CMYK Approx')
y = 700
for (name, color) in all_colors:
canvas.setFillColor(colors.black)
canvas.drawString(100, y, name)
canvas.setFillColor(color)
canvas.rect(200, y - 10, 80, 30, fill=1)
canvas.setFillColor(colors.color2bw(color))
canvas.rect(300, y - 10, 80, 30, fill=1)
c, m, yel, k = colors.rgb2cmyk(color.red, color.green, color.blue)
CMYK = colors.CMYKColor(c, m, yel, k)
canvas.setFillColor(CMYK)
canvas.rect(400, y - 10, 80, 30, fill=1)
y = y - 40
if y < 100:
canvas.showPage()
framePage(canvas,
'Color Demo - page %d' % canvas.getPageNumber())
canvas.setFont('Times-Roman', 10)
y = 700
canvas.drawString(200, 725, 'Pure RGB')
canvas.drawString(300, 725, 'B&W Approx')
canvas.drawString(400, 725, 'CMYK Approx')
canvas.save()
def gentestlabels():
# ascertain edges
global gl_printer
(xwidth, yheight) = letter
margin = .3*inch
xwidth -= margin*2
yheight -= margin*2
xorg = yorg = margin
canvas = canvas_init('tmp/kitlabels.pdf',pagesize=letter,bottomup=1,verbosity=1)
canvas.setStrokeColorRGB(.33,.33,.33)
canvas.setFont('Helvetica',10)
yrows = 3
xcols = 2
ystep = yheight/yrows
xstep = xwidth/xcols
v('xystep: %f %f' % (xstep,ystep) )
x = xorg
i = 0
pages = 2
for page in range(pages):
if (page != 0):
canvas.showPage()
y = yheight-ystep+margin
for yrowcount in reversed(range(yrows)):
for xcolcount in reversed(range(xcols)):
genkitlabel(canvas, x,y,xstep,ystep,'',test=1)
i += 1
x += xstep
x = xorg
y -= ystep
finish_up(canvas)
exit()
def main():
output_path = "../../data/characters/templates_printout.pdf"
canvas = reportlab.pdfgen.canvas.Canvas(
output_path, bottomup=1, pagesize=reportlab.lib.pagesizes.A4)
canvas_size = reportlab.lib.pagesizes.A4
width, height = canvas_size
# Size of image and margin between images on a pdf page
image_size = int(width * 0.2)
margin = int(width * 0.06)
paths = glob.glob("../../data/characters/templates/*.jpg")
templates = [cv2.cvtColor(cv2.imread(path), cv2.COLOR_BGR2GRAY) for path in paths]
temporary_dir = "/tmp/templates/"
# Make directory for temporary images if it doesn't already exist
os.makedirs(temporary_dir, exist_ok=True)
# Write bordered images to temporary dir
for path, template in zip(paths, templates):
temporary_path = temporary_dir + os.path.basename(path)
cv2.imwrite(temporary_path, template)
paths_iterator = iter(glob.glob(temporary_dir + "/*.jpg"))
# Create pages until we run out of template paths
while True:
try:
create_page(canvas, canvas_size, paths_iterator, image_size, margin)
canvas.showPage()
except StopIteration:
break
canvas.save()
# Clean up temporary images
shutil.rmtree(temporary_dir)
def contig_draw(cName, in_file, out_file, annot_mode, key, fct_flags,
fct_colors):
"""Draw sequence map of a single contig to file."""
# load contig record
seq_record = load_genbank(in_file)
ctg_len = len(seq_record.seq)
feats = seq_record.features
cds = [
feature for feature in feats
if feature.type == 'CDS' or feature.type == 'cds'
]
if annot_mode == 'all':
annot_cds = [len(cds)]
else:
try:
annot_cds = [
1 for feature in cds
if feature.qualifiers.get(key)[0] != 'no match'
]
except TypeError:
annot_cds = []
annot_cnt = sum(annot_cds)
# calculate main canvas dimensions
if ctg_len * u < 2000:
seq_len = 2000
else:
seq_len = ctg_len * u
hCan = hmar * 2 + pNsize + seq_len
vCan = dBL + vmar * 4 + (annot_cnt / 2) * ck_vsp
transX = hmar + pNsize
transY = dBL + vmar * 2 + (annot_cnt / 2) * ck_vsp
ctg_Y = vmar
# set up main canvas
canvas = canvasser(hCan, vCan, transX, transY, out_file)
# draw contig baseline and features
base_draw(canvas, cName, ctg_len, feats, key, -doLdn, ctg_Y, 0, 'single',
annot_cnt, None, None, seq_len, annot_mode, fct_flags,
fct_colors)
# draw scale
seq_scale(canvas, (ctg_len * u) - pNsize, incrT, incrN, dip, dop)
# write to file and finalize the figure
canvas.showPage()
canvas.save()
def writepdf(text, p, canvas):
try:
frmts = eval(text[4])
except (IndexError, SyntaxError):
if text[4]:
raise Exception('Error %s' % text[4])
else:
frmts = [[]]
for _ in range(int(text[3])):
for frmt in frmts:
styles = getSampleStyleSheet()
styleN = styles['Normal']
styleN.spaceBefore = 10
styleN.spaceAfter = 10
styleH = styles['Heading1']
title = Paragraph(text[0].format(*frmt), styleH)
story = []
story.append(Paragraph(prep(text[1]).format(*frmt), styleN))
if text[2]:
story.append(
Paragraph('<br/>____________________________<br/>',
styleN))
story.append(
Paragraph('<br/>' + prep(text[2]).format(*frmt), styleN))
canvas.saveState()
f = Frame(spacer + p[0] * width,
spacer + p[1] * height,
width,
height,
showBoundary=1)
f.addFromList([title, KeepInFrame(height, width, story)], canvas)
canvas.restoreState()
if p == (2, 2):
canvas.showPage()
p = (0, 0)
else:
if p[1] == 2:
p = (p[0] + 1, 0)
else:
p = (p[0], p[1] + 1)
return p
def test5(self):
"List and display all named colors and their gray equivalents."
canvas = reportlab.pdfgen.canvas.Canvas(outputfile('test_lib_colors.pdf'))
#do all named colors
framePage(canvas, 'Color Demo - page %d' % canvas.getPageNumber())
all_colors = reportlab.lib.colors.getAllNamedColors().items()
all_colors.sort() # alpha order by name
canvas.setFont('Times-Roman', 10)
text = 'This shows all the named colors in the HTML standard (plus their gray and CMYK equivalents).'
canvas.drawString(72,740, text)
canvas.drawString(200,725,'Pure RGB')
canvas.drawString(300,725,'B&W Approx')
canvas.drawString(400,725,'CMYK Approx')
y = 700
for (name, color) in all_colors:
canvas.setFillColor(colors.black)
canvas.drawString(100, y, name)
canvas.setFillColor(color)
canvas.rect(200, y-10, 80, 30, fill=1)
canvas.setFillColor(colors.color2bw(color))
canvas.rect(300, y-10, 80, 30, fill=1)
c, m, yel, k = colors.rgb2cmyk(color.red, color.green, color.blue)
CMYK = colors.CMYKColor(c,m,yel,k)
canvas.setFillColor(CMYK)
canvas.rect(400, y-10, 80, 30, fill=1)
y = y - 40
if y < 100:
canvas.showPage()
framePage(canvas, 'Color Demo - page %d' % canvas.getPageNumber())
canvas.setFont('Times-Roman', 10)
y = 700
canvas.drawString(200,725,'Pure RGB')
canvas.drawString(300,725,'B&W Approx')
canvas.drawString(400,725,'CMYK Approx')
canvas.save()
def write_text_and_image_example():
src_filepath = './DeepLearning.pdf'
dst_filepath = './DeepLearning_added.pdf'
log_url = 'https://www.google.com/images/srpr/logo11w.png'
img_filepath = './logo11w.png'
# Create a new PDF with Reportlab.
packet = io.BytesIO()
canvas = reportlab.pdfgen.canvas.Canvas(packet, pagesize=reportlab.lib.pagesizes.letter)
canvas.drawString(100, 100, 'Hello World !!!')
if True:
logo = reportlab.lib.utils.ImageReader(log_url)
canvas.drawImage(logo, 100, 250, mask='auto')
else:
mask = [0, 0, 0, 0, 0, 0]
canvas.drawImage(img_filepath, x=100, y=250, width=400, height=200, mask=mask)
canvas.showPage()
canvas.save()
# Move to the beginning of the StringIO buffer.
packet.seek(0)
textPdfReader = PyPDF2.PdfFileReader(packet)
try:
with open(src_filepath, 'rb') as srcPdfFileObj:
# Read your existing PDF.
pdfReader = PyPDF2.PdfFileReader(srcPdfFileObj)
pdfWriter = PyPDF2.PdfFileWriter()
# Add the 'watermark' (which is the new pdf) on the existing page.
page = pdfReader.getPage(0)
page.mergePage(textPdfReader.getPage(0))
pdfWriter.addPage(page)
try:
with open(dst_filepath, 'wb') as dstPdfFileObj:
pdfWriter.write(dstPdfFileObj)
except FileNotFoundError as ex:
print('File not found, {}: {}.'.format(dst_filepath, ex))
except FileNotFoundError as ex:
print('File not found, {}: {}.'.format(src_filepath, ex))
def add_consensus(canvas,title,data,page_limit=PAGE_LIMIT,line_limit=LINE_LIMIT): data_lenght = len(data) i = 0 j = 0 y = CONSENSUS_Y x = CONSENSUS_X string = "" canvas.drawText(new_textobject(title,canvas,TITLE_X,TITLE_Y)) for i in range(data_lenght): string = string + data[i] if i % line_limit == 0 and i != 0: canvas.drawText(new_textobject(string,canvas,x,y)) y = y - 15 string = "" j = j + 1 if j % page_limit == 0 and j != 0: canvas.showPage() canvas.drawText(new_textobject(title,canvas,TITLE_X,TITLE_Y)) y = CONSENSUS_Y j = 0
def add_split_data(canvas,title,data,page_limit):
data_list = data.split('\n')
data_list_lenght = len(data_list)
i = 0
x = TEXT_ORIGIN_X
y = TEXT_ORIGIN_Y
for i in range(data_list_lenght):
canvas.drawText(new_textobject(title,canvas,TITLE_X,TITLE_Y))
string = data_list[i] + '\n'
if string.find('*') != -1:
x = POS_TABS
canvas.drawText(new_textobject(string,canvas,x,y))
x = TEXT_ORIGIN_X
else:
canvas.drawText(new_textobject(string,canvas,x,y))
y = y - 15
if i % page_limit == 0 and i != 0:
canvas.showPage()
y = TEXT_ORIGIN_Y
canvas.showPage()
def draw_page(page, uid, survey_name, canvas : reportlab.pdfgen.canvas.Canvas):
draw_qr_data(canvas, 'survey:'+survey_name+':'+page.name+':'+uid, 64, (48, height-64-48))
canvas.setFillColorRGB(0.2, 0.2, 0.2)
canvas.setStrokeColorRGB(0.2, 0.2, 0.2)
canvas.circle(32, 32, 4, stroke=1, fill=1)
canvas.circle(32+12, 32, 4, stroke=1, fill=1)
canvas.circle(32, 32+12, 4, stroke=1, fill=1)
canvas.circle(width - 32, height - 32, 4, stroke=1, fill=1)
canvas.circle(width - 32-12, height - 32, 4, stroke=1, fill=1)
canvas.circle(width - 32, height - 32-12, 4, stroke=1, fill=1)
canvas.circle(width - 32, 32, 4, stroke=1, fill=1)
canvas.circle(width - 32-12, 32, 4, stroke=1, fill=1)
canvas.circle(width - 32, 32+12, 4, stroke=1, fill=1)
canvas.circle(32, height - 32, 4, stroke=1, fill=1)
canvas.circle(32+12, height - 32, 4, stroke=1, fill=1)
canvas.circle(32, height - 32-12, 4, stroke=1, fill=1)
canvas.setFillColorRGB(0.3, 0.3, 0.3)
canvas.drawString(128, height - 67, survey_name+':'+page.name+':'+uid)
canvas.setFillColorRGB(0.4, 0.4, 0.4)
canvas.setStrokeColorRGB(0.2, 0.2, 0.2)
canvas.setFont('Courier', 8)
for field in page.get_binary_fields():
canvas.circle(field.position[0], height - field.position[1], 5, stroke=1, fill=0)
canvas.drawCentredString(field.position[0], height - field.position[1]-2, field.hint)
canvas.setFillColorRGB(0.1, 0.1, 0.1)
for text in page.get_text_areas():
if text.rotation != 0:
canvas.saveState()
canvas.rotate(text.rotation)
tobj = canvas.beginText(text.position[0], height - text.position[1])
tobj.setFont(text.fontname, text.fontsize)
for line in text.text.split():
tobj.textLine(line)
canvas.drawText(tobj)
if text.rotation != 0:
canvas.restoreState()
canvas.showPage()
def draw(self, canvas):
#agrega una plantilla en blanco por que no se parsea etiquetas
if not self.paginate:
for rect in self.rects:
rect.draw(canvas)
for label in self.labels:
label.draw(canvas)
canvas.showPage()
else:
if len(self.pages) == 0:
self.pages.append([])
for page in self.pages:
for rect in self.rects:
rect.draw(canvas)
for label in self.labels:
label.draw(canvas)
for label in page:
label.draw(canvas)
canvas.showPage()
def writepdf(number, effort, times, p, jpg, canvas):
for frmt in range(times):
styles = getSampleStyleSheet()
styleN = styles['Normal']
styleN.spaceBefore = 10
styleN.spaceAfter = 10
styleH = styles['Heading1']
styleH.alignment = 1
styleN.alignment = 1
story = []
for i in range(5):
story.append(Paragraph('<br/>', styleH))
if effort:
story.append(Paragraph('%i' % number, styleH))
story.append(Paragraph('Harvest %i000 calories' % number, styleN))
else:
story.append(
Paragraph('<font color="blue">%i</font>' % number, styleH))
canvas.saveState()
f = Frame(spacer + p[0] * width,
spacer + p[1] * height,
width,
height,
showBoundary=1)
f.addFromList(story, canvas)
canvas.restoreState()
if jpg:
canvas.showPage()
elif p == (3, 3):
canvas.showPage()
p = (0, 0)
else:
if p[1] == 3:
p = (p[0] + 1, 0)
else:
p = (p[0], p[1] + 1)
return p
def contig_draw(cName, in_file, out_file, annot_mode, key, fct_flags,
fct_colors):
"""Draw sequence map of a single contig to file."""
# load contig record
seq_record = load_genbank(in_file)
ctg_len = len(seq_record.seq)
feats = seq_record.features
cds = [feature for feature in feats
if feature.type == 'CDS' or feature.type == 'cds']
if annot_mode == 'all':
annot_cds = [len(cds)]
else:
try:
annot_cds = [1 for feature in cds
if feature.qualifiers.get(key)[0] != 'no match']
except TypeError:
annot_cds = []
annot_cnt = sum(annot_cds)
# calculate main canvas dimensions
if ctg_len*u < 2000:
seq_len = 2000
else:
seq_len = ctg_len*u
hCan = hmar*2 + pNsize + seq_len
vCan = dBL + vmar*4 + (annot_cnt/2)*ck_vsp
transX = hmar + pNsize
transY = dBL + vmar*2 + (annot_cnt/2)*ck_vsp
ctg_Y = vmar
# set up main canvas
canvas = canvasser(hCan, vCan, transX, transY, out_file)
# draw contig baseline and features
base_draw(canvas, cName, ctg_len, feats, key, -doLdn, ctg_Y, 0, 'single',
annot_cnt, None, None, seq_len, annot_mode, fct_flags,
fct_colors)
# draw scale
seq_scale(canvas, (ctg_len*u)-pNsize, incrT, incrN, dip, dop)
# write to file and finalize the figure
canvas.showPage()
canvas.save()
def generateCover(canvas, pageSettings: PageSettings, packet: Packet, copies):
# Cover page is always printed in portrait mode
(width, height) = pageSettings.pagesize
canvas.setFont("HatWordFont", pageSettings.fontSize)
interval = pageSettings.fontSize * 2
# lines = [
# packet.packetTitle(),
# "%d words" % len(packet.words),
# "(%d pages) " % len(packet.pages),
# ]
lines = []
# if copies > 1:
# lines += [
# "%d copies" % copies,
# "%d pages total" % (qty * len(packet.pages))
# ]
# lines
hOffset = height / 2 + (interval * len(lines)) / 2
for index, line in enumerate(lines):
canvas.drawCentredString(width / 2, hOffset - interval * index, line)
canvas.showPage()
def addPage(canvas, page, strokes):
canvas.setLineCap(1)
if page['height'] > page['width']:
PAGE = (A4[0], A4[1])
else:
PAGE = (A4[1], A4[0])
canvas.setPageSize(PAGE)
S = PAGE[0] / page['width']
for s in strokes:
dots = s['dots']
x0, y0, p0, dt0 = dots[0]
for x, y, p, dt in dots[1:]:
# the factor 1.5 visually matches the thickness in neonote app
canvas.setLineWidth((s['thickness'] + 1.5) * p)
col = s['color']
canvas.setStrokeColorRGB(col[1] / 255, col[2] / 255, col[3] / 255)
canvas.line(S * x0, S * y0, S * x, S * y)
x0, y0, p0 = x, y, p
canvas.showPage()
def gen_label(fnsku, title, sku, canvas, modl):
barcode128 = code128.Code128(value = fnsku, barWidth = modl.barWidth, barHeight = modl.barHeight)
barcode128.drawOn(canvas, modl.bar_x, modl.bar_y)
canvas.setFont(modl.font, modl.fontsize)
canvas.drawString(modl.bar_value_x, modl.bar_value_y, fnsku)
canvas.setFont(modl.font, modl.fontsize - 1)
if len(title) > modl.title_len:
title = title[0:modl.title_left_len] + "..." + title[modl.title_left_len - modl.title_len:]
canvas.scale(0.6, 1.0)
canvas.drawString(modl.title_x, modl.title_y, title)#title
canvas.setFont(modl.fontB, modl.fontsize)
canvas.scale(1.0, 1.0)
canvas.drawString(modl.condition_type_x, modl.condition_type_y, modl.condition_type)
if modl.print_sku:
canvas.setFont(modl.font, modl.fontsize)
canvas.drawString(modl.sku_x, modl.sku_y, sku)
canvas.showPage()
def create_badges(data):
# canvas.translate(0, section_height)
for batch in make_batches(data, 2):
# fold & cut helpers
canvas.setDash(6, 3)
canvas.line(width / 2.0, 0, width / 2.0, height) # vertical line
canvas.setDash(1, 0)
canvas.line(0, height / 2.0, width, height / 2.0) # horizontal
canvas.setDash(1, 0)
draw_margins()
canvas.translate(0, height / 2.0 + margin)
for pos, (ticket_index, attendee) in enumerate(batch, 1):
write_qr_code(attendee, ticket_index)
canvas.translate(width / 2.0 + margin, 0)
write_badge(attendee)
canvas.translate(-width / 2.0 - margin, -height / 2.0 - margin)
canvas.showPage(
) # finish the page, next statements should go next page
canvas.save()
def makeAccountStatement (holder, rows, date=datetime.now()):
from reportlab.pdfgen import canvas
date = str(date)
canvas = canvas.Canvas("accounts/" + holder.replace('/', "") + ".pdf", pagesize=letter)
canvas.setLineWidth(.3)
canvas.setFont('Helvetica', 12)
canvas.drawString(30,750, 'Account Statement of ' + holder)
canvas.drawString(30,735, 'At ACME INDUSTRIES')
canvas.drawString(420,750, date)
# heading
makeHeader(canvas)
diff = 0
for r in rows:
verticalPos = 650-diff
if verticalPos == 50:
canvas.showPage()
makeHeader(canvas)
verticalPos = 650
diff = 0
canvas.drawString(20,verticalPos,r[0])
canvas.drawString(90,verticalPos,r[1][:-1])
canvas.drawString(150,verticalPos,r[2])
canvas.drawString(280,verticalPos,r[3])
canvas.drawString(360,verticalPos,r[4])
canvas.drawString(420,verticalPos,r[5])
canvas.drawString(480,verticalPos,r[6])
diff = diff + 50
canvas.save()
def pdf(http_request, id):
id = int(id)
priority = get_object_or_404(UserPriority, id=id)
if (http_request.user != priority.user
and not http_request.user.is_superuser):
return error_page(http_request, _("Access Denied"),
_("This invoice is for a different user."))
response = HttpResponse(mimetype='application/pdf')
response['Content-Disposition'] = 'attachment; filename=%d.pdf' % id
country = None
if priority.country:
country = priority.country.upper()
assert len(country) == 2
if country == 'US':
pagesize = letter
else:
pagesize = A4
if country == 'DE':
payment = Decimal('%.2f' % (float(priority.payment) / 1.19))
tax = Decimal('%.2f' % (float(priority.payment) - float(payment)))
subject = u"Rechnung Nummer %d" % priority.id
date = u"Datum: %s" % human_date(priority.activated)
amounts = [-12, u"Menge", '', 12, u"1", '', '', u"19%", '', '']
prices = [
-12, u"Preis", '', 12,
u"%s %.2f" % (priority.currency, payment), '', '',
u"%s %.2f" % (priority.currency, tax), '',
u"%s %.2f" % (priority.currency, priority.payment)]
descriptions = [
-12, u"Beschreibung", '', 12,
u"Priority processing für %s" % priority.user.username,
u"von %s bis %s" % (human_date(priority.activated),
human_date(priority.expire)), '',
u"Mehrwertsteuer", '', u"Rechnungsbetrag (Brutto)"]
amounts.extend(['', '',
u"Vielen Dank für Ihren Auftrag.", '',
u"Mit freundlichen Grüßen,",
u"Johann C. Rocholl"])
else:
subject = u"Invoice Number %d" % id
date = u"Date: %s" % human_date(priority.activated)
amounts = [-12, u"Qty", '', 12, u"1", '']
prices = [
-12, u"Price", '', 12,
u"%s %.2f" % (priority.currency, priority.payment)]
descriptions = [
-12, u"Description", '', 12,
u"Priority processing for %s" % priority.user.username,
u"from %s to %s" % (human_date(priority.activated),
human_date(priority.expire))]
amounts.extend(['', '',
u"For customers outside Germany, this invoice does not include",
u"sales tax, value added tax (VAT) or goods and services tax (GST).",
u"You may have to pay use tax or reverse charge VAT, according",
u"to the tax laws in your country or state.",
'',
u"Thank you for your business.",
'',
u"Kind regards,",
u"Johann C. Rocholl"])
canvas = reportlab.pdfgen.canvas.Canvas(response, pagesize=pagesize)
width, height = pagesize
pdf_draw_header(canvas, country)
# canvas.drawString(LEFT_COLUMN, 25*cm, u"Customer:")
address = get_address(priority.user, [priority])
drawStrings(canvas, LEFT_COLUMN, 23*cm, *address)
drawStrings(canvas, LEFT_COLUMN, 17.5*cm, -12, subject)
drawStrings(canvas, LEFT_COLUMN, 17*cm, 12, date)
drawStrings(canvas, LEFT_COLUMN, TABLE_TOP, *amounts)
drawStrings(canvas, MIDDLE_COLUMN, TABLE_TOP, *descriptions)
drawStrings(canvas, RIGHT_COLUMN, TABLE_TOP, *prices)
pdf_draw_footer(canvas, country)
canvas.showPage()
canvas.save()
return response
def draw_pdf(buffer, invoice):
""" Draws the invoice """
canvas = Canvas(buffer, pagesize=A4)
canvas.translate(0, 29.7 * cm)
canvas.setFont('Helvetica', 10)
canvas.saveState()
header_func(canvas)
canvas.restoreState()
canvas.saveState()
footer_func(canvas, invoice.footer)
canvas.restoreState()
canvas.saveState()
address_func(canvas)
canvas.restoreState()
# Client address
textobject = canvas.beginText(1.5 * cm, -2.5 * cm)
for line in invoice.client_business_details:
textobject.textLine(line)
# if invoice.address.contact_name:
# textobject.textLine(invoice.address.contact_name)
# textobject.textLine(invoice.address.address_one)
# if invoice.address.address_two:
# textobject.textLine(invoice.address.address_two)
# textobject.textLine(invoice.address.town)
# if invoice.address.county:
# textobject.textLine(invoice.address.county)
# textobject.textLine(invoice.address.postcode)
# textobject.textLine(invoice.address.country.name)
canvas.drawText(textobject)
# Info
textobject = canvas.beginText(1.5 * cm, -6.75 * cm)
textobject.textLine(u'Invoice ID: %s' % invoice.invoice_id)
textobject.textLine(u'Invoice Date: %s' % invoice.invoice_date.strftime('%d %b %Y'))
textobject.textLine(u'Client: %s' % invoice.client)
for line in invoice.body_text:
textobject.textLine(line)
canvas.drawText(textobject)
# Items
data = [[u'Quantity', u'Description', u'Amount', u'Total'], ]
for item in invoice.items:
data.append([
item.quantity,
item.description,
format_currency(item.unit_price, invoice.currency),
format_currency(item.total(), invoice.currency)
])
data.append([u'', u'', u'Total:', format_currency(invoice.total(), invoice.currency)])
table = Table(data, colWidths=[2 * cm, 11 * cm, 3 * cm, 3 * cm])
table.setStyle([
('FONT', (0, 0), (-1, -1), 'Helvetica'),
('FONTSIZE', (0, 0), (-1, -1), 10),
('TEXTCOLOR', (0, 0), (-1, -1), (0.2, 0.2, 0.2)),
('GRID', (0, 0), (-1, -2), 1, (0.7, 0.7, 0.7)),
('GRID', (-2, -1), (-1, -1), 1, (0.7, 0.7, 0.7)),
('ALIGN', (-2, 0), (-1, -1), 'RIGHT'),
('BACKGROUND', (0, 0), (-1, 0), (0.8, 0.8, 0.8)),
])
tw, th, = table.wrapOn(canvas, 15 * cm, 19 * cm)
table.drawOn(canvas, 1 * cm, -10 * cm - th)
canvas.showPage()
canvas.save()
def project_gantt_chart(project_id, format):
project = get_project_or_404(project_id)
get_project_member_or_403(project)
try:
chart = Chart(project)
except InvalidGanttChart:
chart = None
dynamic = format == 'svg'
svg = flask.render_template('projects/gantt-chart.svg', chart=chart,
project=project, dynamic=dynamic,
today=datetime.datetime.utcnow())
if format == 'svg':
response = flask.make_response(svg)
response.mimetype = 'image/svg+xml'
elif format == 'pdf':
png = cairosvg.svg2png(svg)
image = PIL.Image.open(io.BytesIO(png))
page_size = tuple(reversed(reportlab.lib.pagesizes.A4))
page_margin = 50
output = io.BytesIO()
canvas = reportlab.pdfgen.canvas.Canvas(output, pagesize=page_size)
def draw_title_header():
x = page_size[0] / 2
y = page_size[1] - page_margin
title1 = 'Gantt Chart for {}'.format(project.name)
title2 = '{} to {}'.format(chart.start.date(), chart.end.date())
canvas.setFont('Helvetica', 14)
canvas.drawCentredString(x, y - 10, title1)
canvas.setFont('Helvetica', 10)
canvas.drawCentredString(x, y - 25, title2)
chart_x = page_margin
chart_y = page_margin
chart_width = int(page_size[0] - chart_x - page_margin)
chart_height = int(page_size[1] - chart_y - page_margin - 50)
new_height = int(chart_height)
new_width = int(image.width * (new_height / image.height))
image = image.resize((new_width, new_height), PIL.Image.ANTIALIAS)
def split_image():
for i in range(math.ceil(image.width / chart_width)):
x2 = (i + 1) * chart_width
if x2 >= image.width:
box = (i * chart_width, 0, image.width, image.height)
final = PIL.Image.new(mode='RGB',
size=(chart_width, chart_height),
color=(255, 255, 255))
final.paste(image.crop(box), (0, 0))
yield final
else:
box = (i * chart_width, 0, x2, image.height)
yield image.crop(box)
for subimage in split_image():
canvas.drawImage(reportlab.lib.utils.ImageReader(subimage),
chart_x, chart_y, width=chart_width,
height=chart_height)
draw_title_header()
canvas.showPage()
canvas.save()
pdf = output.getvalue()
output.close()
response = flask.make_response(pdf)
response.mimetype = 'application/pdf'
elif format == 'png':
png = cairosvg.svg2png(svg)
response = flask.make_response(png)
response.mimetype = 'image/png'
else:
raise errors.NotFound()
if format != 'svg':
if not flask.current_app.debug:
filename = 'Gantt Chart for {}.{}'.format(project.name, format)
content_disposition = 'attachment; filename="{}"'.format(filename)
response.headers['Content-Disposition'] = content_disposition
return response
def printcards(self):
drawCard = self.loadPythonFunc("drawCard", self.session.query(Data).get("card.py").data)
page = request.GET.get("page", "card")
type = request.GET.get("type", "blank")
query = (
self.session.query(Driver, Car, Registration)
.join("cars", "registration")
.filter(Registration.eventid == self.eventid)
)
if type == "blank":
registered = [(None, None, None)]
elif type == "lastname":
registered = query.order_by(func.lower(Driver.lastname), func.lower(Driver.firstname)).all()
elif type == "classnumber":
registered = query.order_by(Car.classcode, Car.number).all()
if page == "csv":
# CSV data, just use a template and return
objects = list()
for (dr, car, reg) in registered:
o = Registered()
o.__dict__.update(dr.__dict__)
o.__dict__.update(reg.__dict__)
o.__dict__.update(car.__dict__) # car is last so id = car.id
objects.append(o)
titles = [
"lastname",
"firstname",
"email",
"address",
"city",
"state",
"zip",
"phone",
"sponsor",
"brag",
"id",
"year",
"make",
"model",
"color",
"number",
"classcode",
"indexcode",
]
return self.csv("cards", titles, objects)
# Otherwise we are are PDF
try:
from reportlab.pdfgen import canvas
from reportlab.lib.units import inch
from reportlab.lib.utils import ImageReader
except:
c.text = "<h4>PDFGen not installed, can't create timing card PDF files from this system</h4>"
return render_mako("/admin/simple.mako")
try:
from PIL import Image
except ImportError:
try:
import Image
except:
c.text = "<h4>Python Image not installed, can't create timing card PDF files from this system</h4>"
return render_mako("/admin/simple.mako")
if page == "letter": # Letter has an additional 72 points Y to space out
size = (8 * inch, 11 * inch)
else:
size = (8 * inch, 5 * inch)
if page == "letter" and len(registered) % 2 != 0:
registered.append((None, None, None)) # Pages are always two cards per so make it divisible by 2
buffer = cStringIO.StringIO()
canvas = canvas.Canvas(buffer, pagesize=size, pageCompression=1)
carddata = self.session.query(Data).get("cardimage")
if carddata is None:
cardimage = Image.new("RGB", (1, 1))
else:
cardimage = Image.open(cStringIO.StringIO(carddata.data))
cardimage = ImageReader(cardimage)
while len(registered) > 0:
if page == "letter":
canvas.translate(0, 18) # 72/4, bottom margin for letter page
(driver, car, reg) = registered.pop(0)
drawCard(canvas, c.event, driver, car, cardimage)
canvas.translate(0, 396) # 360+72/2 card size plus 2 middle margins
(driver, car, reg) = registered.pop(0)
drawCard(canvas, c.event, driver, car, cardimage)
else:
(driver, car, reg) = registered.pop(0)
drawCard(canvas, c.event, driver, car, cardimage)
canvas.showPage()
canvas.save()
response.headers["Content-type"] = "application/octet-stream"
response.headers["Content-Disposition"] = "attachment;filename=cards.pdf"
return buffer.getvalue()
def process(self):
super(Drawing, self).process()
canvas = attr.getManager(self, interfaces.ICanvasManager).canvas
canvas.showPage()
def pdfFunctionLoop(author="Jon Barnes", lab="Cascade Meteorite Lab", savedFileName="pdfTestLoop1"):
####Import in Libraries
#
from reportlab.pdfgen import canvas
#
from reportlab.lib.pagesizes import letter
from reportlab.lib.pagesizes import landscape
#
from reportlab.platypus import Image
#
from reportlab.lib.units import cm
#
import time
global imageFileName
global n_clusters
print "start"
####Canvas stuff
canvas = canvas.Canvas(savedFileName + ".pdf", pagesize=letter)
#
canvas.setLineWidth(0.3)
#
canvas.setFont("Helvetica", 12)
########################
# Page 1
## Header Info : Meteorite lab, Thin Section, User, Date
##Lab the Data is From
canvas.drawString(30, 750, lab)
canvas.drawString(30, 735, "Scanning Electron Microscope Analysis")
#
canvas.drawString(400, 730, "Created by " + author)
canvas.line(380, 727, 580, 727)
#
canvas.drawString(400, 710, "Created on " + time.asctime(time.localtime(time.time())))
canvas.line(380, 707, 580, 707)
#
#### BSE Tiff Image
# Image of BSE Tiff
bseMainFile = "/home/jon/Desktop/gsoc2014/CML0615(13).tif"
canvas.drawImage(bseMainFile, 50, 100, width=15 * cm, height=15 * cm, preserveAspectRatio=True)
canvas.drawString(100, 100, "Back Scatter Electron (BSE) Image of Metorite thin section CML0615 ;")
canvas.drawString(100, 80, "mosaic image 13, CML0615(13). Grey scale shows average density.")
canvas.drawString(100, 60, "Lighter spots are heavier then darker spots.")
#
##Save the Page, make new page
canvas.showPage()
print "writing page 1"
bsePNGpath = "/home/jon/Desktop/gsoc2014/"
bsePNGfile = "croppedImageForCML0615(13)BOX"
bsePNG = bsePNGpath + bsePNGfile
bseCROPpngFile = "output"
bseCROPpng = bsePNGpath + bseCROPpngFile
bseNumber = 1
fileExt = ".png"
for i in range(62):
canvas.drawString(400, 400, "this is page 1+" + str(i))
#### BSE Tiff Image
# Image of BSE Tiff
bseWholeFile = bsePNG + str(bseNumber) + fileExt
canvas.drawImage(bseWholeFile, 50, 400, width=10 * cm, height=10 * cm, preserveAspectRatio=True)
# Label Image
bsePNGfileWhole = bsePNGfile + str(bseNumber)
canvas.drawString(50, 400, "BSE Image of " + bsePNGfileWhole)
#### BSE Crop Tiff Image
# Image of BSE Tiff
bseCROPWholeFile = bseCROPpng + str(bseNumber) + fileExt
canvas.drawImage(bseCROPWholeFile, 400, 400, width=5 * cm, height=5 * cm, preserveAspectRatio=True)
# Label Image
bsePNGfileWhole = bsePNGfile + str(bseNumber)
canvas.drawString(400, 400, "Crop Location in BSE Image of " + bseCROPWholeFile)
bseNumber += 1
print "writting page " + str(i)
canvas.showPage()
print "done"
####Save the PDF
canvas.save()
def create_stamp_pdf(survey, output_filename, questionnaire_ids):
sheets = 1 if questionnaire_ids is None else len(questionnaire_ids)
questionnaire_length = survey.questionnaire.page_count
have_pdftk = False
# Test if pdftk is present, if it is we can use it to be faster
try:
result = subprocess.Popen(['pdftk', '--version'], stdout=subprocess.PIPE)
# Just assume pdftk is there, if it was executed sucessfully
if result is not None:
have_pdftk = True
except OSError:
pass
if not have_pdftk:
try:
import pyPdf
except:
log.error(_(u'You need to have either pdftk or pyPdf installed. pdftk is the faster method.'))
sys.exit(1)
# Write the "stamp" out to tmp.pdf if are using pdftk.
if have_pdftk:
stampsfile = file(survey.path('tmp.pdf'), 'wb')
else:
stampsfile = StringIO.StringIO()
canvas = \
reportlab.pdfgen.canvas.Canvas(stampsfile,
bottomup=False,
pagesize=(survey.defs.paper_width * mm,
survey.defs.paper_height * mm))
# bottomup = False =>(0, 0) is the upper left corner
print ungettext(u'Creating stamp PDF for %i sheet', u'Creating stamp PDF for %i sheets', sheets) % sheets
log.progressbar.start(sheets)
for i in range(sheets):
id = questionnaire_ids.pop(0)
for j in range(questionnaire_length):
if survey.defs.style == "classic":
draw_corner_marks(survey, canvas)
draw_corner_boxes(survey, canvas, j)
if not survey.defs.duplex or j % 2:
if questionnaire_ids is not None:
draw_questionnaire_id(canvas, survey, id)
if survey.defs.print_survey_id:
draw_survey_id(canvas, survey)
elif survey.defs.style == "code128":
draw_corner_marks(survey, canvas)
if not survey.defs.duplex or j % 2:
if questionnaire_ids is not None:
draw_code128_questionnaire_id(canvas, survey, id)
# Survey ID has to be printed in CODE128 mode, because it
# contains the page number and rotation.
draw_code128_sdaps_info(canvas, survey, j + 1)
if survey.global_id is not None:
draw_code128_global_id(canvas, survey)
else:
raise AssertionError()
canvas.showPage()
log.progressbar.update(i + 1)
canvas.save()
print ungettext(u'%i sheet; %f seconds per sheet', u'%i sheet; %f seconds per sheet', log.progressbar.max_value) % (
log.progressbar.max_value,
float(log.progressbar.elapsed_time) /
float(log.progressbar.max_value)
)
if have_pdftk:
stampsfile.close()
# Merge using pdftk
print _("Stamping using pdftk")
tmp_dir = tempfile.mkdtemp()
for page in xrange(1, questionnaire_length + 1):
print ungettext(u"pdftk: Splitting out page %d of each sheet.", u"pdftk: Splitting out page %d of each sheet.", page) % page
args = []
args.append('pdftk')
args.append(survey.path('tmp.pdf'))
args.append('cat')
cur = page
for i in range(sheets):
args.append('%d' % cur)
cur += questionnaire_length
args.append('output')
args.append(os.path.join(tmp_dir, 'stamp-%d.pdf' % page))
subprocess.call(args)
print _(u"pdftk: Splitting the questionnaire for watermarking.")
subprocess.call(['pdftk', survey.path('questionnaire.pdf'),
'dump_data', 'output',
os.path.join(tmp_dir, 'doc_data.txt')])
for page in xrange(1, questionnaire_length + 1):
subprocess.call(['pdftk', survey.path('questionnaire.pdf'), 'cat',
'%d' % page, 'output',
os.path.join(tmp_dir, 'watermark-%d.pdf' % page)])
for page in xrange(1, questionnaire_length + 1):
print ungettext(u"pdftk: Watermarking page %d of all sheets.", u"pdftk: Watermarking page %d of all sheets.", page) % page
subprocess.call(['pdftk',
os.path.join(tmp_dir, 'stamp-%d.pdf' % page),
'background',
os.path.join(tmp_dir, 'watermark-%d.pdf' % page),
'output',
os.path.join(tmp_dir, 'watermarked-%d.pdf' % page)])
args = []
args.append('pdftk')
for page in xrange(1, questionnaire_length + 1):
char = chr(ord('A') + page - 1)
args.append('%s=' % char + os.path.join(tmp_dir, 'watermarked-%d.pdf' % page))
args.append('cat')
for i in range(sheets):
for page in xrange(1, questionnaire_length + 1):
char = chr(ord('A') + page - 1)
args.append('%s%d' % (char, i + 1))
args.append('output')
args.append(os.path.join(tmp_dir, 'final.pdf'))
print _(u"pdftk: Assembling everything into the final PDF.")
subprocess.call(args)
subprocess.call(['pdftk', os.path.join(tmp_dir, 'final.pdf'),
'update_info', os.path.join(tmp_dir, 'doc_data.txt'),
'output', output_filename])
# Remove tmp.pdf
os.unlink(survey.path('tmp.pdf'))
# Remove all the temporary files
shutil.rmtree(tmp_dir)
else:
# Merge using pyPdf
stamped = pyPdf.PdfFileWriter()
stamped._info.getObject().update({
pyPdf.generic.NameObject('/Producer'): pyPdf.generic.createStringObject(u'sdaps'),
pyPdf.generic.NameObject('/Title'): pyPdf.generic.createStringObject(survey.title),
})
subject = []
for key, value in survey.info.iteritems():
subject.append(u'%(key)s: %(value)s' % {'key': key, 'value': value})
subject = u'\n'.join(subject)
stamped._info.getObject().update({
pyPdf.generic.NameObject('/Subject'): pyPdf.generic.createStringObject(subject),
})
stamps = pyPdf.PdfFileReader(stampsfile)
del stampsfile
questionnaire = pyPdf.PdfFileReader(
file(survey.path('questionnaire.pdf'), 'rb')
)
print _(u'Stamping using pyPdf. For faster stamping, install pdftk.')
log.progressbar.start(sheets)
for i in range(sheets):
for j in range(questionnaire_length):
s = stamps.getPage(i * questionnaire_length + j)
if not have_pdftk:
q = questionnaire.getPage(j)
s.mergePage(q)
stamped.addPage(s)
log.progressbar.update(i + 1)
stamped.write(open(output_filename, 'wb'))
print ungettext(u'%i sheet; %f seconds per sheet', u'%i sheet; %f seconds per sheet',
log.progressbar.max_value) % (
log.progressbar.max_value,
float(log.progressbar.elapsed_time) /
float(log.progressbar.max_value))
def add_image(canvas,title,image,scale=SCALE): canvas.drawText(new_textobject(title,canvas,TITLE_X,TITLE_Y)) w, h = ImageReader(image).getSize() canvas.drawInlineImage(image,IMAGE_ORIGIN_X,IMAGE_ORIGIN_Y,w * scale,h * scale) canvas.showPage()
def render(canvas, bounding_box=False, pg=None):
assert canvas._pagesize == pagesizes.A4
# query setup
query = (
"SELECT othernames, surname, ticket_id, vip "
"FROM tickets "
"WHERE paid IS NOT NULL AND"
" printed IS NULL "
"ORDER BY user_id, surname, othernames"
)
cur = pg.cursor(True)
cur.execute(query)
# constants
start = (11.93 * units.mm, 24 * units.mm)
size = (41 * units.mm, 17.5 * units.mm)
delta = (48.35 * units.mm, 21.2 * units.mm)
count = (4, 12)
bar_height = size[1] / 4.0 - 1 * units.mm
bar_width = 0.71 * units.mm
coord_positions = [[start[n] + i * delta[n] for i in range(count[n])] for n in (0, 1)]
ticket_types = {
True: {"entry_time": "8:00pm", "type_string": "VIP"},
False: {"entry_time": "8:30pm", "type_string": "Standard"},
}
# position iterator stuff
positions = list(itertools.product(*coord_positions))
pos_enum = itertools.cycle(range(len(positions)))
# page counting
per_page = count[0] * count[1]
pages = cur.rowcount // per_page
if cur.rowcount % per_page:
pages += 1
page = 0
# util
def centred_text(canvas, x, y, row, what):
x_centre = x + size[0] / 2.0
canvas.saveState()
for font_size in range(12, 5, -1):
canvas.setFontSize(font_size)
if canvas.stringWidth(what) < size[0]:
break
else:
print("Warning: text", what, "too wide")
offset = row * size[1] / 4.0
canvas.drawCentredString(x_centre, y + offset, what)
canvas.restoreState()
# go
for pos_n, ticket in itertools.izip(pos_enum, cur):
if pos_n == 0:
if page != 0:
canvas.showPage()
page += 1
footer = "Barcodes page {0} of {1}".format(page, pages)
canvas.drawCentredString(pagesizes.A4[0] / 2.0, 20, footer)
ticket.update(ticket_types[ticket["vip"]])
name = "{othernames} {surname}".format(**ticket)
barcode_value = "{ticket_id:04d}".format(**ticket)
num_type = "{ticket_id:04d} {type_string}".format(**ticket)
entry_time = "Entry time: {entry_time}".format(**ticket)
x, y = positions[pos_n]
barcode = code128.Code128(barcode_value, barWidth=bar_width, barHeight=bar_height, quiet=False)
x_offset = (size[0] - barcode.width) / 2
if x_offset < 0:
raise ValueError("barcode too wide")
barcode.drawOn(canvas, x + x_offset, y + 2 * size[1] / 4.0)
centred_text(canvas, x, y, 3, name)
centred_text(canvas, x, y, 1, num_type)
centred_text(canvas, x, y, 0, entry_time)
if bounding_box:
canvas.setStrokeColor(colors.red)
canvas.rect(x, y, size[0], size[1], stroke=1, fill=0)
canvas.setStrokeColor(colors.black)
# last page
canvas.showPage()
# cleanup
cur.close()
def myLaterPages(canvas, doc):
canvas.showPage()
canvas.saveState()
#canvas.setFont('Times-Roman', 9)
#canvas.drawString(inch, 0.75 * inch,"Page %d %s" % (doc.page, pageinfo))
canvas.restoreState()
def printcards(self):
drawCard = self.loadPythonFunc("drawCard", self.session.query(Data).get("card.py").data)
page = request.GET.get("page", "card")
type = request.GET.get("type", "blank")
query = (
self.session.query(Driver, Car, Registration)
.join("cars", "registration")
.filter(Registration.eventid == self.eventid)
)
if type == "blank":
registered = [(None, None, None)]
elif type == "lastname":
registered = query.order_by(func.lower(Driver.lastname), func.lower(Driver.firstname)).all()
elif type == "classnumber":
registered = query.order_by(Car.classcode, Car.number).all()
if page == "csv":
# CSV data, just use a template and return
c.registered = registered
response.headers["Content-type"] = "application/octet-stream"
response.headers["Content-Disposition"] = "attachment;filename=cards.csv"
response.charset = "utf8"
return render_mako("/admin/csv.mako")
# Otherwise we are are PDF
try:
from reportlab.pdfgen import canvas
from reportlab.lib.units import inch
except:
c.text = "<h4>PDFGen not installed, can't create timing card PDF files from this system</h4>"
return render_mako("/admin/simple.mako")
if page == "letter": # Letter has an additional 72 points Y to space out
size = (8 * inch, 11 * inch)
else:
size = (8 * inch, 5 * inch)
if page == "letter" and len(registered) % 2 != 0:
registered.append((None, None, None)) # Pages are always two cards per so make it divisible by 2
buffer = cStringIO.StringIO()
canvas = canvas.Canvas(buffer, pagesize=size, pageCompression=1)
while len(registered) > 0:
if page == "letter":
canvas.translate(0, 18) # 72/4, bottom margin for letter page
(driver, car, reg) = registered.pop(0)
drawCard(canvas, c.event, driver, car)
canvas.translate(0, 396) # 360+72/2 card size plus 2 middle margins
(driver, car, reg) = registered.pop(0)
drawCard(canvas, c.event, driver, car)
else:
(driver, car, reg) = registered.pop(0)
drawCard(canvas, c.event, driver, car)
canvas.showPage()
canvas.save()
response.headers["Content-type"] = "application/octet-stream"
response.headers["Content-Disposition"] = "attachment;filename=cards.pdf"
return buffer.getvalue()
from reportlab.pdfgen import canvas
"""
Canvas imagem
canvas.drawImage(self, image, x, y, width=None, height=None, mask=None)
canvas.drawInlineImage(self, image, x, y, width=None, height=None)
There are two similar-sounding ways to draw images. The preferred one is the drawImage method. This implements
a caching system so you can define an image once and draw it many times; it will only be stored once in the PDF
file. `drawImage` also exposes one advanced parameter, a transparency mask, and will expose more in future.
The older technique, `drawInlineImage`, stores bitmaps within the page stream and is thus very inefficient if you
use the same image more than once in a document; but can result in PDFs which render faster if the images are
very small and not repeated.
"""
canvas = canvas.Canvas("pdfs/extra-011.pdf")
canvas.drawImage("static/python-logo.png", 100,400, width=150, height=150, mask='auto')
canvas.drawInlineImage("static/python-logo.png", 100, 700)
canvas.showPage()
canvas.save()
