DEV Community: IDRSolutions

How to remove text from a PDF in Java using JPedal (Tutorial)

IDRSolutions — Fri, 19 Jun 2026 08:56:21 +0000

Why remove text from a PDF file?

Removing text from a PDF in Java is a common requirement when dealing with sensitive information, names, email addresses, phone numbers, and other personally identifiable information.

Whether you are meeting GDPR redaction obligations, preparing documents for external sharing, or sanitising files before archiving, this tutorial explains how to do it using the JPedal PDF library.

What redaction actually means

Removing text from a PDF is a two-part problem. First, you find the text. Then you redact it, which itself has two layers:

Hide the text visually, usually done by drawing an opaque box over it
Remove it from the underlying content stream so it cannot be extracted by a PDF reader or copy-paste

Both steps are critical. Drawing a black box without editing the content stream is not true redaction. The text is still there, just invisible, and people will be able to copy and paste it. JPedal handles both steps, and together these are called redaction.

Choosing a Java PDF library for text removal

Most developers reach for Apache PDFBox first, but programmatically removing text from a PDF in Java, rather than just drawing over it, requires direct access to the content stream. JPedal exposes this through a clean API, handling both the search and the redaction in a few lines of code without manual stream manipulation.

Find, delete and redact text from a PDF in Java using JPedal

Open the PDF, scan each page for the target text, redact every match, then write out the modified document. The key methods are findTextOnPage() to locate matches and redact() to remove them. pdf.apply() commits the redaction operations to the document before writing.

Download JPedal trial jar.
Create a File handle to the PDF file
Include a password if file password protected
Open the PDF file
Scan the pages for text
Redact each match
Write the output and close

final File inputFile = new File("inputFile.pdf");
final FindTextInRectangle extract = new FindTextInRectangle(inputFile);
final PdfManipulator pdf = new PdfManipulator();
pdf.loadDocument(inputFile);
if (extract.openPDFFile()) {
    final int pageCount = extract.getPageCount();
    for (int page = 1; page <= pageCount; page++) {
        final float[] coords = extract.findTextOnPage(page, "the", SearchType.MUTLI_LINE_RESULTS);
        for (int val = 0; val < coords.length; val = val + 5) {
            pdf.redact(page, new float[] {coords[val], coords[val + 1], coords[val + 2], coords[val + 3]});
        }
    }
}
extract.closePDFfile();
//apply changes and write out
pdf.apply();
final File outputFile = new File("redactedFile.pdf");
pdf.writeDocument(outputFile);
pdf.closeDocument();

findTextOnPage() returns a flat float array of coordinates for each match, x1, y1, x2, y2, plus a fifth value (magic number documented here) at index 4, which is why the loop increments by 5. The output is a new PDF with every instance of the search term permanently removed from both the visual layer and the content stream.

The original file is not modified unless you overwrite it. Add try-catch blocks around the file operations and PDF calls for production use. For other PDF text manipulation tasks in Java, extracting, searching, or modifying content programmatically, see the JPedal tutorials.

You can expand your understanding of the PDF format by reading our other articles. Similarly, if there is a specific term for PDF you would like to know more about, our PDF Glossary has an extensive list of common terms.

How to draw PDF XFA Forms accurately (in your viewer)

IDRSolutions — Wed, 17 Jun 2026 09:58:16 +0000

Introduction

It is a bit of a complex task if any attempt is made to try and display XFA forms (by following the XFA specification) in a custom viewer rather than the Adobe life cycle. Either you are expected to have a similar functionality to the HTML parser, which should be intelligent enough to draw components recursively, or you should have a custom parser.

Structure of Subforms

Subforms in XFA may contain one or many subforms, and each of them may contain individual components that could be either containers (containing subforms, exclusion groups, area, subformset) or widgets (Rectangle, text, arc, input text, checkbox, choice-list and so on).

Handling Coordinates and Dimensions

Every subform’s x,y coordinates depend on previous and parent elements of it; its height depends on the height and width of the child elements if the H attribute or min H attribute is not specified.

In such a complex situation, the form height and x,y coordinates should be in memory or should be injected as an attribute in order to render them accurately (in my personal opinion, injecting data as an attribute consume much less memory).

Influence of Datasets

Datasets also have a major influence on the way the form is rendered, because form occurrences (number of forms) have to be multiplied based on bind data (be aware that bind names play a major role rather than the typical name attribute of the subform node).

Page Breaks and Content Overflow

Forms do have page breaks that render the form and its components on different pages. In addition to that, components of a single form can be split into multiple pages if their x,y location exceeds the allowed height of the content area of the PageArea element.

Recommended Handling Approach

One of the recommended ways of handling such a scenario described above is to draw the form coordination in memory or as attributes and splitting them later based on page breaks, data sets and content area overflow. Margins (left, right, bottom and top) also need to be considered on the stage of rendering.

Layout Considerations

Possible subform layouts such as Positioned, Top to bottom. Left to right, right to left, table and row have to be considered in finding the relevant heights of the given subform. The calculation may vary from one to another.

Dynamic XFA Forms and JavaScript

Dynamic XFA forms contain JavaScript (a real beast in XFA layout) that determines visibility and total occurrence of individual forms.

PDF to HTML5 conversion – No Even-Odd Winding Rule for filling shapes in HTML5? – Part 1

IDRSolutions — Fri, 12 Jun 2026 09:55:29 +0000

Introduction

When filling shapes in PDFs (and lots of other technologies) you get a choice between using the Even-Odd or the Non-Zero winding rule.

For those of you already thinking to yourself “what the hell is he talking about?” – don’t worry, I shall explain.

Understanding Shape Filling

A shape has an inside and an outside, and what is the inside and what is the outside is quite simple to work out, given that it is a simple shape. But what if you scribble over a page crossing over your paths several times to eventually join up where you started – what is the inside and what is the outside of this shape? And what about if you have nested shapes, or shapes that cover each other?

We can solve this problem by using the Even-Odd rule or the Non-Zero rule.

Even-Odd Rule

Even-Odd:

“This rule determines the “insideness” of a point on the canvas by drawing a ray from that point to infinity in any direction and counting the number of path segments from the given shape that the ray crosses. If this number is odd, the point is inside; if even, the point is outside.”
– w3C SVG

To illustrate:

(Reference w3C SVG 1.1)

Non-Zero Winding Rule

Non-Zero:

“This rule determines the “insideness” of a point on the canvas by drawing a ray from that point to infinity in any direction and then examining the places where a segment of the shape crosses the ray. Starting with a count of zero, add one each time a path segment crosses the ray from left to right and subtract one each time a path segment crosses the ray from right to left. After counting the crossings, if the result is zero then the point is outside the path. Otherwise, it is inside.”
w3C SVG 1.1

To illustrate:

(Reference w3C SVG 1.1)

The Key Difference

So to put it simply – when using the Non-Zero Winding Rule, the direction in which you draw the shapes matters. And if you try to draw a shape that is meant to use the Even-Odd rule instead of using the Non-Zero rule, you are going to end up with areas filled that should not be filled.

The Problem in PDF to HTML5 Conversion

And this becomes a problem when you are trying to convert from PDF (which supports both rules) to HTML5 which only supports the Non-Zero winding rule.

So this leaves us with a dilemma – what do we do with PDF shapes that use the Even-Odd rule when we convert the PDF to HTML5?

To find out, Part 2 of this blog article can be found here.

Odd coloured JPEGs in Java with ImageIO

IDRSolutions — Wed, 10 Jun 2026 08:41:38 +0000

Introduction

One of the best features about Java is the amount of low-level complexity it removes, allowing you to focus on developing the application. However, this does sometimes hide some important issues.

The Hidden Issue with ImageIO

We found one of these with the ImageIO class which offers a whole series of methods to save an image as a Tiff, a PNG or a JPEG. All the complexity is hidden and you can save out the image in one line of code (magic). Unfortunately, it also hides an interesting feature…

Transparency and JPEGs

ImageIO will happily save all kinds of images, including images with transparency (ARGB). And it will save it as a JPEG, even though JPEGs do not really support transparency. The problem comes when you try to view the JPEG. Java understands this hybrid image so it will load back correctly, but very few other tools do.

Because it has 4 bands (RGB are three and then transparency makes the fourth), most JPEG tools assume it must be in the CMYK colorspace and interpret the colours as CMYK. CMYK works completely differently to RGB so the image comes out looking wrong (often with a nasty red tint). Unfortunately, there is no way that a JPEG Decoder can spot this has happened – it is a bug in the way ImageIO works.

Manual Fix: Removing the Alpha Component

You can manually fix it by removing any alpha component from your BufferedImage before you save it in ImageIO with the following code:

private static BufferedImage convertARGBToRGB(BufferedImage image) {
int[] pixels = ((DataBufferInt) image.getRaster().getDataBuffer()).getData();
BufferedImage result = new BufferedImage(image.getWidth(), image.getHeight(), BufferedImage.TYPE_INT_RGB);
int[] pixelsOut = ((DataBufferInt) result.getRaster().getDataBuffer()).getData();
System.arraycopy(pixels, 0, pixelsOut, 0, pixels.length);
return result;
}

JDeli: A Better Alternative

JDeli is the best enterprise-level Java image library for performance and efficiency. In our JDeli image library (which provides a complete JPG Converter), we have actually added a flag to read the JPEG correctly for you if you know the file is broken.

try {
 Map map = new HashMap();
 map.put("DECODE_4_COMPONENTS_AS_ARGB","TRUE");
 BufferedImage image = JDeli.read(new File(“path/file.jpeg”), map);
} catch (IOException e) {
 // Deal with read error here.
}

So while Java makes life much easier most of the time, there are some interesting gotchas out there…

As experienced Java developers, we help you work with images in Java and bring over a decade of hands-on experience with many image file formats.

Why choose a pure Java PDF library?

IDRSolutions — Fri, 05 Jun 2026 12:45:37 +0000

What are the benefits of a pure Java PDF library and why does it matter?

PDF processing sits at the core of many enterprise systems, and the Java PDF library you choose to build your system have significant implications.
If you are building a new system then here is why you should choose a pure Java PDF library.

Whether you are selecting a PDF generation library in Java, for high-volume document creation, evaluating a Java PDF editor library for annotation workflows or integrating a Java PDF API into an existing microservice, the pure Java constraint narrows the field considerably, and for good reason.

Write once, run anywhere

Java’s slogan “write once, run anywhere” is particularly valuable in PDF processing. A pure Java library runs on any platform/operating system which removes the need for recompilation or platform-specific code.

You can deploy the same code that you wrote on your MacBook to a Linux or Windows server. This effectively removes any concerns for environment-specific bugs or cross-platform issues.

Simplified distribution and deployment

With a pure Java solution, the burden of managing different native binaries compiled for different architectures does not exist. You no longer need to maintain multiple builds for x86 or ARM.

This makes distribution much simpler, especially if you are shipping to end users. If deploying to the cloud then you only need to create a single container image.

Improved security and stability

Security is a critical concern in PDF processing. The PDF file format is very complex and has been a frequent target for vulnerabilities and exploits. This is especially common in native libraries written in low level code. (See this scary example!). Running code entirely within the JVM introduces a strong safety layer:

Memory management is handled automatically by the garbage collection, reducing risks like buffer overflow exploits
There is no direct memory access which removes the risk of segmentation faults or other similar memory corruption errors
Java’s security model ensures that execution is isolated and controlled

Easier debugging and maintenance

Java has a very mature ecosystem of development tools, including debuggers, profilers and refactoring utilities which are widely available and well integrated into modern IDEs. This has several benefits:

Identify and resolve issues faster
Easier to maintain codebase
More efficient refactoring

In contrast, debugging native code involves more complex tooling and can pose some platform-specific challenges.

Simpler licensing

When a library has no external dependencies it makes the licensing very straightforward. This can reduce the legal complexity of procurement and lowers the risk of compliance issues.

Conclusion

In conclusion, choosing a pure Java PDF library can be a strategic decision. By leveraging Java’s portability, security and ecosystem, enterprises can create large systems with much less technical debt in the long term. In the intricate field of PDF processing, this reduced complexity pays dividends across the entire software lifecycle.

The table below outlines the differences between a pure Java PDF SDK versus one that was written using native code and Java:

Resources

Looking for a pure Java PDF library to handle processing your documents? Check out JPedal.
Want to learn more about the PDF file format? We have been developing PDF software for over 20 years!

Dynamic XFA/PDF to HTML – resolveNode method

IDRSolutions — Wed, 03 Jun 2026 09:11:39 +0000

Dynamic XFA forms contain JavaScript which needs some considerable tidying up to convert into content which will run on a Browser.

In this technical article, our lead developer of FormVu (which converts Acrobat forms into standalone HTML5) gives you an insight into some of the technical issues involved. FormVu is the best tool for filling PDF forms in HTML.

An XFA form with an example of resolveNode.

In this article I do an overview of some factors that have to be taken into consideration prior to implementing resolveNode subroutine in your code.

Why resolveNode?

Adobe lifecycle designer follows the Ecma Script 357 specification to represent the SOM model structure.

In a simple example:

<class>

<student><name>john</name></student>.

<student><name>david</name></student>

</class>

If you want to access the name of the second student, then you need to pass the query as “class.student[1].name” for access

But such an array-based access algorithm is not available in regular JavaScript; therefore, the resolveNode method is implemented to reference the node information from an ECMAScript 357-supported script.

ResolveNode method plays a major role in adding, removing, and moving subform instances on the fly:

A nice html implementation example of this functionality can be found in this converted example.

Have a go at trying to add and delete items from purchase order form.

Steps to handle resolveNode function:

The following are steps that simplify the process of handling resolveNode functions.

Write down the short representation of your full XFA form model by removing the internal node structure of fields, so you can track the method insertion point and the caller of the function very quickly.
Always use descendant search prior to ascendant search: if you do not find the required item in descendants, then move to the ascendant nodes;
Use parent-by-parent search while traversing to ascendant nodes:
Check for [*] symbol: if you come across this sign, try to traverse through all the nodes that have the same named descendants of the particular node;
Check for “..” symbol for descendant search and “.parent” for accessing the parent node.

As you can see, it can be done but requires a large amount of pre-processing.

PDF to HTML conversion – matching PDF page size

IDRSolutions — Fri, 29 May 2026 09:25:47 +0000

A PDF file is designed to be resolution independent – they are defined using resolution-independent units so that the page will always appear the same size whether it is printed or displayed on any device (regardless of the dpi of the output device). So what happens if you use these units when outputting to HTML canvas and CSS?

It turns out that the page is actually smaller than the PDF page when displayed at 100%. In fact, the HTML page needs the values scaled to 133% to match the size of the PDF file at 100%. Then it all works correctly.

It is actually the same issue that forces us to correct for DPI between platforms in our PDF viewer. Some computers use 96 dpi, and some use 72 dpi (which is where the value 1.33 comes from, as it is 96 divided by 72). Printers can use values from 72 to pretty much infinity. This matters because if you draw a line which is 96 pixels on a 72 dpi display, it will be 1.3 inches long, but only 1 inch on a 96 dpi display.

Adobe made the very sensible decision that a PDF page should appear the same on whatever platform you use, so it adjusts the page size to ‘mimic’ 96dpi as the default setting.

So if you are using HTML, 1.33 is the magical scaling to ensure things appear the same size as they would in PDF when drawn onscreen. If you are using our PDF to HTML converter, the fix is in Friday’s release.

Comparing WebP compression algorithms

IDRSolutions — Thu, 28 May 2026 08:32:19 +0000

In this article, we will be comparing algorithms to compress webp image. To do this, we will be using our Java image library, JDeli. We will be comparing file size, quality of output, and speed. JDeli is the best pure Java image library for performance and efficiency.

For the baseline of our comparisons, we will use the following uncompressed image. It has a file size of 180KB. It takes just under 3 seconds to encode.

What types of compression does WebP support?

Unlike most other image formats, WebP has both a lossless and lossy compression format. Which is best for you all depends…

What is Lossy WebP compression?

When you compress WebP images with lossy compression, it is also known as irreversible compression due to the fact that some data is removed. The process uses the VP8 prediction code commonly used for videos, which includes the algorithm DCT (Discrete cosine transform) to then be able to remove redundant data.

This does mean webp quality loss is expected but usually not visible. Also, something to bear in mind is that you cannot return to the original quality once you have applied this compression. The advantage is that this compression can reduce WebP size much more effectively.

Using lossy compression reduced the file size to 6KB and took just under 2 seconds, and the quality was set to a default of 75.

What is Lossless WebP compression?

This compression, unlike lossy, preserves the original data so when decoded can return the file to its original form. To achieve this, multiple transformations are made, including several colour transforms along with a spatial transform and then finished off by applying a form of entropy coding known as LZ77 huffman coding.

This does then mean that the reduction in file size won’t be as significant, but that is not always the most important aspect when compressing.

Using lossless compression reduced the file size to 67KB and also took just under 2 seconds.

Conclusion

Using our webp compression tool, we can see the lossy far out ranks the lossless compression due to the much smaller file size for similar quality. If you want to reduce webp size, lossy would be your first choice but if you want to be able to return to the original image than the hit of an extra 61KB wouldn’t matter as much especially when they both take the around the same time to complete.

You can learn more about similar image formats by having a look at our Glossary. Our Java Image library JDeli has WebP support for you to convert, read and write the image file type. You can have a look at our documentation to learn more.

As experienced Java developers, we help you work with images in Java and bring over a decade of hands-on experience with many image file formats.

Introductory PDF Font Guide

IDRSolutions — Fri, 22 May 2026 09:32:42 +0000

PDF fonts is a tricky subject and one we frequently get asked about. So we have a lot of tutorials on the subject. I hope they prove useful, and if you have any specific questions, please send me a question and I will make it into an article.

So let us start at the beginning….

How do fonts work in a PDF file

PDF files can contain images, Vector graphics and text. All the text can be in any font. There are 5 standard font families which all PDF viewers must contain (Times, Helvetica, Courier, Symbol and ZapfDingbats) so these can be used in any document. You can use any other font – my daughter always uses her Malinka font because she loves the letters made from cats. In this case, there are three possible approaches. These are set in the PDF creation tool:-

Just include the name of the font and hope it is on everyone’s machine. If it is not, it will be replaced with a Standard font.
Embed the font. This means include the actual font data inside the PDF. You can then guarantee that it will be on everyone’s machine because it is in the PDF file (but can only be used by the PDF containing it). The problem with this is that some fonts are very large, so it makes the PDF files much bigger.
Embed and subset the font. This means include just the data needed to draw any characters. So if my daughter creates a PDF containing the phrase ‘THE CAT SAT ON THE MAT’, it would embed just the font data for the letters T, H, E, C, A, S, O, N, M. This is a good compromise as it keeps the file small but guarantees the PDF file will appear as you wanted it.

Types of PDF font

What can make things confusing is that PDF files can use several different types of font technology.

Type 3

This is the original and simplest font technology. Fonts generally look quite ‘crude’, and you cannot extract the text values.

Postscript (Type1)

These types of fonts produce much higher quality output, and you can extract the text values.

TrueType

This was created as an alternative to PostScript (for which Adobe owned the patents) by Microsoft and Apple. It also produces high-quality output and enables text extraction. Because it was the default for Windows, there is a much wider selection of fonts, but not all are well-designed.

OpenType

This is a ‘merger’ of the best bits from PostScript and TrueType.

Next steps

You should now have a basic grasp of how PDF fonts work in a PDF file. You might want to read the rest of our tutorials….

Dynamic XFA/PDF to HTML – resolveNode method

IDRSolutions — Wed, 20 May 2026 09:52:38 +0000

Dynamic XFA forms contain JavaScript, which needs some considerable tidying up to convert into content which will run on a Browser.

An XFA form with an example of resolveNode

In this article I do an overview of some factors that have to be taken into consideration prior to implementing resolveNode subroutine in your code.

Why resolveNode?

Adobe lifecycle designer follows the Ecma Script 357 specification to represent the SOM model structure.

In a simple example:

<class>

<student><name>john</name></student>.

<student><name>david</name></student>

</class>

In case you want to access the name of the second student, then you need to pass the query as “class.student[1].name” for access

But such an array-based access algorithm is not available in regular JavaScript; therefore, the resolveNode method is implemented to reference the node information from the ECMAScript 357 supported script.

The resolveNode method plays a major role in adding, removing, and moving subform instances on the fly:

A nice HTML implementation example of this functionality can be found in this converted example.

Have a go at trying to add and delete items from the purchase order form.

Steps to handle resolveNode function:

The following are steps that simplify the process of handling resolveNode functions.

Write down the short representation of your full XFA form model by removing the internal node structure of fields, so you can track the method insertion point and the caller of the function very quickly.
Always use descendant search prior to ascendant search: if you do not find the required item in descendants, then move to the ascendant nodes.
Use parent-by-parent search while traversing to ascendant nodes.
Check for [*] symbol: if you come across this sign, try to traverse through all the nodes that have the same named descendants of a particular node.
Check for “..” symbol for descendant search and “.parent” for accessing parent node.

As you can see, it can be done, but requires a large amount of pre-processing.

PDF to HTML5 conversion – Embed an image in HTML5 with Base64 encoding

IDRSolutions — Fri, 15 May 2026 13:40:13 +0000

Introduction

HTML5 can contain links to external images and other resources (which often makes the HTML5 page much faster to load because it is a small text file with links to the images, videos, or audio it needs). This work fine so long as you have network connectivity…

Embedding Images with Base64

One of the big new features in HTML5 is the ability for the code to work without a network connection and to store data offline in a cache. Sometimes, however, this functionality is overkill and you can embed an image more simply by just inserting the data into the HTML5 file.

An image consists of binary data so it needs to be stored in a suitable format inside the text file. Base64 encoding (a simple algorithm which converts bytes into a block of what looks like text data) is ideal (this is what you often use in emails to add in binary content). So instead of the more usual HMTL5 format of:

<img id="Im0″ style="display: none;" src="img/1/Im0.png"
alt="Im0″ width="540″ height="720″ />

you would see:

base64,iV…Big block of chars here…rDYgg=="
alt="Im0″ width="540″ height="720″ />

If you want to try BuildVu, there is a new flag to enable it in today’s release (it is commented out by default in ExtractPagesAsHTML.java example).

/**
 * embed image inside PDF as base64 encoded stream
 */
HTMLoutput.setBooleanValue(HTMLDisplay.EmbedImageAsBase64Stream, true);

Of course once you start playing with images, you may want to have far more control on images and be able to control their exact size.

What is AVIF image format?

IDRSolutions — Wed, 13 May 2026 09:03:18 +0000

What is AVIF?

AVIF stands for AV1 Image File Format and is used for storing images and video. It uses the same container format as HEIC images but with potentially better compression. It offers lossy and lossless compression. It offers an alternative to HEIC and JPEG image file formats but is not as well supported in web browsers.

It is an open standard with no patents.

The file name extension for this format is: .avif

Here are some other questions about AVIF you might also want to ask. If you have any other questions, please feel free to contact us.

What is it used for?

The format has many different use cases. It is an optimal choice for web developers using the format for still images, as it provides rich and vibrant images with a smaller size, leading to stable performance and a better user experience, which is why Web developers use AVIF to deliver fast-loading, visually rich websites.

The format is especially appealing for high-resolution photography, web graphics, icons, and animations due to its superior compression. Tests have shown AVIF files can be 50% smaller than JPEGs at similar quality, and even outperform WebP in many cases.

Differences compared to HEIC

While both use the HEIF container, AVIF also uses the AV1 compression format. AVIF often delivers better quality at lower file sizes and is an open standard with no patent concerns, making it more appealing for universal and commercial use.

Is it better than JPEG?

It may produce better compression than JPEG but JPEG is better supported by web browsers and general software. It is possible to convert AVIF to JPG using third-party software like JDeli.

Limitations and Browser Support

While AVIF is gaining significant popularity, particularly for web use, not all browsers and devices support it yet. Chrome, Firefox, and Safari (as of 2024/2025) include AVIF decoding, but some older browsers and operating systems may require fallback formats like JPEG or PNG.

Software support for editing and conversion is growing but still lags behind legacy image standards.

Is it possible to convert AVIF to PNG?

Yes. The reason many people do this is because PNG is a much better supported Image file format. To convert AVIF to PNG you will need to use a third-party software library.

How to open AVIF files in Java?

ImageIO (the built-in Java Image library) does not support AVIF images by default. JDeli lets you read and write Avif images or add AVIF support to ImageIO.