Document Conversion: PDF <-> TIFF

Thank you for the sample code.

Unfortunately, it is not working properly with other TIFFs. Please refer to the attached file, you will see that the resulting PDF is skewed.

I need to make it work with any TIFF image, regardless of its size.

I tried changing the PdfRectangle settings, but the PDF is still not properly created.

C#
var rect = new PdfRectangle(0, 0, bitmap.Width, bitmap.Height);  
processor.RenderNewPage(rect, graph);  

Thanks,
Daniel

Hello Daniel,
This behavior occurs because you didn't specify the dpi for page rendering. If you want an image to occupy an entire page, use 72 as a dpi value and pass this value to the RenderNewPage method.

C#
using (PdfGraphics graph = processor.CreateGraphics())  
{  
    var rect = new PdfRectangle(0, 0, bitmap.Width, bitmap.Height);  
    graph.DrawImage(byteStream, new PointF(0, 0));  
    processor.RenderNewPage(rect, graph, 72, 72);  
}  

Should you need further assistance, let me know.

Hi,

I'm still a bit unclear as to how to properly convert  TIFF (or any bitmap for that matter) to a PDF.

Please refer to the attached TIFF. It was scanned at 200 dpi, pixel size of the image is 1696x2191, which roughly represents 8.5x11 inch document (1696/200 x 2191/200).

When I convert the image to PDF using your code and open it in Adobe, size of the document will be 23.56x30.43 inches (which is 1696/72 x 2191/72). I need the output PDF to be 8.5x11 while preserving the quality of the original image.

I changed your code, see the snippet below, but the output PDF is still 23.56x30.43 with lot of extra blank space.

C#
var rect = new PdfRectangle(0, 0, width, height);  
graphics.DrawImage(tiff, new PointF(0, 0));  
processor.RenderNewPage(rect, graphics, (float)resolutionX, (float)resolutionY);  

Thanks for your help,
Daniel

Hi Daniel,
An image is always inserted with a source resolution in this case. However, the page size should be set in points (1/72 of an inch). So, the "rect" PdfRectangle should be calculated as follows: the desired size multiplied to 72 ( and the 72 dpi value should be passed to the RenderNewPage method). Please review the following code snippet:

C#
float targetWidth = (float)1696 / 200;  
float targetHeight = (float)2191 / 200;  
var pageSize = new PdfRectangle(0, 0, targetWidth * 72, targetHeight * 72);  
graph.DrawImage(Image.FromStream(byteStream), new RectangleF(0, 0, targetWidth * 72, targetHeight *72));  
processor.RenderNewPage(pageSize, graph, 72, 72);  

Thanks, I assumed that changing the DPI to 72 and decreasing the size (targetWidth * 72, targetHeight * 72) of the image would also decrease the quality of the image, but it looks like the output PDF retains the original pixel size somehow? The image appears to be of the same quality although DPI and image width/height are smaller.

Also, my application using the sample code above is running as ClickOnce application. After I included DevExpress.Pdf.v16.1.Core assembly, it seems that I had to include several other assemblies that are referenced by Pdf.Core?

DevExpress.Spreadsheet.v16.1.Core.dll
DevExpress.Xpf.Core.v16.1.dll
DevExpress.RichEdit.v16.1.Core.dll

These are huge files, so I'm just making sure that this really is a requirement in order to use TIFF->PDF conversion.

Thanks again.

The "targetWidth" and "targetHeight" variables in my sample represent the desired page size measured in inches:

C#
//target width and height in inches  
float targetWidth = (float)1696/200;  
float targetHeight = (float)2191/200;  

The page size should be set in points (1/72 of an inch) in the RenderNewPage method so that it's necessary to multiply the "targetWidth" and "targetHeight" values by 72. Since an image is always inserted with its source resolution, it's also necessary to recalculate the image size and pass the rectangle with the required size to the DrawImage method. As a result, you'll get a document with the 8.5x11 page size (measured in inches).

As for assemblies, the PdfDocumentProcessorcomponent requires the following assemblies to be deployed:
DevExpress.Data.v16.1
DevExpress.Docs.v16.1
DevExpress.Pdf.v16.1.Core
DevExpress.Pdf.v16.1.Drawing

Hi,

I revisited this project and I'm able to properly export TIFF to PDF, but the performance is extremely slow. Using the code below, converting a 1 MB 77-page black&white 1-bit TIFF takes 9s on my PC. Using a different vendor's product, this operation (same TIFF) takes less than 1s!

Virtually all of the processing is spent on graphics.DrawImage method. Am I doing something incorrectly? Obviously, if your library takes almost 10x the time to export a small simple TIFF, the product is unusable. (I changed settings to remove PDF/A compatibility with no performance improvement).

Thank you for your help,
Daniel

C#
using(var memoryStream = new MemoryStream())  
using (var processor = new PdfDocumentProcessor())  
{  
    processor.CreateEmptyDocument(memoryStream, new PdfCreationOptions()  
    {  
        Compatibility = PdfCompatibility.PdfA2b,  
        DisableEmbeddingAllFonts = false  
    });  

    for (int frameIndex = 0; frameIndex < m_framesNum; frameIndex++)  
    {  
        // create new PDF page  
        var image = GetImage(frameIndex);  
        byte[] tiff = image.ToByteArray();  
        using (var graphics = processor.CreateGraphics())  
        {  
            float targetWidth = (float)image.Width / (float)image.Resolution.X;  
            float targetHeight = (float)image.Height / (float)image.Resolution.Y;  
            var pageSize = new PdfRectangle(0, 0, targetWidth * 72, targetHeight * 72);  
            graphics.DrawImage(tiff, new RectangleF(0, 0, targetWidth * 72, targetHeight * 72));  
            processor.RenderNewPage(pageSize, graphics, 72, 72);  
        }  
     }  
 }  

Hi Daniel,

Would you please provide us with the problematic .tiff file for testing? Which version of our controls you are using now? Also, please send us the code you used to perform this operation with another vendor. We will compare the results to improve our product accordingly. Thank you for your time and cooperation.

I'm on version 16.1.7.0.

I cannot attach the original document (it's a confidential document), but I'm attaching a different 70-page TIFF image which again takes 11s to covert!!!

The other vendor is WebSupergoo and their ABCPdf library. Using the code below, converting the attached document takes 1.1s on my PC.

Another vendor I've used is Atalasoft, conversion takes about 2-3 seconds using their library. So unless I'm not doing something properly, DevExpress is unusable…

Thanks again.

C#
private byte[] ConvertTifftoPdf_AbcPdf1(byte[] blob)  
{  
    using (var doc = new Doc())  
    {  
        doc.Read(blob);  
        using (var memStream = new MemoryStream())  
        {  
            doc.Encryption.Type = 0;  
            doc.Save(memStream);  
            blob = memStream.ToArray();  
        }  
    }  

    return blob;  
}  

Thank you for your clarification and providing the file. We have tested it on different operating system and obtain significantly different results. According to our research the most time was engaged by GDI methods calls.

I have attached the project I used for testing. Please run it on your side and let me know of your results.

Would you please specify which operating system is on your machine? I did not find implementation of the GetImage method in your code snippet. Please provide the code of this method or modify the attached project accordingly.

We greatly appreciate your time and efforts in researching this subject.

I am on Windows 7. I executed the code in your project and it took 14.5s… Even a few seconds more than before.

What OS did you use for testing and how long did the conversion take on your PC?

I ran your program on Windows 10 VM and it took 2.5s.

We need to have the same performance on Windows7+ machines. Why such a big difference?

We tested the project on Windows 8.1, Windows 7 and Windows 10 OS. It took 28 seconds on Windows 8.1, and 1,5 seconds on Windows 10.

We have researched the results and found that it takes some time to save images in a memory stream with the ImageFormat.Tiff format.

C#
bitmap.Save(byteStream, ImageFormat.Tiff);  

According to our tests, the Image.Save method operates faster with the Bmp format. So, you can change the code as follows:

C#
bitmap.Save(byteStream, ImageFormat.Bmp);  

With this approach we obtained the following results: 9 seconds on a virtual machine with Windows 8.1 and 10 seconds  - on Windows 7. Please check this point in your project.

So, it looks like GDI had low performance while operating with .tiff images on older operation systems. Since our Pdf suite uses GDI for image conversion and document rendering, our product also faces this limitation. I have informed our developers of this scenario. We will consider it while planning future improvements for our Pdf suite. However, we don't have the Tiff images parsing feature in our immediate development plans, so most probably, it will not be implemented in the near future. Thank you for your understanding.

Hi,

Changing the code to operate with BMP rather than TIFF format substantially increased performance on Windows 7 (it's now comparable to the performance of the other product that I used for testing).

However, I've noticed that the output PDF is about 33% bigger than when using the other vendor's code (this was an issue even when I used TIFF encoding). I'm attaching the two output files for comparison.

My system deals with millions of documents, so 33% increase in storage cost is significant. Can you explain what causes the size difference?

Thanks.

Second attachment.