Technical FAQs for "ImageGear"

As more and more companies embrace digitization of paper documents, they’re looking for ways to minimize the virtual storage space necessary for these new files. They’re already benefiting from increased office space and improved workflow efficiency, but they also need data compression techniques to make access to digital information quicker and less costly.

One standard method is mixed raster content compression (MRC), which greatly reduces the size of stored PDF documents. Since the vast majority of data being digitized and archived is in PDF format, MRC compression is an ideal tool for converting high volumes of paper documents into compressed, searchable files.

MRC: The Basics

Mixed raster compression works by breaking down an image (typically a full page of a PDF document) into its various components: mostly text and color image files. This is done in order to utilize the most thorough compression algorithm available for each part of the page.

As a result, even though the color images are highly compressed into their core elements (background, color, grayscale, etc.) they retain vivid detail and can be displayed subsequently with essentially no loss of quality, and any text from the original page remains searchable.

Putting High-Grade Compression to Use

A real estate firm, for instance, can use MRC compression to efficiently store a database of home listings, each with potentially dozens of color images and a searchable street address, with little to no compromise in file fidelity.

Consider these numbers: MRC can compress a 20 MB .TIFF color image file (which is part of a source PDF) to anywhere between 96 and 170 KB, based on the level of compression desired. This range suggests, of course, a tradeoff between file size and image quality, but is a significant reduction from the source image in any case – with differences in the displayed file barely discernible.

The most recent MRC tools make its integration into existing applications simple as well, usually involving just adding a few lines of code to these make such dramatic compression ratios a reality. For all the talk of companies creating fully digitized records archives, MRC compression is one technique that’s making it more feasible than ever.

Let Us Help

If you’d like to learn more about mixed raster content compression, including how our ImageGear features highly refined MRC functionality, contact us and our experts will get in touch. We’re here to help developers make applications that put organizations on the forefront of digital content management.

Goal

Create a command line program in C# that can read a CAD file (DWG, DXF, or DGN format), then use ImageGear .NET v24 to convert this file to a PDF file with either 2D image conversion or 3D images from the original CAD file.

Requirements

• C# development environment (Visual Studio used in this example)
• Accusoft ImageGear .NET v24 SDK

Computer-Aided Design To Portable Document Format

One of my favorite school projects was Build Your Own House. We were given an imaginary mortgage value, graph paper, and the task of building our dream house based on that budget. I agonized over where to place doors, and how to make sure there was enough room for them to open into my private office where I’d have a collection of Transformer and Teenage Ninja Turtles. Using a ruler, I marked off the dimensions of every room, how my kitchen would be, and because I was 10 years old at the time and knew I’d never marry a girl because girls are “yucky” at that age, I’d have just one big room with enough space for a Pac-Man machine in the corner.

Sadly, I never got my own Pac-Man machine. But the principles behind Computer-Aided Design (CAD) files and my old graphs of my house are the same – a way to represent on computer what my ruler and graph paper tried to. With CAD, you can represent everything from machinery to the skyscrapers. Every detail, from the smallest object to the largest structure, can be represented.

Odds are, though, not everyone has access to a CAD viewer. You want to show off that great new condo design to a prospective buyer, or automate the process of updating documentation based on the most current CAD designs. The best option would be to take your CAD files and convert them to PDF format, but without all the tedium of sitting at the computer to open and convert the files by hand.

This demonstration will show how to perform that same task using Accusoft ImageGear v24, which has built-in support for a variety of image files, PDF documents, and CAD file conversion. The sample code will be using C# as our base, but with the ImageGear .NET SDK any supported .NET language will work for you.

The sample code is below, and a code walkthrough will follow.

Get the code!

Prepping the Development Environment

Before we get started, we’ll need to perform a few tasks.

Install Visual Studio

This demonstration uses Visual Studio 2017 Community Edition, but ImageGear .NET will support previous versions.

Install ImageGear .Net SDK

An evaluation copy can be found here. As of this writing, the most current version is .NET v24, which adds support for CAD files as well as a plethora of other file formats.

The ImageGear .NET SDK installs by default under “C:UsersPublicDocumentsAccusoftImageGear.NET v24”. We’ll call this the INSTALL_DIRECTORY through the document. We’ll be referring to this directory for some files we’ll need in a moment.

Create Your Project

This demonstration shows how to construct a command line version. Fire up Visual Studio, create a New Project, and select C#, then “Console App.” Give your project a name – we’re going with “AutoCAD2PDF” here:

Once our project is created, we need some files from our ImageGear .NET SDK. Go into your ImageGear .NET SDK install directory and navigate to “INSTALL_DIRECTORYBinx64” (or “INSTALL_DIRECTORYBinx86 if you’re still working in the 32-bit world). Copy all of these files into your Visual Studio project into the Debug directory, so if you named your project AutoCAD2PDF, you’ll want to put these Accusoft resources files into “AutoCADto2DPDFAutoCADto2DPDFbinDebug”.

One other thing that will help us keep things organized. In the Debug directory, create two folders:

• Input: Place the CAD files to be converted in here.
• Output: The program will place the converted files into this directory.

Getting the Code Ready

We need to add in our ImageGear libraries into our project. We’re going to put in the minimum ones to make our program work. In Visual Studio, go to the menu and select Project, then “Add Reference”. Select Browse, then browse to the Debug directory where we copied the resource files and select the following DLL files:

• ImageGear24.Formats.Common.dll
• ImageGear24.Formats.Vector.dll
• ImageGear24.Core.dll
• ImageGear24.Evaluation.dll

Now it’s time to code.

Architecture of a Conversion

Converting CAD files to PDF using ImageGear requires we know a few things:

1. What is the CAD file to read from (supported file formats are DWG, DXF, and DGN)?
2. What will be the name of the file to write to (this program will verify that the file extension is .pdf)?
3. What version of PDF are we writing to (this program supports version 1.3 up to 1.7, with 1.7 being the default)?
4. Do we want to export the images as 2D or as 3D objects in our PDF file?

Optional: This step just helps keep track of your code. In the Solution Window, right click on “Program.cs” and rename it to “CAD2PDF.cs”. This is just if you want to keep your various classes organized, so if you add this code to other projects you don’t have a class with a boring name like “Program.”

What’s in a NameSpace?

Let’s set up our name spaces to add support for our various C# objects.  Add the following name spaces into the start of our CAD2PDF.cs file:

We’ll focus on our main class first, where we get our parameters. Our main class is looking for four parameters we defined above: the CAD file to read, the PDF file to write to, what version of PDF (listed as “PDFv1_3”, “PDFv1_4”, and so on to “PDFv1_7”), and whether we want a “2D” or “3D”. So a typical program call will look like this:

Here’s how we set up our main function to track this. If we don’t get these four arguments, the program will exit:

Before we go any further, we’ll want to validate and make sure that everything will run right. Our function ValidateParameters will make sure that our input file exists, that we can write to our output files, and that both files are the proper format as far as file extensions for CAD and PDF:

Next, we want to set up the save options for our CAD to PDF conversion. All of these are stored in our function BuildPDFOptions, which takes our PDF version settings, whether it’s going to be in 2D or 3D, and then puts them together in the ImageGear CADPDFSaveOptions object. It sets up the metadata for our PDF file, the dots per inch settings, and the background color. In this case, we’re setting up the page background to be white. If you need more information on the various CADPDFSaveOptions settings, check out the ImageGear .NET documentation

If everything checks out, we’ll use the real workhorse function, ExportCADtoPDF. This is the meat of the ImageGear experience. We’ll take in our CADPDFSaveOptions, the inputFile and outputFile and run the conversion process:

Once the evaluation settings are complete, the conversion code very quick, so don’t blink or you might miss something. First, we read the CAD file into a ImageGear ImGearCADPage object:

Well, that was simple enough. Now we just use our CADPDFSaveOptions settings, and write to our target file:

“That’s it?,” you may ask. That’s it. There are other options you can pursue using Accusoft, such as which pages to export. But let’s use an example. Here’s a CAD rendering of a gripper arm-cute little thing:

You can get your own copy from AutoDesk here.

So how does it look when we run it through our program and bring it to a 2D PDF?

And here’s the PDF rendering with a white background:

Let’s have some fun. Go back into the BuildPDFOptions function and let’s change the background from white:

To black:

And how does our converted PDF file look now?

The movie TRON would be so proud of this look.

Give the source code a try and play with it, and see if ImageGear meets your image editing and converting needs. Want to know more? Read the official documentation, try out the code samples, or feel free to contact us and see how we can meet your needs.

Goal

Create a C# command line program that can read from existing Microsoft .docx (or .doc) documents and convert them to an Adobe PDF file

Requirements

• Microsoft Windows 7 or greater
• Microsoft Visual Studio
• Accusoft ImageGear .NET Developer Toolkit ( download free trial version here )

Programming Skill

Visual C# Intermediate Level

Need to turn Microsoft Word documents into PDFs? That’s easy: Click File > Export > Create PDF/XPS > Publish. Want to do this 1000 times? Nah. The process is laborious if you have more than one document.

So let’s use C# to convert Docx or Doc files to PDF programmatically, so you can convert hundreds of documents in seconds.

Installing The Docx To PDF SDK (ImageGear)

First, we need to install a .NET SDK for handling the heavy lifting of the Word to PDF file conversion. The examples below will be using Microsoft Visual Studio 2017, but you can use previous versions back to Visual Studio 2010.

1. After you’ve installed Visual Studio to your liking, head over to the Accusoft ImageGear Developer Toolkit, and download the version for .NET. As we can see, there is support for C and C++ to fit your favorite development platform. Download the .NET installer.
2. Now you can run the Accusoft ImageGear Developer Toolkit installer. It will take a little bit as it downloads additional libraries.
3. OK – installation is done! Let’s get to coding!

The ImageGear Developer Toolkit will put the files into the Public Documents of the file system, usually located at “C:UsersPublicDocumentsAccusoft”. We’ll be referring to them as we go along.

Setup Your Project

Once you have the toolkit installed, let’s create a new C# project. For this project we’ll just do a C# command line program so we dive right into the meat of the program, rather than needing to build a GUI with Windows Forms or WPF. But once you have it here, you can import this class into any other .NET project you like.

Just click on File, Project, and from the “Visual C#” list select Console App (.Net Framework):

To keep things simple we’ll name the project “ImageGearConversionDemo.”

Once the project is started in Visual Studio, we can use NuGet to add the reference files we need:

1. 1. From within Visual Studio, click on Tools, NuGet Package Manager, then Manage NuGet Packages for Solution.
   2. Make sure that the Package Source is set to nuget.org:

1. 1. Select “Browse”, then input “ImageGear” into the search window. You’ll see different installation options depending on your project. Just to make things easier on us, select “Accusoft.ImageGear.All” to snag everything in one fell swoop. Or you can just specify the ones you need: ImageGear.Core, ImageGear.Evaluation, ImageGear.Formats, ImageGear.Formats.Office, & ImageGear.Formats.PDF. Click the project we want to apply it to, click “Install”, and NuGet will take care of the details.

1. 1. We can also see via the “Solutions Explorer” window that NuGet automatically added the references we need for the project:

Next we’ll want to make sure that the components that do the document conversion are in place.

1. 1. Click on Project, then Properties at the bottom. In the case of our example, that will be ImageGearConversionDemo. Click on Build. Make sure the Platform Target is x64, and the output directory is binDebug.

1. 1. In the Toolkit install directory, in a standard install, is a folder C:UsersPublicDocumentsAccusoftImageGear.NET v23 64-bitBinOfficeCore. Copy the entire folder to your Debug directory.

To make things easier, let’s also set up our project properties for how the program is run. Click the Debug tab. Our final program is going to take two parameters:

1. The DOCX file we’re going to convert.
2. The PDF file we’re converting our DOCX file to.

You can set Command line arguments in Visual Studio by right clicking on your project in the Solutions Explorer, and going to Properties > Debug. Put in the two file names we’ll be using. In our case, we will be using TheGreatestDocInTheWorld.docx, and outputting it to TheGreatestDocInTheWorld.pdf . Set those as your arguments, then make sure that the Working directory is in our Debug folder since that’s where we’re generating our program to.

If you want to add the ImageGear references to your program manually, you can use the instructions in the Accusoft ImageGear .NET documentation.

With that, now we can get to coding!

C# Sample Code

Here’s our C# code for testing out ImageGear’s Word to PDF conversion capabilities. It works with .docx and .doc files. You can copy/paste this code to get started (you’ll also need a free trial version of ImageGear), or keep scrolling for a walkthrough of the code.

using ImageGear.Core;
using ImageGear.Evaluation;
using ImageGear.Formats;
using ImageGear.Formats.Office;
using ImageGear.Formats.PDF;
using System.IO;
using System;
namespace MyProgram
{
    /*
     * This class acts as a simple method for converting documents from DocX format to PDF format.
     *
     * */
    class DocConverter
    {
        //Initialize the license - save time later as the program runs
        public DocConverter()
        {
            // Initialize evaluation license.
            ImGearEvaluationManager.Initialize();
            ImGearEvaluationManager.Mode = ImGearEvaluationMode.Watermark;
            // Initialize common formats
            //Console.WriteLine("Initializing the format.");
            ImGearCommonFormats.Initialize();
        }
        /*
         * SaveAs function:  takes 3 arguments.
         *
         * This function has no exception handling, so be sure the files exist and are proper formats
         *
         *      fileIn:  The docx document to be converted to a pdf.
         *      fileOut:  The pdf file to be output.
         *      verbose:  True - write command line statements.  False - stay silent
         *
         *
         * */
        public void SaveDocxAsPDF(string fileIn, string fileOut, bool verbose = false)
        {
            //set the filters
            ImGearFileFormats.Filters.Add(ImGearOffice.CreateWordFormat());
            //Console.WriteLine("PDF Document additions.");
            ImGearFileFormats.Filters.Add(ImGearPDF.CreatePDFFormat());
            ImGearPDF.Initialize();
            using (FileStream inStream = new FileStream(fileIn, FileMode.Open, FileAccess.Read))
            {
                using (FileStream outStream = new FileStream(fileOut, FileMode.Create, FileAccess.Write))
                {
                    int startPageNumber = 0;
                    // Load Office document.
                    if (verbose == true)
                        Console.WriteLine("Reading the document " + fileIn);
                    ImGearDocument igDocument = ImGearFileFormats.LoadDocument(inStream);
                    // Save PDF, overwrite the file if it's already there.
                    if (verbose == true)
                        Console.WriteLine("Writing the PDF " + fileOut);
                    ImGearPDFSaveOptions pdfOptions = new ImGearPDFSaveOptions();
                    ImGearFileFormats.SaveDocument(igDocument, outStream, startPageNumber, ImGearSavingModes.OVERWRITE, ImGearSavingFormats.PDF, pdfOptions);
                }
            }
            // Dispose of the PDF component.
            if (verbose == true)
                Console.WriteLine("Terminate the PDF");
            ImGearPDF.Terminate();
        }
        static void Main(string[] args)
        {
            Console.WriteLine("Starting the conversion program.");
            DocConverter docx2pdf = new DocConverter();
            //check to make sure we have two arguments - file 1 and file 2
            if (args.Length == 2)
            {
                //make sure that the files exist
                if (File.Exists(args[0]))
                {
                    docx2pdf.SaveDocxAsPDF(args[0], args[1], true);
                }
                else
                {
                    Console.WriteLine("File does not exist: " + args[0]);
                }
            }
            else
            {
                Console.WriteLine("Not enough arguments.");
                for (int i = 0; i  args.Length; i++)
                    Console.WriteLine(args[i]);
            }
            //requests the user hit enter to end the program
            Console.WriteLine("Conversion complete.");
            Console.WriteLine("Hit Enter to terminate.");
            Console.ReadLine();
        }
    }
}

Understanding The Word To PDF C# Code

The first part of the C# program is going to be importing our namespaces. If you used NuGet then you have all of the references you need. But the program needs then declared so they can be used. You can find more information on the API calls on the ImageGear User Guide, but here’s the namespaces we’ll need:

using ImageGear.Core;
using ImageGear.Evaluation;
using ImageGear.Formats;
using ImageGear.Formats.Office;
using ImageGear.Formats.PDF;
using System.IO;
using System;

The ImageGear.Formats.Office and ImageGear.Formats.PDF are what’s going to provide the bulk of the work here – they are what will be able to read from a docx, and write to a pdf file.

To handle the class conversions, we’ll create a simple class and call it DocConverter. For this example, we’re going to populate it with just one method – SaveDocXAsPdf:

class DocConverter
{
    public void SaveDocXAsPDF(string fileIn, string fileOut, bool verbose = false)
{
...

SaveDocXAsPDF has two required arguments, and one optional one that we’ll use in this example to control any console output. They’re just there so we can trace the program steps as it goes through – by default, they won’t display.

Before we do anything, we have to initialize the license. We’ll be using an evaluation copy for this demonstration – but if you already have a license, follow the registration steps on the Accusoft ImageGear .NET instruction page ( http://help.accusoft.com/ImageGear-Net/v24.0/Windows/HTML/webframe.html#topic601.html ).

// Initialize evaluation license.
ImGearEvaluationManager.Initialize();
ImGearEvaluationManager.Mode = ImGearEvaluationMode.Watermark;

The next thing to do is to initialize the ImageGear File Format – in this case, Microsoft Word. In another example we’ll show how to expand that to other file formats.

And while we’re at it, we’ll also initialize the ImageGear PDF object. This is an important step: Whenever we Initialize an ImageGear PDF object, it must be terminated later. Here’s how it looks in our program:

ImGearPDF.Initialize();
    //SOME CODE HERE
ImGearPDF.Terminate();

ImGearPDF is not a typical C# object that self terminates, so make sure it’s terminated.

Now – the actual reading of .doc/.docx files and writing of PDF files is pretty simple:

using (FileStream inStream = new FileStream(fileIn, FileMode.Open, FileAccess.Read))
{
	if (verbose == true)
         Console.WriteLine("Writing the PDF "+fileOut);
         using (FileStream outStream = new FileStream(fileOut, FileMode.Create, FileAccess.Write))
         {
             int startPageNumber = 0;
            // Load Office document.
                ImGearDocument igDocument = ImGearFileFormats.LoadDocument(inStream);
            // Save PDF, overwrite the file if it's already there.
                ImGearPDFSaveOptions pdfOptions = new ImGearPDFSaveOptions();
                ImGearFileFormats.SaveDocument(igDocument, outStream, startPageNumber, ImGearSavingModes.OVERWRITE, ImGearSavingFormats.PDF, pdfOptions);
         }

If we follow the code, the process is straightforward. Remember the “verbose” option will turn on and off the console outputs if you want the program to be quieter.

First, we create a file input stream, and a file output stream. The office document is loaded into the variable igDocument. We then set up the pdfOptions that will be used for exporting the file. And finally – write the file. If there is already a PDF file with the same name, we’re going to overwrite it.

Let’s see our C# Docx to Pdf code in action:

If we compare our new PDF to a PDF created using Microsoft Word’s export option, the file created by ImageGear is smaller – 383 KB versus 504 KB. And the PDF file generated with ImageGear has kept all internal links and formatting.

Converting a DOCX to PDF is just scratching the surface of what ImageGear can do. ImageGear supports over 100 file formats for conversion, editing, compression, and more To find out more, check out the ImageGear overview page.

So you’ve tried out our SDKs and you’re ready to install the license. The problem? You’re not sure how to get started. Accusoft offers a number of different license types based on customer need and environment. The following will show you how to install licenses for both evaluation and deployment depending on your specific needs.

The Basics on Activating Your Development License

The development machine licensing allows you to develop your applications without receiving evaluation prompts during runtime. To activate your license on your development machine, you will need to use the License Manager. Activating your license is simple. Just log into the License Manager using your account information and then click Activate.

Also, make sure to comment out any licensing calls in your code so that the toolkit will not look for a deployment license on the machine. When you’re ready to deploy your application, you have three different options for deployment: Node-Locked, OEM, and Web‑OEM. Our sales team can work with you on finding the right licensing for your project. Ready to get started?

Evaluation Licensing

During evaluation of Accusoft products, Evaluation licenses can be used to try out products. This license permits an Accusoft product or toolkit to be used on a system, whether it is a development machine or any other type of system. This type of license is best noted by an Evaluation dialog displaying occasionally while the product is in use.

Once the Evaluation dialog is dismissed, the product will continue to operate. Other forms of Evaluation or trial behavior include the watermarking of images when displayed or saved. When an Accusoft product is first installed onto a system, if no other license currently exists on the machine (and no other license is provided by the user during the installation), an Evaluation license will be placed on the system by default.

Interested in a more permanent licensing solution? Here are some instructions for installation for various scenarios.

Development SDK Licensing

As a precursor, Accusoft software is limited for use on a single CPU. Any runtimes or copies installed or distributed must be granted by a direct license from Accusoft. The first thing you’ll want to do is check your customer portal to make sure that you have an SDK license available.

Next, make sure there are no active license calls in your code (comment out any calls using a solution name, solution key, and OEM license key). When the license calls are active, the toolkit will be expecting a deployment license to be on the machine – which will fail since only a development license is on the system. When the licensing calls are not being used, the toolkit will automatically look for a development license.

You’ll want to make sure that there are no calls to SetSolutionName, SetSolutionKey, or SetOEMLicenseKey in your code. This ensures that no keys are pulled from your deployment pool.

Next, we’ll open the License Manager and log in.

Select a toolkit under the “Purchased Toolkit” section in the License Manager and click Activate on the right side of the dialog.

Once this is done, you can run your project and you won’t receive any licensing prompts. Your development machine is now licensed.

Deployment Runtime Licensing Overview

Node-locked licensing is designed for when your applications will run on a relatively small number of machines. Each of the machines will be assigned a license that is tied to the system’s hardware.

Once the license is applied, it cannot be removed. If a machine is being removed from service, please contact our sales department, who can assist with obtaining new licenses. You can license deployment machines programmatically (by using the LDK component) or by using the Server License Utility (SLU) provided with the SDK. In your code, you will call SetSolutionName and SetSolutionKey.

An OEM key unlocks the toolkit for use on many machines. With this key, there is no need to run the license utility and the license is not tied to any hardware. You can just throw it in your code and you can deploy without worrying about licensing individual machines.

The Web‑OEM key is used when embedding our ActiveX controls on your web page and is used to license client machines in the web application. The license is applied similarly to regular OEM with a SetSolutionName, SetSolutionKey, and SetOEMLicense key. When you purchase this license model, your OEM key will be web‑enabled.

Node-Locked Licensing

There are two methods you can use to register a runtime node‑locked license. SLU, the Server License Utility, and LDK, the License Deployment Kit. Both of these methods perform the same function of registering the runtime node‑locked license. The only difference is that the SLU provides a user interface for the LDK.

If you wish to hide the license registration from your end user, you will likely want to use the License Deployment Kit, which allows you to integrate the registration process in your application. Please note that when installing the license, the user that you’re running as must have administrative rights in order to add the key to the registry.

You will need a license configuration file for the SLU or LDK to activate licenses. The license configuration file contains information about runtime licenses for a particular platform, a version of a toolkit, and it can be downloaded from your Accusoft customer portal. Next, you will need to register your SLU if you’re planning to use the Server License Utility. The instructions are in the ReadMe file.

You’ll want to run the command prompt in administrative mode. Navigate to the location containing the Accusoft license client DLL. Once the DLL is registered, we can run the SLU. Here, we’re adding the config file that was downloaded. It gives us the option to auto‑register. This is available when you have an online connection, or manual register. When the computer is offline, you can do a manual registration. Here, we’re going to do the auto‑registration.

If licensing fails to register, you will receive an error message and a 14‑day temporary license will be applied, allowing you time to get the licensing issue resolved. If the license succeeds, your application should run without issues. As mentioned earlier, if your computer is offline, meaning that it has no Internet access, you can register using the manual registration process.

In this case, you will want to copy the hardware key and URL to a removable media device such as a thumb drive, and then, take it to a system that is connected to the Internet. From the connected system, paste the URL into the browser. A page will appear that contains a field into which you will enter the hardware key. After this hardware key is entered, a license file with a license key is downloaded, which you then save to the removable media, and take it to your offline system. Place your key in the SLU and click the license button to register your offline machine.

Once you’ve completed either process, your machine is licensed.

OEM Licensing

OEM licensing is ideal when deploying to many workstations or servers that have no Internet access. It provides an easier means of licensing for when your application runs in a secure environment. Accusoft’s OEM licensing is not tied to a specific computer and offers a quick and easy way to get your application licensed and ready for deployment.

First, if you haven’t already, you will want to obtain your license information from your customer portal. To apply an OEM license, simply add the solution name, solution key, and OEM key to your solution. It’s important that this information is placed before the usage of the toolkit within your project. Otherwise, when the application runs, you will see the licensing prompt. Now, we’ll run the application, and you see that the prompts to install the license are now gone.

Web OEM Licensing

If you’re using our ActiveX toolkits and you would like to embed them in your web page for running in a browser, you will need to use a special OEM license that’s intended for this type of deployment. To obtain a Web OEM license, please contact our sales department. They will provide you with access to a special site for generating Web OEM keys.

Once you access this site, you will enter the domain of your website where your web page will be hosted as well as the associated license information provided by our sales department. This will generate an OEM key, which you will be able to use on your web page.

In your web page’s scripting code, you will need to call the SetSolutionName, SetSolutionKey, and SetOEMLicenseKey functions, respectively, providing the license information for that toolkit. With this information in place, you can host your web page, and the ActiveX control will be licensed.

If this fails, however, then you might see a license error dialog display. Make sure that you’re using an actual license that was generated from the Web OEM license generator website provided by our sales department per your purchase.

If you need specific directions for licensing a particular SDK, please view the product on the Accusoft website and select documentation under the reference drop-down menu. For all of your other licensing questions, please contact a sales representative at info@accusoft.com or call us +1-800-875-7009 nationwide or +1-813-875-7575 international.

Accidents happen all the time. People are rushed to the emergency room for everything from headaches, to chest pain, to broken bones. Each of these ailments, and many others, require some form of imaging. The machines that take your X-Rays, to MRIs, to CT Scans are needed to diagnose and start treatment.

While all of these machines utilize different kinds of images, they are all the same file type; DICOM. DICOM image files, or Digital Imaging and Communications in Medicine files are viewed by doctors and patients every single day, all around the world. DICOM files are the standard for viewing, storing, printing, and transmitting, information in medical imaging. With medical records being moved online, DICOM images are following suit. Meaning that both old and new images are being scanned and imported in an electronic medical record storage. All of the scanning and printing of these images can distort them and make them difficult to evaluate.

So how can you be sure that doctors are able to accurately diagnose patients?

ImageGear Medical is the answer.

ImageGear Medical comes with a host of different available integrations and DICOM toolkits that can be used to correct distortion of DICOM images and so much more.

Scanning DICOM images can severely diminish the quality of the images, but ImageGear Medical has you covered. ImageGear comes with ImageCleanTM which features noise removal, including auto-cropping of your crooked images, clean borders to clean up unneeded space, and much more.

The last thing patients want is to be incorrectly diagnosed by low quality or warped images. So if your images need more correction, do not fear! ImageGear also features advanced filtering, including Sharpen, Smooth, and Convolution to ensure that your images are crystal clear.

ImageGear Medical also comes with Accusoft Redlining Toolkit™ (ART) which enables you to annotate on your DICOM files. You can draw arrows, attach sticky notes, and highlight problem areas to collaborate more effectively. And all of these collaboration tools can be merged with the image or stored in a separate file, ensuring that the original file remains unaltered.

Keep up with DICOM industry trends and create a more efficient solution for viewing your images. Evaluate ImageGear Medical for yourself today and see why our imaging SDKs are unbeatable!