Estoy tratando de usar el programa de línea de comandos convertpara llevar un PDF a una imagen (JPEG o PNG). Aquí está uno de los PDF que estoy tratando de convertir.

Quiero que el programa recorte el exceso de espacio en blanco y devuelva una imagen de calidad suficientemente alta para que los superíndices se puedan leer con facilidad.

Este es mi mejor intento actual . Como puede ver, el recorte funciona bien, solo necesito agudizar bastante la resolución. Este es el comando que estoy usando:

convert -trim 24.pdf -resize 500% -quality 100 -sharpen 0x1.0 24-11.jpg

He tratado de tomar las siguientes decisiones conscientes:

• cambiar su tamaño más grande (no tiene efecto en la resolución)
• hacer que la calidad sea lo más alta posible
• use el -sharpen(he intentado un rango de valores)

Cualquier sugerencia, por favor, sobre cómo obtener la resolución de la imagen en el PNG / JPEG final será muy apreciada.

Parece que lo siguiente funciona:

convert           \
   -verbose       \
   -density 150   \
   -trim          \
    test.pdf      \
   -quality 100   \
   -flatten       \
   -sharpen 0x1.0 \
    24-18.jpg

Resulta en la imagen de la izquierda . Compare esto con el resultado de mi comando original ( la imagen de la derecha ):

(Para ver y apreciar realmente las diferencias entre los dos, haga clic derecho en cada uno y seleccione "Abrir imagen en nueva pestaña ..." ).

También tenga en cuenta los siguientes hechos:

• La peor imagen borrosa a la derecha tiene un tamaño de archivo de 1.941.702 Bytes (1.85 MByte). Su resolución es de 3060x3960 píxeles, utilizando un espacio de color RGB de 16 bits.
• La imagen mejor y nítida de la izquierda tiene un tamaño de archivo de 337.879 Bytes (330 kByte). Su resolución es de 758x996 píxeles, utilizando un espacio de color gris de 8 bits.

Por lo tanto, no es necesario cambiar el tamaño; agrega la -densitybandera. El valor de densidad 150 es extraño: ¡probar un rango de valores da como resultado una imagen peor en ambas direcciones!

Personalmente me gusta esto.

convert -density 300 -trim test.pdf -quality 100 test.jpg

Es un poco más del doble del tamaño del archivo, pero me parece mejor.

-density 300 establece el dpi en el que se representa el PDF.

-trim elimina los píxeles de borde que son del mismo color que los píxeles de esquina.

-quality 100 establece la calidad de compresión JPEG a la más alta calidad.

Cosas como -sharpenno funcionan bien con el texto porque deshacen las cosas que hizo su sistema de representación de fuentes para hacerlo más legible.

Si realmente quiere explotar, use el cambio de tamaño aquí y posiblemente un valor de dpi más grande de algo como targetDPI * scalingFactor Eso hará que el PDF tenga la resolución / tamaño que desea.

Las descripciones de los parámetros en imagemagick.org están aquí

Utilizo pdftoppmen la línea de comandos para obtener la imagen inicial, generalmente con una resolución de 300 ppp, entonces pdftoppm -r 300, utilizo convertpara hacer la conversión de recorte y PNG.

normalmente extraigo la imagen incrustada con 'pdfimages' en la resolución nativa, luego uso la conversión de ImageMagick al formato necesario:

$ pdfimages -list fileName.pdf
$ pdfimages fileName.pdf fileName   # save in .ppm format
$ convert fileName-000.ppm fileName-000.png

Esto genera el mejor y más pequeño archivo de resultados.

Nota: Para imágenes incrustadas JPG con pérdida, tenía que usar -j:

$ pdfimages -j fileName.pdf fileName   # save in .jpg format

Con Poppler reciente puedes usar -todos que ahorran con pérdida como jpg y sin pérdida como png

En una plataforma Win poco proporcionada, tuvo que descargar un binario reciente (0.37 2015) 'poppler-util' de: http://blog.alivate.com.au/poppler-windows/

Lo he encontrado más rápido y más estable cuando proceso por lotes PDF grandes en PNG y JPG para usar el gscomando subyacente (también conocido como Ghostscript) que convertusa.

Puede ver el comando en la salida de convert -verbosey hay algunos ajustes más posibles allí (YMMV) que son difíciles / imposibles de acceder directamente a través de convert.

Sin embargo, sería más difícil hacer el recorte y el afilado gs, así que, como dije, ¡YMMV!

También te da buenos resultados:

exec("convert -geometry 1600x1600 -density 200x200 -quality 100 test.pdf test_image.jpg");

Usuario de Linux aquí: probé la convertutilidad de línea de comandos (para PDF a PNG) y no quedé satisfecho con los resultados. Encontré que esto es más fácil, con un mejor resultado:

• extraer la (s) página (s) pdf con pdftk
  • p.ej: pdftk file.pdf cat 3 output page3.pdf
• abrir (importar) ese pdf con GIMP
  • importante: cambiar la importación Resolutionde 100a 300o600 pixel/in
• en GIMPexportar como PNG (cambiar la extensión del archivo a .png)

Editar:

Imagen agregada, según lo solicitado en el Comments. Comando de conversión utilizado:

convert -density 300 -trim struct2vec.pdf -quality 100 struct2vec.png

GIMP: importado a 300 ppp (px / in); exportado como nivel de compresión PNG 3.

No he usado GIMP en la línea de comando (re: mi comentario, a continuación).

Realmente no he tenido un buen éxito con convert[actualización de mayo de 2020: en realidad: casi nunca funciona para mí], pero he tenido un EXCELENTE éxito con pdftoppm. Aquí hay un par de ejemplos de producción de imágenes de alta calidad a partir de un PDF:

1. [Produce ~ 25 MB de archivos de tamaño por página] Imprime el formato de archivo .tif sin comprimir a 300 DPI en una carpeta llamada "imágenes", con archivos que se llaman pg-1.tif , pg-2.tif , pg-3.tif , etc:

   mkdir -p images && pdftoppm -tiff -r 300 mypdf.pdf images/pg
   

2. [Produce ~ 1 MB de archivos por página] Salida en formato .jpg a 300 DPI :

   mkdir -p images && pdftoppm -jpeg -r 300 mypdf.pdf images/pg
   

3. [Produce archivos de ~ 2 MB de tamaño por página] Salida en formato .jpg con la más alta calidad (menos compresión) y aún a 300 DPI :

   mkdir -p images && pdftoppm -jpeg -jpegopt quality=100 -r 300 mypdf.pdf images/pg
   

Para obtener más explicaciones, opciones y ejemplos, consulte mi respuesta completa aquí:

/ubuntu/150100/extracting-embedded-images-from-a-pdf/1187844#1187844 .

Relacionado:

1. [Cómo convertir un PDF en un PDF con capacidad de búsqueda w / pdf2searchablepdf] /ubuntu/473843/how-to-turn-a-pdf-into-a-text-searchable-pdf/1187881#1187881
2. Reticulado:
   1. ¿Cómo convertir un PDF a JPG con línea de comandos en Linux?
   2. /unix/11835/pdf-to-jpg-without-quality-loss-gscan2pdf/585574#585574

En ImageMagick, puedes hacer "supermuestreo". Usted especifica una gran densidad y luego redimensiona tanto como desee para el tamaño de salida final. Por ejemplo con tu imagen:

convert -density 600 test.pdf -background white -flatten -resize 25% test.png

Descargue la imagen para verla en resolución completa y compararla.

No recomiendo guardar en JPG si espera realizar un procesamiento adicional.

Si desea que la salida sea del mismo tamaño que la entrada, cambie el tamaño a la inversa de la relación de su densidad a 72. Por ejemplo, -densidad 288 y -resize 25%. 288 = 4 * 72 y 25% = 1/4

Cuanto mayor sea la densidad, mejor será la calidad resultante, pero llevará más tiempo procesarla.

Una sugerencia más es que puedes usar GIMP.

Simplemente cargue el archivo PDF en GIMP-> guardar como .xcf y luego puede hacer lo que quiera con la imagen.

Yo uso icepdf, un motor de código abierto de Java PDF. Verifique la demostración de la oficina .

package image2pdf;

import org.icepdf.core.exceptions.PDFException;
import org.icepdf.core.exceptions.PDFSecurityException;
import org.icepdf.core.pobjects.Document;
import org.icepdf.core.pobjects.Page;
import org.icepdf.core.util.GraphicsRenderingHints;
import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.awt.image.RenderedImage;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;

public class pdf2image {

   public static void main(String[] args) {

      Document document = new Document();
      try {
         document.setFile("C:\\Users\\Dell\\Desktop\\test.pdf");
      } catch (PDFException ex) {
         System.out.println("Error parsing PDF document " + ex);
      } catch (PDFSecurityException ex) {
         System.out.println("Error encryption not supported " + ex);
      } catch (FileNotFoundException ex) {
         System.out.println("Error file not found " + ex);
      } catch (IOException ex) {
         System.out.println("Error IOException " + ex);
      }

      // save page captures to file.
      float scale = 1.0f;
      float rotation = 0f;

      // Paint each pages content to an image and
      // write the image to file
      for (int i = 0; i < document.getNumberOfPages(); i++) {
         try {
         BufferedImage image = (BufferedImage) document.getPageImage(
             i, GraphicsRenderingHints.PRINT, Page.BOUNDARY_CROPBOX, rotation, scale);

         RenderedImage rendImage = image;
         try {
            System.out.println(" capturing page " + i);
            File file = new File("C:\\Users\\Dell\\Desktop\\test_imageCapture1_" + i + ".png");
            ImageIO.write(rendImage, "png", file);
         } catch (IOException e) {
            e.printStackTrace();
         }
         image.flush();
         }catch(Exception e){
             e.printStackTrace();
         }
      }

      // clean up resources
      document.dispose();
   }
}

También probé imagemagick y pdftoppm , tanto pdftoppm como icepdf tienen una alta resolución que imagemagick.

Tenga en cuenta antes de rechazar la votación, esta solución es para Gimp usando una interfaz gráfica, y no para ImageMagick usando una línea de comando, pero funcionó perfectamente bien para mí como alternativa, y es por eso que me pareció necesario compartir aquí.

Siga estos sencillos pasos para extraer imágenes en cualquier formato de documentos PDF

1. Descargar el programa de manipulación de imágenes GIMP
2. Abra el programa después de la instalación.
3. Abra el documento PDF que desea extraer Imágenes.
4. Seleccione solo las páginas del documento PDF de las que desea extraer imágenes. N / B: Si solo necesita las imágenes de portada, seleccione solo la primera página.
5. Haga clic en abrir después de seleccionar las páginas de las que desea extraer imágenes
6. Haga clic en el menú Archivo cuando GIMP cuando se abren las páginas
7. Seleccione Exportar como en el menú Archivo
8. Seleccione su tipo de archivo preferido por extensión (digamos png) debajo del cuadro de diálogo que aparece.
9. Haga clic en Exportar para exportar su imagen a la ubicación deseada.
10. Luego puede verificar su explorador de archivos para la imagen exportada.

Eso es todo.

espero que esto ayude

El archivo PNG que adjuntas se ve muy borroso. En caso de que necesite utilizar postprocesamiento adicional para cada imagen que generó como vista previa en PDF, disminuirá el rendimiento de su solución.

2JPEG puede convertir el archivo PDF que adjuntó a un bonito JPG de enfoque y recortar márgenes vacíos en una sola llamada:

2jpeg.exe -src "C:\In\*.*" -dst "C:\Out" -oper Crop method:autocrop

Use esta línea de comando:

convert -geometry 3600x3600 -density 300x300 -quality 100 TEAM\ 4.pdf team4.png

Esto debería convertir correctamente el archivo como lo solicitó.

El siguiente script de Python funcionará en cualquier Mac (Snow Leopard y versiones posteriores). Se puede usar en la línea de comando con archivos PDF sucesivos como argumentos, o se puede poner en una acción Ejecutar script de Shell en Automator y hacer un Servicio (Acción rápida en Mojave).

Puede establecer la resolución de la imagen de salida en el script.

El script y una acción rápida se pueden descargar desde github.

#!/usr/bin/python
# coding: utf-8

import os, sys
import Quartz as Quartz
from LaunchServices import (kUTTypeJPEG, kUTTypeTIFF, kUTTypePNG, kCFAllocatorDefault) 

resolution = 300.0 #dpi
scale = resolution/72.0

cs = Quartz.CGColorSpaceCreateWithName(Quartz.kCGColorSpaceSRGB)
whiteColor = Quartz.CGColorCreate(cs, (1, 1, 1, 1))
# Options: kCGImageAlphaNoneSkipLast (no trans), kCGImageAlphaPremultipliedLast 
transparency = Quartz.kCGImageAlphaNoneSkipLast

#Save image to file
def writeImage (image, url, type, options):
    destination = Quartz.CGImageDestinationCreateWithURL(url, type, 1, None)
    Quartz.CGImageDestinationAddImage(destination, image, options)
    Quartz.CGImageDestinationFinalize(destination)
    return

def getFilename(filepath):
    i=0
    newName = filepath
    while os.path.exists(newName):
        i += 1
        newName = filepath + " %02d"%i
    return newName

if __name__ == '__main__':

    for filename in sys.argv[1:]:
        pdf = Quartz.CGPDFDocumentCreateWithProvider(Quartz.CGDataProviderCreateWithFilename(filename))
        numPages = Quartz.CGPDFDocumentGetNumberOfPages(pdf)
        shortName = os.path.splitext(filename)[0]
        prefix = os.path.splitext(os.path.basename(filename))[0]
        folderName = getFilename(shortName)
        try:
            os.mkdir(folderName)
        except:
            print "Can't create directory '%s'"%(folderName)
            sys.exit()

        # For each page, create a file
        for i in range (1, numPages+1):
            page = Quartz.CGPDFDocumentGetPage(pdf, i)
            if page:
        #Get mediabox
                mediaBox = Quartz.CGPDFPageGetBoxRect(page, Quartz.kCGPDFMediaBox)
                x = Quartz.CGRectGetWidth(mediaBox)
                y = Quartz.CGRectGetHeight(mediaBox)
                x *= scale
                y *= scale
                r = Quartz.CGRectMake(0,0,x, y)
        # Create a Bitmap Context, draw a white background and add the PDF
                writeContext = Quartz.CGBitmapContextCreate(None, int(x), int(y), 8, 0, cs, transparency)
                Quartz.CGContextSaveGState (writeContext)
                Quartz.CGContextScaleCTM(writeContext, scale,scale)
                Quartz.CGContextSetFillColorWithColor(writeContext, whiteColor)
                Quartz.CGContextFillRect(writeContext, r)
                Quartz.CGContextDrawPDFPage(writeContext, page)
                Quartz.CGContextRestoreGState(writeContext)
        # Convert to an "Image"
                image = Quartz.CGBitmapContextCreateImage(writeContext) 
        # Create unique filename per page
                outFile = folderName +"/" + prefix + " %03d.png"%i
                url = Quartz.CFURLCreateFromFileSystemRepresentation(kCFAllocatorDefault, outFile, len(outFile), False)
        # kUTTypeJPEG, kUTTypeTIFF, kUTTypePNG
                type = kUTTypePNG
        # See the full range of image properties on Apple's developer pages.
                options = {
                    Quartz.kCGImagePropertyDPIHeight: resolution,
                    Quartz.kCGImagePropertyDPIWidth: resolution
                    }
                writeImage (image, url, type, options)
                del page

Puede hacerlo en LibreOffice Draw (que generalmente está preinstalado en Ubuntu ):

1. Abra el archivo PDF en LibreOffice Draw.
2. Desplácese a la página que necesita.
3. Asegurarse los elementos de texto / imagen se coloquen correctamente. Si no, puede ajustarlos / editarlos en la página.
4. Menú superior: Archivo> Exportar ...
5. Seleccione el formato de imagen que necesita en el menú inferior derecho. Recomiendo PNG.
6. Asigne un nombre a su archivo y haga clic en Guardar.
7. Aparecerá la ventana de opciones, para que pueda ajustar la resolución y el tamaño.
8. Haga clic en Aceptar y ya está.

He usado pdf2image . Una biblioteca de python simple que funciona como encanto.

Primero instale poppler en una máquina que no sea Linux. Solo puedes descargar el zip. Descomprima los archivos de programa y agregue bin a la ruta de la máquina.

Después de eso, puede usar pdf2image en una clase de Python como esta:

from pdf2image import convert_from_path, convert_from_bytes
images_from_path = convert_from_path(
   inputfile,
   output_folder=outputpath,
   grayscale=True, fmt='jpeg')

No soy bueno con Python, pero pude hacer exe de él. Más tarde, puede usar el exe con el parámetro de entrada y salida de archivo. Lo he usado en C # y las cosas funcionan bien.

La calidad de la imagen es buena. OCR funciona bien.

En realidad, es bastante fácil de hacer con Vista previa en una Mac. Todo lo que tiene que hacer es abrir el archivo en Vista previa y guardar como (o exportar) un png o jpeg, pero asegúrese de usar al menos 300 ppp en la parte inferior de la ventana para obtener una imagen de alta calidad.