How to extract images from PDF files using c# and itextsharp

Welcome to my new blog! For my first post here, I’m rewriting and updating a post that originally appeared on my other blog some time back. Even though I wrote it back in September 2011, it remains my most popular programming post there, simply because of the lack of c# code examples online to do this.

PdfUtils source code zip file

Maybe things have changed now, but back when I wrote the original article, I was shocked to find no decent c# code examples that reliably, efficiently and quickly extracted images from pdf files. All the samples I found were copies of the same horrendous code, that iterated all the objects in a pdf file (this is terribly slow) and then used some uneducated guesswork to determine the formats of the image streams it had found.

If you take just a moment to think about such a technique, ask yourself where the collection of all embedded objects in the pdf came from. Most probably, itextsharp used a private method to parse the entire document and build up this collection of all objects. There are plenty of different kinds of objects that can be embedded, so this collection could potentially contain thousands of irrelevant objects. Now you iterate this entire collection again? There isn’t a right and a wrong way to extract images from a pdf file programmatically, but clearly, this way does more wrong than it does right.

A better way would surely be to iterate the pdf pages, and for each page, get a collection of only the images contained by that page, on the fly. As it happens, itextsharp supports this, with their PdfReaderContentParser type. All you need to do is call its ProcessContent method, passing it an instance of their IRenderListener interface (which you have to implement) each time it processes a page.

As a bonus, the IRenderListener interface has access to the PdfImageObject type, which has a GetDrawingImage method. This method does all the “heavy lifting” required to deserialize the image stream from the pdf file, so you don’t have to worry about what type of image stream was saved in the file, and how to read the stream data back into an image.

I didn’t find a sample that did this online; all I found was a vague reference to the technique by a developer, in the context of the original Java itext library, on which itextsharp is based, but once I knew the basics, finding the relevant types to use in itextsharp was a piece of cake. (After a few minutes of panicking paranoia… thinking “Oh crap, I hope they implemented this when porting it to .Net”)

My solution

If you download my PdfUtils.zip file, you’ll find a very small class library (the PdfUtils project) that contains a single static class, PdfImageExtractor, which uses an internal implementation of the IRenderListener interface. The solution also contains a console application that demonstrates extracting different format images from a pdf file, and saves them to disk.

Here is the full PdfImageExtractor source code as well:

1. using iTextSharp.text.pdf;
2. using iTextSharp.text.pdf.parser;
3. using System;
4. using System.Collections.Generic;
5. using System.IO;
6.  
7. namespace PdfUtils
8. {
9.     /// <summary>Helper class to extract images from a PDF file. Works with the most
10.     /// common image types embedded in PDF files, as far as I can tell.</summary>
11.     /// <example>
12.     /// Usage example:
13.     /// <code>
14.     /// foreach (var filename in Directory.GetFiles(searchPath, “*.pdf”, SearchOption.TopDirectoryOnly))
15.     /// {
16.     ///    var images = ImageExtractor.ExtractImages(filename);
17.     ///    var directory = Path.GetDirectoryName(filename);
18.     ///
19.     ///    foreach (var name in images.Keys)
20.     ///    {
21.     ///       images[name].Save(Path.Combine(directory, name));
22.     ///    }
23.     ///  }
24.     /// </code></example>
25.     public static class PdfImageExtractor
26.     {
27.         #region Methods
28.         #region Public Methods
30.         /// <summary>Checks whether a specified page of a PDF file contains images.</summary>
31.         /// <returns>True if the page contains at least one image; false otherwise.</returns>
32.         public static bool PageContainsImages(string filename, int pageNumber)
33.         {
34.             using (var reader = new PdfReader(filename))
35.             {
36.                 var parser = new PdfReaderContentParser(reader);
37.                 ImageRenderListener listener = null;
38.                 parser.ProcessContent(pageNumber, (listener = new ImageRenderListener()));
39.                 return listener.Images.Count > 0;
40.             }
41.         }
43.         /// <summary>Extracts all images (of types that iTextSharp knows how to decode) from a PDF file.</summary>
44.         public static Dictionary<string, System.Drawing.Image> ExtractImages(string filename)
45.         {
46.             var images = new Dictionary<string, System.Drawing.Image>();
48.             using (var reader = new PdfReader(filename))
49.             {
50.                 var parser = new PdfReaderContentParser(reader);
51.                 ImageRenderListener listener = null;
53.                 for (var i = 1; i <= reader.NumberOfPages; i++)
54.                 {
55.                     parser.ProcessContent(i, (listener = new ImageRenderListener()));
56.                     var index = 1;
58.                     if (listener.Images.Count > 0)
59.                     {
60.                         Console.WriteLine(“Found {0} images on page {1}.”, listener.Images.Count, i);
62.                         foreach (var pair in listener.Images)
63.                         {
64.                             images.Add(string.Format(“{0}_Page_{1}_Image_{2}{3}”,
65.                                 Path.GetFileNameWithoutExtension(filename), i.ToString(“D4”), index.ToString(“D4”), pair.Value), pair.Key);
66.                             index++;
67.                         }
68.                     }
69.                 }
70.                 return images;
71.             }
72.         }
74.         /// <summary>Extracts all images (of types that iTextSharp knows how to decode)
75.         /// from a specified page of a PDF file.</summary>
76.         /// <returns>Returns a generic <see cref=”Dictionary&lt;string, System.Drawing.Image&gt;”/>,
77.         /// where the key is a suggested file name, in the format: PDF filename without extension,
78.         /// page number and image index in the page.</returns>
79.         public static Dictionary<string, System.Drawing.Image> ExtractImages(string filename, int pageNumber)
80.         {
81.             Dictionary<string, System.Drawing.Image> images = new Dictionary<string, System.Drawing.Image>();
82.             PdfReader reader = new PdfReader(filename);
83.             PdfReaderContentParser parser = new PdfReaderContentParser(reader);
84.             ImageRenderListener listener = null;
86.             parser.ProcessContent(pageNumber, (listener = new ImageRenderListener()));
87.             int index = 1;
89.             if (listener.Images.Count > 0)
90.             {
91.                 Console.WriteLine(“Found {0} images on page {1}.”, listener.Images.Count, pageNumber);
93.                 foreach (KeyValuePair<System.Drawing.Image, string> pair in listener.Images)
94.                 {
95.                     images.Add(string.Format(“{0}_Page_{1}_Image_{2}{3}”,
96.                         Path.GetFileNameWithoutExtension(filename), pageNumber.ToString(“D4”), index.ToString(“D4”), pair.Value), pair.Key);
97.                     index++;
98.                 }
99.             }
100.             return images;
101.         }
103.         #endregion Public Methods
105.         #endregion Methods
106.     }
108.     internal class ImageRenderListener : IRenderListener
109.     {
110.         #region Fields
112.         Dictionary<System.Drawing.Image, string> images = new Dictionary<System.Drawing.Image, string>();
113.         #endregion Fields
115.         #region Properties
117.         public Dictionary<System.Drawing.Image, string> Images
118.         {
119.             get { return images; }
120.         }
121.         #endregion Properties
123.         #region Methods
125.         #region Public Methods
127.         public void BeginTextBlock() { }
129.         public void EndTextBlock() { }
131.         public void RenderImage(ImageRenderInfo renderInfo)
132.         {
133.             PdfImageObject image = renderInfo.GetImage();
134.             PdfName filter = (PdfName)image.Get(PdfName.FILTER);
135.  
136.             //int width = Convert.ToInt32(image.Get(PdfName.WIDTH).ToString());
137.             //int bitsPerComponent = Convert.ToInt32(image.Get(PdfName.BITSPERCOMPONENT).ToString());
138.             //string subtype = image.Get(PdfName.SUBTYPE).ToString();
139.             //int height = Convert.ToInt32(image.Get(PdfName.HEIGHT).ToString());
140.             //int length = Convert.ToInt32(image.Get(PdfName.LENGTH).ToString());
141.             //string colorSpace = image.Get(PdfName.COLORSPACE).ToString();
143.             /* It appears to be safe to assume that when filter == null, PdfImageObject
144.              * does not know how to decode the image to a System.Drawing.Image.
145.              *
146.              * Uncomment the code above to verify, but when I’ve seen this happen,
147.              * width, height and bits per component all equal zero as well. */
148.             if (filter != null)
149.             {
150.                 System.Drawing.Image drawingImage = image.GetDrawingImage();
152.                 string extension = “.”;
154.                 if (filter == PdfName.DCTDECODE)
155.                 {
156.                     extension += PdfImageObject.ImageBytesType.JPG.FileExtension;
157.                 }
158.                 else if (filter == PdfName.JPXDECODE)
159.                 {
160.                     extension += PdfImageObject.ImageBytesType.JP2.FileExtension;
161.                 }
162.                 else if (filter == PdfName.FLATEDECODE)
163.                 {
164.                     extension += PdfImageObject.ImageBytesType.PNG.FileExtension;
165.                 }
166.                 else if (filter == PdfName.LZWDECODE)
167.                 {
168.                     extension += PdfImageObject.ImageBytesType.CCITT.FileExtension;
169.                 }
171.                 /* Rather than struggle with the image stream and try to figure out how to handle
172.                  * BitMapData scan lines in various formats (like virtually every sample I’ve found
173.                  * online), use the PdfImageObject.GetDrawingImage() method, which does the work for us. */
174.                 this.Images.Add(drawingImage, extension);
175.             }
176.         }
177.         public void RenderText(TextRenderInfo renderInfo) { }
179.         #endregion Public Methods
181.         #endregion Methods
182.     }
183. }