Technical FAQs

Today’s organizations are inundated with a variety of document and image formats on a regular basis. By integrating comprehensive PDF functionality into their applications, developers can provide the tools to manage those files much more easily. Converting files into PDFs makes them easier to share, modify, and annotate without having to worry about compatibility issues across applications.

Simply converting documents or images into searchable PDF files is easy enough, but in many cases, several files need to be merged into a single document or one large file must be split into multiple documents. Accusoft’s ImageGear SDK gives applications the ability to process PDFs programmatically, allowing users to quickly prepare documents for viewing and collaboration.

How to Merge PDF Files with ImageGear Using C#

ImageGear can merge two multi-page PDF documents into a single document. This is especially useful for organizations that have multiple files associated with the same workflow or account, such as loan applications or medical records. The following steps will walk you through the merge PDF process using ImageGear.NET in C#.

Step 1: Initialize PDF Support

Before getting started, you’ll need to initialize PDF support within ImageGear.NET (if you haven’t done so already during deployment). This initialization will allow your application to load, save, and process PDF files.

After creating a new “Console Application” and adding the required assembly reference and resources, you can use the following code snippet to load and save PDF files.

using System.IO;
using ImageGear.Formats;
using ImageGear.Formats.PDF;
using ImageGear.Evaluation;
namespace MyPDFProject
{
    class Program
    {
        public void Initialize()
        {
            // Initialize evaluation license.
            ImGearEvaluationManager.Initialize();
            ImGearEvaluationManager.Mode = ImGearEvaluationMode.Watermark;
            // Initialize common formats.
            ImGearCommonFormats.Initialize();
            // Add support for PDF files.
            ImGearFileFormats.Filters.Insert(0, ImGearPDF.CreatePDFFormat());
            ImGearPDF.Initialize();
        }
        public void Terminate()
        {
            // Dispose of support for PDF files.
            ImGearPDF.Terminate();
        }
        public void LoadAndSave(string fileIn, string fileOut)
        {
            ImGearPDFDocument igPDFDocument = null;
            try
            {
                // Load the PDF document.
                using (FileStream inStream = new FileStream(fileIn, FileMode.Open))
                    igPDFDocument = (ImGearPDFDocument)ImGearFileFormats.LoadDocument(inStream, 0, (int)ImGearPDFPageRange.ALL_PAGES);
                // Save the PDF document to a new file.
                ImGearPDFSaveOptions pdfOptions = new ImGearPDFSaveOptions();
                using (FileStream outStream = new FileStream(fileOut, FileMode.Create))
                    ImGearFileFormats.SaveDocument(igPDFDocument, outStream, 0, ImGearSavingModes.OVERWRITE, ImGearSavingFormats.PDF, pdfOptions);
            }
            finally
            {
                igPDFDocument?.Dispose();
            }
        }
        static void Main(string[] args)
        {
            Program myProgram = new Program();
            myProgram.Initialize();
            myProgram.LoadAndSave(@"C:\PATHTOPDF\FILENAME.pdf", @"C:\PATHTOPDF\NEWNAME.pdf");
            myProgram.Terminate();
        }
    }
}

       

Step 2: Set the Merge PDF Parameters

You will need to determine what order the documents will be combined in and set the page numeration for the new document.

Step 3: Merge the PDF Documents

Once you’ve identified the files you want to merge and the order they should go in, you can use the “MergePdfDocuments” command to assemble the new PDF file. Here’s what the code snippet looks like in C#:

        // Merges two PDF document into a third PDF document.
        public void Merge(string fileInFirst, string fileInSecond, string fileOut)
        {
            // ImageGear uses zero-based page numbers.
            const int FIRST_PAGE_INDEX = 0;
            ImGearPDFDocument igPDFDocumentFirst = null;
            ImGearPDFDocument igPDFDocumentSecond = null;
            ImGearPDFDocument igPDFDocumentResult = null;
            try
            {
                // Load the source PDF documents.
                using (FileStream inStream = new FileStream(fileInFirst, FileMode.Open))
                    igPDFDocumentFirst = (ImGearPDFDocument)ImGearFileFormats.LoadDocument(inStream, 0, (int)ImGearPDFPageRange.ALL_PAGES);
                using (FileStream inStream = new FileStream(fileInSecond, FileMode.Open))
                    igPDFDocumentSecond = (ImGearPDFDocument)ImGearFileFormats.LoadDocument(inStream, 0, (int)ImGearPDFPageRange.ALL_PAGES);
                // Create the resulting PDF document.
                igPDFDocumentResult = new ImGearPDFDocument();
                // Copy all pages of first document into resulting PDF document.
                for (int pageIndex = FIRST_PAGE_INDEX; pageIndex < igPDFDocumentFirst.Pages.Count; pageIndex++)
                    igPDFDocumentResult.Pages.Add(igPDFDocumentFirst.Pages[pageIndex].Clone());
                // Copy all pages of second document into resulting PDF document.
                for (int pageIndex = FIRST_PAGE_INDEX; pageIndex < igPDFDocumentSecond.Pages.Count; pageIndex++)
                    igPDFDocumentResult.Pages.Add(igPDFDocumentSecond.Pages[pageIndex].Clone());
                // Save the resulting PDF document to a new file.
                ImGearPDFSaveOptions pdfOptions = new ImGearPDFSaveOptions();
                using (FileStream outStream = new FileStream(fileOut, FileMode.Create))
                    ImGearFileFormats.SaveDocument(igPDFDocumentResult, outStream, 0, ImGearSavingModes.OVERWRITE, ImGearSavingFormats.PDF, pdfOptions);
            }
            finally
            {
                igPDFDocumentFirst?.Dispose();
                igPDFDocumentSecond?.Dispose();
                igPDFDocumentResult?.Dispose();
            }
        }
        static void Main(string[] args)
        {
            Program myProgram = new Program();
            myProgram.Initialize();
            myProgram.Merge(@"C:\PATHTOPDF\FIRSTFILENAME.pdf", @"C:\PATHTOPDF\SECONDFILENAME.pdf", @"C:\PATHTOPDF\NEWNAME.pdf");
            myProgram.Terminate();
        }

After merging your files into a new document, you can begin working with the resulting PDF using ImageGear’s other PDF features:

• Compressing PDF files
• Set PDF security features
• Manage PDF metadata
• Add watermarks to PDF
• Edit PDF content
• Extract text from PDF

How to Split PDF Files with ImageGear Using C#

While the merge PDF command is used to combine multiple documents into a new, single PDF file, the split PDF command saves pages from an existing document as a separate document. A three-page PDF file, for instance, can be broken into three, single-page PDF documents.

Once you’ve initialized PDF support for ImageGear.NET, you can split a PDF document by following a few simple steps:

Step 1: Read the PDF into a System.IO.Stream Object

This allows ImageGear to read the stream using ImGearFileFormats.LoadDocument(FILE NAME) command.

Step 2: Determine PDF Page Count

The ImGearPDFDocument.Pages property provides access to the document’s page array, which can then be used to assemble a new document.

Step 3: Create a New PDF Document

The ImGearPDFDocument object can be used to create an empty PDF document that will serve as the destination file for the split pages.

Step 4: Insert Pages into the New Document

The InsertPages command takes specific pages from the source document (the PDF you’re splitting), and inserts them into the destination document. After the pages are inserted, you can save the new PDF to disk or memory. Keep in mind that the original document will still contain all pages, so splitting it into two documents will require you to create two new documents.

Here is a what splitting a single PDF document into several single-page PDF documents looks like in C#:

public void Split(string fileIn, string directoryOut)
        {
            // ImageGear uses zero-based page numbers.
            const int FIRST_PAGE = 0;
            // Ensure output directory exists.
            if (!System.IO.Directory.Exists(directoryOut))
                Directory.CreateDirectory(directoryOut);
            // Load the source PDF document.
            using (FileStream inStream = new FileStream(fileIn, FileMode.Open))
            {
                using (ImGearPDFDocument igPDFDocument = ImGearFileFormats.LoadDocument(inStream, FIRST_PAGE, (int)ImGearPDFPageRange.ALL_PAGES) as ImGearPDFDocument)
                {
                    // Write each page in source PDF document to a separate PDF file.
                    for (int pageIndex = FIRST_PAGE; pageIndex < igPDFDocument.Pages.Count; pageIndex++)
                    {
                        // Construct the output filepath.
                        string outputFileName = string.Format("{0}_{1}.pdf", Path.GetFileNameWithoutExtension(fileIn), pageIndex + 1);
                        string outputPath = System.IO.Path.Combine(directoryOut, outputFileName);
                        // Create a new empty PDF document.
                        using (ImGearPDFDocument igPDFDocumentResult = new ImGearPDFDocument())
                        {
                            // Insert page into new PDF document.
                            igPDFDocumentResult.InsertPages((int)ImGearPDFPageNumber.BEFORE_FIRST_PAGE, igPDFDocument, pageIndex, 1, ImGearPDFInsertFlags.DEFAULT);
                            // Save new PDF document to file.
                            igPDFDocumentResult.Save(outputPath, ImGearSavingFormats.PDF, FIRST_PAGE, FIRST_PAGE, 1, ImGearSavingModes.OVERWRITE);
                        }
                    }
                }
            }
        }
        static void Main(string[] args)
        {
            Program myProgram = new Program();
            myProgram.Initialize();
            myProgram.Split(@"C:\PATHTOPDF\FILENAME.pdf", @"C:\PATHTOPDF\OUTPUTDIRECTORY");
            myProgram.Terminate();
        }

Enhance Your PDF Capabilities with ImageGear

Accusoft’s ImageGear SDK provides a broad range of document and image processing functions beyond the ability to split and merge PDFs. Whether you need powerful file conversion capabilities, multi-language OCR support, or image cleanup, correction, and transformation functions, ImageGear integrations can enhance your application’s performance and versatility. 

Learn more about the ImageGear collection of SDKs and see how they can help you shorten your development cycle and get your innovative products to market faster.

The financial industry has made significant investments in document lifecycle management solutions to enhance their productivity, accuracy, and flexibility. There is broad recognition that paper-based processes are a huge source of waste and inefficiency, but simply transitioning away from paper often isn’t enough on its own to achieve true digital transformation. That’s because performing a digital-based process manually still presents many of the same problems. In order to leverage the true benefits of digital document management, FinTechs need to implement data capture and document generation capabilities as part of a broader process automation solution.

A Quick History of Data Capture & Document Generation

To understand how FinTechs can use data capture and document generation technology to enable their digital transformation, it’s helpful to take a moment to understand the history of these tools and how they’ve developed since their origins.

Data Capture

The financial industry was an early innovator in data capture technology with the development of the specialized OCR-A font in the 1960s. This simple monospace font is still used today for the account and routing numbers on an ordinary bank check. Early data capture technology relied on pattern recognition, so an exact pixel match was needed to read the characters electronically and match them to a corresponding character in a font library. While this worked well enough for scanning printed bank checks into a computer system to track transactions, reading anything else on the check with an automated system required further developments in data capture tools.

Modern character recognition technology utilizes a more sophisticated feature detection approach that uses the component elements of each character to distinguish them from one another. An “A,” for example, usually consists of the same basic elements (two angular lines that come to a point with a horizontal line crossing them) regardless of the font used. Breaking characters down into their component elements has even made it possible for software to read handwritten characters as well as machine-printed text.

Document Generation

Document generation technology emerged in the 1970s in the form of document assembly, which was originally used by lawyers to streamline contract creation. Contracts are highly structured and rules-oriented, which made it easy to build a decision-tree logic that could be understood by the software tools of that era. Early document assembly programs used a collection of document templates that incorporated conditional fields the software could replace automatically each time it generated a contract.

Modern document assembly is typically used as part of a more robust document automation solution. Software extracts information from a database and inserts it into a template to generate unique documents quickly, easily, and accurately. These programs are much more sophisticated and flexible than early document assembly tools, allowing organizations to programmatically generate a wide range of documents without ever having to look at the contents prior to the final review process.

Data Capture & Document Assembly in FinTech Today

Despite being an early innovator in OCR technology, the financial industry has been slow to implement more robust data capture capabilities throughout their operations. According to a recent study, 63% of banks are still collecting information from documents manually, a process that’s not only time consuming, but also incredibly prone to error. They’ve been slightly faster to adopt document generation, with 49% of banks still relying on manual processes to create documents. 

Ironically, FinTech organizations are even more dependent upon manual practices than traditional banks. When it comes to data capture, 75% of FinTechs are reviewing documents and entering their data manually rather than using an automated solution. The story is largely the same for document generation, as 79% of them are still creating documents manually.

Understandably, most of these organizations are planning to implement some form of automated data capture and document generation solution within the next two to three years. That’s because they recognize that it will be difficult to achieve true digital transformation without them.

Why Data Capture and Document Generation Are So Important for FinTech

FinTech companies have developed a wide range of innovative financial tools that allow consumers to take better control of their finances and help organizations manage their resources more efficiently. In order to deliver those streamlined solutions, however, FinTechs need to have the capabilities in place to make their own processes more efficient.

Data capture and document generation work together to help these organizations maximize the value and potential of their document management systems. Financial information can be submitted in many different formats, ranging from digital forms and fillable PDFs to images, flattened PDFs, and scanned documents. Extracting information from each of these formats requires a sophisticated understanding of data capture that few software developers possess. 

Once that data is extracted, it can be routed anywhere it’s needed by workflow automation tools. That could be a new document that’s being generated, but more often it will be sent to a database. When the time comes to generate a new document, previously captured information can be inserted wherever it’s needed programmatically. Multiple documents (or just sections of them) can also be merged or split apart to create entirely new ones filled with information drawn from several sources.

All of this can be done in a matter of seconds with the right software integrations, which saves a tremendous amount of time for FinTech teams who have many other priorities to focus on. By incorporating robust data capture and document generation capabilities into their platforms, they can provide faster, better functionality to their customers. Rather than uploading a document and waiting for it to be processed, information can be extracted and routed wherever it’s needed instantly to facilitate faster reviews and resolutions.

Another key benefit of data capture and document generation is accuracy. Between manually reviewing information, entering it by hand into a system, and then retrieving it to create new documents, there are plenty of opportunities for mistakes to be made. In a financial context, those errors often have the potential to be systemic, creating additional errors that are time consuming and expensive to remediate. Automated extraction and assembly remove the risk of human error, which enables FinTechs to accelerate and scale their processes more effectively.

Integrating Data Capture and Document Generation with Accusoft

For over 30 years, Accusoft has been a pioneer in building software integrations that expand application functionality. We provide a variety of data capture and document generation solutions that meet the needs of today’s FinTech platforms. Whether you’re incorporating functionality directly into your application with an SDK or deploying a cloud-based solution that connects to one of our APIs, we have the flexibility to help you integrate the features you need to complete your digital transformation.

To learn more about how Accusoft can enhance your FinTech application with data capture and document generation, talk to one of our solutions experts today.

Continuous innovation has allowed Accusoft to build sustained success over the course of three decades. Much of that innovation comes from talented developers creating novel solutions to everyday problems, many of which go on to become patented technologies that provide the company with an edge over competitors. 

Others, however, are the byproduct of looking at problems from a different perspective or using existing technologies in unique ways. Accusoft supports both approaches by hosting special “hackathon” events each year. These events encourage developers to spend time working on their own unique projects or try out ideas they think may have potential but have never been implemented.

For this year’s hackathon, I took a closer look at how our SmartZone SDK could be implemented as part of an automation solution within a .NET environment without creating an entire application from the ground up. What I discovered was that PowerShell modules offer a quick and easy way to deploy character recognition for limited, unique use cases.

.NET and PowerShell

One of the underestimated abilities of the .NET infrastructure is support loading and executing assemblies out of box from the command line using a shell module. Although there are many shell variants available, PowerShell comes preinstalled on most Windows machines and is the only tool required to make the scripts and keep them running. PowerShell also runs on Linux and macOS, which makes it a true cross-platform task automation solution for inventive developers who crave flexibility in their scripting tools. 

Incorporating the best features of other popular shells, PowerShell consists of a command-line shell, a scripting language, and a configuration management framework. One of the unique features of PowerShell, however, is that unlike most shells which can only accept and return text, it can do the same with .NET objects. This means PowerShell modules can be used to build, test, and deploy solutions as well as manage any technology as part of an extensible automation platform.

Implementing SmartZone Character Recognition

Accusoft’s SmartZone technology allows developers to incorporate advanced zonal character recognition to capture both machine-printed and hand-printed data from document fields. It also supports full page optical character recognition (OCR) and allows developers to set confidence values to determine when manual review of recognition results are necessary. 

Implementing those features into an application through a third-party integration is the best way to incorporate recognition capabilities, but there are some use cases where they might need to be used for general tasks outside of a conventional workflow. A number of Accusoft customers, for instance, had inquired about simple ways to use some of SmartZone’s features in their existing process automation software without having to spend weeks of development time integrating those capabilities on a larger scale.

Thanks to the versatility of PowerShell, there’s no reason to build such an application from scratch. SmartZone’s zonal recognition technology can easily be incorporated into any .NET environment with just a few snippets of code. PowerShell syntax itself is not very difficult to understand and for a quick start it should be enough to use a Windows Notepad application, but we recommend using your favorite integrated development environment (IDE) for a better experience.

Getting Started

First, you need to download SmartZoneV7.0DotNet-AnyCPU.zip from the Accusoft SmartZone download page and unpack it to any suitable directory. This bundle contains all required binaries to run SmartZone.

Create a Simple.ps1 file inside the unpacked directory and start typing your script:

using namespace System.Drawing
using namespace System.Reflection
using namespace Accusoft.SmartZoneOCRSdk

# Load assemblies.
Add-Type -AssemblyName System.Drawing
$szPath = Resolve-Path ".\bin\netstandard2.0\Accusoft.SmartZoneOCR.Net.dll"
[Assembly]::LoadFrom($szPath)

# Create a SmartZone instance.
$szObj = [SmartZoneOCR]::new()
$szAssetsPath = Resolve-Path ".\bin\assets"
$szObj.OCRDataPath = $szAssetsPath.Path

# Licensing
# $szObj.Licensing.SetSolutionName("Contact Accusoft for getting the license.")
# $szObj.Licensing.SetSolutionKey(+1, 800, 875, 7009)
# $szObj.Licensing.SetOEMLicenseKey("https://www.accusoft.com/company/legal/licensing/");

# Load test image.
$bitmapPath = Resolve-Path ".\demos\images\OCR\MultiLine.bmp"
[Bitmap] $bitmap = [Image]::FromFile($bitmapPath.Path)

# Recognize the image and print the result.
$result = $szObj.Reader.AnalyzeField([Bitmap] $bitmap);
Write-Host $result.Text

# Free the resources.
$bitmap.Dispose();
$szObj.Dispose();

This simple code snippet allows you to use SmartZone together with PowerShell in task automation processes like recognizing screenshots, email attachments, and images downloaded by the web browser. It can also be deployed in other similar cases where the advantages of PowerShell modules and cmdlets can help to achieve results faster than writing an application from scratch.

Another Hackathon Success

Identifying a new way to deploy existing Accusoft solutions is one of the reasons why the hackathon event was first created. This script may not reinvent the wheel, but it will help developers save time and money in a lot of situations, which means fewer missed deadlines and faster time to market for software products. Developing unique approaches to existing problems can be difficult with deadlines and coding demands hanging over a developer’s head, so Accusoft’s hackathons are incredibly important for helping the company stay at the forefront of innovation. 

To learn more about how that innovation can help your team implement powerful new features into your applications, talk to one of our solutions experts today!

Sept. 7, 2022 – TAMPA, Fla. — Accusoft, a software development company specializing in content processing, conversion, and automation solutions, and Snowbound, a leader in document viewing and conversion SDK solutions, announced today that they have entered into a definitive agreement under which Accusoft will acquire Snowbound. In the largest acquisition in its 30-year history, the transaction will significantly expand Accusoft’s presence and product portfolio.

Snowbound’s VirtualViewer® technology, supported by its powerful RasterMaster® SDK, supports numerous formats including PDF, MS Office, AFP, DWG, TIFF, email, video, audio files, and more within one universal interface. Its REST API and RESTful content handler provide a more flexible development and deployment capability enabling it to be easily integrated into most applications. In addition, the company offers connectors for IBM FileNet, Alfresco, and Pega. This acquisition will enable Accusoft to expand into new viewing and collaboration technologies offering customers a more robust web-based document viewing experience. 

“Today, we celebrate the joining of two companies who have both driven significant innovation for web-based viewing, conversion, and imaging SDK technologies. I have always had the utmost respect for Snowbound’s leadership team and their employees as we have competed against one another for sales opportunities over the decades.  I am honored to bring Snowbound into the Accusoft family,” said Jack Berlin, CEO of Accusoft.

“We were incredibly selective as we looked for the right acquisition partner. We were deliberate in selecting an organization with a leadership team and product portfolio that would be compatible with our own, and that would continue to grow, develop and nurture what we have built at Snowbound. We have proudly driven 26 years of innovation in the way that companies securely share, collaborate, and process documents and images.  With the acquisition, our technology will expand RasterMaster®’s and VirtualViewer®’s Java-based feature set and allow continued empowerment to customers as they navigate the ever-changing world of digital transformation and the complexities of document management,” Simon Wieczner, CEO Snowbound.

While the acquisition is complete, Accusoft will wait until January 2023 to take full operational control of Snowbound. In the meantime, the two leadership teams will partner to close out a strong 2022 and transition the team and its assets.

For more information about Accusoft, please visit https://www.accusoft.com/.

About Accusoft: 

Founded in 1991, Accusoft is a software development company specializing in content processing, conversion, and automation solutions. From out-of-the-box and configurable applications to APIs built for developers, Accusoft software enables users to solve their most complex workflow challenges and gain insights from content in any format, on any device. Backed by 40 patents, the company’s flagship products, including OnTask, PrizmDoc™ Viewer, and ImageGear, are designed to improve productivity, provide actionable data, and deliver results that matter. The Accusoft team is dedicated to continuous innovation through customer-centric product development, new version release, and a passion for understanding industry trends that drive consumer demand. Visit us at www.accusoft.com.

About Snowbound

For over two decades, Snowbound Software has been the independent leader in document viewing and conversion technology. It plays an integral role in enhancing and speeding company workflows for the Fortune 2000, including insurance claims processing, financial transactions, and more. Snowbound excels in providing customers with powerful solutions for capturing, viewing, processing, and archiving hundreds of different document and image types. Thanks to its pure Java technology and multi-environment support, Snowbound’s products operate across all popular platforms and can be integrated into new or existing enterprise content management systems. Nine of the 10 largest banks in the United States (seven of 10 in the world), as well as some of the biggest healthcare providers, government agencies, and insurance companies rely on Snowbound for their mission-critical needs. For more information, contact us at 617-607-2010 or info@snowbound.com, or visit www.snowbound.com

Introduction

A large government agency with millions of employees needed to manage personnel records and payment information while also making documents and images easily accessible for all users. Each document trail spanned the duration of the employee’s time with the agency, resulting in a repository containing hundreds of millions of documents. The existing system used a combination of custom-developed, Windows-based image viewers that were cumbersome, difficult to maintain, and presented security risks. 

Overview

As the system struggled to keep up with demand, employees became increasingly frustrated with the system. Rather than viewing documents within the system, they began using workarounds like printing out files or saving them to another device, both of which presented serious security risks since the records contained personally identifiable information. The agency needed a solution that could manage hundreds of millions of documents while still providing users with simple, secure, and quick access to personnel records and payment information. 

Although the document repository’s legacy viewing solution was no longer able to meet the agency’s needs, developing a new document viewer was prohibitively expensive and required expertise its IT team did not possess. Rather than building a solution from scratch, it made more sense to evaluate viewing integrations available on the market. The agency set out to find a viewer that could support multiple document types, including TIFF and PDF/A, for both viewing and archival purposes. Whatever solution the IT team chose to adopt would have to integrate smoothly into the existing legacy system to avoid a costly and time-consuming overhaul. 

Challenges

After evaluating several options, the agency turned to Accusoft’s PrizmDoc^® for Java, formerly VirtualViewer^®. As a Java-based viewer that uses HTML5 to render files for viewing, PrizmDoc^® for Java would allow the document repository to access files quickly and easily. PrizmDoc^® for Java’s extensive file format support allowed the agency to render PDF, Word, Excel, AFP, DWG, TIFF, and more in one universal viewer. The integration’s built-in library eliminated the need for a third-party application or additional license, further simplifying the agency’s document management processes. 

Another key priority was giving employees the ability to access documents from multiple devices. In the past, the system’s legacy viewer only allowed them to open and view documents on a desktop with the right software installed. To streamline the employee experience, the agency required a viewer that could be accessed from any device that supports a web browser, including tablets and smartphones. PrizmDoc^® for Java’s true cross-platform support and complete mobility provided the flexibility the agency needed to access documents from anywhere, at any time. The integration’s HTML5 technology and Java-based viewing allowed users to view and manipulate files within the browser, eliminating the need for an external application. 

PrizmDoc^® for Java’s quick installation and integration process made it the ideal solution for the agency. Installing PrizmDoc^® for Java’s document viewer took less than 10 minutes for proof of concept (POC) testing on any desktop, laptop, or virtual machine. The integration also provided APIs and developer tools to make integrating and leveraging the technology simple and easy, including RESTful content handlers that allowed for a more flexible development and deployment process.

Results

PrizmDoc^® for Java’s high-speed viewing for large files allowed document rendering and processing to be split between the server and browser, delivering an extremely high-speed response. The integration’s advanced features, including annotation, redaction, splitting, merging, and more, provided far more functionality than was possible under the legacy viewer. PrizmDoc^® for Java’s robust thumbnail panels also simplified working on large documents using full-panel thumbnail displays, as well as the option to adjust thumbnail size. 

By implementing PrizmDoc^® for Java, the government agency was able to provide more streamlined access to personnel and payroll records, saving employees and HR personnel time and money while eliminating security and management issues associated with the previous viewing solution. Millions of users are now able to view critical information related to their records via any device that has access to a web browser. PrizmDoc^® for Java’s robust document support and easy-to-use interface made it an essential tool for the agency’s document management and collaboration processes. The agency was able to continue using their existing repository system while also gaining the benefits of a modern, user-friendly document viewer.

About Accusoft

Founded in 1991, Accusoft is a software development company specializing in content processing, conversion, and automation solutions. From out-of-the-box and configurable applications to APIs built for developers, Accusoft software enables users to solve their most complex workflow challenges and gain insights from content in any format, on any device. Backed by 40 patents, the company’s flagship products, including Docubee, PrizmDoc Viewer, and ImageGear, are designed to improve productivity, provide actionable data, and deliver results that matter. The Accusoft team is dedicated to continuous innovation through customer-centric product development, new version release, and a passion for understanding industry trends that drive consumer demand. Visit us at www.accusoft.com.  

Managing and viewing documents is critical to providing a quality user experience in today’s applications. Without some way of controlling the presentation of digital files like PDFs, organizations put themselves in a situation where they must rely on external solutions that may not be responsive to their needs. PDF integration into their applications helps developers to maintain control over their documents while providing a more consistent viewing experience for users.

What Are Your PDF Reader Options?

Sharing and viewing PDFs online has become much easier with the development of HTML5 viewing technology and PDF.js-based software. For many years, the only way to view a PDF was to download a file and open it using a dedicated PDF reader application. Although many of these readers could be added to a web browser using a plug-in, this wasn’t always a reliable solution and inconsistent support for these extensions often created security risks.

After Mozilla introduced the PDF.js open-source library in 2011, integrated PDF viewing quickly became an essential feature for web browsers. Most users now simply take PDF viewing for granted, trusting that their browser will be able to open and read any file. For some organizations, relying on a browser PDF reader is a perfectly reasonable solution, especially if they don’t have any concerns over controlling the document viewing experience.

But for many developers building web applications, these browsers and external PDF readers put them at the mercy of third-party providers. Changes or security problems with these solutions can leave development teams scrambling to implement workarounds that could have been avoided if they had their own dedicated viewing solution. That’s why applications increasingly feature a built-in PDF reader that allows them to better manage and present important digital documents.

Why Your Application Needs a Built-in PDF Reader

The core problem with relying on an external viewing solution comes down to control. In order to view a PDF in a dedicated reader, the file needs to be downloaded. Once that document is removed from a secure application, it could easily be distributed or altered without any authorization or oversight. This often results in serious version confusion that leaves everyone wondering which version of a PDF is the most up-to-date. By keeping documents within a controlled application, developers can ensure that the files viewed there are current.

Relying on external PDF viewers can also create an inconsistent user experience. Since not all viewers render documents, in the same way, it’s impossible to control what someone will see when they open a given PDF. In some cases, that could result in wrong fonts being displayed or some image layers failing to render properly. But it may also prevent someone from even viewing a file at all. For example, browser-based viewers that use the base PDF.js library without making any improvements to it often struggle to render lengthy or complex files. 

When applications incorporate a built-in PDF reader, developers can ensure that every document viewed within that solution will look the same on every device (and that it will open in the first place!). This level of control is incredibly important for organizations looking to build a frictionless and compelling user experience.

Integrating a PDF Reader

By incorporating a PDF reader into their web-based applications, developers are able to both retain full control over the viewing experience and keep files within a protected environment. When users are interacting with the application, all PDF viewing can be handled by the built-in viewer rather than handed off to external software. This makes it easier to manage access effectively and limits the number of downloads. 

Since every user will be viewing documents through the same built-in PDF reader, developers can also craft a consistent experience across multiple platforms. With more and more people accessing their applications with mobile devices, it’s important for development teams to offer responsive viewing solutions that can accommodate various screen sizes and interfaces.

In order to maintain complete control over files and deliver better performance, a built-in PDF reader should be able to operate as an entirely client-side solution. Whether it’s running within an on-premises technology stack or as part of an application’s cloud deployment, a PDF viewer without any complicated dependencies never has to worry about connecting to a third-party service to facilitate viewing. 

But why stop at PDF viewing?

PDF Editing

Often users need the ability to view as well as collaborate on their PDF documents, and providing the ability to edit those documents presents a challenge for developers. In a recent survey conducted amongst developers, there appears to be a disconnect between the PDF editing features that are available in most applications, to what developers actually need to fulfill and enhance their applications. So what’s the solution? 

Third-party Integrated PDF Viewing and Editing

A PDF solution provider has already worked out the challenges associated with viewing and editing PDF documents within an application. They’ve also devoted their resources to improving their document capabilities and expanding features to offer greater flexibility.

A good third-party provider also offers extensive support during and after the implementation process. If the developer needs to add a new PDF-related capability to their application or if they encounter a problem, they can quickly resolve the issue by working with their provider rather than wasting valuable resources trying to identify and fix the problem themselves. That combination of expertise and service means that developers can spend more time focusing on their application’s unique features rather than continuously wrestling with PDF-related challenges.

Enhance Your Application with PDF Integrations from Accusoft

With more than three decades of experience managing documents and images, Accusoft has been building innovative PDF solutions since the format was first introduced. Whether you need to add flexible front-end viewing and editing features to your application or are looking to add powerful programmatic PDF capabilities into the back end of your software, we provide a wide range of PDF solutions that address multiple development needs.

To learn more about how Accusoft can solve your PDF document management challenges, talk to one of our PDF specialists today and find the integration that works best for your software project.