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 __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 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 __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 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 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 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 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 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 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 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 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 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

#.........这里部分代码省略.........
                        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: ')
            canvas.drawString(180,height,prismDetails['authentication']['username'])
            height = height - 20
            canvas.drawString(80,height,'Password:')
            canvas.drawString(180,height,prismDetails['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:')
            canvas.drawString(180,height,prismDetails['user'])           

            height = height - 20
            canvas.drawString(80,height,'password: ')
            canvas.drawString(180,height,prismDetails['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:')
                    canvas.drawString(320,height,onehost['user'])
                    
                    canvas.drawString(420,height,'Password: ')
                    canvas.drawString(480,height,str(onehost['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 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 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")
#.........这里部分代码省略.........