def test_report():
from reportlab.lib.pagesizes import letter
from reportlab.pdfgen import canvas
import time
start_date = time.strftime('%d-%m-%Y %H:%M:%S')
canvas = canvas.Canvas("form1.pdf", pagesize=letter)
canvas.setLineWidth(1)
canvas.setFont('Helvetica', 12)
canvas.drawString(30, 750, 'DATE GENERATE')
canvas.drawString(450, 750, start_date)
canvas.line(440, 745, 570, 745)
# canvas.line(420, 730, 600, 730)
canvas.drawString(30, 730, 'REPORT TOPIC')
canvas.drawString(450, 730, 'PROBES')
canvas.line(440, 725, 570, 725)
# canvas.line(480, 747, 580, 747)
#
# canvas.drawString(275, 725, 'AMOUNT OWED:')
# canvas.drawString(500, 725, "$1,000.00")
# canvas.line(378, 723, 580, 723)
#
# canvas.drawString(30, 703, 'RECEIVED BY:')
# canvas.line(120, 700, 580, 700)
# canvas.drawString(120, 703, "JOHN DOE")
canvas.save()
def __init__(self, pt_ID, amount):
self.amount = amount
self.pt_ID = pt_ID
from reportlab.lib.pagesizes import letter
from reportlab.pdfgen import canvas
lt = "%s/EMR_outputs/%s/Other/rcpt-%s.pdf" % (
settings.LINUXPATH, self.pt_ID,
EMR_utilities.dateToday('file format'))
at = "%s/EMR_outputs/%s/Other/rcpt-%s.pdf" % (
settings.APPLEPATH, self.pt_ID,
EMR_utilities.dateToday('file format'))
wt = "%s\EMR_outputs\%s\Other\rcpt-%s.pdf" % (
settings.WINPATH, self.pt_ID,
EMR_utilities.dateToday('file format'))
filename = EMR_utilities.platformText(lt, at, wt)
canvas = canvas.Canvas(filename, pagesize=letter)
canvas.setLineWidth(.3)
canvas.setFont('Helvetica', 12)
canvas.drawString(
30, 750, 'PAYMENT FOR MEDICAL SERVICES FOR %s' % self.name_find())
canvas.drawString(30, 735, 'RENDERED AT BARRON FAMILY MEDICINE')
canvas.drawString(500, 750, "%s" % EMR_utilities.dateToday())
canvas.line(480, 747, 580, 747)
canvas.drawString(275, 725, 'AMOUNT PAID:')
canvas.drawString(500, 725, "$%s" % self.amount)
canvas.line(378, 723, 580, 723)
canvas.drawString(30, 703, 'RECEIVED BY:')
canvas.line(120, 700, 580, 700)
canvas.drawString(120, 703, settings.NAME)
canvas.save()
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 __init__(self, pt_ID, amount):
self.amount = amount
self.pt_ID = pt_ID
from reportlab.lib.pagesizes import letter
from reportlab.pdfgen import canvas
lt = "%s/EMR_outputs/%s/Other/rcpt-%s.pdf" % (settings.LINUXPATH, self.pt_ID, EMR_utilities.dateToday('file format'))
at = "%s/EMR_outputs/%s/Other/rcpt-%s.pdf" % (settings.APPLEPATH, self.pt_ID, EMR_utilities.dateToday('file format'))
wt = "%s\EMR_outputs\%s\Other\rcpt-%s.pdf" % (settings.WINPATH, self.pt_ID, EMR_utilities.dateToday('file format'))
filename = EMR_utilities.platformText(lt, at, wt)
canvas = canvas.Canvas(filename, pagesize=letter)
canvas.setLineWidth(.3)
canvas.setFont('Helvetica', 12)
canvas.drawString(30,750,'PAYMENT FOR MEDICAL SERVICES FOR %s' % self.name_find())
canvas.drawString(30,735,'RENDERED AT BARRON FAMILY MEDICINE')
canvas.drawString(500,750,"%s" % EMR_utilities.dateToday())
canvas.line(480,747,580,747)
canvas.drawString(275,725,'AMOUNT PAID:')
canvas.drawString(500,725,"$%s" % self.amount)
canvas.line(378,723,580,723)
canvas.drawString(30,703,'RECEIVED BY:')
canvas.line(120,700,580,700)
canvas.drawString(120,703, settings.NAME)
canvas.save()
def pdf():
try:
path = os.path.join(os.path.abspath(os.path.dirname(__file__)),
'form.pdf')
os.remove(path)
except FileNotFoundError:
pass
now = datetime.datetime.now()
from reportlab.pdfgen import canvas
canvas = canvas.Canvas("form.pdf", pagesize=letter)
canvas.setLineWidth(.3)
canvas.setFont('Helvetica', 12)
canvas.drawString(450, 50, 'CREATED BY SOLARIS')
canvas.drawString(
500, 750, "{day}/{month}/{year}".format(day=now.day,
month=now.month,
year=now.year))
canvas.line(480, 747, 580, 747)
canvas.setFont('Helvetica', 18)
canvas.drawString(225, 725, 'Performance metric')
canvas.setFont('Helvetica', 12)
canvas.drawString(50, 670, 'Information:')
canvas.setFont('Helvetica', 11)
canvas.drawString(70, 630, '- This data is based on Solaris algorithm')
canvas.drawString(70, 600, '- Frequency - 1 FPS')
canvas.drawInlineImage('dio.png', 80, 250, height=270, width=480)
canvas.save()
return None
def __init__(self, pt_ID, amount):
self.amount = amount
self.pt_ID = pt_ID
from reportlab.lib.pagesizes import letter
from reportlab.pdfgen import canvas
canvas = canvas.Canvas("/home/mb/Desktop/GECKO/EMR_outputs/%s/Other/rcpt-%s.pdf" % \
(self.pt_ID, EMR_utilities.dateToday()), pagesize=letter)
canvas.setLineWidth(.3)
canvas.setFont('Helvetica', 12)
canvas.drawString(
30, 750, 'PAYMENT FOR MEDICAL SERVICES FOR %s' % self.name_find())
canvas.drawString(30, 735, 'RENDERED AT BARRON FAMILY MEDICINE')
canvas.drawString(500, 750, "%s" % EMR_utilities.dateToday())
canvas.line(480, 747, 580, 747)
canvas.drawString(275, 725, 'AMOUNT PAID:')
canvas.drawString(500, 725, "$%s" % self.amount)
canvas.line(378, 723, 580, 723)
canvas.drawString(30, 703, 'RECEIVED BY:')
canvas.line(120, 700, 580, 700)
canvas.drawString(120, 703, "MICHAEL BARRON MD")
canvas.save()
def cratepdf(companynamepdf, companyaddresspdf, amountpdf, staxpdf, emailpdf, timestamppdf, canvas2, datepdf, finalstaxpdf, productpdf):
canvas = canvas2.Canvas("/home/raj/Documents/MyProjects/Python Invoice Generator with Database Connection and E-mail Support/INVOICE/Invoice (" + str(timestamppdf) + ").pdf", pagesize=letter)
canvas.setLineWidth(.3)
canvas.setFont('Helvetica', 12)
canvas.line(50, 747, 580, 747) #FROM TOP 1ST LINE
canvas.drawString(280, 750, "INVOICE")
canvas.drawString(60, 720, "COMPANY NAME:- "+ companynamepdf)
canvas.drawString(60, 690, "EMAIL-ID:- "+ emailpdf)
canvas.drawString(60, 660, "ADDRESS:- "+ companyaddresspdf)
canvas.drawString(450, 720, "DATE :- "+ str(datepdf))
canvas.line(450, 710, 560, 710)
canvas.line(50, 640, 580, 640)#FROM TOP 2ST LINE
canvas.line(50, 748, 50, 50)#LEFT LINE
canvas.line(400, 640, 400, 50)# MIDDLE LINE
canvas.line(580, 748, 580, 50)# RIGHT LINE
canvas.drawString(475, 615, 'TOTAL AMOUNT')
canvas.drawString(100, 615, 'PRODUCT')
canvas.line(50, 600, 580, 600)#FROM TOP 3rd LINE
canvas.drawString(60, 550, productpdf)
canvas.drawString(500, 550, amountpdf)
TOTAL = int(amountpdf) * ((int(staxpdf)) / 100)
canvas.drawString(60, 500, "SERVICE TAX (" +staxpdf+"%)")
canvas.drawString(500, 500, str(TOTAL))
canvas.line(50, 100, 580, 100)#FROM TOP 4th LINE
canvas.drawString(60, 80, " TOTAL AMOUNT")
canvas.drawString(500, 80, str(finalstaxpdf))
canvas.line(50, 50, 580, 50)#FROM TOP LAST LINE
canvas.save()
def downloadPdf():
output = BytesIO()
canvas = canvas.Canvas(output, pagesize=letter)
width, height = letter
# print(width)
# print(height)
canvas.setLineWidth(.3)
canvas.setFont('Helvetica', 20)
canvas.drawString(width / 2 - 60, 750, 'MEDICAL REPORT')
canvas.drawImage(path + "static/" + str(X[0]), 50, 500, 3 * inch, 3 * inch)
canvas.drawImage(path + "static/" + str(X[2]), width - 50 - (3 * inch),
500, 3 * inch, 3 * inch)
canvas.drawImage(path + "static/" + str(X[1]), 50, 500 - 3 * inch - 50,
3 * inch, 3 * inch)
canvas.drawImage(path + "static/" + str(X[3]), width - 50 - (3 * inch),
500 - 3 * inch - 50, 3 * inch, 3 * inch)
canvas.drawString(100, 500 - 3 * inch - 150,
"LEFT EYE STAGE: " + str(val[0]))
canvas.drawString(width - (2 * inch) - 100, 500 - 3 * inch - 150,
"RIGHT EYE STAGE: " + str(val[1]))
canvas.save()
pdf_out = output.getvalue()
output.close()
response = make_response(pdf_out)
response.headers[
'Content-Disposition'] = "attachment; filename='REPORT1.pdf"
response.mimetype = 'application/pdf'
return response
def __init__(self, pt_ID, amount):
self.amount = amount
self.pt_ID = pt_ID
from reportlab.lib.pagesizes import letter
from reportlab.pdfgen import canvas
canvas = canvas.Canvas("/home/mb/Desktop/GECKO/EMR_outputs/%s/Other/rcpt-%s.pdf" % \
(self.pt_ID, EMR_utilities.dateToday()), pagesize=letter)
canvas.setLineWidth(.3)
canvas.setFont('Helvetica', 12)
canvas.drawString(30,750,'PAYMENT FOR MEDICAL SERVICES FOR %s' % self.name_find())
canvas.drawString(30,735,'RENDERED AT BARRON FAMILY MEDICINE')
canvas.drawString(500,750,"%s" % EMR_utilities.dateToday())
canvas.line(480,747,580,747)
canvas.drawString(275,725,'AMOUNT PAID:')
canvas.drawString(500,725,"$%s" % self.amount)
canvas.line(378,723,580,723)
canvas.drawString(30,703,'RECEIVED BY:')
canvas.line(120,700,580,700)
canvas.drawString(120,703,"MICHAEL BARRON MD")
canvas.save()
def pdf(name, adult, children, total, time):
from reportlab.pdfgen import canvas
canvas = canvas.Canvas("static/website/pdf/print.pdf", pagesize=(300, 500))
canvas.setLineWidth(.3)
canvas.setFont('Helvetica', 19)
canvas.drawInlineImage("static/website/images/butterfly.jpeg",
82,
443,
width=46,
height=46)
canvas.drawString(138, 470, 'Butterfly')
canvas.drawString(138, 447, 'Garden')
canvas.line(10, 431, 290, 431)
canvas.drawInlineImage("qrcodes/qrcode.png",
72,
271,
width=155,
height=155)
canvas.line(10, 264, 290, 264)
canvas.setFont('Helvetica', 16)
canvas.drawString(20, 240, 'Total : ' + str(total))
canvas.setFont('Helvetica', 12)
canvas.drawString(20, 220, 'Name : ' + str(name))
canvas.drawString(20, 200, 'Adult : ' + str(adult))
canvas.drawString(170, 200, 'Children : ' + str(children))
canvas.drawString(20, 185, 'Time : ' + str(time))
canvas.line(10, 169, 290, 169)
canvas.line(10, 170, 290, 170)
canvas.drawInlineImage("qrcodes/qrcode.png", 72, 10, width=155, height=155)
canvas.save()
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 pdf(name, adult, children, total, date_time, counter):
from reportlab.pdfgen import canvas
canvas = canvas.Canvas("static/website/pdf/print.pdf", pagesize=(300, 360))
canvas.setLineWidth(.3)
canvas.setFont('Helvetica', 19)
canvas.drawInlineImage("static/website/images/butterfly.jpeg",
82,
303,
width=46,
height=46)
canvas.drawString(138, 340, 'The')
canvas.drawString(138, 322, 'Butterfly')
canvas.drawString(138, 300, 'Corner')
canvas.setFont('Helvetica', 14)
canvas.drawString(220, 300, 'Sr. No : ' + str(counter))
canvas.line(10, 291, 290, 291)
canvas.drawInlineImage("qrcodes/qrcode.png",
72,
131,
width=155,
height=155)
canvas.line(10, 124, 290, 124)
canvas.setFont('Helvetica', 16)
canvas.drawString(20, 100, 'Total : ' + total + ' THB')
canvas.setFont('Helvetica', 14)
canvas.drawString(20, 80, 'Date & Time : ' + date_time)
canvas.drawString(20, 60, 'Name : ' + name)
canvas.drawString(20, 40, 'Adult : ' + adult)
canvas.drawString(170, 40, 'Children : ' + children)
canvas.save()
def index():
import StringIO
# fairy = FairyImage.getrandomfairy()
# imgstring = fairy['image']
# filelike = StringIO.StringIO(imgstring)
# canvas = Image.open(filelike)
# canvas = FairyImage.addFairyNametoImage(canvas, fairy)
# output=StringIO.StringIO()
# canvas.save(output, format="JPEG")
# contents= output.getvalue().encode('base64')
# output.close()
#
# return render_template("index.html",contents=urllib.quote(contents.rstrip('\n')))
x = random.randint(1, 3)
if (x == 1):
princesses = Image.open("static/Princess_Tabitha.png")
name = ("Tabitha")
elif (x == 2):
princesses = Image.open("static/Princess_Esme.png")
name = ("Esme")
else:
princesses = Image.open("static/Princess_Violet.png")
name = ("Violet")
canvas = princesses
output = StringIO.StringIO()
canvas.save(output, format="JPEG")
contents = output.getvalue().encode('base64')
return render_template("index.html", contents=urllib.quote(contents.rstrip('\n')), Princess_name=name)
def get(self, request):
tables = Table.objects.filter(user=request.user)
context = {
'tables': tables,
}
from reportlab.lib.pagesizes import letter
from reportlab.pdfgen import canvas
from datetime import date
import random
today = date.today().strftime("%d/%m/%Y")
canvas = canvas.Canvas("/tmp/form.pdf", pagesize=letter)
canvas.setLineWidth(.3)
canvas.setFont('Helvetica', 12)
canvas.drawString(30, 750, 'REGALOS S.A de CV')
canvas.drawString(30, 735, 'FACTURA #%s' % random.randint(1, 1000))
canvas.drawString(500, 750, today)
canvas.line(480, 747, 580, 747)
canvas.drawString(30, 703, 'RFC de REGALOS S.A de CV:')
canvas.drawString(230, 703, "SAVR090503795")
canvas.drawString(30, 683, 'Direccion de REGALOS S.A de CV:')
canvas.drawString(
230, 683,
"AV JUAREZ NO. 907, PERIODISTAS, 42000, Pachuca, HIDALGO")
canvas.drawString(30, 643, 'Nombre:')
canvas.drawString(230, 643, "Mauricio Mejia")
canvas.drawString(30, 623, 'RFC:')
canvas.drawString(230, 623, "MERM971214HDFJMKR07")
canvas.drawString(30, 603, 'Direcciom:')
canvas.drawString(230, 603, "Calle 28 133 Progreso Nacional")
canvas.drawString(30, 583, 'Importe:')
canvas.drawString(230, 583, "20")
canvas.drawString(30, 563, 'IVA:')
canvas.drawString(230, 563, "20")
canvas.drawString(30, 543, 'TOTAL:')
canvas.drawString(230, 543, "20")
canvas.save()
email = EmailMessage()
email.subject = "New shirt submitted"
email.body = "Tu factura esta lista"
email.from_email = "*****@*****.**"
email.to = [
"*****@*****.**",
]
email.attach_file("/tmp/form.pdf") # Attach a file directly
email.send()
return TemplateResponse(request, 'users/profile.html', context)
def main():
# PDF document layout
canvas = canvas.Canvas(
"H:\College Fourth Year\Development Project\Final Year Project 2018\Forensic Reports\SMS Report.pdf",
pagesize=letter)
canvas.setLineWidth(.3)
canvas.setFont('Helvetica', 12)
canvas.drawString(30, 750, 'LYIT MOBILE FORENSICS DIVISION')
canvas.drawString(
500, 750, "Date: " +
now.strftime("%d-%m-%y")) # Prints date of the report(on the fly)
canvas.line(500, 747, 595, 747)
canvas.drawString(500, 725, 'Case Number:')
canvas.drawString(580, 725, "10")
canvas.line(500, 723, 595, 723)
# Introduction text
line1 = 'This forensic report on sms data has been compiled by the forensic'
line2 = 'examiner in conclusion to the investigation into the RTA'
line3 = 'case which occurred on the 23/01/2018.'
textObject = canvas.beginText(30, 700)
lines = [line1, line2, line3]
for line in lines:
textObject.textLine(line)
canvas.drawText(textObject)
canvas.save()
def create_report():
from reportlab.lib.pagesizes import letter
from reportlab.pdfgen import canvas
width, height = letter
canvas = canvas.Canvas("form.pdf", pagesize=letter)
canvas.setLineWidth(.3)
canvas.setFont('Helvetica', 10)
canvas.drawString(30, 750, 'OFFICIAL COMMUNIQUE')
canvas.drawString(30, 735, 'OF ACME INDUSTRIES')
canvas.drawString(500, 750, "12/12/2010")
canvas.line(480, 747, 580, 747)
canvas.drawString(275, 725, 'AMOUNT OWED:')
canvas.drawString(500, 725, "$1,000.00")
canvas.line(378, 723, 580, 723)
canvas.drawString(30, 703, 'RECEIVED BY:')
canvas.line(110, 700, 580, 700)
canvas.drawString(110, 703, "JOHN DOE")
canvas.save()
def createPDF(canvas, files):
logo = "UQRlogo.png"
partNo = str(entry['Part Number'])
creator = entry['Creators Name']
while len(partNo) < 4:
partNo = '0'+partNo
canvas = canvas.Canvas("PartNo"+ partNo +".pdf", pagesize=letter)
canvas.setLineWidth(.3)
canvas.setFont('Helvetica', 12)
canvas.drawString(30,750,'OFFICIAL PART')
canvas.drawString(30,735,'OF UQ RACING')
canvas.drawString(500,750, str(datetime.date.today()))
canvas.line(480,747,580,747)
canvas.drawString(275,725,'PART OF CAR:')
canvas.drawString(500,725, 'EV42 2017' )
canvas.line(378,723,580,723)
canvas.drawString(30,703,'PART CREATED BY:')
canvas.line(150,700,580,700)
canvas.drawString(160,703, creator.upper() )
canvas.drawImage(logo, 512, -15)
canvas.save()
def archive_watermark_page(archive_date):
"""Return PDF object with archiving watermark.
Args:
archive_date (datetime.datetime): Date of archiving.
Returns:
PyPDF2.pdf.PageObject: Page with just the archive watermark.
"""
size = {"width": 20 * pagesizes.inch, "height": 18 * pagesizes.inch}
font = {
"name": "Helvetica",
"size": 256,
"color": colors.red.clone(alpha=0.20),
"start_x": size["width"] * 0.50,
"start_y": size["height"] * 0.45,
}
text_lines = ["ARCHIVED", archive_date.strftime("%Y-%m-%d")]
packet = io.BytesIO()
canvas = reportlab.pdfgen.canvas.Canvas(
filename=packet, pagesize=(size["width"], size["height"]), bottomup=0
)
canvas.setFillColor(font["color"])
canvas.setFont(psfontname=font["name"], size=font["size"])
for i, line in enumerate(text_lines):
canvas.drawCentredString(
x=font["start_x"], y=(font["start_y"] + canvas._leading * i), text=line
)
canvas.save()
packet.seek(0)
watermark_page = PyPDF2.PdfFileReader(packet).getPage(0)
return watermark_page
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 process_stories(filepath):
with open(filepath, 'r') as infile:
reader = csv.DictReader(infile)
canvas = None
for row in reader:
canvas = generate_pdf(row, canvas)
canvas.save()
print "Stories saved to %s" % OUT_FILENAME
def generate_barcodes(self):
for r in range(self.rows):
for c in range(self.cols):
if self.entries[r][c].get() not in self.empty:
self.generate_code39(canvas, label_pos[r][c],
self.entries[r][c].get())
canvas.save()
self.open_pdf()
self.client_exit()
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 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 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 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 get_stamp_pdf(PROJ_NAME, PAGE_NO):
from reportlab.pdfgen import canvas
out_path = tempfile.mktemp(suffix=".pdf")
canvas = canvas.Canvas(out_path, pagesize=A4)
canvas.setLineWidth(.3)
canvas.setFont('Segoe UI', 8)
canvas.setStrokeColorRGB(0, 0, 0)
canvas.setFillColorRGB(0, 0, 0)
canvas.drawString(30, 10, "Feedback Report for {0}".format(PROJ_NAME))
canvas.drawString(540, 10, "Page {0}".format(PAGE_NO))
canvas.save()
return out_path
def montagea12():
import StringIO
size = 800, 550
canvas = FairyImage.getrandomfairysheet(12)
canvas.thumbnail(size, Image.ANTIALIAS)
output = StringIO.StringIO()
canvas.save(output, format="JPEG")
contents = output.getvalue().encode('base64')
output.close()
isadmin = current_user.has_role('superuser')
loggedin = current_user.is_authenticated
return render_template('montage12.html', contents=urllib.quote(contents.rstrip('\n')), admin=isadmin, auth=loggedin)
def generate(self):
canvas = self.canvas
canvas.setLineWidth(0.3)
canvas.setFont("Helvetica", 12)
self.__add_header()
for i in range(len(self.questions)):
question = self.questions[i]
answers = self.answers[i]
self.__add_block(question, answers, i)
canvas.save()
def login():
import StringIO
fairy = FairyImage.getrandomfairy()
imgstring = fairy['image']
filelike = StringIO.StringIO(imgstring)
canvas = Image.open(filelike)
canvas = FairyImage.addFairyNametoImage(canvas, fairy)
output = StringIO.StringIO()
canvas.save(output, format="JPEG")
contents = output.getvalue().encode('base64')
output.close()
return render_template("index.html", contents=urllib.quote(contents.rstrip('\n')))
def generate_lists(lists, title="Coffee list"):
"""
Given multiple list descriptions as an iterable of list_id and names,
generate one PDF that contains them all.
See generate_list.
"""
outfile = StringIO.StringIO()
canvas = reportlab.pdfgen.canvas.Canvas(outfile, pagesize=COFFEE_SHEET_PAGE_FORMAT)
for a_list in lists:
generate_list(*a_list, title=title, canvas=canvas)
canvas.save()
return outfile
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 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 print_receipt(tot_price, trans_id, cashier_id, amount_paid, amount_rem):
#global last_trans, canvas, base, values, currentprinter, canvas
print str(tot_price)+' '+str(trans_id)+' '+str(cashier_id)+str(last_trans)
#raw_input("Press Enter to continue...")
canvas = canvas.Canvas("receipt.pdf", pagesize=letter)
canvas.setLineWidth(.3)
canvas.setFont('Helvetica', 12)
canvas.drawString(30,750,'CASHIER ID: '+str(cashier_id))
canvas.drawString(30,735,'TRANSACTION ID: '+str(trans_id))
canvas.drawString(500,750,time.strftime("%d/%m/%Y"))
canvas.line(480,747,580,747)
canvas.drawString(275,725,'TOTAL PRICE:')
canvas.drawString(500,725,"$"+str(tot_price))
canvas.line(378,723,580,723)
canvas.drawString(30,703,'PRODUCTS:')
canvas.drawString(120,703,'<Barcode>')
canvas.drawString(190,703,'<Quantity>')
canvas.drawString(260,703,'<Price>')
#items = ['10005058 2 24.00', '10005058 2 24.00']
base = 683
print last_trans
for check in last_trans:
values = check.split()
print values
#raw_input('print check')
left= 120
for value in values:
canvas.drawString(left,base,str(value))
left+=70
base=base-30
canvas.line(120,base,580,base)
base-=30
canvas.drawString(120,base,'AMOUNT PAID: $ %.2f'%amount_paid)
canvas.line(120,base-10,580,base-10)
base-=30
canvas.drawString(120,base,'CHANGE: $ %.2f'%amount_rem)
base-=30
canvas.line(120,base-10,580,base-10)
canvas.save()
currentprinter = win32print.GetDefaultPrinter()
if len(currentprinter):
win32print.SetDefaultPrinter(currentprinter)
win32api.ShellExecute(0, "print", 'receipt.pdf', None, ".", 0)
threading.Timer(15, lambda: os.remove('receipt.pdf') ).start()
def home():
import StringIO
fairy = FairyImage.getrandomfairy()
imgstring = fairy['image']
filelike = StringIO.StringIO(imgstring)
canvas = Image.open(filelike)
canvas = FairyImage.addFairyNametoImage(canvas, fairy)
output = StringIO.StringIO()
canvas.save(output, format="JPEG")
contents = output.getvalue().encode('base64')
output.close()
isadmin = current_user.has_role('superuser')
loggedin = current_user.is_authenticated
return render_template("main.html", contents=urllib.quote(contents.rstrip('\n')), admin=isadmin, auth=loggedin)
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 addbfairy():
import StringIO
newfairy = FairyImage.createfairy('m')
canvas = FairyImage.getfairypicfromdb(newfairy['name'])
canvas = FairyImage.addFairyNametoImage(canvas, newfairy)
output = StringIO.StringIO()
canvas.save(output, format="JPEG")
contents = output.getvalue().encode('base64')
output.close()
loggedin = current_user.is_authenticated
gfairies = FairyImage.numberoffairies('f')
bfairies = FairyImage.numberoffairies('m')
tfairies = bfairies + gfairies
fairyref = FairyImage.getfairyreferences('FAIRY_TBL')
return render_template("dblist2.html", gfairies=str(gfairies), bfairies=str(bfairies), tfairies=str(tfairies),
fairyref=str(fairyref), contents=urllib.quote(contents.rstrip('\n')), auth=loggedin)
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 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 dict_to_pdf_proc(file_pdf,dict_aa): from reportlab.pdfgen import canvas fontname_g = "HeiseiKakuGo-W5" pdfmetrics.registerFont (UnicodeCIDFont(fontname_g)) canvas = canvas.Canvas(file_pdf) canvas.setFont(fontname_g, 20) ypos = 700 for key in sorted(dict_aa.keys()): unit = dict_aa[key] canvas.drawString(50,ypos,key) canvas.drawString(185,ypos,unit['name']) canvas.drawString(285,ypos,str (unit['population'])) canvas.drawString(400,ypos,unit['date_mod']) ypos = ypos - 25 # canvas.save()
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 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 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 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 generate_list(list_id, names, pre_cross_dict={}, title="Coffee list", canvas=None):
"""
Generate a PDF for a coffee list
Parameters:
list_id: A (preferably unique) ID for this list.
Will be embedded as a QR code into the URL
names: A list of names for this list
pre_cross_dict:
A dictionary mapping names to a number of crosses to pre-draw
onto the list
title: A heading for the list. Could e.g. include a date.
canvas: If set, draw to this canvas.
Returns:
A StringIO instance with the PDF file, or None if canvas is given.
"""
assert len(names) <= COFFEE_COUNT_PER_PAGE
# Prepare QR code
qr_code = tempfile.NamedTemporaryFile(suffix=".png")
qr_data = "%s?id=%d" % (COFFEE_HOMEPAGE, list_id)
qrcode.make(qr_data, border=0).save(qr_code.name)
# Start page, prepare units
had_canvas = canvas is not None
if not had_canvas:
outfile = StringIO.StringIO()
canvas = reportlab.pdfgen.canvas.Canvas(outfile, pagesize=COFFEE_SHEET_PAGE_FORMAT)
width, height = COFFEE_SHEET_PAGE_FORMAT
cm_unit = reportlab.lib.units.cm
qr_size = 2 * cm_unit
canvas.translate(1.5 * cm_unit, 1.5 * cm_unit)
width -= 3 * cm_unit
height -= 3 * cm_unit
# Draw orientation markers
path = canvas.beginPath()
path.moveTo(cm_unit, height)
path.lineTo(0, height)
path.lineTo(0, height - cm_unit)
canvas.setLineWidth(5)
canvas.setLineJoin(0)
canvas.drawPath(path)
path = canvas.beginPath()
path.moveTo(width, height - cm_unit)
path.lineTo(width, height)
path.lineTo(width - cm_unit, height)
canvas.drawPath(path)
path = canvas.beginPath()
path.moveTo(width, cm_unit)
path.lineTo(width, 0)
path.lineTo(width - cm_unit, 0)
canvas.drawPath(path)
path = canvas.beginPath()
path.moveTo(0, cm_unit)
path.lineTo(0, 0)
path.lineTo(cm_unit, 0)
canvas.drawPath(path)
canvas.setLineWidth(1)
# Draw title
canvas.setFont("Helvetica", 16)
canvas.drawString(.5 * cm_unit, height - 1 * cm_unit, title)
# Draw the QR code and ID
canvas.drawImage(qr_code.name, .5 * cm_unit, .5 * cm_unit, qr_size, qr_size)
canvas.setFont("Helvetica", 8)
canvas.drawString(.5 * cm_unit, .2 * cm_unit, "#%d" % list_id)
# Draw bottom text
canvas.setFont("Helvetica", 9)
ypos = -.2
COFFEE_SHEET_BOTTOM_TEXT = getattr(config, "COFFEE_SHEET_BOTTOM_TEXT", "")
for text in COFFEE_SHEET_BOTTOM_TEXT.split("\n"):
text = text.strip()
canvas.drawString(qr_size + 1. * cm_unit, qr_size - ypos * cm_unit, text)
ypos += .5
# Draw grid
grid_y = height - 2*cm_unit
canvas.line(0, grid_y, width, grid_y)
for name in names:
new_y = grid_y - COFFEE_LINE_HEIGHT * cm_unit
canvas.line(0, grid_y, 0, new_y)
canvas.line(width, grid_y, width, new_y)
box_start = COFFEE_NAME_FIELD_WIDTH * cm_unit
box_width = (width - box_start) / COFFEE_BOXES_PER_LINE
pre_draw_crosses = pre_cross_dict.get(name, 0)
for i in range(int((width - box_start) / box_width)):
canvas.line(box_start, grid_y, box_start, new_y)
if pre_draw_crosses > 0:
pre_draw_crosses -= 1
cross_margin = 2
canvas.line(box_start + cross_margin, grid_y - cross_margin, box_start + box_width - cross_margin, new_y + cross_margin)
canvas.line(box_start + cross_margin, new_y + cross_margin, box_start + box_width - cross_margin, grid_y - cross_margin)
box_start += box_width
canvas.drawString(.2 * cm_unit, grid_y - (COFFEE_LINE_HEIGHT - .1) * cm_unit, name)
grid_y = new_y
canvas.line(0, grid_y, width, grid_y)
canvas.showPage()
if not had_canvas:
canvas.save()
return outfile
def process_canvas(self, canvas, f):
canvas.save(filename=f)
#
# Colorindo elementos
#
# Parâmetros (R, G, B)
canvas.setFillColorRGB(255, 0, 0)
canvas.rect(60, 300, 50, 100, stroke=0, fill=1)
# Somente uma escala para tons de cinza (0 - 1)
canvas.setFillGray(0.9)
canvas.rect(180, 300, 50, 100, stroke=0, fill=1)
# Alterando a cor da borda
canvas.setStrokeColorRGB(0, 0, 255)
canvas.rect(300, 300, 50, 100, stroke=1, fill=1)
#
# Utilizando o HexCode
#
from reportlab.lib.colors import HexColor
canvas.setFillColor(HexColor('#ff8100'))
canvas.rect(420, 300, 50, 100, stroke=1, fill=1)
canvas.save()
def GET(self):
data = web.input()
cid = data['cid']
tid = data['tid']
canvas.setLineWidth(.3)
canvas.setFont('Helvetica', 12)
canvas.drawString(200,750,'FOUNDATION CONFIGURATION')
# canvas.line(200,750,580,747)
canvas.setFont('Helvetica', 8)
canvas.drawString(50,700,'SERVER:')
get_customer_specific_task = model.get_history_by_taskid(cid,tid)
configuration = json.loads(get_customer_specific_task[0]['json_data'])
canvas.drawString(150,700,configuration['foundation']['server'])
canvas.drawString(50,680,'Cluster External IP: ')
canvas.drawString(180,680,configuration['foundation']['restInput']['cluster_external_ip'])
canvas.drawString(250,680,'Redundancy Factor:')
canvas.drawString(420,680,configuration['foundation']['restInput']['redundancy_factor'])
canvas.drawString(50,660,'Ipmi Netmask: ')
canvas.drawString(130,660,configuration['foundation']['restInput']['ipmi_netmask'])
canvas.drawString(210,660,'Cvm Netmask:')
canvas.drawString(290,660,configuration['foundation']['restInput']['cvm_netmask'])
canvas.drawString(380,660,'Hypervisor Netmask:')
canvas.drawString(510,660,configuration['foundation']['restInput']['hypervisor_netmask'])
canvas.drawString(50,630,'CVM Netmask: ')
canvas.drawString(180,630,configuration['foundation']['restInput']['cvm_netmask'])
canvas.drawString(280,630,'Cvm Gateway:')
canvas.drawString(420,630,configuration['foundation']['restInput']['cvm_gateway'])
canvas.drawString(50,600,'Cvm Dns Servers: ')
canvas.drawString(180,600,configuration['foundation']['restInput']['cvm_dns_servers'])
canvas.drawString(280,600,'Cvm Ntp Servers:')
canvas.drawString(420,600,configuration['foundation']['restInput']['cvm_ntp_servers'])
canvas.drawString(50,570,'Hypervisor ntp servers: ')
canvas.drawString(180,570,configuration['foundation']['restInput']['hypervisor_ntp_servers'])
canvas.drawString(280,570,'Hypervisor Nameserver:')
canvas.drawString(420,570,configuration['foundation']['restInput']['hypervisor_nameserver'])
canvas.drawString(50,530,'Hypervisor Password: '******'foundation']['restInput']['hypervisor_password'])
canvas.drawString(280,530,'Hypervisor Gateway:')
canvas.drawString(420,530,configuration['foundation']['restInput']['hypervisor_gateway'])
canvas.drawString(50,500,'Ipmi Password: '******'foundation']['restInput']['ipmi_password'])
canvas.drawString(280,500,'Ipmi User:'******'foundation']['restInput']['ipmi_user'])
canvas.drawString(50,470,'Ipmi Netmask: ')
canvas.drawString(180,470,configuration['foundation']['restInput']['ipmi_netmask'])
canvas.drawString(280,470,'Ipmi Gateway:')
canvas.drawString(420,470,configuration['foundation']['restInput']['ipmi_gateway'])
canvas.drawString(50,430,'BLOCKS')
height = 400
blocknum = 1
nodnum = 1
for oneblock in configuration['foundation']['restInput']['blocks']:
canvas.drawString(50,height,'BLOCKS'+ str(blocknum))
if oneblock['nodes'][0]:
for onenode in oneblock['nodes']:
height = height - 20
canvas.drawString(80,height,'Ipmi Mac: ')
canvas.drawString(180,height,onenode['ipmi_mac'])
canvas.drawString(280,height,'Ipv6 address:')
canvas.drawString(420,height,onenode['ipv6_address'])
height = height - 20
canvas.drawString(80,height,'Image Now: ')
canvas.drawString(180,height,str(onenode['image_now']))
canvas.drawString(280,height,'Node Position:')
canvas.drawString(420,height,onenode['node_position'])
height = height - 20
canvas.drawString(80,height,'Image Successful: ')
canvas.drawString(180,height,onenode['image_successful'])
canvas.drawString(280,height,'Ipmi Configured:')
canvas.drawString(420,height,str(onenode['ipmi_configured']))
height = height - 20
canvas.drawString(80,height,'Hypervisor Hostname: ')
canvas.drawString(220,height,onenode['hypervisor_hostname'])
canvas.drawString(310,height,'Cvm gb ram:')
canvas.drawString(420,height,str(onenode['cvm_gb_ram']))
height = height - 20
canvas.drawString(80,height,'Ipmi Ip: ')
canvas.drawString(180,height,onenode['ipmi_ip'])
canvas.drawString(280,height,'Cluster Member:')
canvas.drawString(420,height,str(onenode['cluster_member']))
height = height - 20
canvas.drawString(80,height,'Cvm Ip: ')
canvas.drawString(180,height,onenode['cvm_ip'])
canvas.drawString(280,height,'Ipmi configure now:')
canvas.drawString(420,height,str(onenode['ipmi_configure_now']))
height = height - 40
if height < 100:
height = 750
canvas.showPage()
canvas.setFont('Helvetica', 8)
canvas.drawString(80,height,'Hypervisor Ip: ')
canvas.drawString(180,height,onenode['hypervisor_ip'])
canvas.drawString(280,height,'Ipv6 Interface:')
canvas.drawString(420,height,onenode['ipv6_interface'])
nodnum = nodnum + 1
height = height - 20
blocknum = blocknum +1
canvas.setFont('Helvetica', 12)
canvas.drawString(200,height,'PRISM CONFIGURATION')
# canvas.line(200,750,580,747)
canvas.setFont('Helvetica', 8)
if configuration['prismDetails']:
height = height - 20
prismDetails = configuration['prismDetails']
canvas.drawString(80,height,'Rest url: ')
canvas.drawString(180,height,prismDetails['restURL'])
height = height - 20
canvas.drawString(80,height,'Container:')
canvas.drawString(180,height,prismDetails['container']['name'])
height = height - 20
prismDetails = configuration['prismDetails']
canvas.drawString(80,height,'UserName: '******'authentication']['username'])
height = height - 20
canvas.drawString(80,height,'Password:'******'authentication']['password'])
height = height - 20
canvas.drawString(80,height,'Storage Pool:')
canvas.drawString(180,height,prismDetails['storagepool']['name'])
height = height - 20
canvas.setFont('Helvetica', 12)
canvas.drawString(200,height,'Vcenter CONFIGURATION')
# canvas.line(200,750,580,747)
canvas.setFont('Helvetica', 8)
if configuration['vCenterConf']:
height = height - 20
prismDetails = configuration['vCenterConf']
canvas.drawString(80,height,'Host: ')
canvas.drawString(180,height,prismDetails['host'])
height = height - 20
canvas.drawString(80,height,'User:'******'user'])
height = height - 20
canvas.drawString(80,height,'password: '******'password'])
height = height - 20
canvas.drawString(80,height,'port:')
canvas.drawString(180,height,prismDetails['port'])
height = height - 20
canvas.drawString(80,height,'datacenter: ')
canvas.drawString(180,height,prismDetails['datacenter'])
height = height - 20
canvas.drawString(80,height,'datacenter_reuse_if_exist:')
canvas.drawString(180,height,prismDetails['datacenter_reuse_if_exist'])
height = height - 20
canvas.drawString(80,height,'cluster: ')
canvas.drawString(180,height,prismDetails['cluster'])
height = height - 20
canvas.drawString(80,height,'cluster_reuse_if_exist:')
canvas.drawString(180,height,prismDetails['cluster_reuse_if_exist'])
height = height - 20
canvas.drawString(80,height,'HOSTS: ')
for onehost in prismDetails['hosts']:
canvas.drawString(120,height,'IP: ')
canvas.drawString(180,height,onehost['ip'])
canvas.drawString(280,height,'user:'******'user'])
canvas.drawString(420,height,'Password: '******'pwd']))
height = height - 20
canvas.save()
web.header('Content-Type', 'application/pdf')
web.header('Content-Disposition','filename=form.pdf')
data = open('form.pdf', 'rb').read()
return data
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 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):
if questionnaire_ids is not None:
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)
elif survey.defs.style == "custom":
# Only draw corner marker
draw_corner_marks(survey, canvas)
pass
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()
if sheets == 1:
# Shortcut if we only have one sheet.
# In this case form data in the PDF will *not* break, in
# the other code path it *will* break.
print _(u"pdftk: Overlaying the original PDF with the markings.")
subprocess.call(
["pdftk", survey.path("questionnaire.pdf"), "stamp", survey.path("tmp.pdf"), "output", output_filename]
)
else:
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),
]
)
if sheets == 1:
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),
]
)
else:
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 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 pdfFunction(author = 'Jon Barnes' ,
lab = 'Cascade Meteorite Lab' ,
savedFileName = 'pdfTest1'):
####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(.3)
#
canvas.setFont('Helvetica', 12)
########################
#Page 1
##Layer 1 - Header Info : Meteorite lab, Thin Section, User, Date
########################
############
#Layer 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')
#
##Info on the image
#
canvas.drawString(300,750, "Backscatter Electron Image from " + imageFileName)
canvas.line(280,747,580,747)
#
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
#bseTif = '/home/jon/Desktop/gsoc2014/semData2014/CML0615(13).tif'
#canvas.drawImage(bseTif, 50, 400, width=10*cm, height=10*cm, preserveAspectRatio=True)
#Label Image
canvas.drawString(50,400, "BSE Image of " + imageFileName)
#### BSE Tiff Image Histogram
#Image of BSE Histogram
#bseHist = '/home/jon/Desktop/BSEHistogramFirstLast3Removed.png'
#canvas.drawImage(bseHist, 400, 400, width=7*cm, height=7*cm, preserveAspectRatio=True)
#Label Image
canvas.drawString(400,400, "BSE Histogram from " + imageFileName)
##Save the Page, make new page
canvas.showPage()
print 'writing page 1'
########################
#Page 2
##Layer 1 - Crop BSE and BSE Hist
##Layer 2 - Countour and Heat Map
##Layer 3 - Hist of Size and Boxplot of Values
########################
############
####Layer 1 - Crop BSE and BSE Hist
############
#
## BSE Cropped Image
#Image of BSE Tiff cropped
#bseContour = '/home/jon/Desktop/cropped bse image.png'
#canvas.drawImage(bseContour, 50, 500, width=10*cm, height=10*cm, preserveAspectRatio=True)
#Label Image
canvas.drawString(50,500, "BSE Image subsection of " + imageFileName)
#
##BSE Hist
#bseHistCrop = '/home/jon/Desktop/bseDistOfCrop.png'
#canvas.drawImage(bseHistCrop, 350, 600, width=7*cm, height=7*cm, preserveAspectRatio=True)
#Label Image
canvas.drawString(350,600, "BSE Histogram from")
canvas.drawString(350,590, imageFileName + " Cropped Area")
############
####Layer 2 - Countour and Heat Map
############
#
## BSE Tiff Contours
#Image of BSE Tiff
#bseContour = '/home/jon/Desktop/testContour.png'
#canvas.drawImage(bseContour, 50, 300, width=10*cm, height=10*cm, preserveAspectRatio=True)
#Label Image
canvas.drawString(50,300, "BSE Image Contours for")
canvas.drawString(50,290, "subsection of " + imageFileName)
canvas.drawString(50,280, "Using " + str(n_clusters) + " number of grains")
#
#
#### BSE Tiff BSE Mineral Heat Map
#Image of BSE Mineral Heat Map
#bseMineralShade = '/home/jon/Desktop/testShade.png'
#canvas.drawImage(bseMineralShade, 350, 300, width=7*cm, height=7*cm, preserveAspectRatio=True)
#Label Image
canvas.drawString(350,300, "BSE Shaded map from subsection of " + imageFileName)
############
####Layer 3 - Hist of Size and Boxplot of Values
############
#### Histogram of Sizes of Mineral Group
#bseMineralShade = '/home/jon/Desktop/pixelSizeOfMineralGroups.png'
#canvas.drawImage(bseMineralShade, 50, 100, width=7*cm, height=7*cm, preserveAspectRatio=True)
#Label Image
canvas.drawString(50,100, "Histogram of Sizes of Mineral Group")
#
#
#### Boxplot of BSE values for Mineral Group
#bseMineralShade = '/home/jon/Desktop/Scatter Plot of BSE values for Mineral Groups.png'
#canvas.drawImage(bseMineralShade, 350, 100, width=7*cm, height=7*cm, preserveAspectRatio=True)
#Label Image
canvas.drawString(350,100, "Scatter Plot of BSE values for Mineral Group" )
canvas.drawString(350,90, "Hope to turn into Boxplot Later")
#
#
##Save the Page, make new page
canvas.showPage()
print 'writing page 2'
print 'done'
####Save the PDF
canvas.save()
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 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 create_frontpdf(toaddress_full,fromaddress_full = from_add):
# (to_name, to_street_address, to_city, to_state, to_zip_code, from_name, from_street_address, from_city, from_state, from_zip_code):
#
#
# tempaddr1 = {
# 'name': 'Siddharth Saha',
# 'address_line': '220 William T Morrissey, Sunset Town',
# 'address_city': 'Boston',
# 'address_state': 'MA',
# 'address_country': 'US',
# 'address_zip': '02125'
# }
to_name = toaddress_full["name"]
to_street_address = toaddress_full["address_line1"]
to_city = toaddress_full["address_city"]
to_state = toaddress_full["address_state"]
to_zip_code = toaddress_full["address_zip"]
from_name = fromaddress_full["name"]
from_street_address = fromaddress_full["address_line1"]
from_city = fromaddress_full["address_city"]
from_state = fromaddress_full["address_state"]
from_zip_code = fromaddress_full["address_zip"]
from reportlab.pdfgen import canvas
from reportlab.lib.units import inch
from reportlab.lib.colors import black, white
#CREATE THE FRONT SIDE
canvas = canvas.Canvas("PC_front.pdf")
canvas.setLineWidth(.3)
canvas.setFont('Helvetica', 10)
canvas.setPageSize((6*inch, 4*inch))
#Border and Stamp
canvas.setFillColor(white)
canvas.rect(0.1*inch, 0.1*inch, 5.8*inch, 3.8*inch, stroke=1, fill=1)
#canvas.rect(4.8*inch, 2.8*inch, 0.85*inch, 0.85*inch, stroke=1, fill=1)
#Center Line
canvas.line(3*inch, 0.5*inch, 3*inch, 3.5*inch)
#To Address Lines (5 nos)
canvas.setFillColor(black)
canvas.drawString(3.4*inch, 3.4*inch,'To,')
canvas.drawString(3.5*inch, 3.2*inch,to_name)
canvas.drawString(3.5*inch, 3.0*inch,to_street_address)
canvas.drawString(3.5*inch, 2.8*inch,to_city)
canvas.drawString(3.5*inch, 2.6*inch,to_state)
canvas.drawString(3.5*inch, 2.4*inch,to_zip_code)
#From Address Lines (5 nos)
canvas.setFillColor(black)
canvas.drawString(3.4*inch, 2.0*inch,'From,')
canvas.drawString(3.5*inch, 1.8*inch,from_name)
canvas.drawString(3.5*inch, 1.6*inch,from_street_address)
canvas.drawString(3.5*inch, 1.4*inch,from_city)
canvas.drawString(3.5*inch, 1.2*inch,from_state)
canvas.drawString(3.5*inch, 1.0*inch,from_zip_code)
canvas.setFont('Helvetica', 18)
canvas.drawString(0.5*inch, 2.5*inch,'Many Many Happy ')
canvas.drawString(0.5*inch, 2.0*inch,'Returns of the Day')
canvas.save()
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 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()
