Imagen PDF en documento PDF usando ReportLab (Python)

Question

Guardé algunas parcelas de matplotlib en un formato pdf porque parece ofrecer una mejor calidad. ¿Cómo incluyo la imagen PDF en un documento PDF usando ReportLab? El método de conveniencia Imagen (ruta de archivo) no funciona para este formato.

Gracias.

Answer 1

Uso de reportlab.graphics importar renderPDF

Answer 2

Según ReportLab's FAQ esto sólo es posible con ReportLab PLUS:

¿Puedo usar los gráficos vectoriales en mis archivos PDF?

No, el paquete de código abierto no hace esto. PageCatcher (ver el respuesta anterior) le permite fácilmente incorporar cualquier imagen vectorial por el ahorro de como un archivo PDF y luego usarlo exactamente como lo haría con un archivo de imagen, e Informe lenguaje de marcado acepta archivos PDF junto con JPG, GIF y PNG.

actualización: No he mirado en esto durante un tiempo, pero on the page of pdfrw que dice:

pdfrw puede leer y escribir archivos PDF, y también puede ser utilizado para leer documentos PDF en la que puede luego se usará dentro de ReportLab.

Answer 3

Usted puede utilizar el paquete pdfrw maravillosa junto con reportlab y lo utilizan para pasar objetos de archivos como de figuras matplotlib directamente en un fluido:

Esto fue respondido antes, pero quiero dar un ejemplo mínimo aquí, por favor, también mira aquí: https://stackoverflow.com/a/13870512/4497962

from io import BytesIO 
import matplotlib.pyplot as plt 
from pdfrw import PdfReader, PdfDict 
from pdfrw.buildxobj import pagexobj 
from pdfrw.toreportlab import makerl 
from reportlab.platypus import Flowable 
from reportlab.lib.enums import TA_JUSTIFY,TA_LEFT,TA_CENTER,TA_RIGHT 

class PdfImage(Flowable): 
    """ 
    PdfImage wraps the first page from a PDF file as a Flowable 
    which can be included into a ReportLab Platypus document. 
    Based on the vectorpdf extension in rst2pdf (http://code.google.com/p/rst2pdf/) 

    This can be used from the place where you want to return your matplotlib image 
    as a Flowable: 

     img = BytesIO() 

     fig, ax = plt.subplots(figsize=(canvaswidth,canvaswidth)) 

     ax.plot([1,2,3],[6,5,4],antialiased=True,linewidth=2,color='red',label='a curve') 

     fig.savefig(img,format='PDF') 

     return(PdfImage(img)) 

    """ 

    def __init__(self, filename_or_object, width=None, height=None, kind='direct'): 
     # If using StringIO buffer, set pointer to begining 
     if hasattr(filename_or_object, 'read'): 
      filename_or_object.seek(0) 
      #print("read") 
     self.page = PdfReader(filename_or_object, decompress=False).pages[0] 
     self.xobj = pagexobj(self.page) 

     self.imageWidth = width 
     self.imageHeight = height 
     x1, y1, x2, y2 = self.xobj.BBox 

     self._w, self._h = x2 - x1, y2 - y1 
     if not self.imageWidth: 
      self.imageWidth = self._w 
     if not self.imageHeight: 
      self.imageHeight = self._h 
     self.__ratio = float(self.imageWidth)/self.imageHeight 
     if kind in ['direct','absolute'] or width==None or height==None: 
      self.drawWidth = width or self.imageWidth 
      self.drawHeight = height or self.imageHeight 
     elif kind in ['bound','proportional']: 
      factor = min(float(width)/self._w,float(height)/self._h) 
      self.drawWidth = self._w*factor 
      self.drawHeight = self._h*factor 

    def wrap(self, availableWidth, availableHeight): 
     """ 
     returns draw- width and height 

     convenience function to adapt your image 
     to the available Space that is available 
     """ 
     return self.drawWidth, self.drawHeight 

    def drawOn(self, canv, x, y, _sW=0): 
     """ 
     translates Bounding Box and scales the given canvas 
     """ 
     if _sW > 0 and hasattr(self, 'hAlign'): 
      a = self.hAlign 
      if a in ('CENTER', 'CENTRE', TA_CENTER): 
       x += 0.5*_sW 
      elif a in ('RIGHT', TA_RIGHT): 
       x += _sW 
      elif a not in ('LEFT', TA_LEFT): 
       raise ValueError("Bad hAlign value " + str(a)) 

     #xobj_name = makerl(canv._doc, self.xobj) 
     xobj_name = makerl(canv, self.xobj) 

     xscale = self.drawWidth/self._w 
     yscale = self.drawHeight/self._h 

     x -= self.xobj.BBox[0] * xscale 
     y -= self.xobj.BBox[1] * yscale 

     canv.saveState() 
     canv.translate(x, y) 
     canv.scale(xscale, yscale) 
     canv.doForm(xobj_name) 
     canv.restoreState() 

Answer 4

puede utilizar SVG exportación desde matplotlib y el uso de la biblioteca svglib pitón para incluir gráficos vectoriales en reportlab genera archivos PDF. svglib toma un archivo svg y crea un objeto de dibujo que se puede usar directamente en el informe.

Ver también esta pregunta para más detalles: Generating PDFs from SVG input