DEV Community: IDRSolutions

How to add a watermark to a PDF in Java (Tutorial)

IDRSolutions — Fri, 10 Jul 2026 08:59:37 +0000

What is a PDF watermark?

A watermark in a PDF file is a visual element placed behind or over the main content of the page. They are typically faint and translucent. The primary purpose of adding a watermark to a PDF is to convey document status (like “Confidential”) or company branding.

Why Add a Watermark to a PDF Using Java?

If you are building an automated document pipeline, you may want to watermark a PDF using Java to protect your intellectual property. You can programmatically stamp your name or logo so that you can be identified as the owner, or automatically mark unfinished documents with a “Draft” image before they are distributed.

Which Java PDF library should you choose?

When looking to add a watermark to a PDF in Java, there are several options to choose from, each with tradeoffs to consider:

Apache PDFBox and iText can both add watermarks to PDFs, but they often require low-level handling of content streams and rendering edge cases to work reliably across complex documents. PDFBox is a free Java API, but can struggle with performance and inconsistent rendering. iText provides a more powerful API, but introduces AGPL/commercial licensing constraints
JPedal is often preferred for enterprise Java PDF watermarking because its high-fidelity and high-performance engine handles complex PDFs with ease and consistency. It is the perfect tool for batch-processing large volumes of documents.

How to watermark a PDF in Java using JPedal

First, download the JPedal JAR and then add it to your project.

To make edits to PDF files, you can use JPedal’s PDFManipulator class. You can learn more about this powerful tool here. To get started, we will create the basic structure for editing PDF files:

final PdfManipulator pdf = new PdfManipulator();
pdf.loadDocument(new File("inputFile.pdf"));
// insert operations here…
pdf.apply();
pdf.reset();
pdf.writeDocument(new File("outputFile.pdf"));
pdf.closeDocument();

Now we can add different operations depending on what kind of watermarks we want to add.

Add a Watermark to All PDF Pages

You should rebuild the list of pages each time when loading a document, otherwise a document with more pages than the previous one will not have the watermark applied to the additional pages.

final PageRanges pages = new PageRanges(1, pdf.getPageCount());

Add an Image Watermark to a PDF

To add an image watermark to a PDF:

final BufferedImage image = JDeli.read(new File("watermark.png"));
final float[] rect = new float[] {0, 0, 100, 100}; // X1, Y1, X2, Y2
addImage(pages, image, rect)

Images may be transparent or in different colour spaces.

Add a Text Watermark to a PDF

To add a text watermark to a PDF:

final float x = 10;
final float y = 10;
final int fontSize = 12;
final float[] color = {1, 0.3f, 0.2f, 1.0f}; // RGBA
pdf.addText(pages, "Hello World", x, y, BaseFont.HelveticaBold, fontSize, color[0], color[1], color[2], color[3]);

You can also draw text at an angle.

Add a Shape Watermark

To draw a shape onto your PDF:

final Shape shape = new Rectangle2D.Float(56.7f, 596.64f, 131.53f, 139.25f);
final DrawParameters params = new DrawParameters();
params.setStrokeColor(new float[] {1, 0, 0});
params.setFillRule(DrawParameters.STROKE);
pdf.addShape(pages, shape, params);

Using Annotations with Watermarks

Annotations by themselves are not suitable for watermarks, as users can easily remove them. However, you could use an annotation to create a clickable hyperlink over your PDF watermarks.

pdf.addAnnotation(pages, new Link(
    rect,
    Annotation.getFlagsValue(false, false, true, false, false, false, true, true, false, true),
    new float[3], // annotation color
    1.0f, // stroking opacity
    1.0f, // fill opacity
    "https://www.idrsolutions.com/"
));

Learn more

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!

How to extract JPG data from PDF

IDRSolutions — Wed, 08 Jul 2026 09:00:48 +0000

Overview

It is actually possible to extract some raw images from the PDF file. In general, images do not exist inside a PDF file – TIFFs and PNGs are ripped apart and the data stored in separate objects. The data is compressed using various compression formats (JBIG2, CCITT, FLATE, LZW).

However, one of the formats used for image data is the DCT format. This is actually a JPEG, and if you take the binary data out and save it in a file with a .jpeg format, you can open it. It includes not just the pixel data but also the JPEG header at the start – it is a complete file.

How is the JPEG data stored?

If you open a PDF file, the stored JPEG data will appear in the XObject image. Here is an example.

14 0 obj
<<
/Intent/RelativeColorimetric
/Type/XObject
/ColorSpace/DeviceGray
/Subtype/Image
/Name/X
/Width 2988
/BitsPerComponent 8
/Length 134030
/Height 2286
/Filter/DCTDecode
>>
stream (binary data) endstream

Key Indicators in the PDF Object

The /Type shows that this is an image. The key section is the /Filter value – DCTDecode indicates a JPEG (JPX shows a JPEG2000), which also works.

The data is between stream and endstream. You need to extract the raw data (cut and paste of text is unlikely to work) for the JPEG file. The **/Length **value shows how long it is.

Understanding the Colour Space

Lastly, the /Colorspace is important because it shows the colour-coding used in the JPEG. If it is DeviceRGB, it will look exactly as it is in the PDF display. Not many viewers understand types like DeviceCMYK – you may need a heavyweight package like Photoshop to see it correctly.

Notes on Clipped Images

If the image is clipped, you may find you can see background details not in the PDF display and the image may also be a different size or even upside down. But you have extracted the raw image data!

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.

How to redact PDF text with the JPedal Viewer

IDRSolutions — Fri, 03 Jul 2026 13:44:05 +0000

What is redaction and why should you use it?

Redaction is the process of removing sensitive information from a document so that it is suitable for publishing. It is commonly used in legal or government processes when documents are made available to the public while keeping certain details hidden.

If you want to publish parts of a document and have certain secrets remain secrets, then redaction is the right tool to use.

How Redaction in PDFs Works

Redaction typically consists of a black rectangle which covers up the text you want hidden. Traditionally, this was done by drawing over text with a black marker and then scanning it back in.

In the age of digital media, the concept is the same, but care must be taken to ensure that the content is actually removed and cannot be recovered through some sneaky techniques.

Pitfalls of Weak Digital Redaction Tools

One common mistake with low-quality redaction tools is drawing a black box over the text, but leaving the text remaining underneath. Other tools may then allow people to remove the boxes and see the text that was there, or you may just see that large characters like j may poke out of top or bottom of the black box.
Another mistake is replacing the text with empty characters of the same width. This is done to preserve the layout of subsequent characters, however it is possible to reverse-engineer what text used to be there by looking at the widths of the blank characters and comparing them with the widths from the font. Ideally, any blank spacing should be accumulated so not to leak any information.
Finally, a common pitfall to be aware of is that sometimes you can simply figure out what used to be there based on context e.g. “Jane ■■■” appears in one place, but “Jane Doe” appears nearby.

How to redact text using the JPedal Viewer

The JPedal Viewer has a tools menu which contains various operations you can perform on the currently opened document.

The tools menu is hidden by default, so you will need to enable it by going to edit -> preferences -> menu, and selecting tools.

Now that the tools menu is visible, you can open a PDF document in the JPedal Viewer, navigate to the desired page, and select redact from the tools menu.

This will bring up a dialog box to confirm which page you want to draw over, press OK to confirm.

You can now drag a rectangle over the area you want to redact. Any text that intersects this rectangle will be removed and a black box will take its place.

Download JPedal

You can download a copy of the JPedal jar from our website and get started using the JPedal Viewer as a PDF redaction tool.

How FormVu Adds Signature Fields to Converted HTML Forms

IDRSolutions — Wed, 01 Jul 2026 09:15:19 +0000

Digital Signatures: PDF vs HTML

If you convert PDF forms to HTML, you’ve probably run into the signature problem. Every other HTML form signature field converts cleanly, text inputs, checkboxes, dropdowns, radio buttons all have direct HTML equivalents whereas signature fields don’t.

The PDF spec ties them to cryptographic infrastructure (certificate chains, byte ranges, PKCS#7 envelopes) that doesn’t exist in a browser. Implementing a digital signature in HTML has always meant bolting something on after the fact.

Whereas with FormVu’s new feature users don’t need to download the raw PDF, sign it, and upload it back. FormVu’s May 2026 release adds a digital signature field to the HTML output. Signature fields in the source PDF now convert to a browser-based signing interface, just like every other form field.

How the HTML signature field works

When FormVu encounters a signature field in a source PDF and signing is enabled, the converted HTML includes an HTML electronic signature input at the same position in the form. The interface gives users three ways to sign:

Draw a signature directly in the browser
Upload an image of their signature
Type their name as text

No additional JavaScript libraries, no manual integration per form.

Enabling the signature field in HTML output

No need to write electronic signature HTML code yourself. The feature is controlled by a single JVM flag:

-Dorg.jpedal.pdf2html.useFormVuSigning=true

Or via the Java API:

FormViewerOptions options = new FormViewerOptions();
options.setUseFormVuSigning(true);

Set it to true and signature fields in the source PDF will convert to the signing interface. Set it to false (or omit it) and you get the previous behavior, signature fields render as empty space. You can find the Javadoc for FormVu digital signing here.

What this is (and what it isn’t)

FormVu’s signature feature is visual image-based signing, not cryptographic signing. The user draws, uploads, or types a signature, and that image is placed on the signature field. There’s no certificate embedding, no hash validation, no PKCS#7 envelope generated in the browser.

This approach works better for converter HTML forms since you’re outside the PDF signing infrastructure when signing. The browser captures the signature input, storing it, embedding it back into a PDF. If you need cryptographic signatures applied to the original PDF document, use JPedal directly.

Why this matters for PDF-to-HTML conversion

Signature fields were a major form field type that FormVu couldn’t convert before. For teams in insurance, government, healthcare, or compliance, where forms almost always require a signature, this was the gap that kept them serving raw PDFs or maintaining custom workarounds for every converted form.

That constraint is gone. With useFormVuSigning enabled, every signature field in the HTML form works. One flag, no per-form integration work.

Version and compatibility

Available in the May 2026 release of FormVu. There are no changes needed to your existing conversion pipeline beyond setting the JVM flag. The generated signature interface works in all current browsers.

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

IDRSolutions — Fri, 26 Jun 2026 11:20:07 +0000

This is part 2 of this subject. If you haven’t already read it, please read part 1 to understand the winding problem.

So to recap quickly: HTML5 only supports the Non-Zero winding rule, PDF supports both Non-Zero and Even-Odd rules. This means that we need to do something with shapes filled using the Even-Odd rule; they may not display correctly.

To demonstrate in this blog article, I will be using this example:

Just a red circle? The first time I saw it, that was my thought too. It’s only after changing the fill to a stroke that you realise what it actually is.

To help understand what’s going on, here it is with arrows showing the directions of the paths shown.

So our first thought was that we needed to make some kind of change to the way that we draw the shape. The obvious thing was to change the direction of some of the paths drawn in order to “convert” it from Even-Odd to Non-Zero.

Would alternating between clockwise and anti-clockwise work? Well, it was worth a try just to see what the effect was. And besides, it will only take a minute anyway.

Well, it turns out that it’s actually a bit of a headache. It’s fine if you are doing something simple, like just using lineTo to draw a box, but with bezier curves, it’s not quite so easy.

If you were to just reverse the order of the draw commands, you get something like this:

The order of the two control points makes a difference to the way that the curve is drawn. So what about reversing the order of the control points for the lines, too?

Oh, that doesn’t quite seem right either. The type of bezier curve used is a bezierCurveTo, which means that it takes our current position (where we ended up from the previous command), and draws a curve to a position that we specify using two control points.

What that means is that we need to step back to position backwards so that each command uses the position of the last command, so that our control points draw our curve correctly.

Good. So we can reverse the direction of the path so that our image draws correctly:

So are we done? No. While doing something like this may be OK for our no-entry sign, where we can control the order and direction of the shapes that get drawn, this approach is no good for a general case.

In the real world, we can’t just program for specific cases; we need to program for a general case so that our code works for any PDF file, not just the ones we’ve seen before.

And this means that doing something like alternating the direction between paths is not going to work. Here’s how it would look for our no-entry sign:

My next thought was that we could just fill the overlapping shapes with the background colour. But this wouldn’t work either because again, the order is important.

Even if we were to fill our two D’s with white, when we draw and fill the circle around them, it’s just going to cover up all of our hard work. It would also be no good for shapes that only partially overlap each other, because only the intersection of the two would need to be unfilled.

And it’s also important to remember that the unfilled pieces are just that – unfilled. By filling them with a background colour, you lose transparency, which means we wouldn’t be able to put anything behind our no entry sign to say you’re not allowed to do it.

So what now? If we can’t draw the shapes in a different order, and we can’t change the direction that some of the shapes are drawn, and we can’t fill in different pieces to create the illusion that we have fixed the problem, how else can we alter our shape so that it magically works using the Non-Zero winding rule?

We could get really clever and do some really complicated stuff and somehow cut our combined shape into lots of smaller shapes so that we can detect how it should be drawn, and then fill the smaller shapes accordingly.

A bit like this:

But that’s a little overkill for what we want. After all, it might not even matter that the shape we are drawing is drawn using Non-Zero rather than Even-Odd. And that’s a lot of computation time that will just be wasted, resulting in poor performance for our converter. And besides, I am nowhere near clever enough to be able to code that up.

Since I started playing with these shapes, there has been a niggling thought at the back of my mind. What if we were just to output these shapes as images and be done with it?

This would work just fine, but it is not optimal. Very rarely is there a shape drawn where the output from using either the Non-Zero or Even-Odd rule is actually different. So, outputting as an image every time a shape is drawn using the Even-Odd rule is going to output lots of images that are not actually required.

And this is no fun because shapes are nice. They scale beautifully, take no time at all to convert from PDF to HTML5, and take up barely any space at all compared to an image.

But what other option is there? Unfortunately, we are left with a compromise. The best we can do is create some criteria that the shape must pass before we output it as an image.

How to Save Java images as Tifs with JAI

IDRSolutions — Wed, 24 Jun 2026 09:54:07 +0000

Java makes it very easy to create images as BufferedImages which can then be saved out in standard image file formats. Here is the code to save an image as a Tif image using the JAI image (a free library from Sun).

com.sun.media.jai.codec.TIFFEncodeParam params = new com.sun.media.jai.codec.TIFFEncodeParam();
FileOutputStream os = new FileOutputStream(outputDir + imageName+”.tif”);

javax.media.jai.JAI.create(“encode”, image, os, “TIFF”, params);

This works very nicely but there are a number of extra tricks worth knowing.

Firstly, there is a compression option available to compress the image – use the modified code as shown below. There are several types of compression but several of them produce Tif files which will not display under Windows or Mac – COMPRESSION_PACKBITS works well.

com.sun.media.jai.codec.TIFFEncodeParam params = new com.sun.media.jai.codec.TIFFEncodeParam();

params.setCompression(com.sun.media.jai.codec.TIFFEncodeParam.COMPRESSION_PACKBITS);

Secondly, the type of image you save out can have a huge effect on the size of the Tif image. If you save a grayscale image, it produces a much smaller file and also compresses much better than an RGB or ARGB image.

You can find out the image type by using image.getType() – the int values returned are all static Constants in the BufferedImage class.

You can convert the image to another format by creating a second BufferedImage in that format and drawing the original image onto it. Here is the code to make any image grayscale.

BufferedImage image_to_save2=new BufferedImage(image_to_save.getWidth(),image_to_save.getHeight(), BufferedImage.TYPE_BYTE_GRAY);
image_to_save2.getGraphics().drawImage(image_to_save,0,0,null);
image_to_save = image_to_save2;

For our PDF library, we always generate images in ARGB (we need to because PDF files can have transparency which only works in ARGB). But sometimes the image is only grayscale. Using both these tricks of converting to grayscale and compressing allowed us to reduce the size of the Tif files created from a sample PDF file from 1.4 Meg to 52K – pretty impressive!

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.

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.