LlosLab Software Development BlogTekniska anteckningar för utvecklare av PDF-, Delphi- och dokumentprogramvara.

Teknisk artikel

Konvertera PDF-sidor till JPEG-bilder med PDFium VCL i Delphi

· PDF-programmering

Att konvertera PDF-sidor till bilder är viktigt för miniatyrer, förhandsvisningar och webbvisning. Den PDF till JPG demo visar hur du renderar PDF-sidor som högkvalitativa JPEG-bilder med PDFium VCL.

Översikt

Denna demo konverterar PDF-sidor till JPEG-bilder med anpassningsbar DPI, kvalitetsinställningar och sidval. Det är perfekt för att generera miniatyrer, skapa bildbaserade arkiv eller förbereda PDF-filer för webbvisning.

Nyckelfunktioner

  • Anpassningsbar DPI – Styr utgångsupplösning (72-600 DPI)
  • Kvalitetsinställningar – Justera JPEG-komprimeringskvaliteten
  • Sidval – Konvertera alla sidor eller specifika sidintervall
  • Utdatakatalog – Välj var du vill spara konverterade bilder
  • Framstegsspårning – Visuell återkoppling under konvertering
  • Avbokningsstöd – Avbryt långa konverteringar när som helst

PDFium DLL-krav

Innan du kör ett PDFium VCL-program, se till att PDFium DLL-filerna är installerade:

  • pdfium32.dll / pdfium64.dll – Standardversioner (~5-6 MB)
  • pdfium32v8.dll / pdfium64v8.dll – Med V8 JavaScript-motor (~23-27 MB)

Installation: Kör PDFiumVCL\DLLs\CopyDlls.bat som administratör för att automatiskt kopiera DLL:erna till Windows systemkataloger.

Grundläggande konvertering av PDF till bild

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;

Komplett konvertering med alternativ

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;

Förstå RenderPage

Den RenderPage Metoden är nyckeln till PDF-till-bild-konvertering:

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 = []
);

Renderalternativ

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);

DPI och kvalitetsriktlinjer

Användningsfall Rekommenderad DPI JPEG-kvalitet
Miniatyrer 72 60-70
Skärmvisning 96-150 80-85
Högkvalitativ display 200-300 85-95
Utskrift 300-600 90-100

Parsar sidintervall

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;

Skapa miniatyrer

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;

Användningsfall

  • Generering av miniatyrbilder – Skapa förhandsvisningar för dokumentläsare
  • Webbpublicering – Konvertera PDF-filer till bilder för webbvisning
  • Sociala medier – Dela PDF-innehåll som bilder
  • Arkivkonvertering – Konvertera PDF-arkiv till bildformat
  • OCR-förbearbetning – Förbered PDF-filer för OCR-bearbetning

Slutsats

PDF till JPG-demon visar hur enkelt det är att konvertera PDF-sidor till högkvalitativa bilder med PDFium VCL. Den RenderPage metod ger dig full kontroll över upplösning, kvalitet och renderingsalternativ.

Oavsett om du bygger en miniatyrbildsgenerator, webbpublicist eller dokumentkonverterare, ger PDFium VCL de renderingsmöjligheter du behöver.

Börja konvertera PDF-filer till bilder med PDFium VCL-komponent idag.