This post is part of our 2017 Developer App Series, which showcases apps created by our Support Agents over the course of eight weeks. These apps are intended to be larger, more thoughtful apps with highly practical purposes in mind, as opposed to a basic “how to” for a feature.

App Description

This app uses the LEADTOOLS Barcode Engine alongside the LEADTOOLS Image Processing SDK to concurrently run different image processing algorithms in a multithreaded environment on a barcode image until the barcode can be found in one thread and cancel the others. This will help decode barcodes on particularly difficult images by doing 5 sets of image processing commands at the same time that are each optimized to find barcodes on commonly difficult images.

Each barcode pass has a different set of image processing commands that are do the following for each image:

• AutoColorBinary – This set of IP commands will auto color the image to enhance shadows and brighten the image. Then it will apply DynamicBinary to convert it to B/W. This is useful for extracting barcodes on images with glare or shadows on it.
• SmallImageResize – This set of IP Commands will resize smaller images using Bicubic interpolation and then AutoBinarize the image to convert to B/W. This is useful for extracting barcodes on smaller images, such as images under 720p.
• DocumentCleanup – This set of IP commands will run some document cleanup commands. It will despeckle, deskew, then darken the image to try to process the image. This is useful for extracting barcodes on scanned documents.
• SharpenEnhance – This set of IP commands will deskew the image and then try to sharpen the image. This is useful for extracting barcodes on blurry images.
• MaxMedianMin – This set of IP commands will lighten, blend, then darken the image. This is useful for extracting 2D barcodes that are damaged.

Features Used

• Barcode
• Image Processing

Instructions for Running the App

1. Download the source code for this app from here
2. Extract the contents to the C:\LEADTOOLS 19\Examples\DotNet\CS directory.
3. Build csproj file with Visual Studio and run
4. Download and test with the attached hard to read barcode images

Few things have as great an impact on document imaging as cleanup. Its benefits reach far beyond the the improved visuals and readability. Document image cleanup is the salt to the meatier document imaging technologies like OCR, barcode, PDF, forms recognition, archival, and the like—it enhances them.

• Accuracy – Images are rarely perfect. Colors, angles, imperfections in the original document all have an affect on the accuracy of recognition technologies. By correctly aligning the image and removing obstacles around the important areas, the recognition processes can scan the image and look for the predictable patterns that make up the text and data that you wish to extract.
• Compression – Most compression algorithms work by finding ways to cleverly group pixels together in a way that uses fewer bits but still reconstruct the image to its original (or close to original for lossy methods), uncompressed data. In the document world, this is especially the case for black and white images. By minimizing unnecessary artifacts like dots, hole punches, and borders, the single-color runs are longer and therefore compress better.
• Speed – With fewer unnecessary pixels getting in the way, nearly every algorithm can do its work more efficiently.

Using LEADTOOLS for your document image cleanup

Enough of the why, you probably knew a lot of that already. Let’s get into the fun stuff of how to do it and what’s available in LEADTOOLS! Here are some of the most popular cleanup functions that can easily be applied to any and every image to give your more advanced functions a better base to run on.

Inverted Image

Bitonal images can become inverted for many reasons. Scanner settings, inverted palette, color masks, or conversion from one format to another can all cause the pixels that should be black be white and vice versa. This function is a great first step that can be run on every image just in case.

InvertedPageCommand invertedPage = new InvertedPageCommand(InvertedPageCommandFlags.Process);
invertedPage.Run(img);

Despeckle

Speckles often appear from dust on the image, scanner, or through half-toning. It works for both black speckles on a white background and white speckles on a black background. Run this function to remove them and create longer runs of like-pixel colors.

DespeckleCommand despecklePage = new DespeckleCommand();
despecklePage.Run(img);

Line Removal

The two most common sources for lines are tables and folded paper. In both cases, the narrow horizontal or vertical line can be detected and removed, even when it intersects with machine printed or hand-written text. This is a must-have for any recognition technology.

LineRemoveCommand lnPage = new LineRemoveCommand();
lnPage.Type = LineRemoveCommandType.Horizontal;
lnPage.Flags = LineRemoveCommandFlags.UseGap;
lnPage.GapLength = 2;
lnPage.MaximumLineWidth = 5;
lnPage.MinimumLineLength = 200;
lnPage.MaximumWallPercent = 10;
lnPage.Wall = 7;
lnPage.Run(img);

Border Removal

If an image comes in at any angle or there is extra space on the flatbed backing, the scanner will fill the gap with a color. If it is black, then it can be removed.

BorderRemoveCommand borderPage = new BorderRemoveCommand();
borderPage.Run(img);

Hole Punch Removal

This one is pretty cut and dry. If any hole punches were picked up by the scanner and made black, you can eliminate them to restore those areas to match the background.

HolePunchRemoveCommand holePage = new HolePunchRemoveCommand();
holePage.Run(img);

Additional cleanup

The functions above are great general-purpose document cleanup functions for any document image. LEADTOOLS offers even more document image processing functions like Deskew, Min, Max, etc. which can be used for more precise tuning, or that benefit one technology more than another.

Download an Example

One of our support guys recently posted a great image cleanup sample project, which you can download here. If you need LEADTOOLS as well, you can download the latest installer here.

Now get out there and create some amazing document imaging applications while eating some bacon-wrapped red meat. The programmer-friendliness of LEADTOOLS toolkits and the time saved on your project should offset any blood pressure concerns!

As always, LEAD will be exhibiting this year at the RSNA Annual Meeting in Chicago. The theme of RSNA 2017, Explore. Invent. Transform, invites attendees to investigate and advance radiology through innovation as a means of creating positive impact on patient care. Our entire product line will be on display and available to demo at the meeting, with a special focus on our Medical & Document Imaging technologies and upcoming major version release.

RSNA 2017
November 26 – December 1, 2017
McCormick Place
Chicago, IL
Hall B, Booth #7708

We are on the brink of releasing LEADTOOLS Version 20 and will have a lot of new features and demos to share with you at the meeting, including new .NET Standard libraries (.NET Core, .NET Framework, Xamarin) for our Document and Medical Imaging Toolkits. This significant new addition enables .NET developers to expand their market reach and target multiple platforms such as Linux, iOS, macOS, Android, and UWP as a native application written from a single source. Here are some additional highlights of features and benefits recently added to the Medical Toolkits:

• In addition to accessing 3rd party PACS using DICOM messaging, the Zero-footprint HTML5/JavaScript Medical Web Viewer can now query, retrieve, and view studies stored in 3rd party PACS using DICOMweb and WADO REST services over the Internet.
• We have added the DICOM Hanging Protocol wizard to easily define hanging protocols based on information stored in existing DICOM studies.
• One-click DICOM Structured Display generation has been implemented.
• The Display Layout Composer has been updated to create non-grid layouts. This can be used for mounting studies and series as needed by specialties and for creating DICOM Structured Display data sets and DICOM Hanging Protocol data sets.
• Many new productivity tools have been added, such as special locator (3D cursor), and multi-study registration and synchronization (stacking, reference line, cine, etc..).
• Client-side Lazy Loading and Multi-Resolution Tiled Image (MRTI) rendering have been added to overcome device and network bandwidth bottlenecks, allowing for immediate viewing of very large stacks and full-fidelity large images on mobile devices.

LEAD will also be adding various Azure services for recognition and conversion to its portfolio for users to leverage the LEADTOOLS SDK in any platform that can access web services. These services, joined with the newly added .NET Standard libraries and LEAD’s existing native Medical and Document Imaging libraries for all major platforms make LEADTOOLS the toolkit of choice when it comes to developing Medical or Document applications and enterprise-level systems.

If you are attending the RSNA Annual Meeting this year, our senior sales and support engineers will be available to consult with you on any projects you are working on. Our engineers have years of experience developing solutions involving DICOM, recognition, PDF, document conversion, barcode, and HTML5 viewing, and they can help determine if LEADTOOLS would benefit you and your project. Be sure to email RSNA-2017@leadtools.com to schedule a demo or consultation.

LEAD will be exhibiting again this year at Microsoft Build and we want you to join us! We probably don’t need to tell you, but here are just a few reasons to attend:

• Learn from 300+ technical sessions and 80 interactive workshops on the Microsoft tools and platforms we rely on. Topics include: AI, machine learning, mixed reality, serverless, hybrid cloud, IoT, big data, advanced analytics, and more.
• Connect with experts and engineers to share insights and imagine innovative solutions.
• Explore exciting emerging tech to prepare our organization to solve today’s challenges and lead in digital transformation.
• Connect with the LEAD team and see LEADTOOLS Version 20 and the upcoming, brand new LEADTOOLS Azure Cloud Services in action!

Win a FREE Conference Pass!

The conference is May 7–9 in Seattle, Washington, and a pass costs a whopping $2,495. BUT for one lucky LEADTOOLS subscriber we’re giving away a FREE conference pass. To enter:

• 1. Like our Facebook page or follow us on Twitter
• 2. Post or tweet to us using the hashtags #LEADTOOLSMSBuild #MSBuild and let us know that you’d like to attend by either posting a picture with your LEADTOOLS shirt/swag or give us a compelling reason why you’d like to go. Note: Make sure to make your Facebook posts public so that we can see them and count you in the contest!
• 3. Find out if you’ve won yourself a conference pass when we announce the winner of the contest at the end of this week. Update: Congrats to Carlos on winning our contest – We’ll see you at Build!

If you are already attending, great! Let’s get a meeting or demo set up with one of our solution experts while you’re at the conference. We look forward to seeing you in Seattle!

Microsoft Build

Booth #E56
May 7-9th, 2018
Washington State Convention Center
Seattle, WA

One highly practical new feature in LEADTOOLS Version 20 is the parsing of AAMVA barcodes. If you’re not familiar, the American Association of Motor Vehicle Administrators (AAMVA) created a standard for those barcodes on the back of your driver’s license. It contains all the information on the front and provides reliable, fast, and accurate reading of that information by parsing the barcode.

Why LEADTOOLS?

Technically, we’ve been able to read these barcodes for quite a while because it’s simply a PDF417 barcode. However, standards adoption is a slow process but is finally widespread throughout North America. What makes LEADTOOLS special compared to the many other barcode engines out there is that one of our poor developers spent weeks reading the AAMVA specs for you (he’s a pretty nice guy for a Patriots fan), and now we have a high-level .NET class that encapsulates the whole spec.

That means that you can turn this gibberish (the raw data of the barcode):

@
ANSI 636004080002DL00410266ZN03070017DLDAQ123456789123
DCSDOE
DDEN
DACJANE
DDFN
DAD
DDGN
DCAC
DCBNONE
DCDNONE
DBD08152015
DBB08151987
DBA08152020
DBC2
DAU070 in
DAYBRO
DAG1100 NEW BERN AVENUE
DAIRALEIGH
DAJNC
DAK276970001
DCF0123456789
DCGUSA
DAZBRO
DCLU  
DCK000012345678NCSVTL01
DDB10242014
DDK1
DDL1
ZNZNADUP
ZNB
ZNC0

into this lovely AAMVAID class with strongly typed properties for all those fields!

using (AAMVAID id = BarcodeData.ParseAAMVAData(data.GetData(), false))
{
   Console.WriteLine("Issuer Identification Number: " + id.IssuerIdentificationNumber);
   Console.WriteLine("First Name: " + id.FirstName.Value);
   Console.WriteLine("Last Name: " + is.LastName.Value);
   Console.WriteLine("Over 21?: " + id.Over21);
   // etc.
}

Writing AAMVA barcodes that conform to the 2016 AAMVA CDS is similarly easy in LEADTOOLS. The AAMVAIDBuilder object will collect and organize the customer information and then output the AAMVA string for use in our BarcodeEngine class.

Full Example on Code Project

Enough blabbering on, you’re a developer after all and probably communicate better with code. For more details and a full example of how to read and write AAMVA barcodes from driver’s licenses, see our recent article on Code Project.

Change the World! (or at least your DMV…)

credit: Giphy and Walt Disney Animation Studios

Reading is actually the easy part. Most of you on this blog are pretty keen and might’ve picked up on how the raw data in that string worked and thought, “I could parse that!” As mentioned previously, the biggest catch out there is adoption. It’s one thing to figure out how to parse some values from a long text string, but writing them out correctly and following the AAMVA spec is what’s really holding states and countries back. LEADTOOLS makes it incredibly easy to make sure your data follows the specifications, AND can write the barcode. So get out there and code something that’s so easy, even a sloth can do it!

This video showcases how you can use the Visual Studio Xamarin template in combination with LEADTOOLS Barcode SDK libraries to create a simple Barcode Reader application. This sample application loads a QR Code test image and returns the symbology, position and value of the recognized QR code when the user selects the button.

For the source code for this project please visit our support forum: http://bit.ly/XamarinBarcode

New product alert! LEADTOOLS now has a completely new way to add its world-leading OCR, barcode, MICR, and document conversion into your app. Introducing LEADTOOLS Cloud Services, a high-powered, scalable, and lightweight Web API for adding advanced LEADTOOLS recognition and document conversion technologies into their applications.

As cloud hosting services like Microsoft Azure, Amazon AWS, and Google Cloud gain popularity, applications can be developed in new and exciting ways. LEADTOOLS Cloud Services dives into the hosted cloud processing world by providing its most popular technologies via a consumption-based pricing model. This new product is a programmer-friendly addition to any desktop, mobile, or web application with an Internet connection. This opens the door to many popular languages such as PHP, Python, and Perl, in addition to C# and JavaScript, which LEADTOOLS already supports in its existing SDK product line.

We are very excited about this product and will be talking about it much more over the course of this summer, so stay tuned!

To read more, check out the following links:

• Official LEAD Technologies Press Release
• Example Project and Tutorial on The Code Project

We take great pride in the fact that LEADTOOLS is truly a comprehensive imaging SDK. We developed LEADTOOLS with the mindset that we want it to be a one-stop-shop for imaging. There are many applications, especially in the document imaging world, where technologies intersect and you may find the need to piecemeal multiple SDKs together. For example, Scanning + Document Cleanup + OCR, OMR + Forms Recognition + OCR, or OCR + PDF. How about something a little less common, like OCR + Barcode?

Huh? Those don’t really go together do they?

Most of the time you probably think of OCR and Barcodes as the last step in a document imaging process:

1. Scan an image
  --> 2. Clean the image
        --> 3.a. Use OCR to get the text
        --> 3.b. Use Barcode to get encoded data

That may be true, but you’re only thinking about reading. Creating barcodes, especially QR codes, is still an important and popular task. Plus, they can pack in a ton of information so you can encode and squeeze all the text from a document into a QR code. Or use zonal OCR to convert just a block of text into a QR code. Or even better yet, use your mobile phone to capture a picture of the text you want to convert into a QR code.

The Code

It doesn’t take much to do either of these advanced imaging processes with LEADTOOLS. Check out the following code snippet that loads an image, OCRs the text, then creates a QR Code on a blank image.

// Create and use OCR to get text from the image
using (IOcrEngine ocrEngine = OcrEngineManager.CreateEngine(OcrEngineType.LEAD, false))
{
   ocrEngine.Startup(null, null, null, @"C:\LEADTOOLS 20\Bin\Common\OcrLEADRuntime");

   using (IOcrPage ocrPage = ocrEngine.CreatePage(ocrEngine.RasterCodecsInstance.Load(imagePath, 1), OcrImageSharingMode.AutoDispose))
   {
      ocrPage.AutoZone(null);
      ocrPage.Recognize(null);
      string recognizedCharacters = ocrPage.GetText(-1);

      // Create a QR code using the text
      BarcodeEngine engine = new BarcodeEngine();
      int resolution = 300;
      using (RasterImage image = RasterImage.Create((int)(8.5 * resolution), (int)(11.0 * resolution), 1, resolution, RasterColor.FromKnownColor(RasterKnownColor.White)))
      {
         BarcodeWriter writer = engine.Writer;

         QRBarcodeData data = BarcodeData.CreateDefaultBarcodeData(BarcodeSymbology.QR) as QRBarcodeData;

         data.Bounds = new LeadRect(0, 0, image.ImageWidth, image.ImageHeight);
         QRBarcodeWriteOptions writeOptions = writer.GetDefaultOptions(data.Symbology) as QRBarcodeWriteOptions;
         writeOptions.XModule = 30;
         writeOptions.HorizontalAlignment = BarcodeAlignment.Near;
         writeOptions.VerticalAlignment = BarcodeAlignment.Near;
         data.Value = recognizedCharacters;

         writer.CalculateBarcodeDataBounds(new LeadRect(0, 0, image.ImageWidth, image.ImageHeight), image.XResolution, image.YResolution, data, writeOptions);

         writer.WriteBarcode(image, data, writeOptions);
      }
   }
}

Download the Full Example

To download the full example and see more information on the classes and methods used in this code tip, check out the original forum post.

Since releasing LEADTOOLS Cloud Services only a few months ago, we have seen a lot of usage from customers as well as some feedback. It’s a product we look forward to supporting and improving by making additional LEADTOOLS imaging functionality available in an easy-to-consume Web API. Today marks the first update to LEADTOOLS Cloud Services and are happy to announce a new method endpoint for the service: ConvertBarcodeSplit.

Batch scanning with barcode separators is not a new concept, but is typically a low-level process built into a scanner itself or buried within a desktop scanning application. Typically, a barcode signals to the scanner how and where to split the document. More advanced scenarios can even use barcodes to signal changes to the scanner settings, such as scanning in color instead of black and white.

With many applications moving towards containerized microservices, this kind of workflow isn’t necessarily becoming out-dated, but is harder to compartmentalize. In modern application environments and workflows, it makes far more sense to scan large batches of documents into a single multipage file, then split it with another microservice after the scanning batch is completed. This workflow also opens up the application to use mobile device capture rather than traditional scanners. The new ConvertBarcodeSplit is perfect for that kind of task, allowing you to upload a large file and split the document up into multiple documents based on where it finds a barcode. It is highly configurable, allowing you to search for a specific barcode type (e.g., QR Code, Patch Code, etc.), and how to split the pages (barcode is on first page, last page, or a page on its own to be discarded).

Example

Here’s a quick .NET example of how to use the new method. For examples in additional languages, visit the API Reference for ConvertBarcodeSplit.

public async void ConvertFile()
{
   //The first page in the file to mark for processing
   int firstPage = 1;

   //Sending a value of -1 will indicate to the service that all pages in the file should be processed.
   int lastPage = -1;

   string fileURL = "https://demo.leadtools.com/images/lcs/barcode_split.tif";

   //Enum corresponding to the output format for the file. For the purposes of this script, we will be converting to tif.
   int fileFormat = 3; // TIFF

   string conversionUrl = string.Format("Conversion/ConvertBarcodeSplit?firstPage={0}&lastPage={1}&fileurl={2}&format={3}", firstPage, lastPage, fileURL, fileFormat);

   var client = InitClient();
   var result = await client.PostAsync(conversionUrl, null);
   if (result.StatusCode == HttpStatusCode.OK)
   {
      //Unique ID returned by the services
      string id = await result.Content.ReadAsStringAsync();
      Console.WriteLine("Unique ID returned by the services: " + id);
   }
   else
      Console.WriteLine("Request failed with the following response: " + result.StatusCode);

}

The idea for this function came from a customer request. If you have checked out LEADTOOLS Cloud Services and you wished there was additional functionality, or if you’re just starting your hunt for a high-level web API for document and raster imaging tasks, don’t hesitate to contact us!

Download demo!

Intelligent capture can refer to a couple different ways of capturing data from images or documents. In this post, I’ll be talking about how you can intelligently capture barcodes from scanned in files. The LEADTOOLS TWAIN SDK and Barcode SDK are libraries that developers can easily use to create applications for scanning in physical documents while capturing and extracting any barcode data found.

A recent survey by AIIM states that 32% of the surveyed companies use intelligent capture to extract barcodes from PDFs as well as other digital documents.^[1] With that being said, let’s create a .NET desktop application that will recognize barcodes from scanned in images. For each barcode found, we will extract the data and then save that data to a text file while also saving the scanned document as a PDF.

This app will only use three buttons. One for selecting an output directory where the PDF and TXT will be saved to, one to select the scanner you wish to scan from, and one more to perform the scan and recognize the barcodes.

SelectDir_Click

// Change the output directory 
using (FolderBrowserDialog dlg = new FolderBrowserDialog())
{
    dlg.ShowNewFolderButton = true;
    if (dlg.ShowDialog(this) == DialogResult.OK)
        _outputDirectory = System.IO.Path.GetFullPath(dlg.SelectedPath);
}

ScannerSelect_Click

// Select the scanner to use 
_twainSession.SelectSource(null);

Scan_Read_Click

// Scan the new page(s) 
_twainSession.Acquire(TwainUserInterfaceFlags.Show);

Now add the following variables.

private static BarcodeEngine engine = new BarcodeEngine();
private static BarcodeReader reader = engine.Reader;

// The Twain session 
private static TwainSession _twainSession;

// The output directory for saving PDF files 
private static string _outputDirectory;

// The image processing commands we are going to use to clean the scanned image
private static List<RasterCommand> _imageProcessingCommands;

private static int _scanCount;
private static StringBuilder sb;

Within Form1_Load, add the code for setting your license, initializing a new Twain session, subscribe to the TwainSession.Acquire event, and then initialize any image processing commands.

RasterSupport.SetLicense(@"", "");            

_twainSession = new TwainSession();
_twainSession.Startup(this.Handle, "My Company", 
	"My Product", 
	"My Version", 
	"My Application", 
	TwainStartupFlags.None);

_twainSession.AcquirePage += new EventHandler<TwainAcquirePageEventArgs>(_twainSession_AcquirePage);

// Add as many as you like, here we will add Deskew and Despeckle 
_imageProcessingCommands = new List<RasterCommand>();
_imageProcessingCommands.Add(new DeskewCommand());
_imageProcessingCommands.Add(new DespeckleCommand());

Within Form1_FormClosed, end the TWAIN session.

// End the twain session 
_twainSession.Shutdown();

Finally add the code for the Twain acquire handle.

private void _twainSession_AcquirePage(object sender, TwainAcquirePageEventArgs e)
{
    _scanCount++;

    // We have a page 
    RasterImage image = e.Image;

    // First, run the image processing commands on it 
    foreach (RasterCommand command in _imageProcessingCommands)
    {
        command.Run(image);
    }            

    // Read all the barcodes in this image 
    BarcodeData[] barcodes = reader.ReadBarcodes(e.Image, LeadRect.Empty, 0, null);

    // Print out the barcodes we found 
    sb = new StringBuilder();
    sb.AppendLine($"Contains {barcodes.Length} barcodes");
    for (int i = 0; i < barcodes.Length; i++)
    {
        BarcodeData barcode = barcodes[i];
        sb.AppendLine($"  {i + 1} - {barcode.Symbology} - {barcode.Value}");
    }

    // Save string builder to a text file
    System.IO.File.WriteAllText($@"{_outputDirectory}&bsol;barcodes{_scanCount}.txt", sb.ToString());

    // Save image as PDF
    using (RasterCodecs codecs = new RasterCodecs())
    {
        codecs.Save(e.Image,
        	$@"{_outputDirectory}&bsol;ScannedImage{_scanCount}.pdf",
        	RasterImageFormat.RasPdf, 0);
    }
}

To test this with the latest version of LEADTOOLS, download the free 60 day evaluation straight from our site. If you have any comments or questions regarding this, feel free to comment on this post or contact our Support department at support@leadtools.com.

References

1. ^ "Incorporating Intelligent Capture in Your Digital TransformationStrategy", page 22
   IIM Best Practices Report
   AIIM (2019)