Converting TIFF to PDF using iText in Java

In the world of document processing, there are often scenarios where you need to convert images to PDF format. One such common image format is TIFF (Tagged Image File Format), which is widely used for high - quality images, especially in the printing and publishing industries. iText is a popular Java library that provides powerful capabilities for creating, manipulating, and converting PDF documents. In this blog post, we will explore how to use iText to convert TIFF images to PDF in Java.

Table of Contents#

  1. Core Concepts
  2. Typical Usage Scenarios
  3. Setting up the Project
  4. Code Example
  5. Common Pitfalls
  6. Best Practices
  7. Conclusion
  8. FAQ
  9. References

Core Concepts#

iText#

iText is a Java library that allows developers to create, manipulate, and convert PDF documents programmatically. It provides a rich set of APIs for tasks such as adding text, images, tables, and more to PDF files.

TIFF#

TIFF is a flexible and widely supported image file format. It can store multiple images in a single file (multi - page TIFF), and it supports various compression methods and color models. When converting a TIFF to PDF, we need to extract each page of the TIFF image and add it to the PDF document.

Typical Usage Scenarios#

  • Document Archiving: TIFF images are often used for high - quality scans. Converting these TIFF files to PDF makes them more accessible and easier to manage in an archive system.
  • Printing: PDF is a standard format for printing. Converting TIFF images to PDF ensures that the images can be printed correctly using common printing software.
  • Sharing: PDF files are more widely supported across different platforms and devices. Converting TIFF images to PDF makes it easier to share the images with others.

Setting up the Project#

To use iText in your Java project, you need to add the iText dependency to your project. If you are using Maven, add the following dependency to your pom.xml:

<dependency>
    <groupId>com.itextpdf</groupId>
    <artifactId>itext7-core</artifactId>
    <version>7.2.5</version>
    <type>pom</type>
</dependency>

If you are using Gradle, add the following to your build.gradle:

implementation 'com.itextpdf:itext7-core:7.2.5'

Code Example#

import com.itextpdf.io.image.ImageData;
import com.itextpdf.io.image.ImageDataFactory;
import com.itextpdf.kernel.geom.PageSize;
import com.itextpdf.kernel.pdf.PdfDocument;
import com.itextpdf.kernel.pdf.PdfWriter;
import com.itextpdf.layout.Document;
import com.itextpdf.layout.element.Image;
 
import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
 
public class TiffToPdfConverter {
 
    public static void convertTiffToPdf(String tiffFilePath, String pdfFilePath) throws IOException {
        // Create a new PDF writer
        PdfWriter writer = new PdfWriter(pdfFilePath);
        // Create a new PDF document
        PdfDocument pdf = new PdfDocument(writer);
        // Create a new document instance
        Document document = new Document(pdf, PageSize.A4);
 
        // Read the TIFF file
        File tiffFile = new File(tiffFilePath);
        int pageIndex = 0;
        BufferedImage page;
        while ((page = ImageIO.read(tiffFile, pageIndex)) != null) {
            // Convert the BufferedImage to ImageData
            java.io.ByteArrayOutputStream baos = new java.io.ByteArrayOutputStream();
            ImageIO.write(page, "png", baos);
            ImageData imageData = ImageDataFactory.create(baos.toByteArray());
 
            // Create an Image object from the ImageData
            Image image = new Image(imageData);
 
            // Add the image to the PDF document
            document.add(image);
            pageIndex++;
        }
 
        // Close the document
        document.close();
    }
 
    public static void main(String[] args) {
        String tiffFilePath = "input.tiff";
        String pdfFilePath = "output.pdf";
        try {
            convertTiffToPdf(tiffFilePath, pdfFilePath);
            System.out.println("TIFF converted to PDF successfully.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Code Explanation#

  1. Initialization: We first create a PdfWriter and a PdfDocument to write the PDF file. Then we create a Document instance which provides a higher - level API for adding elements to the PDF.
  2. Reading the TIFF file: We use ImageIO to read each page of the TIFF file.
  3. Converting the image: We convert the BufferedImage to ImageData which is used by iText to represent an image.
  4. Adding the image to the PDF: We create an Image object from the ImageData and add it to the PDF document.
  5. Closing the document: Finally, we close the Document to save the changes.

Common Pitfalls#

  • Memory Issues: Reading large TIFF files can consume a significant amount of memory, especially if the TIFF file has many pages or high - resolution images. To avoid this, you can process the TIFF file page by page and release the memory after each page is processed.
  • Image Quality: The conversion process may result in a loss of image quality. You can adjust the compression settings in iText to balance between file size and image quality.
  • Dependency Issues: Make sure you have the correct version of iText and its dependencies. Incompatible versions can lead to runtime errors.

Best Practices#

  • Error Handling: Always handle exceptions properly when working with file operations. In the code example, we catch IOException to handle errors related to file reading and writing.
  • Resource Management: Close all resources such as PdfWriter and Document after you are done with them to avoid resource leaks.
  • Testing: Test your code with different types of TIFF files, including single - page and multi - page TIFFs, to ensure that it works correctly in all scenarios.

Conclusion#

Converting TIFF to PDF using iText in Java is a straightforward process. By understanding the core concepts, typical usage scenarios, and following best practices, you can effectively convert TIFF images to PDF documents. iText provides a powerful and flexible API for working with PDF files, making it a great choice for document processing tasks.

FAQ#

Q1: Can iText handle multi - page TIFF files?#

Yes, iText can handle multi - page TIFF files. In the code example, we use ImageIO to read each page of the TIFF file and add it to the PDF document.

Q2: Does the conversion process affect the image quality?#

The conversion process may affect the image quality depending on the compression settings. You can adjust the compression settings in iText to control the image quality.

Q3: Can I convert TIFF files with different color models?#

Yes, iText can handle TIFF files with different color models. The ImageIO library used in the code example can read TIFF files with various color models.

References#

2025-10