Python Canvas.setCreator方法代码示例

# 需要导入模块: from reportlab.pdfgen.canvas import Canvas [as 别名]
# 或者: from reportlab.pdfgen.canvas.Canvas import setCreator [as 别名]
    def overlay_hocr_page(self, dpi, hocr_filename, img_filename):
        hocr_dir, hocr_basename = os.path.split(hocr_filename)
        img_dir, img_basename = os.path.split(img_filename)
        logging.debug("hocr_filename:%s, hocr_dir:%s, hocr_basename:%s" % (hocr_filename, hocr_dir, hocr_basename))
        assert(img_dir == hocr_dir)

        #basename = hocr_basename.split('.')[0]
        basename = os.path.splitext(hocr_basename)[0]
        pdf_filename = os.path.join("text_%s_ocr.pdf" % (basename))

        # Switch to the hocr directory to make this easier
        cwd = os.getcwd()
        if hocr_dir != "":
            os.chdir(hocr_dir)

        with open(pdf_filename, "wb") as f:
            logging.info("Overlaying hocr and creating text pdf %s" % pdf_filename)
            pdf = Canvas(f, pageCompression=1)
            pdf.setCreator('pypdfocr')
            pdf.setTitle(os.path.basename(hocr_filename))
            pdf.setPageCompression(1)

            width, height, dpi_jpg = self._get_img_dims(img_basename)
            pdf.setPageSize((width,height))
            logging.info("Page width=%f, height=%f" % (width, height))

            pg_num = 1

            logging.info("Adding text to page %s" % pdf_filename)
            self.add_text_layer(pdf,hocr_basename,pg_num,height,dpi)
            pdf.showPage()
            pdf.save()

        os.chdir(cwd)
        return os.path.join(hocr_dir, pdf_filename)

# 需要导入模块: from reportlab.pdfgen.canvas import Canvas [as 别名]
# 或者: from reportlab.pdfgen.canvas.Canvas import setCreator [as 别名]
 def process_pdf(self, image_data, hocr_data, pdf_filename):
     """Utility function if you'd rather get the PDF data back instead of save it automatically."""
     pdf = Canvas(pdf_filename, pageCompression=1)
     pdf.setCreator('hocr-tools')
     pdf.setPageSize((self.width, self.height))
     pdf.drawImage(image_data, 0, 0, width=self.width, height=self.height)
     pdf = self.add_text_layer(pdf, hocr_data)
     pdf_data = pdf.getpdfdata()
     return pdf_data

# 需要导入模块: from reportlab.pdfgen.canvas import Canvas [as 别名]
# 或者: from reportlab.pdfgen.canvas.Canvas import setCreator [as 别名]
def create_new_pdf(playground, width, height):
  import reportlab.rl_config
  from reportlab.pdfgen.canvas import Canvas
  pdf = Canvas(os.path.join(playground, "book.pdf"),
               pagesize=(width, height), pageCompression=1)
  pdf.setCreator('cheesegrater')
  pdf.setTitle(os.path.basename(playground))
  load_font()
  return pdf

# 需要导入模块: from reportlab.pdfgen.canvas import Canvas [as 别名]
# 或者: from reportlab.pdfgen.canvas.Canvas import setCreator [as 别名]
    def overlay_hocr(self, dpi, hocr_filename):
        hocr_dir, hocr_basename = os.path.split(hocr_filename)
        logging.debug("hocr_filename:%s, hocr_dir:%s, hocr_basename:%s" % (hocr_filename, hocr_dir, hocr_basename))
        basename = hocr_basename.split('.')[0]
        pdf_filename = os.path.join("%s_ocr.pdf" % (basename))
        # Switch to the hocr directory to make this easier

        cwd = os.getcwd()
        if hocr_dir != "":
            os.chdir(hocr_dir)

        with open(pdf_filename, "wb") as f:
            logging.info("Overlaying hocr and creating final %s" % pdf_filename)
            pdf = Canvas(f, pageCompression=1)
            pdf.setCreator('pyocr')
            pdf.setTitle(os.path.basename(hocr_filename))
            logging.info("Analyzing OCR and applying text to PDF...")

            pdf.setPageCompression(1)
            logging.info("Searching for %s" % ("%s*.jpg" % basename))

            for jpg_file in glob.glob("%s*.jpg" % basename):

                jpg = Image.open(jpg_file)
                w,h = jpg.size
                dpi_jpg = jpg.info['dpi']
                width = w*72.0/dpi_jpg[0]
                height = h*72.0/dpi_jpg[1]
                del jpg

                pdf.setPageSize((width,height))
                logging.info("Adding page image %s" % jpg_file)
                logging.info("Page width=%f, height=%f" % (width, height))
                pdf.drawImage(jpg_file,0,0, width=width, height=height)
                # Get the page number
                pg_num = int(jpg_file.split(basename)[1].split('.')[0])
                logging.info("Adding text to page %d" % pg_num)
                self.add_text_layer(pdf, hocr_basename,pg_num,height,dpi)
                pdf.showPage()
                os.remove(jpg_file)

            pdf.save()
        logging.info("Created OCR'ed pdf as %s" % (pdf_filename))

	# Now we have to fix up stuff on windows because of reportlab
	# adding \r\r\n on each line (instead of \r\n)
	f = open(pdf_filename, "rb")
	s = str(f.read())
	f.close()
	#s = s.replace('\r\r\n', '\r\n')
	#s = re.sub("\r\r\n", "\r\n", s)
	#f = open(pdf_filename, "wb")
	#f.write(s)
	#f.close()
        os.chdir(cwd)
        return os.path.join(hocr_dir,pdf_filename)

# 需要导入模块: from reportlab.pdfgen.canvas import Canvas [as 别名]
# 或者: from reportlab.pdfgen.canvas.Canvas import setCreator [as 别名]
 def render(self, path):
     canvas = Canvas(path, pagesize=A4, pageCompression=1)
     canvas.setTitle(self.title)
     canvas.setSubject(self.subject)
     canvas.setAuthor(self.author)
     canvas.setCreator(self.creator)
     canvas._doc.info.producer = self.creator
     self.canvas = canvas
     self.render_pages()
     self.canvas.save()

# 需要导入模块: from reportlab.pdfgen.canvas import Canvas [as 别名]
# 或者: from reportlab.pdfgen.canvas.Canvas import setCreator [as 别名]
    def draw(self, invoice, stream):
        """ Draws the invoice """
        # embed unicode font
        pdfmetrics.registerFont(
            TTFont('FreeSans', join(STATIC_DIR, 'FreeSans.ttf'))
        )
        addMapping('FreeSans', 0, 0, 'FreeSans')

        self.baseline = -2*cm

        canvas = Canvas(stream, pagesize=A4)
        canvas.setCreator("django-invoice")
        canvas.setAuthor(smart_text(invoice.contractor))
        canvas.setTitle(smart_text(invoice))

        canvas.translate(0, 29.7*cm)
        canvas.setFont(self.FONT_NAME, 10)

        canvas.saveState()
        self.draw_header(invoice, canvas)
        canvas.restoreState()

        canvas.saveState()
        self.draw_subscriber(invoice, canvas)
        canvas.restoreState()

        canvas.saveState()
        self.draw_contractor(invoice, canvas)
        canvas.restoreState()

        canvas.saveState()
        self.draw_info(invoice, canvas)
        canvas.restoreState()

        canvas.saveState()
        self.draw_items(invoice, canvas)
        canvas.restoreState()

        canvas.saveState()
        self.draw_footer(invoice, canvas)
        canvas.restoreState()

        canvas.showPage()
        canvas.save()
        canvas = None
        self.baseline = 0

# 需要导入模块: from reportlab.pdfgen.canvas import Canvas [as 别名]
# 或者: from reportlab.pdfgen.canvas.Canvas import setCreator [as 别名]
 def run(self):
     try:
         filename = self.filename + '.pdf'
         if os.path.exists(filename):
             raise Exception('File already exists')
         canvas = Canvas(filename, pageCompression=1)
         canvas.setCreator('Scanvark')
         canvas.setTitle('Scanned document')
         i = 0
         count = len(self.pages)
         for i, page in enumerate(self.pages):
             self._progress_callback(self, i, count)
             w, h = [a * 72 / page.resolution for a in page.size]
             canvas.setPageSize((w, h))
             reader = ImageReader(page.open_jpeg())
             canvas.drawImage(reader, 0, 0, width=w, height=h)
             canvas.showPage()
         self._progress_callback(self, i, count)
         canvas.save()
     except Exception, e:
         self._error_callback(self, str(e))

# 需要导入模块: from reportlab.pdfgen.canvas import Canvas [as 别名]
# 或者: from reportlab.pdfgen.canvas.Canvas import setCreator [as 别名]
class PDFCreator(object):
    appName = "txt2pdf (version 1.0)"

    def __init__(self, args, margins):
        pageWidth, pageHeight = reportlab.lib.pagesizes.__dict__[args.media]
        if args.landscape:
            pageWidth, pageHeight = reportlab.lib.pagesizes.landscape(
                (pageWidth, pageHeight))
        self.author = args.author
        self.title = args.title
        self.keywords = args.keywords
        self.subject = args.subject
        self.canvas = Canvas(args.output, pagesize=(pageWidth, pageHeight))
        self.canvas.setCreator(self.appName)
        if len(args.author) > 0:
            self.canvas.setAuthor(args.author)
        if len(args.title) > 0:
            self.canvas.setTitle(args.title)
        if len(args.subject) > 0:
            self.canvas.setSubject(args.subject)
        if len(args.keywords) > 0:
            self.canvas.setKeywords(args.keywords)
        self.fontSize = args.font_size
        if args.font not in ('Courier'):
            self.font = 'myFont'
            pdfmetrics.registerFont(TTFont('myFont', args.font))
        else:
            self.font = args.font
        self.kerning = args.kerning
        self.margins = margins
        self.leading = (args.extra_vertical_space + 1.2) * self.fontSize
        self.linesPerPage = int(
            (self.leading + pageHeight
             - margins.top - margins.bottom - self.fontSize) / self.leading)
        self.lppLen = len(str(self.linesPerPage))
        fontWidth = self.canvas.stringWidth(
            ".", fontName=self.font, fontSize=self.fontSize)
        self.lineNumbering = args.line_numbers
        if self.lineNumbering:
            margins.adjustLeft(fontWidth * (self.lppLen + 2))
        contentWidth = pageWidth - margins.left - margins.right
        self.charsPerLine = int(
            (contentWidth + self.kerning) / (fontWidth + self.kerning))
        self.top = pageHeight - margins.top - self.fontSize
        self.filename = args.filename
        self.verbose = not args.quiet
        self.breakOnBlanks = args.break_on_blanks
        self.encoding = args.encoding
        self.pageNumbering = args.page_numbers
        if self.pageNumbering:
            self.pageNumberPlacement = \
               (pageWidth / 2, margins.bottom / 2)

    def _process(self, data):
        flen = os.fstat(data.fileno()).st_size
        lineno = 0
        read = 0
        for line in data:
            lineno += 1
            if sys.version_info.major == 2:
                read += len(line)
                yield flen == \
                    read, lineno, line.decode(self.encoding).rstrip('\r\n')
            else:
                read += len(line.encode(self.encoding))
                yield flen == read, lineno, line.rstrip('\r\n')

    def _readDocument(self):
        with open(self.filename, 'r') as data:
            for done, lineno, line in self._process(data):
                if len(line) > self.charsPerLine:
                    self._scribble(
                        "Warning: wrapping line %d in %s" %
                        (lineno + 1, self.filename))
                    while len(line) > self.charsPerLine:
                        yield done, line[:self.charsPerLine]
                        line = line[self.charsPerLine:]
                yield done, line

    def _newpage(self):
        textobject = self.canvas.beginText()
        textobject.setFont(self.font, self.fontSize, leading=self.leading)
        textobject.setTextOrigin(self.margins.left, self.top)
        textobject.setCharSpace(self.kerning)
        if self.pageNumbering:
            self.canvas.drawString(
                self.pageNumberPlacement[0],
                self.pageNumberPlacement[1],
                str(self.canvas.getPageNumber()))
        return textobject

    def _scribble(self, text):
        if self.verbose:
            sys.stderr.write(text + os.linesep)

    def generate(self):
        self._scribble(
            "Writing '%s' with %d characters per "
            "line and %d lines per page..." %
            (self.filename, self.charsPerLine, self.linesPerPage)
#.........这里部分代码省略.........

# 需要导入模块: from reportlab.pdfgen.canvas import Canvas [as 别名]
# 或者: from reportlab.pdfgen.canvas.Canvas import setCreator [as 别名]
    def overlay_hocr(self, dpi, hocr_filename):
        hocr_dir, hocr_basename = os.path.split(hocr_filename)
        logging.debug("hocr_filename:%s, hocr_dir:%s, hocr_basename:%s" % (hocr_filename, hocr_dir, hocr_basename))
        basename = hocr_basename.split('.')[0]
        pdf_filename = os.path.join("%s_ocr.pdf" % (basename))
        # Switch to the hocr directory to make this easier

        cwd = os.getcwd()
        if hocr_dir != "":
            os.chdir(hocr_dir)

        with open(pdf_filename, "wb") as f:
            logging.info("Overlaying hocr and creating final %s" % pdf_filename)
            pdf = Canvas(f, pageCompression=1)
            pdf.setCreator('pyocr')
            pdf.setTitle(os.path.basename(hocr_filename))
            logging.info("Analyzing OCR and applying text to PDF...")

            pdf.setPageCompression(1)
            logging.info("Searching for %s" % ("%s*.jpg" % basename))

            # Find all the jpg files, and sort them by page number
            jpg_files = []

            # Make the jpg search a little bit more robust
            for f in os.listdir("."):
                if re.match(r"^%s_\d+\.%s$" % (basename, self.gs.img_file_ext), f):
                    jpg_files.append(f)
            #jpg_files = glob.glob("%s*.jpg" % basename)
            jpg_files.sort(key=self.natural_keys)

            if len(jpg_files) == 0:
                logging.warn("No jpg files found to embed in PDF.  Please check this!")
            # We know the following loop will iterate in page order 
            # because we sorted the jpg filenames
            for i, jpg_file in enumerate(jpg_files):

                jpg = Image.open(jpg_file)
                w,h = jpg.size
                dpi_jpg = jpg.info['dpi']
                width = w*72.0/dpi_jpg[0]
                height = h*72.0/dpi_jpg[1]
                del jpg

                pdf.setPageSize((width,height))
                logging.info("Adding page image %s" % jpg_file)
                logging.info("Page width=%f, height=%f" % (width, height))
                pdf.drawImage(jpg_file,0,0, width=width, height=height)
                # Get the page number
                pg_num = i+1
                # Do a quick assert to make sure our sorted page number matches
                # what's embedded in the filename
                file_pg_num = int(jpg_file.split(basename+"_")[1].split('.')[0])
                if file_pg_num != pg_num:
                    logging.warn("Page number from file (%d) does not match iteration (%d)... continuing anyway" % (file_pg_num, pg_num))

                logging.info("Adding text to page %d" % pg_num)
                self.add_text_layer(pdf, hocr_basename,pg_num,height,dpi)
                pdf.showPage()
                os.remove(jpg_file)

            pdf.save()
        logging.info("Created OCR'ed pdf as %s" % (pdf_filename))

	# Now we have to fix up stuff on windows because of reportlab
	# adding \r\r\n on each line (instead of \r\n)
	f = open(pdf_filename, "rb")
	s = str(f.read())
	f.close()
	#s = s.replace('\r\r\n', '\r\n')
	#s = re.sub("\r\r\n", "\r\n", s)
	#f = open(pdf_filename, "wb")
	#f.write(s)
	#f.close()
        os.chdir(cwd)
        return os.path.join(hocr_dir,pdf_filename)

# 需要导入模块: from reportlab.pdfgen.canvas import Canvas [as 别名]
# 或者: from reportlab.pdfgen.canvas.Canvas import setCreator [as 别名]
    def overlay_hocr_old(self, dpi, hocr_filename):
        hocr_dir, hocr_basename = os.path.split(hocr_filename)
        logging.debug("hocr_filename:%s, hocr_dir:%s, hocr_basename:%s" % (hocr_filename, hocr_dir, hocr_basename))
        basename = hocr_basename.split('.')[0]
        pdf_filename = os.path.join("%s_ocr.pdf" % (basename))
        text_pdf_filename = pdf_filename + ".tmp"

        # Switch to the hocr directory to make this easier
        cwd = os.getcwd()
        if hocr_dir != "":
            os.chdir(hocr_dir)

        with open(text_pdf_filename, "wb") as f:
            logging.info("Overlaying hocr and creating text pdf %s" % text_pdf_filename)
            pdf = Canvas(f, pageCompression=1)
            pdf.setCreator('pyocr')
            pdf.setTitle(os.path.basename(hocr_filename))
            logging.info("Analyzing OCR and applying text to PDF...")

            pdf.setPageCompression(1)
            logging.info("Searching for %s" % ("%s*.jpg" % basename))

            # Find all the jpg files, and sort them by page number
            img_files = []

            # Make the jpg search a little bit more robust
            for f in os.listdir("."):
                if re.match(r"^%s_\d+\.%s$" % (basename, self.gs.img_file_ext), f):
                    img_files.append(f)
            img_files.sort(key=self.natural_keys)

            if len(img_files) == 0:
                logging.warn("No %s files found to embed in PDF.  Please check this!" % self.gs.img_file_ext)

            # We know the following loop will iterate in page order 
            # because we sorted the jpg filenames
            for i, img_file in enumerate(img_files):

                jpg = Image.open(img_file)
                w,h = jpg.size
                dpi_jpg = jpg.info['dpi']
                width = w*72.0/dpi_jpg[0]
                height = h*72.0/dpi_jpg[1]
                del jpg

                pdf.setPageSize((width,height))
                logging.info("Adding page image %s" % img_file)
                logging.info("Page width=%f, height=%f" % (width, height))
                #pdf.drawImage(img_file,0,0, width=width, height=height)
                # Get the page number
                pg_num = i+1
                # Do a quick assert to make sure our sorted page number matches
                # what's embedded in the filename
                file_pg_num = int(img_file.split(basename+"_")[1].split('.')[0])
                if file_pg_num != pg_num:
                    logging.warn("Page number from file (%d) does not match iteration (%d)... continuing anyway" % (file_pg_num, pg_num))

                logging.info("Adding text to page %d" % pg_num)
                self.add_text_layer(pdf, hocr_basename,pg_num,height,dpi)
                pdf.showPage()
                os.remove(img_file)

            pdf.save()

        return os.path.join(hocr_dir,pdf_filename)

# 需要导入模块: from reportlab.pdfgen.canvas import Canvas [as 别名]
# 或者: from reportlab.pdfgen.canvas.Canvas import setCreator [as 别名]
            ypos += 24
            c.save()
        
    # Handle filename
    if args.filename is not None:
        fname = args.filename
    else:
        fname = args.year + '-' + args.month + '.pdf'

    #    
    # Draw the calendar
    #

    # Initialize PDF output
    c = Canvas(fname, pagesize=landscape(A4))
    c.setCreator("PyCalendarGen 0.9.5 - github.com/jwarlander/pycalendargen")
    year = int(args.year)
    month = args.month

    # Draw cover page
    if args.cover_image is not None:
      drawCoverPage(c, args.cover_image)

    # Set up iterator for monthly images
    image_files = []
    if args.monthly_image_dir is not None:
      image_dir = args.monthly_image_dir
      image_files = [os.path.join(image_dir, f) for f in os.listdir(image_dir) 
                     if os.path.isfile(os.path.join(image_dir, f))]
    image_files = itertools.cycle(image_files)

# 需要导入模块: from reportlab.pdfgen.canvas import Canvas [as 别名]
# 或者: from reportlab.pdfgen.canvas.Canvas import setCreator [as 别名]
    def _on_first_page(self, canvas: Canvas, doc):
        canvas.setCreator('pretix.eu')
        canvas.setTitle(pgettext('invoice', 'Invoice {num}').format(num=self.invoice.number))

        canvas.saveState()
        canvas.setFont('OpenSans', 8)
        canvas.drawRightString(self.pagesize[0] - 20 * mm, 10 * mm, pgettext("invoice", "Page %d") % (doc.page,))

        for i, line in enumerate(self.invoice.footer_text.split('\n')[::-1]):
            canvas.drawCentredString(self.pagesize[0] / 2, 25 + (3.5 * i) * mm, line.strip())

        textobject = canvas.beginText(25 * mm, (297 - 15) * mm)
        textobject.setFont('OpenSansBd', 8)
        textobject.textLine(pgettext('invoice', 'Invoice from').upper())
        canvas.drawText(textobject)

        self._draw_invoice_from(canvas)

        textobject = canvas.beginText(25 * mm, (297 - 50) * mm)
        textobject.setFont('OpenSansBd', 8)
        textobject.textLine(pgettext('invoice', 'Invoice to').upper())
        canvas.drawText(textobject)

        self._draw_invoice_to(canvas)

        textobject = canvas.beginText(125 * mm, (297 - 38) * mm)
        textobject.setFont('OpenSansBd', 8)
        textobject.textLine(pgettext('invoice', 'Order code').upper())
        textobject.moveCursor(0, 5)
        textobject.setFont('OpenSans', 10)
        textobject.textLine(self.invoice.order.full_code)
        canvas.drawText(textobject)

        textobject = canvas.beginText(125 * mm, (297 - 50) * mm)
        textobject.setFont('OpenSansBd', 8)
        if self.invoice.is_cancellation:
            textobject.textLine(pgettext('invoice', 'Cancellation number').upper())
            textobject.moveCursor(0, 5)
            textobject.setFont('OpenSans', 10)
            textobject.textLine(self.invoice.number)
            textobject.moveCursor(0, 5)
            textobject.setFont('OpenSansBd', 8)
            textobject.textLine(pgettext('invoice', 'Original invoice').upper())
            textobject.moveCursor(0, 5)
            textobject.setFont('OpenSans', 10)
            textobject.textLine(self.invoice.refers.number)
        else:
            textobject.textLine(pgettext('invoice', 'Invoice number').upper())
            textobject.moveCursor(0, 5)
            textobject.setFont('OpenSans', 10)
            textobject.textLine(self.invoice.number)
        textobject.moveCursor(0, 5)

        if self.invoice.is_cancellation:
            textobject.setFont('OpenSansBd', 8)
            textobject.textLine(pgettext('invoice', 'Cancellation date').upper())
            textobject.moveCursor(0, 5)
            textobject.setFont('OpenSans', 10)
            textobject.textLine(date_format(self.invoice.date, "DATE_FORMAT"))
            textobject.moveCursor(0, 5)
            textobject.setFont('OpenSansBd', 8)
            textobject.textLine(pgettext('invoice', 'Original invoice date').upper())
            textobject.moveCursor(0, 5)
            textobject.setFont('OpenSans', 10)
            textobject.textLine(date_format(self.invoice.refers.date, "DATE_FORMAT"))
            textobject.moveCursor(0, 5)
        else:
            textobject.setFont('OpenSansBd', 8)
            textobject.textLine(pgettext('invoice', 'Invoice date').upper())
            textobject.moveCursor(0, 5)
            textobject.setFont('OpenSans', 10)
            textobject.textLine(date_format(self.invoice.date, "DATE_FORMAT"))
            textobject.moveCursor(0, 5)

        canvas.drawText(textobject)

        if self.invoice.event.settings.invoice_logo_image:
            logo_file = self.invoice.event.settings.get('invoice_logo_image', binary_file=True)
            ir = ThumbnailingImageReader(logo_file)
            try:
                ir.resize(25 * mm, 25 * mm, 300)
            except:
                logger.exception("Can not resize image")
                pass
            canvas.drawImage(ir,
                             95 * mm, (297 - 38) * mm,
                             width=25 * mm, height=25 * mm,
                             preserveAspectRatio=True, anchor='n',
                             mask='auto')

        def shorten(txt):
            txt = str(txt)
            p = Paragraph(txt.strip().replace('\n', '<br />\n'), style=self.stylesheet['Normal'])
            p_size = p.wrap(65 * mm, 50 * mm)

            while p_size[1] > 2 * self.stylesheet['Normal'].leading:
                txt = ' '.join(txt.replace('…', '').split()[:-1]) + '…'
                p = Paragraph(txt.strip().replace('\n', '<br />\n'), style=self.stylesheet['Normal'])
                p_size = p.wrap(65 * mm, 50 * mm)
            return txt
#.........这里部分代码省略.........