LlosLab Software Development BlogEngineering notes for PDF, Delphi, and document software developers.

Artículo técnico

Conversión de páginas PDF a imágenes JPEG con PDFium VCL en Delphi

· Programación PDF

Convertir páginas PDF a imágenes es esencial para miniaturas, vistas previas y visualización en la web. PDF a JPG La demostración muestra cómo renderizar páginas PDF como imágenes JPEG de alta calidad utilizando PDFium VCL.

Resumen

Esta demostración convierte páginas PDF en imágenes JPEG con DPI, configuraciones de calidad y selección de páginas personalizables. Es perfecta para generar miniaturas, crear archivos basados en imágenes o preparar archivos PDF para su visualización en la web.

Características principales

  • DPI personalizable. – Controla la resolución de salida (72-600 DPI).
  • Configuración de calidad. – Ajustar la calidad de compresión JPEG.
  • Selección de páginas – Convertir todas las páginas o rangos de páginas específicos.
  • Directorio de salida. – Elija dónde guardar las imágenes convertidas.
  • Seguimiento del progreso. – Retroalimentación visual durante la conversión.
  • Soporte para cancelación. – Cancela conversiones largas en cualquier momento.

Requisitos de la DLL PDFium

Antes de ejecutar cualquier aplicación PDFium VCL, asegúrese de que los archivos DLL de PDFium estén instalados:

  • pdfium32.dll / pdfium64.dll – Versiones estándar (~5-6 MB)
  • pdfium32v8.dll / pdfium64v8.dll – Con el motor JavaScript V8 (~23-27 MB)

Instalación: Ejecutar PDFiumVCL\DLLs\CopyDlls.bat como administrador para copiar automáticamente los archivos DLL a los directorios del sistema de Windows.

Conversión básica de PDF a imagen.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
procedure ConvertPdfToImages;
var
  Pdf: TPdf;
  I: Integer;
  Bitmap: TBitmap;
  JpegImage: TJpegImage;
  Dpi: Integer;
begin
  Dpi := 150; // 150 DPI is good for screen viewing
  
  Pdf := TPdf.Create(nil);
  try
    Pdf.FileName := 'document.pdf';
    Pdf.Active := True;
    
    for I := 1 to Pdf.PageCount do
    begin
      Pdf.PageNumber := I;
      
      // Calculate size based on DPI
      // PDF default is 72 DPI, so scale accordingly
      Bitmap := Pdf.RenderPage(
        0, 0,
        Round(Pdf.PageWidth * Dpi / 72),
        Round(Pdf.PageHeight * Dpi / 72),
        ro0,      // No rotation
        [],       // Default render options
        clWhite   // Background color
      );
      
      try
        // Convert to JPEG
        JpegImage := TJpegImage.Create;
        try
          JpegImage.Assign(Bitmap);
          JpegImage.CompressionQuality := 85;
          JpegImage.SaveToFile(Format('page_%03d.jpg', [I]));
        finally
          JpegImage.Free;
        end;
      finally
        Bitmap.Free;
      end;
    end;
    
  finally
    Pdf.Active := False;
    Pdf.Free;
  end;
end;

Conversión completa con opciones.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
procedure TFormMain.ButtonConvertClick(Sender: TObject);
var
  I: Integer;
  OutDir, BaseName, FileName: string;
  JpegImage: TJpegImage;
  Bitmap: TBitmap;
  Dpi, Quality: Integer;
  Pages: TIntArray;
  PageDigits: Integer;
  UseAllPages: Boolean;
begin
  ProgressBar.Position := 0;
  FCancelRequested := False;
  Screen.Cursor := crHourGlass;
  
  try
    try
      if not FileExists(EditPdfFile.Text) then
        raise Exception.Create('PDF file does not exist.');
        
      // Parse settings
      Dpi := StrToIntDef(Trim(EditDPI.Text), 150);
      if Dpi <= 0 then Dpi := 150;
      if Dpi > 600 then Dpi := 600;
      
      Quality := StrToIntDef(Trim(EditQuality.Text), 85);
      if Quality < 1 then Quality := 1;
      if Quality > 100 then Quality := 100;
      
      // Load PDF
      Pdf.FileName := EditPdfFile.Text;
      Pdf.Active := True;
      
      // Parse page ranges
      UseAllPages := Trim(EditPageRange.Text) = '';
      if UseAllPages then
      begin
        SetLength(Pages, Pdf.PageCount);
        for I := 1 to Pdf.PageCount do
          Pages[I - 1] := I;
      end
      else
      begin
        if not ParsePageRanges(EditPageRange.Text, Pdf.PageCount, Pages) then
          raise Exception.Create('Invalid page range.');
      end;
      
      ProgressBar.Max := Length(Pages);
      PageDigits := Length(IntToStr(Pdf.PageCount));
      
      // Setup output
      OutDir := EnsureOutputDir(Pdf.FileName, EditOutputDir.Text);
      BaseName := ChangeFileExt(ExtractFileName(Pdf.FileName), '');
      
      JpegImage := TJpegImage.Create;
      try
        for I := 0 to High(Pages) do
        begin
          if FCancelRequested then
            Break;
            
          Pdf.PageNumber := Pages[I];
          
          // Render page to bitmap
          Bitmap := Pdf.RenderPage(
            0, 0,
            Round(Pdf.PageWidth * Dpi / 72),
            Round(Pdf.PageHeight * Dpi / 72),
            ro0, [], clWhite
          );
          
          try
            // Save as JPEG
            FileName := Format('%s\%s_%.*d.jpg',
              [OutDir, BaseName, PageDigits, Pages[I]]);
              
            JpegImage.Assign(Bitmap);
            JpegImage.CompressionQuality := Quality;
            JpegImage.SaveToFile(FileName);
          finally
            Bitmap.Free;
          end;
          
          ProgressBar.Position := I + 1;
          Application.ProcessMessages;
        end;
      finally
        JpegImage.Free;
      end;
      
    except
      on E: Exception do
        Application.MessageBox(
          PChar('Conversion failed: ' + E.Message),
          'Error', MB_ICONERROR or MB_OK);
    end;
    
  finally
    Screen.Cursor := crDefault;
    Pdf.Active := False;
  end;
end;

Entendiendo RenderPage.

El RenderPage El método es clave para la conversión de PDF a imagen:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// Render to a new bitmap
function TPdf.RenderPage(
  Left, Top, Width, Height: Integer;
  Rotation: TRotation = ro0;
  Options: TRenderOptions = [];
  Color: TColor = clWhite
): TBitmap;
 
// Render to an existing bitmap
procedure TPdf.RenderPage(
  Bitmap: TBitmap;
  Left, Top, Width, Height: Integer;
  Rotation: TRotation = ro0;
  Options: TRenderOptions = [];
  Color: TColor = clWhite
);
 
// Render directly to a device context (for printing)
procedure TPdf.RenderPage(
  DeviceContext: HDC;
  Left, Top, Width, Height: Integer;
  Rotation: TRotation = ro0;
  Options: TRenderOptions = []
);

Opciones de renderizado:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
type
  TRenderOption = (
    reAnnotations,       // Include annotations in output
    reLcd,               // Optimize for LCD displays
    reNoNativeText,      // Don't use system text rendering
    reGrayscale,         // Output in grayscale
    reLimitCache,        // Limit memory cache
    reHalftone,          // Better image downscaling
    rePrinting,          // Optimize for printing
    reNoSmoothText,      // Disable text anti-aliasing
    reNoSmoothImage,     // Disable image anti-aliasing
    reNoSmoothPath       // Disable path anti-aliasing
  );
 
// Example: High-quality output with annotations
Bitmap := Pdf.RenderPage(0, 0, Width, Height, ro0,
  [reAnnotations, reLcd], clWhite);
  
// Example: Fast, grayscale thumbnail
Bitmap := Pdf.RenderPage(0, 0, 200, 280, ro0,
  [reGrayscale, reNoSmoothText, reNoSmoothImage], clWhite);

Directrices de DPI y calidad:

Use Case Recommended DPI JPEG Quality
Thumbnails 72 60-70
Screen viewing 96-150 80-85
High-quality display 200-300 85-95
Printing 300-600 90-100

Análisis de rangos de páginas:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
function TFormMain.ParsePageRanges(const S: string; MaxPage: Integer;
  out Pages: TIntArray): Boolean;
var
  List: TStringList;
  I, A, B, J: Integer;
  Part: string;
  DashPos: Integer;
  Used: array of Boolean;
  Count: Integer;
begin
  Result := False;
  SetLength(Pages, 0);
  
  if Trim(S) = '' then
  begin
    Result := True;
    Exit;
  end;
  
  SetLength(Used, MaxPage + 1);
  for I := 0 to High(Used) do
    Used[I] := False;
    
  List := TStringList.Create;
  try
    List.Delimiter := ',';
    List.DelimitedText := StringReplace(Trim(S), ' ', '', [rfReplaceAll]);
    
    for I := 0 to List.Count - 1 do
    begin
      Part := Trim(List[I]);
      DashPos := Pos('-', Part);
      
      if DashPos > 0 then
      begin
        // Range: "1-5"
        A := StrToIntDef(Trim(Copy(Part, 1, DashPos - 1)), 0);
        B := StrToIntDef(Trim(Copy(Part, DashPos + 1, Length(Part))), 0);
        
        if (A < 1) or (B < A) or (B > MaxPage) then
          Exit;
          
        for J := A to B do
          Used[J] := True;
      end
      else
      begin
        // Single page
        A := StrToIntDef(Part, 0);
        if (A < 1) or (A > MaxPage) then
          Exit;
        Used[A] := True;
      end;
    end;
  finally
    List.Free;
  end;
  
  // Build result array
  Count := 0;
  for I := 1 to MaxPage do
    if Used[I] then Inc(Count);
    
  SetLength(Pages, Count);
  J := 0;
  for I := 1 to MaxPage do
    if Used[I] then
    begin
      Pages[J] := I;
      Inc(J);
    end;
    
  Result := True;
end;

Creación de miniaturas:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
function CreateThumbnail(Pdf: TPdf; PageNumber: Integer;
  MaxWidth, MaxHeight: Integer): TBitmap;
var
  PageWidth, PageHeight: Double;
  Scale: Double;
  ThumbWidth, ThumbHeight: Integer;
begin
  Pdf.PageNumber := PageNumber;
  
  PageWidth := Pdf.PageWidth;
  PageHeight := Pdf.PageHeight;
  
  // Calculate scale to fit in max dimensions
  Scale := Min(MaxWidth / PageWidth, MaxHeight / PageHeight);
  
  ThumbWidth := Round(PageWidth * Scale);
  ThumbHeight := Round(PageHeight * Scale);
  
  Result := Pdf.RenderPage(0, 0, ThumbWidth, ThumbHeight,
    ro0, [reGrayscale], clWhite);
end;

Casos de uso.

  • Generación de miniaturas: – Crear vistas previas para navegadores de documentos:
  • Publicación web: – Convertir archivos PDF a imágenes para su visualización en la web.
  • Redes sociales. – Compartir contenido de archivos PDF como imágenes.
  • Conversión de archivos. – Convertir archivos PDF a formatos de imagen.
  • Preprocesamiento OCR. – Preparar archivos PDF para el procesamiento OCR.

Conclusión.

La demostración de conversión de PDF a JPG muestra lo fácil que es convertir páginas de archivos PDF a imágenes de alta calidad con PDFium VCL. RenderPage Este método le brinda control total sobre la resolución, la calidad y las opciones de renderizado.

Ya sea que esté creando un generador de miniaturas, un publicador web o un convertidor de documentos, PDFium VCL proporciona las capacidades de renderizado que necesita.

Comience a convertir archivos PDF a imágenes hoy mismo. con Componente PDFium VCL hoy.