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

技術記事

PDF 処理パフォーマンスの最適化: 数分から数秒まで

· PDFプログラミング

PDF処理アプリケーションにおける、分単位の処理を秒単位に

PDF処理のパフォーマンスは、ドキュメント処理アプリケーションの成否を左右します。本来は簡単なページ抽出操作でも、完了までに数分かかることがあり、ユーザーを不満させ、システムパフォーマンスを低下させます。この記事では、PDF処理アプリケーションにおける一般的なパフォーマンスのボトルネックを探り、処理速度を最適化し、メモリリークを解消し、より効率的なドキュメント処理ワークフローを作成するための効果的な戦略を提供します。

パフォーマンスの問題:現実世界のシナリオ

考えてみてください。一見すると簡単な操作、つまり、PDFドキュメントから1ページを抽出する操作です。理想的には、これは数秒で完了するはずです。しかし、現実世界のシナリオでは、しばしば大きな課題が生じます。最近の事例として、弊社の Delphi PDFコンポーネント ページコピーのサンプルプログラムがあり、通常のサイズのドキュメントからページを抽出するのに2分かかりました。これは許容できないパフォーマンスの低下であり、即座の最適化が必要でした。

迅速に実行されるべきコマンド:

1
CopyPage.exe PDF-Reference-1.7-Fonts.pdf -page 1-3

しかし、この操作は数秒で完了するはずなのに、深刻なパフォーマンスの問題が発生しました。具体的には、以下の問題が見られました。

  • 処理時間が長くなり、数分かかることがあります。
  • 処理中に大量のメモリを消費します。
  • 不要な一時ファイルが作成されます。
  • クリーンアップ中にメモリアクセス違反が発生します。
  • 非効率なページツリーのトラバーサルアルゴリズム。

パフォーマンスのボトルネックの特定。

最適化の最初のステップは、パフォーマンスのボトルネックが実際にどこにあるかを特定することです。 多くの最新のPDF処理アプリケーションは、いくつかの一般的な問題に悩まされています。

複雑なページツリー操作。

多くのPDFライブラリは、標準的なドキュメントには適した複雑なページツリー走査アルゴリズムを実装していますが、非標準の構造では効率が悪くなることがあります。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// Performance bottleneck: Complex tree reordering
procedure ReorderPagesByPagesTree(PDFDoc: TPDFDocument);
var
  i, j: Integer;
  TempList: TObjectList;
begin
  // This operation can be extremely slow for large documents
  for i := 0 to PDFDoc.PageCount - 1 do
  begin
    for j := 0 to PDFDoc.Objects.Count - 1 do
    begin
      // Nested loops create O(n²) complexity
      if IsPageObject(PDFDoc.Objects[j]) then
        ProcessPageTreeNode(PDFDoc.Objects[j]);
    end;
  end;
end;

不要なメタデータ処理

アプリケーションは、特定の操作には不要なドキュメントメタデータを処理することがよくあります。

1
2
3
4
5
6
7
8
9
// Unnecessary overhead: Processing all metadata
procedure ProcessDocumentMetadata(PDFDoc: TPDFDocument);
begin
  ExtractDocumentInfo(PDFDoc);        // Not needed for page copy
  ProcessBookmarks(PDFDoc);           // Not needed for page copy
  AnalyzeImageCompression(PDFDoc);    // Not needed for page copy
  ValidateDigitalSignatures(PDFDoc);  // Not needed for page copy
  OptimizeImageQuality(PDFDoc);       // Slow and unnecessary
end;

非効率なメモリ管理

不適切なメモリ管理は、パフォーマンスに大きな影響を与える可能性があります。

  • 必要な特定のページのみが必要な場合に、ドキュメント全体をメモリにロードする。
  • 一時ファイルを適切にクリーンアップせずに作成する。
  • 不要なオブジェクト参照をメモリに残しておく。
  • 非効率なガベージコレクションのパターン

最適化戦略1:複雑なツリー操作の排除

最も重要なパフォーマンス改善は、複雑なページツリー操作を簡素化または排除することから得られることが多い。 複雑なツリー構造に基づいてページを並べ替える代わりに、直接的なシーケンシャルアクセスを実装する。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// Optimized approach: Skip complex tree operations
function CopyPageOptimized(SourcePDF: TPDFDocument; PageIndex: Integer): TPDFDocument;
begin
  Result := TPDFDocument.Create;
  try
    // Skip complex tree analysis - go directly to page copying
    // This reduces processing time from minutes to seconds
    CopyPageDirectly(SourcePDF, PageIndex, Result);
    
    // Skip metadata copying for performance
    // Skip image optimization for performance
    // Skip bookmark processing for performance
    
  except
    on E: Exception do
    begin
      Result.Free;
      raise Exception.Create('Page copy failed: ' + E.Message);
    end;
  end;
end;

実装の詳細

この最適化を実装する際には、必要な最小限の操作に焦点を当てる。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
procedure CopyPageDirectly(Source: TPDFDocument; PageIndex: Integer; Dest: TPDFDocument);
var
  SourcePage: TPDFPage;
  DestPage: TPDFPage;
begin
  // Get source page without tree traversal
  SourcePage := Source.GetPageDirect(PageIndex);
  if not Assigned(SourcePage) then
    raise Exception.Create('Source page not found');
  
  // Create destination page with minimal metadata
  DestPage := Dest.AddPage;
  DestPage.CopyContentFrom(SourcePage);
  
  // Skip unnecessary operations:
  // - Don't copy all document metadata
  // - Don't optimize images
  // - Don't process bookmarks
  // - Don't validate page tree structure
end;

最適化戦略2:一時ファイルの作成を削減する

多くのPDF処理アプリケーションは、処理中に一時ファイルを作成しますが、これはパフォーマンスに大きな影響を与える可能性があります。特に、大規模なドキュメントや複数の同時操作を処理する場合に顕著です。

一時ファイルの発生源の特定

一時ファイルが作成される一般的な原因には、以下が含まれます。

  • デバッグ中に中間結果をディスクへ書き出す解凍操作。
  • 変換済み画像をキャッシュする画像処理ルーチン。
  • バックアップコピーを作成するページツリー分析機能。
  • 内容検証用の検証ルーチン。

1
2
3
4
// Example of unwanted temporary file creation in Release builds
// Temporary files created for verifying complex content stream processing
Creating temporary file: compressed_data_117.bin
Creating temporary file: compressed_data_200.bin<br>

一時ファイル操作の削減

一時ファイルの作成をなくすには、その処理を担当している機能を特定し、回避します。

1
2
3
4
5
6
7
8
9
10
// Remove functions that create temporary files
procedure OptimizeProcessing(PDFDoc: TPDFDocument);
begin
  // REMOVED: CreateDecompressedPDF(PDFDoc) - creates temporary files
  // REMOVED: GetCorrectPageOrderFromPagesTree(PDFDoc) - creates debug files
  // REMOVED: ReorderPageArrByPagesTree(PDFDoc) - creates backup files
  
  // Use direct memory processing instead
  ProcessPagesInMemory(PDFDoc);
end;

最適化戦略 3: 選択的処理の実装

ドキュメント全体を処理する代わりに、操作に必要な特定の内容だけを処理する選択的処理を実装します。

遅延読み込みの実装

1
2
3
4
5
6
7
8
9
10
11
12
// Lazy loading approach for better performance
function GetPageContent(PDFDoc: TPDFDocument; PageIndex: Integer): string;
begin
  // Don't load entire document - just the required page
  if not IsPageLoaded(PageIndex) then
    LoadSinglePage(PDFDoc, PageIndex);
  
  Result := ExtractPageContentDirect(PDFDoc, PageIndex);
  
  // Clean up immediately after use
  UnloadPage(PageIndex);
end;

条件機能処理。

実行中の操作に応じて不要な処理をスキップするため、機能フラグを実装します。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
type
  TProcessingOptions = record
    SkipMetadata: Boolean;
    SkipImageOptimization: Boolean;
    SkipBookmarks: Boolean;
    SkipPageTreeValidation: Boolean;
    UseSequentialMode: Boolean;
  end;
 
function CopyPageWithOptions(Source: TPDFDocument; PageIndex: Integer;
  Options: TProcessingOptions): TPDFDocument;
begin
  Result := TPDFDocument.Create;
  
  if Options.UseSequentialMode then
    SetSequentialProcessingMode(True);
  
  if Options.SkipPageTreeValidation then
    SkipComplexTreeOperations := True;
  
  // Perform only the required operations
  CopyPageMinimal(Source, PageIndex, Result);
end;

メモリ管理の最適化

効果的なメモリ管理は性能維持に不可欠です。特に大きなドキュメントや複数の並行処理を扱う場合に重要です。

リソース解放戦略

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
// Implement comprehensive resource cleanup
procedure ProcessPDFWithCleanup(const FileName: string);
var
  PDFDoc: TPDFDocument;
  TempObjects: TObjectList;
begin
  PDFDoc := nil;
  TempObjects := TObjectList.Create(True);
  try
    PDFDoc := TPDFDocument.Create;
    PDFDoc.LoadFromFile(FileName);
    
    // Process document
    ProcessDocument(PDFDoc);
    
  finally
    // Ensure cleanup even if exceptions occur
    TempObjects.Free;
    if Assigned(PDFDoc) then
      PDFDoc.Free;
    
    // Force garbage collection
    System.GC;
  end;
end;

メモリプールの実装

大量のドキュメント処理が必要なアプリケーションでは、割り当てコストを減らすためにメモリプールを実装します。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// Memory pool for frequently used objects
type
  TPDFDocumentPool = class
  private
    FAvailableDocuments: TQueue;
    FMaxPoolSize: Integer;
  public
    function GetDocument: TPDFDocument;
    procedure ReturnDocument(Doc: TPDFDocument);
    constructor Create(MaxSize: Integer = 10);
  end;
 
function TPDFDocumentPool.GetDocument: TPDFDocument;
begin
  if FAvailableDocuments.Count > 0 then
  begin
    Result := FAvailableDocuments.Dequeue;
    Result.Reset; // Clear previous content
  end
  else
    Result := TPDFDocument.Create;
end;

性能監視と分析

最良の性能を維持するため、包括的な監視と分析機能を実装します。

実行時間の追跡

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// Performance monitoring implementation
type
  TPerformanceProfiler = class
  private
    FStartTime: TDateTime;
    FOperationTimes: TDictionary<string, Double>;
  public
    procedure StartOperation(const OperationName: string);
    procedure EndOperation(const OperationName: string);
    procedure GenerateReport;
  end;
 
procedure TPerformanceProfiler.EndOperation(const OperationName: string);
var
  ElapsedTime: Double;
begin
  ElapsedTime := MilliSecondsBetween(Now, FStartTime);
  FOperationTimes.AddOrSetValue(OperationName, ElapsedTime);
  
  // Log slow operations
  if ElapsedTime > 1000 then // More than 1 second
    WriteLn(Format('WARNING: Slow operation %s took %.2f ms',
      [OperationName, ElapsedTime]));
end;

メモリ使用状況の監視

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// Monitor memory usage during processing
procedure MonitorMemoryUsage(const OperationName: string);
var
  MemStatus: TMemoryManagerState;
  UsedMemory: NativeUInt;
begin
  GetMemoryManagerState(MemStatus);
  UsedMemory := MemStatus.TotalAllocatedMediumBlockSize +
                MemStatus.TotalAllocatedLargeBlockSize;
  
  WriteLn(Format('%s: Memory usage: %d KB',
    [OperationName, UsedMemory div 1024]));
  
  // Alert on high memory usage
  if UsedMemory > 100 * 1024 * 1024 then // More than 100MB
    WriteLn('WARNING: High memory usage detected');
end;

並列処理の最適化

複数のドキュメント処理やバッチ操作が必要なアプリケーションでは、並列処理によって大きな性能向上が期待できます。

多线程ドキュメント処理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// Parallel processing implementation
procedure ProcessDocumentsParallel(const FileList: TStringList);
var
  ParallelTask: ITask;
  i: Integer;
begin
  // Create parallel tasks for document processing
  ParallelTask := TTask.Create(
    procedure
    var
      LocalIndex: Integer;
    begin
      TParallel.For(0, FileList.Count - 1,
        procedure(Index: Integer)
        begin
          ProcessSingleDocument(FileList[Index]);
        end);
    end);
  
  ParallelTask.Start;
  ParallelTask.Wait; // Wait for completion
end;

スレッドセーフなリソース管理

並列処理を実装する際は、スレッドセーフなリソース管理を必ず行ってください。

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
// Thread-safe PDF processing
type
  TThreadSafePDFProcessor = class
  private
    FCriticalSection: TCriticalSection;
    FDocumentPool: TPDFDocumentPool;
  public
    function ProcessDocument(const FileName: string): Boolean;
    constructor Create;
    destructor Destroy; override;
  end;
 
function TThreadSafePDFProcessor.ProcessDocument(const FileName: string): Boolean;
var
  Doc: TPDFDocument;
begin
  FCriticalSection.Enter;
  try
    Doc := FDocumentPool.GetDocument;
  finally
    FCriticalSection.Leave;
  end;
  
  try
    // Process document outside critical section
    Doc.LoadFromFile(FileName);
    Result := ProcessDocumentContent(Doc);
  finally
    // Return document to pool
    FCriticalSection.Enter;
    try
      FDocumentPool.ReturnDocument(Doc);
    finally
      FCriticalSection.Leave;
    end;
  end;
end;

エラー処理とリカバリの最適化

効率的なエラー処理は、アプリケーションの信頼性を向上させるだけでなく、高価なリカバリ処理を回避することで、パフォーマンスの向上にも貢献します。

早期エラー検出

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// Quick validation to avoid expensive processing
function QuickValidatePDF(const FileName: string): Boolean;
var
  FileStream: TFileStream;
  Header: array[0..7] of AnsiChar;
begin
  Result := False;
  FileStream := TFileStream.Create(FileName, fmOpenRead or fmShareDenyWrite);
  try
    // Quick header check - avoid loading entire file
    if FileStream.Size < 8 then Exit;
    
    FileStream.ReadBuffer(Header, 8);
    Result := CompareMem(@Header[0], @'%PDF-', 5);
    
    // Additional quick checks can be added here
    if not Result then
      WriteLn('Fast-fail: Invalid PDF header detected');
      
  finally
    FileStream.Free;
  end;
end;

パフォーマンスのテストとベンチマーク

最適化の影響を測定するために、包括的なパフォーマンステストを実施してください。

自動パフォーマンステスト

1
2
3
4
5
6
7
8
9
10
11
Performance Test Results:
============================
Before Optimization:
- Single page copy: 120,150 ms (2 minutes)
- Memory usage: 85 MB
- Temporary files: 2 created
 
After Optimization:
- Single page copy: 1,230 ms (1.2 seconds)
- Memory usage: 12 MB
- Temporary files: 0 created

回帰テスト

最適化が新たな問題を生まないことを確認するため、自動回帰テストを実装します。

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
// Automated performance regression testing
procedure RunPerformanceRegressionTests;
var
  TestFiles: TStringList;
  i: Integer;
  StartTime, EndTime: TDateTime;
  ProcessingTime: Double;
begin
  TestFiles := GetTestFileList;
  try
    for i := 0 to TestFiles.Count - 1 do
    begin
      StartTime := Now;
      ProcessTestFile(TestFiles[i]);
      EndTime := Now;
      
      ProcessingTime := MilliSecondsBetween(EndTime, StartTime);
      
      // Alert if processing time exceeds baseline
      if ProcessingTime > GetBaselineTime(TestFiles[i]) * 1.2 then
        WriteLn(Format('REGRESSION: %s processing time increased to %.2f ms',
          [TestFiles[i], ProcessingTime]));
    end;
  finally
    TestFiles.Free;
  end;
end;

高性能を維持するためのベストプラクティス

最良の PDF 処理性能を維持するには、いくつかの重要領域に継続して注意を払う必要があります。

リソース管理

  • 立即清理使用後は常にリソースをすぐ解放します。
  • メモリプール可能な場合は、高価なオブジェクトを再利用する。
  • 遅延読み込み必要なときだけ内容を読み込む。
  • バッチ処理類似した操作をグループ化して効率を高めます。

アルゴリズムの選択

  • 順次処理とツリー処理ルート据ドキュメント構造行う選択。
  • 缓存策略。よくアクセスされるデータをキャッシュします。
  • 早期終了目標が達成されたら処理を停止します。
  • 前処理の最適化重い処理の前にドキュメントを分析します。

アクセス違反の防止

パフォーマンスを低下させる一般的な原因は、高価なエラー回復を強制するアクセス違反です。 これを防ぐには、慎重なメモリ管理が必要です。

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
// Prevent access violations with proper bounds checking
function SafeAccessPDFObject(PDFDoc: TPDFDocument; ObjectIndex: Integer): TPDFObject;
begin
  Result := nil;
  
  // Validate input parameters
  if not Assigned(PDFDoc) then
    Exit;
    
  if (ObjectIndex < 0) or (ObjectIndex >= PDFDoc.Objects.Count) then
    Exit;
  
  // Additional validation for object integrity
  try
    Result := PDFDoc.Objects[ObjectIndex];
    if not Assigned(Result) then
      Exit;
      
    // Verify object is properly initialized
    if Result.ObjectNumber <= 0 then
    begin
      Result := nil;
      Exit;
    end;
    
  except
    on E: Exception do
    begin
      // Log the error but don't crash
      WriteLn('WARNING: Object access failed: ' + E.Message);
      Result := nil;
    end;
  end;
end;

実世界のパフォーマンス事例研究

これらの最適化手法がどれほど大きな効果をもたらすかを示すため、PDF ページコピー操作を最適化した実例を見てみます。

初始状态:性能問題

元のアプリケーションには深刻な性能問題がありました。

1
2
3
4
5
6
7
8
9
// Original problematic approach
Starting PDF processing...
Analyzing page tree structure... (31 seconds)
Reordering pages by tree hierarchy... (34 seconds)
Creating temporary decompressed file... (12 seconds)
Processing metadata and bookmarks... (17 seconds)
Optimizing image quality... (16 seconds)
Copying single page... (9 seconds)
Total time: 119 seconds (1.98 minutes)

最適化後の状態: 解決策

前述の最適化戦略を適用した後。

1
2
3
4
5
6
7
8
// Optimized approach results
Starting PDF processing...
Direct page access (skipping tree analysis)... (0.2 seconds)
Copying page content directly... (0.8 seconds)
Skipping unnecessary metadata processing... (0 seconds)
Skipping image optimization... (0 seconds)
Cleanup and finalization... (0.2 seconds)
Total time: 1.2 seconds

大規模アプリケーションでの実装方針

本番環境でこれらの最適化を導入する際は、次の段階的な進め方を検討してください。

第 1 段階: すぐ効果が出る改善

  • 不要なメタデータ処理を削除する。
  • 単純なページ操作では、複雑なツリー操作をスキップする。
  • 基本的なリソースクリーンアップを実装する。
  • パフォーマンスロギングを追加する。

フェーズ2:メモリ管理。

  • 頻繁に利用されるオブジェクトのメモリプーリングを実装する。
  • 包括的なリソースクリーンアップを実装する。
  • 遅延読み込み戦略を実装する。
  • メモリ利用量の監視機能を追加します。

第3段階:高度な最適化。

  • バッチ処理に並列処理を実装します。
  • 複雑なキャッシュメカニズムを追加します。
  • ドキュメント分析に基づいた適応型処理を実装します。
  • 包括的なパフォーマンス回帰テストを追加します。

共通の問題点とその回避方法。

最適化戦略が最適でも、開発者はしばしば一般的な問題点に遭遇し、パフォーマンスの改善を打ち消してしまうことがあります。

過度最適化

開発者は、全体性能への影響が小さいコード部分を最適化してしまうことがあります。最適化の前には必ず性能分析を行ってください。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// Don't optimize everything - focus on bottlenecks
procedure OptimizeBasedOnProfiling;
begin
  // Profile first to identify real bottlenecks
  StartProfiling;
  
  // Only optimize the operations that actually matter
  if IsBottleneck('PageTreeTraversal') then
    OptimizePageTreeTraversal;
    
  if IsBottleneck('MemoryAllocation') then
    ImplementMemoryPooling;
    
  // Don't waste time optimizing operations that take <1% of total time
  StopProfiling;
end;

過早優化

首先實現基本機能、然後ルート據實際利用模式進行優化:

1
2
3
4
5
6
7
8
9
10
// Implement basic functionality first
function ProcessPDFBasic(FileName: string): Boolean;
begin
  // Get basic functionality working correctly
  Result := LoadPDF(FileName) and ProcessContent and SaveResult;
  
  // Only add optimizations after confirming correctness
  if Result and NeedsOptimization then
    Result := ProcessPDFOptimized(FileName);
end;

監控與維護

性能最適化は一度きりの作業ではありません。継続的な性能を確保するため、継続監視を実施します。

自動效能監控

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
// Implement continuous performance monitoring
type
  TPerformanceMonitor = class
  private
    FMetrics: TDictionary<string, TPerformanceMetric>;
    FAlertThresholds: TDictionary<string, Double>;
  public
    procedure RecordOperation(Operation: string; Duration: Double; MemoryUsed: NativeUInt);
    procedure CheckForRegressions;
    procedure GeneratePerformanceReport;
  end;
 
procedure TPerformanceMonitor.CheckForRegressions;
var
  Operation: string;
  Metric: TPerformanceMetric;
  Threshold: Double;
begin
  for Operation in FMetrics.Keys do
  begin
    Metric := FMetrics[Operation];
    if FAlertThresholds.TryGetValue(Operation, Threshold) then
    begin
      if Metric.AverageDuration > Threshold then
        LogAlert(Format('Performance regression detected in %s: %.2f ms (threshold: %.2f ms)',
          [Operation, Metric.AverageDuration, Threshold]));
    end;
  end;
end;

結論

PDF 処理性能の最適化は、多面的な課題であり、慎重な分析、戦略的な計画、体系的な実装が必要です。本記事で説明した技術は実際の場面で有効性が確認されており、処理時間を数分から数秒へ短縮し、ユーザー体験を大きく改善します。

最適化を成功させる鍵は、すべての PDF 操作が同じ効率で動くわけではないことを理解する点にあります。不要な処理を見つけて取り除き、効率的なリソース管理を導入し、特定のドキュメント構造に適したアルゴリズムを選ぶことで、大規模環境でも安定して動作する PDF 処理アプリケーションを作成できます。

性能最適化は反復的なプロセスであることを忘れないでください。定期的な監視、分析、テストにより、ドキュメントの種類や処理要件が変化しても最適化の効果を保てます。性能最適化への投資は、ユーザー満足度、システムの拡張性、運用効率という形で大きな見返りをもたらします。

現代の PDF 処理では、機能が正しいだけでは不十分です。アプリケーションはさまざまなドキュメント構造を効率よく処理し、現在のデジタル環境でユーザーが期待する性能水準を維持する必要があります。本ガイドの戦略を適用することで、正しく動作するだけでなく、現代的なアプリケーションに求められる応答性も備えた PDF 処理解決策を構築できます。

ここで紹介した手法は、複雑なツリー操作の削減から包括的なメモリ管理、並列処理まで、高性能な PDF 処理アプリケーションを構築するための土台になります。PDF 処理の最適化で成果を出すには、用途ごとの具体的な要件を理解し、これらの技術を最適な組み合わせで適用することが重要です。