# IronOCR > The C# OCR Library. Read text and barcodes from scanned images. Supports multiple international languages. Output as plain text or structured data. A single-file summary of the IronOCR documentation: 145 pages, each as its own abstract, so a model can read the documentation in one pass rather than fetching every URL. Blog posts are not included — see https://ironsoftware.com/ocr/csharp/llms.txt for the link index, and https://ironsoftware.com/ocr/csharp/llms-full-catalog.txt for one that covers the blog too. ## Getting Started ### Advanced NuGet Installation for C# Tesseract ‒ .NET 10 Edition | IronOCR https://ironsoftware.com/ocr/csharp/get-started/advanced-installation-nuget/ The article titled "Advanced NuGet Installation for C# Tesseract | IronOCR" provides a comprehensive guide for developers looking to implement Optical Character Recognition (OCR) in their C# projects using IronOCR. It offers detailed instructions on selecting and installing the appropriate NuGet packages necessary for advanced OCR functionalities. The guide emphasizes the importance of choosing the correct packages to enhance performance and compatibility with various OCR tasks. It includes steps on how to access the NuGet Package Manager within Visual Studio and how to search for specific OCR-related packages. Additionally, the article discusses best practices for configuring these packages to maximize their efficiency in processing and recognizing text from images and scanned documents. By following this guide, developers can ensure a smoother integration of OCR capabilities into their applications, leveraging the strengths of the Tesseract engine alongside IronOCR's enhancements. Overall, the article serves as a valuable resource for developers aiming to upgrade their OCR solutions, providing them with the necessary tools and knowledge to optimize their installation process via NuGet. ### C# Tesseract Configuration on Android | IronOCR https://ironsoftware.com/ocr/csharp/get-started/android/ The article provides a comprehensive guide on performing Optical Character Recognition (OCR) on Android devices using the IronOCR library within a .NET MAUI application. .NET MAUI, an evolution of Xamarin.Forms, allows developers to create cross-platform applications for Android, iOS, macOS, and Windows using .NET. The IronOcr.Android package facilitates OCR support specifically for Android within these projects. The implementation process involves several steps: downloading the IronOcr.Android library via NuGet, creating a .NET MAUI App project, and editing relevant XAML and C# files to incorporate OCR functionalities. The guide details the installation of the IronOcr.Android package and its configuration in Visual Studio, ensuring it targets only the Android platform to prevent conflicts with other platforms. Developers are instructed to modify files such as "MainActivity.cs" and "MainPage.xaml.cs" to initialize IronTesseract and handle image selection and text extraction. Finally, the article offers a downloadable sample project for quick setup and mentions that similar implementation can be done in Avalonia projects. For iOS OCR, a separate guide is available. This resource is designed to help developers utilize Tesseract OCR capabilities effectively in Android applications via .NET MAUI. ### OCR on AWS using IronOCR https://ironsoftware.com/ocr/csharp/get-started/aws/ The article titled "OCR on AWS using IronOCR" provides a comprehensive guide on integrating IronOCR with AWS Lambda, enabling Optical Character Recognition (OCR) for documents stored in Amazon S3 buckets using C#. The tutorial walks through the setup process, starting with downloading the necessary C# library and creating an AWS Lambda project using Visual Studio. It emphasizes the importance of setting up the temporary folder and logging paths for IronOCR when using the ZIP version. The article outlines the steps for modifying the FunctionHandler code to process images retrieved from an S3 bucket and convert them into searchable PDFs saved back to the bucket. It also covers configuring memory and timeout settings in the Lambda function to efficiently handle documents, recommending 512 MB of memory and a 300-second timeout. The guide concludes with instructions on publishing the Lambda function using Visual Studio and provides links for further reading on troubleshooting and deploying Lambda functions. This resourceful guide is ideal for developers looking to implement OCR functionality in their AWS cloud solutions. ### OCR on Azure using IronOCR https://ironsoftware.com/ocr/csharp/get-started/azure/ The article "OCR on Azure using IronOCR" provides a comprehensive guide on integrating IronOCR, an Optical Character Recognition library, with Microsoft Azure in C# applications. IronOCR addresses developer challenges with Azure OCR integration by offering features like converting images and PDFs into searchable documents, reading barcodes and QR codes, and ensuring exceptional accuracy and speed without relying on SaaS. The guide walks through setting up an Azure OCR service, including creating a C# console application, installing IronOCR via NuGet, and coding examples for extracting text from images and PDFs using IronTesseract. It also illustrates creating a Microsoft Azure Function for text extraction from images. Additionally, the article highlights the advantages of IronOCR, such as its support for numerous languages, compatibility with various .NET frameworks, and image filters to improve OCR performance. IronOCR is depicted as a superior alternative to Azure's native OCR, providing improved accuracy, speed, and ease of use without needing Tesseract installation. The article concludes with details on pricing, licensing options, and further resources for developers looking to leverage IronOCR in their projects. ### C# Tesseract Configuration on Docker | IronOCR https://ironsoftware.com/ocr/csharp/get-started/docker/ The article titled "C# Tesseract Configuration on Docker | IronOCR" provides a comprehensive guide on installing and configuring IronOCR, a C# OCR library using Tesseract, within Docker containers. It details the advantages of using Docker, such as enabling developers to easily pack, ship, and run applications as portable, self-sufficient containers that can operate across different environments. The guide specifically focuses on setting up IronOCR on Linux and Windows Docker containers, with a particular emphasis on Azure Docker Containers. For Linux users, the article recommends using the latest 64-bit distributions like Ubuntu 20, Ubuntu 18, Debian 11, and Debian 10 for easy configuration. It provides step-by-step instructions and Dockerfile examples for setting up IronOCR using .NET 5 and .NET 3.1 LTS on both Ubuntu and Debian distributions. Additionally, it advises installing necessary packages and using Microsoft's official Docker images for optimal performance. The article further recommends using the IronOcr NuGet package, which supports development on Windows, macOS, and Linux, to simplify the integration process. Overall, the guide serves as a valuable resource for developers looking to deploy .NET OCR applications efficiently within Docker environments. ### C# Tesseract Configuration on iOS | IronOCR https://ironsoftware.com/ocr/csharp/get-started/ios/ The article provides a comprehensive guide on using the IronOCR library to perform Optical Character Recognition (OCR) on iOS devices using .NET MAUI, an evolution of the Xamarin.Forms framework designed for creating cross-platform apps. The IronOcr.iOS package is specifically tailored for iOS, enabling developers to implement OCR functionalities on iOS devices without needing the vanilla IronOCR package. The guide details step-by-step instructions starting from downloading the IronOcr.iOS package via NuGet and creating a .NET MAUI App project. It includes modifying the project file to conditionally include the package for the iOS platform, editing the MainPage.xaml to create a user interface with a button and label for OCR results, and programming the MainPage.xaml.cs file to handle file import and OCR processing using the IronTesseract class. The guide emphasizes that the current implementation is limited to image files and advises against using the package for PDF documents. Additionally, the article mentions that using IronOcr.iOS in Avalonia requires an additional .NET SDK version. A downloadable sample project is provided for developers to expedite the process. ### Applying .NET 10 License Keys for Your IronOCR Project | IronOCR https://ironsoftware.com/ocr/csharp/get-started/license-keys/ The article titled "Applying Software License Keys for your .NET OCR Project" on IronOCR's website provides a comprehensive guide on implementing and managing license keys for IronOCR in C# applications. It emphasizes the importance of obtaining a license key to deploy projects without restrictions or watermarks, offering options to purchase or obtain a free 30-day trial. The guide details the steps to get started, including downloading the latest version of IronOCR via DLL or NuGet. It instructs users on applying the license key in various ways: through code at the application's start, or by configuring it globally in Web.Config or App.Config files for ASP.NET projects, and in appsettings.json for .NET Core applications. It highlights a known licensing issue affecting certain ASP.NET and .NET Framework versions, directing users to a troubleshooting article. The article also advises testing the key to ensure it's correctly installed and suggests resources for further project development. For any inquiries, users are encouraged to contact IronSoftware's support. This structured guide ensures proper usage and compliance, facilitating a smooth integration of IronOCR into .NET projects. ### C# .NET 10 Tesseract OCR on Linux [Setup Guide] https://ironsoftware.com/ocr/csharp/get-started/linux/ The IronOCR setup guide provides a comprehensive walkthrough for configuring Tesseract OCR on Linux systems using C# and IronOCR. It supports .NET Core and .NET 5 applications across multiple platforms, including Docker, Azure, macOS, and Windows. The guide emphasizes the importance of using long-term support (LTS) versions of .NET Core for stability and reliability on Linux. IronOCR is designed to work seamlessly on Linux without any code changes, thanks to extensive testing and configuration. The guide highlights the significance of Linux support due to its widespread use in cloud services like Azure and AWS, which are crucial for many enterprise and SaaS customers. Officially supported Linux distributions include Ubuntu 20, Ubuntu 18, Debian 11, and Debian 10, with specific setup instructions provided for each version. The document also addresses installation on other Linux distributions, ensuring compatibility with various package managers like `apt`, `apt-get`, `yum`, and `HFS`. The installation process involves updating package lists and installing key dependencies and Tesseract OCR. This guide is a valuable resource for developers seeking to leverage IronOCR's capabilities on Linux-based systems. ### Install IronOCR on macOS environments in C# https://ironsoftware.com/ocr/csharp/get-started/mac/ IronOCR provides comprehensive support for macOS environments, accommodating both Intel and Apple Silicon (ARM) processors. Whether you're using a MacBook Pro with the latest M3 chip or an earlier Intel-based iMac, IronOCR offers a tailored package to suit your platform. The software is compatible with recent macOS versions including Monterey, Ventura, and Sonoma, and supports .NET versions 6 through 9. Developers can integrate IronOCR using JetBrains Rider, Visual Studio Code, or through CLI-based development with dotnet. The macOS-specific NuGet packages encompass all necessary native dependencies for seamless OCR processing. For Intel-based Macs, the IronOcr.MacOs package is recommended, whereas Apple Silicon Macs should use IronOcr.MacOs.ARM to ensure optimized performance and avoid runtime conflicts. IronOCR leverages the Tesseract OCR engine along with native image processing libraries, making it resource-intensive, particularly with high-resolution images or multiple language models. To run these operations efficiently, a minimum of 1 core and 2 GB of RAM is required, though 4 cores and 8 GB of RAM or more are recommended for optimal performance in complex tasks. ### .NET MAUI OCR Library (99.8-100% Accuracy) | IronOCR https://ironsoftware.com/ocr/csharp/get-started/net-maui-ocr-tutorial/ The article serves as a tutorial for creating an OCR processor app using the .NET MAUI framework in conjunction with the IronOCR library. .NET MAUI is a Microsoft-released, cross-platform framework that allows developers to use a single codebase for Android, iOS, and Windows applications. IronOCR is a .NET OCR library that integrates seamlessly with C# projects, enabling the conversion of PDF documents into searchable and editable text with high accuracy. The tutorial outlines the steps necessary to build an OCR application: downloading the IronOCR library via NuGet, configuring the frontend in Visual Studio, and writing the necessary C# code to perform OCR operations. The IronTesseract object is used to process images selected through a FilePicker and extract text, which is then displayed in an Editor control. The tutorial highlights IronOCR's superior accuracy and speed compared to the generic Tesseract library, offering a 99% accuracy rate with support for 125 languages. Complete with comprehensive documentation and support, IronOCR is user-friendly even for novice developers. The guide concludes by encouraging further exploration through additional resources and details IronOCR’s pricing plans for production use. ### How to Use the IronOCR Windows Installer https://ironsoftware.com/ocr/csharp/get-started/windows-installer/ IronOCR, a .NET library for Optical Character Recognition, offers developers the ability to extract text from images and scanned PDFs using C# or VB.NET applications. While typically installed via NuGet, the IronOCR Windows Installer provides an alternative for offline or GUI-based setups. To begin, users download and extract the IronOCR installer, then launch the executable, agreeing to the End User License Agreement. Installation involves selecting an installation folder, choosing a Start Menu folder option, and finally installing the program. Post-installation, the setup usually configures environment variables automatically, but manual adjustments may be necessary, especially for Visual Studio integration. Instructions are provided for modifying the `IRONOCR_INSTALL_DIR` environment variable on both Windows 11 and Windows 10. This involves opening the System Properties, navigating to Environment Variables, and adding or editing the required system or user variables. Users should reboot their systems to ensure changes take effect. For any installation challenges, Iron Software provides a troubleshooting guide, technical support resources, and direct support team contact options, ensuring users have adequate assistance throughout the setup process. ### Setup .NET Tesseract OCR on Windows https://ironsoftware.com/ocr/csharp/get-started/windows/ IronOCR is a robust .NET OCR library designed for extracting text from various formats such as scanned documents, images, and PDFs. It is compatible with multiple Windows environments, including Windows 11, Windows 10, and several versions of Windows Server. The library supports .NET Framework as well as .NET versions 6, 7, and 8. This guide details the steps to set up IronOCR on Windows, emphasizing configurations for optimal performance. The recommended installation method is through the NuGet Package Manager, which provides the core OCR engine, Windows dependencies, and support for multiple languages. Additional language packs like Arabic, Chinese, and German can also be installed via NuGet. For those requiring offline or manual setups, IronOCR offers compiled DLL downloads. These can be easily integrated into Visual Studio projects by adding them as references. Additionally, a Windows Installer is available for manual library installations, particularly beneficial for offline environments or enterprise-level deployment. It includes all necessary DLLs for the OCR engine and language support, streamlining integration into Windows projects without relying on NuGet. ## Tutorials ### C# OCR Image Filter Techniques | IronOCR https://ironsoftware.com/ocr/csharp/tutorials/c-sharp-ocr-image-filters/ The article titled "OCR Image Filter Settings in C# | IronOCR" from Iron Software provides a comprehensive guide on enhancing the accuracy and performance of Optical Character Recognition (OCR) using image filters in C#. IronOCR offers various filters to preprocess images, making them more suitable for OCR processing. Key filters include those for changing image orientation, such as Rotate and Deskew, which adjust and correct the skew of images. Color manipulation filters like Binarize, ToGrayScale, and Invert are discussed for improving contrast and readability by altering pixel colors. Contrast enhancement filters, including Contrast, Dilate, and Erode, are also detailed. These improve OCR accuracy in low-contrast scenarios. Noise reduction filters like Sharpen and DeNoise are explained to eliminate digital noise, while EnhanceResolution is used for low-quality images. The article provides practical examples and usage scenarios for each filter, demonstrating how to apply them in code. It highlights the importance of debugging by saving filtered image results to visualize the changes made by each filter. Overall, the guide is aimed at developers seeking to optimize OCR processes by employing appropriate image filters in their C# projects. ### Tesseract OCR C# .NET 10 Tutorial - 99.8% Accuracy | IronOCR https://ironsoftware.com/ocr/csharp/tutorials/c-sharp-tesseract-ocr/ This comprehensive tutorial demonstrates how to implement optical character recognition in C# applications using enhanced Tesseract technology. While traditional Tesseract integration requires complex C++ interop and extensive image preprocessing, IronOCR provides a managed .NET library that achieves 99.8-100% accuracy out of the box. The guide covers installation through NuGet, automatic image preprocessing, multi-format support including PDFs and TIFFs, cross-platform deployment, and advanced features like barcode reading and searchable PDF creation. With practical code examples and performance optimization techniques, developers learn to build production-ready OCR solutions that work reliably across Windows, Linux, macOS, and cloud platforms. The tutorial compares vanilla Tesseract limitations with IronOCR's enterprise features, helping developers choose the right solution for their specific requirements. ### C# OCR Image to Text Tutorial - IronOCR Without Tesseract | Iron Software https://ironsoftware.com/ocr/csharp/tutorials/how-to-read-text-from-an-image-in-csharp-net/ This comprehensive tutorial demonstrates how to implement optical character recognition (OCR) in C# applications using IronOCR. Learn to convert images to text without complex Tesseract configurations, process multi-page documents, handle low-quality scans with image filters, and extract text from specific regions. The guide covers advanced features including multi-language support for 125+ languages, barcode reading, searchable PDF creation, and detailed result analysis. With practical code examples and performance optimization techniques, developers can quickly integrate powerful OCR capabilities supporting various image formats, PDFs, and TIFF files while achieving exceptional accuracy rates even on imperfect documents. ### How to Read Specialized Documents in C# | IronOCR https://ironsoftware.com/ocr/csharp/tutorials/read-specific-document/ The article "How to Read Specific Documents" on IronOCR's website addresses the complexities of using OCR technology to accurately read various document types such as standard text documents, license plates, passports, and photos. Given the diverse formats and contents of each document type, IronOCR offers specialized methods to optimize accuracy and performance. These methods include `ReadLicensePlate`, `ReadPassport`, `ReadPhoto`, and `ReadScreenShot`, which are extensions to the IronOCR package and require the IronOcr.Extensions.AdvancedScan package, available only on Windows. The methods support multiple languages, though additional language packages are necessary. To get started, users are instructed to download the C# library from NuGet, prepare their images or PDFs, and apply the specific reading methods tailored to each document type. Special configurations like PageSegmentationMode enhance the reading of scanned documents with complex layouts. The `ReadLicensePlate` method identifies license plate information, while the `ReadPassport` method extracts details from the machine-readable zone of passport photos. The `ReadPhoto` and `ReadScreenShot` methods are designed for images with challenging text, returning detailed text region data. The article provides code examples for each method, guiding users through the setup process. ## How-To Guides ### C# Async OCR Tutorial - ReadAsync & Multithreading https://ironsoftware.com/ocr/csharp/how-to/async/ IronOCR provides comprehensive async and multithreading support for C# OCR operations, automatically utilizing all CPU cores to enhance performance. The library's ReadAsync() method enables non-blocking OCR execution, keeping applications responsive while processing large documents. IronOCR's built-in multithreading requires no specialized API configuration from developers to get started - it automatically detects and leverages available cores for parallel processing. Key features include thread-safe operations, a memory footprint you can bound with the MaxDegreeOfParallelism property, and scalable performance that decreases processing time proportionally with available cores. The library excels at handling PDF documents and multiple image files simultaneously through its seamless integration of parallelism into the OCR workflow. Developers can implement async OCR with a single line of code using IronTesseract's ReadAsync method, making it simple to add responsive text recognition to applications. This automatic multithreading approach significantly boosts OCR performance while simplifying development, as the library handles all thread management internally. The combination of async support and automatic multithreading makes IronOCR particularly effective for processing large volumes of text data efficiently without blocking the main application thread. ### Read Barcodes & QR Codes in C# | IronOCR Tutorial https://ironsoftware.com/ocr/csharp/how-to/barcodes/ IronOCR is a C# library that enables developers to read barcodes and QR codes from PDFs and images with a simple configuration setting. By setting ReadBarCodes = true, the library automatically extracts barcode values alongside regular text recognition, supporting over 20 barcode formats including QR codes, Code 128, Data Matrix, and various 1D formats like EAN-13 and UPC. The library performs dual extraction, capturing both human-readable text through standard OCR and machine-readable barcode data in a single processing pass. This unified approach eliminates the need for multiple libraries or separate processing steps. IronOCR's workflow involves importing target documents, enabling barcode reading, using the Read method for OCR processing, and accessing results through the OcrResult class which separates text output (via the Text property) and barcode data (via the Barcodes collection). This functionality is particularly useful for processing documents like invoices, shipping labels, and inventory reports where barcode values correlate with printed text. ### C# Computer Vision OCR Tutorial - Text Detection Guide https://ironsoftware.com/ocr/csharp/how-to/computer-vision/ IronOCR leverages OpenCV computer vision technology to automatically identify text regions within images before OCR processing, significantly improving accuracy for challenging images with noise, multiple text areas, or warped text. The FindTextRegion() method focuses Tesseract recognition exclusively on detected text areas rather than processing entire images, resulting in enhanced extraction quality. The tutorial demonstrates a simple one-line implementation for text detection and extraction using IronOCR's Computer Vision capabilities. The minimal workflow involves five steps: installing the C# library, utilizing FindTextRegion for automatic text detection, verifying detected regions with StampCropRectangleAndSaveAs, separating images into text-based regions using FindMultipleTextRegions, and retrieving crop areas through GetTextRegions. Implementation requires the separate IronOcr.ComputerVision NuGet package, with platform-specific versions available for Windows, Linux, and macOS. The technology employs OpenCV algorithms similar to those used in specialized applications like license plate recognition and passport scanning, making it suitable for various document processing scenarios including invoices, screenshots, and subtitles. ### How to Debug OCR in C# — Logging & Error Handling | IronOCR https://ironsoftware.com/ocr/csharp/how-to/debugging/ The article "How to Debug OCR in C#" by IronOCR provides a comprehensive guide on enhancing Optical Character Recognition (OCR) debugging processes within C# applications. The piece emphasizes the importance of accurate error handling and efficient logging to optimize OCR performance. It introduces IronOCR's built-in features such as logging, which records detailed information about OCR tasks, aiding developers in pinpointing and resolving issues swiftly. The article also highlights the role of typed exceptions that facilitate the identification of specific errors, thereby improving the robustness of the code. Confidence scoring is discussed as a critical tool for assessing the reliability of the OCR output, allowing developers to gauge the quality of text recognition. Furthermore, the article discusses progress tracking, which provides real-time updates on the OCR process, thus enhancing transparency and control. IronOCR recommends production-ready try-catch patterns to manage exceptions efficiently, ensuring that applications remain stable even when encountering errors. Overall, the article serves as a valuable resource for developers seeking to refine their OCR debugging techniques in C#, ensuring their applications can handle OCR tasks more effectively and with greater accuracy. ### Detect Page Rotation in C# - IronOCR Tutorial & Examples https://ironsoftware.com/ocr/csharp/how-to/detect-page-rotation/ IronOCR's DetectPageOrientation method provides automatic page rotation detection for C# applications, identifying whether PDF documents and images are rotated at 0°, 90°, 180°, or 270° angles. This functionality is essential for accurate text extraction and proper document rendering. The method returns a RotationAngle property for each page along with confidence scores, enabling developers to programmatically correct orientation issues with minimal code. The tutorial demonstrates a simple workflow: loading documents, calling DetectPageOrientation, accessing the RotationAngle property for correction, and utilizing the HighConfidence property to handle edge cases. The method works best with text-dense documents and provides page-by-page analysis through properties like PageNumber, RotationAngle, and HighConfidence. For documents with non-standard rotations or skewing, IronOCR recommends using the Deskew method in combination with image correction filters. The HighConfidence property is particularly valuable when dealing with ambiguous documents, sparse text, unusual layouts, or poor scan quality, allowing developers to implement fallback strategies or additional validation when rotation detection uncertainty is high. This feature streamlines document processing workflows by eliminating manual orientation checks and ensuring consistent text extraction results. ### C# OCR DPI Settings: Boost Text Recognition | IronOCR https://ironsoftware.com/ocr/csharp/how-to/dpi-setting/ IronOCR's TargetDPI property enables developers to enhance OCR accuracy by upscaling low-resolution images. DPI (Dots Per Inch) measures image quality and directly impacts OCR performance, as engines analyze character shapes to convert them into machine-readable text. Low-resolution scans often produce blurry or pixelated text that creates obstacles for accurate data extraction. IronOCR effectively handles these challenges, achieving high accuracy on scans with resolutions as low as 225 DPI through advanced image preprocessing capabilities. The library automatically detects and compensates for various image quality issues, making it suitable for processing documents from diverse sources. Setting TargetDPI is straightforward - developers can configure it in a single line of code using the OcrInput class. The article demonstrates this with a practical example using a 100 DPI image with artificial noise, showing how the TargetDPI feature improves text clarity and recognition. This optimization is crucial for developers working with scanned documents or legacy digitization systems, whether implementing simple one-line OCR solutions or building complex document processing pipelines. The minimal workflow involves downloading the C# library, instantiating OcrInput, setting TargetDPI, loading the image, and extracting data using the Read method. ### C# OCR Filter Wizard: Auto-Test Image Preprocessing https://ironsoftware.com/ocr/csharp/how-to/filter-wizard/ IronOCR's Filter Wizard is a C# tool that automates the optimization of image preprocessing for optical character recognition (OCR). The wizard addresses the common challenge of manually testing multiple filter combinations to improve OCR accuracy, which is particularly difficult with low-quality scans or images containing noise and distortion. Using the OcrInputFilterWizard class, developers can automatically evaluate all possible preprocessing filter combinations with a single line of code. The tool tests various filters on the input image, measures the OCR confidence score for each combination, and returns both the highest confidence score achieved and the exact C# code snippet needed to reproduce those optimal results. This eliminates time-consuming trial and error, making it especially valuable for processing diverse image types where optimal preprocessing varies. The Filter Wizard seamlessly integrates with IronOCR's OcrInput class, simplifying the application of discovered filter chains to similar images. The workflow involves instantiating the IronTesseract engine, loading an image into the wizard, running the analysis, and then applying the generated code to achieve optimal OCR results. ### C# OCR Text Highlighting - Visualize Results | IronOCR https://ironsoftware.com/ocr/csharp/how-to/highlight-texts-as-images/ IronOCR's `HighlightTextAndSaveAsImages` method is a diagnostic tool that visualizes OCR results by drawing bounding boxes around detected text elements (characters, words, lines, or paragraphs) and saving them as images. This C# feature enables developers to validate OCR accuracy and debug recognition issues by providing visual feedback on what the OCR engine has identified and where potential errors occur. The method is particularly useful when working with complex documents or troubleshooting recognition problems. Implementation is straightforward - developers can load a PDF document using `LoadPdf` and call `HighlightTextAndSaveAsImages` with three parameters: the IronTesseract OCR engine, an output filename prefix, and a `ResultHighlightType` enum specifying whether to highlight characters, words, lines, or paragraphs. The method automatically appends page identifiers to filenames when processing multi-page documents. This visual feedback mechanism is essential for quality control measures in document processing systems, allowing developers to instantly see what text the OCR engine detects and verify the accuracy of their OCR implementation through saved diagnostic images. ### Export OCR Results as hOCR HTML Files in C# | IronOCR https://ironsoftware.com/ocr/csharp/how-to/html-hocr-export/ IronOCR is a C# library that enables developers to export OCR results as hOCR HTML files, preserving text layout and character coordinates in a structured format. By setting the RenderHocr property to true and using SaveAsHocrFile or SaveAsHocrString methods, developers can generate HTML files containing recognized text with spatial information. hOCR (HTML-based OCR) is valuable for applications requiring text position data, such as document indexing, accessibility tools, and advanced search implementations. The format stores not just the recognized text but also its exact location within the original document, enabling features like text highlighting for debugging and creating clickable overlays. This functionality is particularly useful for enterprise applications processing scanned documents, providing a foundation for advanced document understanding and extraction workflows. The process involves a simple workflow: downloading the IronOCR library, preparing the target image or PDF, enabling the RenderHocr property, and using the appropriate export method to generate either an HTML file or string output containing the structured OCR results with complete layout preservation. ### Fix Image Colors for C# OCR - Binarize & Grayscale Guide https://ironsoftware.com/ocr/csharp/how-to/image-color-correction/ This article provides a comprehensive guide on fixing image colors for C# OCR using IronOCR. It covers essential techniques including binarization, grayscale conversion, image inversion, and color replacement to enhance text readability and OCR accuracy. The guide demonstrates how to use IronOCR's SelectTextColor method to extract specific text colors without complex image manipulation. Binarization converts images to two-color format for better contrast, while grayscale conversion reduces visual clutter. The article includes practical code implementations showing how to apply these filters, export modified images for comparison, and combine multiple preprocessing techniques. It explains when to use each method - binarization for scanned documents with uneven lighting, grayscale for colored backgrounds or watermarks, and inversion for light text on dark backgrounds. The guide also covers advanced features like the Filter Wizard for determining optimal filter combinations and batch processing capabilities. Each technique is illustrated with before/after image comparisons and complete code examples, making it easy for developers to implement these color correction methods in their C# OCR applications. ### Fix Image Orientation in C# OCR | Rotate & Deskew Tutorial https://ironsoftware.com/ocr/csharp/how-to/image-orientation-correction/ IronOCR provides comprehensive image orientation correction capabilities for C# developers to fix common OCR scanning issues. The library offers rotation, deskewing, and scaling methods that can be chained together to correct tilted scans, upside-down documents, and improperly sized images in .NET applications. Developers can rotate images by any degree value, with common rotations being 90-degree increments for standard orientation fixes. The Rotate method accepts positive values for clockwise rotation and negative for counterclockwise, rotating around the image center point while maintaining original dimensions. This functionality is essential for scenarios including documents scanned incorrectly, mobile photos requiring orientation changes, multi-page documents with inconsistent orientations, and specialized applications like passport scanning and license plate recognition. IronOCR also features automatic orientation detection through its DetectPageOrientation method, which analyzes text to determine correct positioning. The library enables developers to chain multiple transformation methods in a single line of code, creating an efficient workflow that includes loading images, applying corrections, and performing OCR text extraction without extensive boilerplate code. ### C# OCR Image Filters: Sharpen, Enhance & Correct Text https://ironsoftware.com/ocr/csharp/how-to/image-quality-correction/ IronOCR is a C# library that provides five essential image correction filters to preprocess images and significantly improve OCR accuracy. The filters include sharpen, enhance resolution, denoise, dilate, and erode functions that help clarify text and reduce noise before text extraction. The library allows developers to easily apply these filters using simple code, such as sharpening blurry images with a single line: `new IronOcr.OcrImageInput("sample.png").Sharpen()`. The sharpen filter increases contrast along text edges, making character boundaries more distinct for better recognition. This is particularly useful for slightly out-of-focus images, scanned documents with soft edges, or photos taken in poor lighting. The library recommends targeting 300 DPI for optimal OCR performance. Users can apply filters individually or in combination, then export the corrected images for viewing before processing with the Read method. The article emphasizes that proper image preprocessing is crucial for accurate OCR, as blurry text with soft edges commonly causes character misidentification. IronOCR simplifies the image correction workflow, making it accessible for developers to enhance OCR accuracy in their C# applications through automated image preprocessing techniques. ### Read Images in C# with IronOCR - JPG PNG TIFF OCR Guide https://ironsoftware.com/ocr/csharp/how-to/input-images/ IronOCR is a C# library that enables text extraction from images using optical character recognition (OCR) technology. Supporting JPG, PNG, GIF, TIFF, and BMP formats, it requires just one line of code for basic text extraction after NuGet installation. The library leverages Tesseract 5's advanced machine learning algorithms combined with proprietary image preprocessing to achieve industry-leading accuracy. IronOCR automatically handles format detection and applies appropriate preprocessing, making it suitable for various image qualities from high-resolution scans to compressed web images. The library features built-in image filters that automatically correct common quality issues. Implementation is straightforward - developers instantiate the IronTesseract class and use the Read method with an OcrImageInput object containing the image file path. The library ensures proper resource disposal through 'using' statements. Recent updates (version 2025.6) have improved TIFF image processing performance, with some users experiencing up to twice the speed depending on GPU capabilities. IronOCR offers cross-platform support with installation guides available for Windows, Linux, and macOS environments. ### Read PDFs in C# with IronOCR - Extract Text from PDF Files https://ironsoftware.com/ocr/csharp/how-to/input-pdfs/ IronOCR is a C# library that enables developers to extract text from PDF files using optical character recognition (OCR) technology. Built on the Tesseract engine, it supports all PDF versions from 1.0 to 2.0 standards and can process both scanned (image-based) and searchable (text-based) PDFs with a single line of code. The library simplifies PDF text extraction through its OcrPdfInput class, which accepts a PDF file path and optional parameters like DPI settings for enhanced accuracy. Developers can quickly implement OCR functionality by instantiating the IronTesseract class, creating an OcrPdfInput object, and calling the Read method to perform text extraction. The library handles various document types and maintains consistent results regardless of the original application used to create the PDF. IronOCR is particularly useful for automating document processing workflows, extracting data from scanned documents, and converting PDF content into searchable text. The tool offers flexibility in processing entire PDF files or specific pages, with options to optimize performance through DPI adjustments when dealing with low-resolution scanned documents or PDFs containing small text. ### C# OCR Stream Processing: Read Images from Memory | IronOCR https://ironsoftware.com/ocr/csharp/how-to/input-streams/ IronOCR enables direct OCR processing from image streams in C# without requiring disk storage. By passing streams to OcrInput or OcrImageInput constructors, developers can efficiently handle image data from various sources including web uploads, database BLOBs, and in-memory transformations. The library's stream processing approach offers significant advantages: enhanced memory efficiency by processing data in chunks, improved security by avoiding temporary file creation, better performance through eliminated file I/O overhead, and flexibility in handling diverse data sources. The implementation is straightforward - instantiate IronTesseract, pass the stream to OcrImageInput, and call the Read method to extract text. This stream-based approach is particularly beneficial for web applications receiving image uploads, processing database-stored images, or handling sensitive documents that shouldn't be written to disk. IronOCR maintains its simple API while delivering robust performance for both single images and multi-page documents, making it an ideal solution for applications requiring efficient, secure, and scalable OCR capabilities without the overhead of file system operations. ### C# OCR Read System.Drawing Objects - IronOCR Tutorial https://ironsoftware.com/ocr/csharp/how-to/input-system-drawing/ IronOCR is a C# library that enables text extraction from System.Drawing objects including Bitmap and Image classes. The library provides OCR functionality across Windows, macOS, and Linux platforms by wrapping System.Drawing objects in OcrImageInput. System.Drawing.Bitmap handles bitmap images in .NET Framework, while System.Drawing.Image serves as the base class for GDI+ image objects. For cross-platform compatibility, IronOCR supports IronSoftware.Drawing.AnyBitmap from IronDrawing, an open-source alternative to System.Drawing.Common. The quickstart example demonstrates single-line text extraction: creating an IronTesseract instance and feeding it a System.Drawing.Bitmap wrapped in OcrImageInput. The workflow involves downloading the library, obtaining System.Drawing objects, constructing OcrImageInput, utilizing AnyBitmap for Linux/macOS support, and optionally defining crop regions. The tutorial emphasizes using the 'using' statement with OcrImageInput for proper resource management, as it implements IDisposable to handle unmanaged resources. This prevents memory leaks and file locks, especially important during batch processing operations. ### C# OCR: Read Multi-Frame TIFF & GIF Files | IronOCR https://ironsoftware.com/ocr/csharp/how-to/input-tiff-gif/ IronOCR is a C# library that simplifies text extraction from multi-frame TIFF and GIF files through its OcrImageInput class. The library automatically detects and processes all frames within these file formats without requiring complex configuration. For TIFF files, which are high-quality image formats supporting lossless compression ideal for scanned documents, IronOCR iterates through each frame, applies OCR to every page, and consolidates results into a single OcrResult object. Similarly, GIF files, commonly used for web images and animations, can be processed using the same straightforward approach. The implementation requires just a few lines of code: instantiating the IronTesseract class, creating an OcrImageInput object with the target file, and calling the Read method. The library handles both single-frame and multi-frame documents automatically, eliminating the need for frame-by-frame processing logic. Additional features include the ability to define specific reading areas through crop regions and optimize performance through fast OCR configuration and multithreaded processing capabilities. This makes IronOCR an efficient solution for batch processing multi-page documents and extracting text from various image formats in C# applications. ### Iron Tesseract C# Guide - OCR Configuration & Setup https://ironsoftware.com/ocr/csharp/how-to/iron-tesseract/ IronTesseract is a C# OCR library that provides an optimized implementation of Tesseract 5 for converting images and scanned documents into searchable text and PDFs. The library supports 125 international languages and includes advanced features like barcode reading and computer vision capabilities. To use IronTesseract, developers create an instance of the IronTesseract class, configure it with specific language settings and OCR parameters, then call the Read() method on an OcrInput object containing images or PDFs. The library offers extensive configuration options including the ability to enable/disable barcode reading, generate searchable PDFs, and whitelist or blacklist specific characters. The basic workflow involves installing the library via NuGet, loading documents for processing, extracting text, and optionally saving results as searchable PDFs. IronTesseract also supports multithreading for batch operations, allowing simultaneous processing of multiple documents for improved performance. The API is designed to be intuitive and can perform OCR operations with just a single line of code once configured. ### OCR Configuration for Advanced Reading | IronOCR https://ironsoftware.com/ocr/csharp/how-to/ocr-configurations-for-advanced-reading/ The article "OCR Configuration for Advanced Reading" on IronOCR's website provides a comprehensive guide on customizing TesseractConfiguration properties within IronOCR to enhance optical character recognition performance. It is tailored for users who require advanced OCR capabilities, such as configuring character whitelists specifically for reading license plates, and offers detailed instructions for setting up barcode and data table reading. Furthermore, the article delves into adding international language support, focusing on languages with complex scripts like Chinese, Japanese, and Korean. It explores the practical applications and benefits of these configurations in various industries and use cases, highlighting how such customizations can improve accuracy and efficiency in data extraction tasks. By leveraging these advanced settings, users can fine-tune IronOCR to better meet their specific needs, ensuring more precise and reliable text recognition outcomes. The guide not only enhances the understanding of IronOCR's flexibility and power but also provides actionable steps for users to implement these configurations effectively. Overall, the article serves as an invaluable resource for developers and tech enthusiasts looking to optimize OCR processes for complex and multilingual text recognition scenarios. ### Train Custom Fonts for OCR in C# with Tesseract 5 https://ironsoftware.com/ocr/csharp/how-to/ocr-custom-font-training/ This article provides a comprehensive guide for Windows developers on training custom fonts for OCR in C# using Tesseract 5. The process involves creating specialized .traineddata files that enable IronOCR to accurately recognize decorative or special fonts that standard OCR engines struggle with. The tutorial covers the complete workflow from initial setup through implementation, including installing WSL2 and Ubuntu (as Linux is required for training), setting up Tesseract 5, and preparing font files. The article demonstrates how to use the resulting trained font files in C# applications with IronOCR through simple code examples. Key steps include downloading the target font file (.ttf or .otf format), following the training process, troubleshooting common errors, and exporting the final trained data file. The guide emphasizes that while training requires a Linux environment, the generated .traineddata files work seamlessly across all platforms. This makes it possible for developers to enhance OCR accuracy for specialized fonts in their C# applications, particularly useful for processing documents with non-standard or decorative typography. ### Custom Language OCR with Tesseract in C# | IronOCR Guide https://ironsoftware.com/ocr/csharp/how-to/ocr-custom-language/ IronOCR provides robust support for optical character recognition (OCR) of custom languages, specialized scripts, and ciphers through integration with Tesseract's `.traineddata` files. Using the `UseCustomTesseractLanguageFile` method, developers can load custom-trained language models to extract text from documents containing non-standard writing systems, historical scripts, or invented languages. The implementation process is straightforward: initialize the IronTesseract engine, load the custom training data file, create an OcrInput object with the target document, and execute the Read() method to extract text. This capability extends IronOCR's functionality beyond its built-in support for 125 international languages, enabling specialized applications such as deciphering historical manuscripts, processing constructed languages, or reading specialized notation systems. The guide demonstrates that while creating custom `.traineddata` files requires Tesseract's training tools, IronOCR seamlessly integrates these files into the OCR workflow. This feature is particularly valuable for researchers, historians, and developers working with unique or proprietary text systems that aren't covered by standard language packages. ### C# Fast OCR Configuration: 17% Speed Boost | IronOCR https://ironsoftware.com/ocr/csharp/how-to/ocr-fast-configuration/ IronOCR's fast configuration delivers up to 17% faster OCR processing speeds without sacrificing accuracy by utilizing the EnglishFast language mode and disabling non-essential features like barcode reading. This optimization is particularly valuable for high-volume text extraction scenarios where processing time is critical. The configuration works by setting the Language property to OcrLanguage.EnglishFast, which prioritizes speed over marginal accuracy gains, and turning off unnecessary features such as ReadBarCodes. Additionally, allowing IronOCR to auto-detect page segmentation keeps the setup streamlined. The fast configuration is ideal for bulk processing applications, including scanned documents, PDFs, and images, where mission-critical time constraints exist. While the standard IronOCR configuration provides excellent out-of-the-box performance, the fast configuration option offers significant scanning performance improvements with minimal accuracy impact. The article provides code examples and benchmark comparisons between fast and standard configurations, demonstrating how developers can implement these optimizations in C# applications to enhance their OCR processing efficiency. ### C# OCR: Multilingual Text Recognition with Tesseract https://ironsoftware.com/ocr/csharp/how-to/ocr-multiple-languages/ IronOCR is a C# library that enables text extraction from documents and images in over 125 languages using the Tesseract OCR engine. The tool simplifies multilingual document processing by allowing developers to configure primary and secondary languages with just one line of code. This capability is essential for modern applications dealing with international business documents, multilingual websites, and global communication platforms that require accurate text extraction across language barriers. The library provides seamless integration with Tesseract's extensive language support, enabling simultaneous text extraction from documents containing multiple scripts and character sets. While English is installed by default, developers can easily download additional language packs via NuGet. The implementation is straightforward - users can set a primary language using the Language property and add secondary languages using the AddSecondaryLanguage method. IronOCR's multilingual capabilities make it particularly valuable for processing PDFs containing multiple languages. By specifying primary and secondary languages before processing documents, developers can ensure optimal recognition accuracy across different scripts and character sets. This flexibility and ease of use make IronOCR an effective solution for organizations needing to extract text from diverse multilingual documents and images in their C# applications. ### Define OCR Region in C# - Extract Text from Image Areas https://ironsoftware.com/ocr/csharp/how-to/ocr-region-of-an-image/ IronOCR enables C# developers to extract text from specific regions of images using the Rectangle object to define precise areas for OCR processing. By specifying x/y coordinates, width, and height in pixels, developers can target exact portions of an image rather than processing the entire document. This targeted approach significantly improves performance, accuracy, and reduces errors from irrelevant text capture. The process involves creating a Rectangle object from the IronSoftware.Drawing namespace, where x/y coordinates represent the top-left corner of the desired area, then passing this rectangle as a parameter to the LoadImage method. This technique is particularly valuable for structured documents like invoices, forms, and identity documents where information appears in predictable locations. Regional OCR eliminates the inefficiency of full document scanning and minimizes false positives. Developers can use simple image editors like MS Paint to determine the exact coordinates needed for their Rectangle definitions. The implementation requires installing IronOCR via NuGet, instantiating the IronTesseract OCR engine, defining the region, loading the image with the specified area, and extracting the text through the Read method. ### C# OCR Progress Tracking with IronOCR | Real-Time Monitor https://ironsoftware.com/ocr/csharp/how-to/progress-tracking/ IronOCR provides an event-based progress tracking system for C# OCR operations through its OcrProgress event, enabling real-time monitoring of text extraction from PDFs and images. Developers can subscribe to this event to receive instant feedback including completion percentage, pages processed, and time metrics. The system is particularly valuable when processing large documents or batch files, offering comprehensive progress data such as ProgressPercent (0-100%), TotalPages, PagesComplete, StartTime, Duration, and EndTime. Implementation requires minimal code - simply subscribing to the OcrProgress event before initiating OCR operations. This feature integrates seamlessly with async operations and multithreading for enhanced performance. The progress tracking helps developers create responsive applications with progress bars and status updates, improving user experience during lengthy OCR tasks. It's especially useful for monitoring PDF OCR operations and multipage TIFF file processing, allowing applications to provide meaningful feedback to users about the current state of text extraction operations. ### Advanced OCR Results in C#: Words, Characters, and Bounding Boxes https://ironsoftware.com/ocr/csharp/how-to/read-document-advanced/ The article titled "Advanced OCR Results in C#: Words, Characters, and Bounding Boxes" provides a comprehensive guide on utilizing IronOCR's advanced OCR pipeline to extract detailed word and character data. It focuses on how developers can access and manipulate these results in C# by iterating through Words and Characters collections. The guide explains how to read bounding box coordinates, which are crucial for identifying the precise location of text within an image. Additionally, the article covers filtering OCR results based on confidence scores to ensure accuracy and reliability in text recognition. It also discusses methods to reconstruct the reading order of recognized text, which is vital for maintaining the logical flow in documents. Furthermore, the guide demonstrates how to crop source images effectively using ReadDocumentAdvanced and ReadPhoto, allowing developers to focus on specific areas of interest within an image. This detailed tutorial equips developers with the skills to enhance the performance and accuracy of OCR applications by leveraging the advanced features of IronOCR. ### Read Handwriting from Images in C# | IronOCR Guide https://ironsoftware.com/ocr/csharp/how-to/read-handwritten-image/ IronOCR offers a specialized `ReadHandwriting` method for digitizing handwritten text from images in C# applications, achieving approximately 90% accuracy for English handwriting recognition. This solution addresses the challenges of processing handwritten documents like medical forms, historical records, and customer surveys, which traditionally require error-prone manual processing. Built on the Tesseract 5 engine, IronOCR combines advanced image processing with machine learning capabilities to deliver reliable handwriting OCR. The implementation process is straightforward: developers need to install IronOCR along with the IronOcr.Extensions.AdvancedScan package, create an IronTesseract instance, load the handwriting image using LoadImage(), call the ReadHandwriting() method, and access the extracted text from the OcrResult. The library handles the inherent difficulties of handwriting recognition, including irregular spacing and stroke variations that make OCR challenging. Currently, the ReadHandwriting method supports English only, though standard OCR methods with appropriate language packs can be used for multiple language support. This guide provides step-by-step instructions for implementing handwriting OCR in .NET applications, making it accessible for developers to digitize various handwritten documents efficiently. ### Read License Plates in C# with IronOCR - Tutorial https://ironsoftware.com/ocr/csharp/how-to/read-license-plate/ IronOCR's `ReadLicensePlate` method provides automated license plate recognition in C# applications, enabling developers to extract vehicle plate numbers from images with high accuracy. This tutorial demonstrates how to implement license plate reading for vehicle management systems, parking management, toll collection, and security surveillance. The method requires the IronOcr.Extension.AdvancedScan package and supports English, Chinese, Japanese, Korean, and Latin alphabets. With a single method call, developers can process license plate images and receive both the extracted text and confidence scores. The implementation involves loading an image into OcrInput and calling ReadLicensePlate, which returns an OcrLicensePlateResult containing the plate data. The tutorial covers a minimal 5-step workflow: downloading the C# library, importing the license plate image, ensuring the image contains only the plate without headers or footers, using the ReadLicensePlate method, and accessing the result properties. Optional configurations include whitelisting specific characters to optimize processing speed. The method is particularly useful for automating vehicle identification tasks that would otherwise be time-consuming and error-prone when performed manually. ### Read MICR Check Numbers in C# | IronOCR Tutorial https://ironsoftware.com/ocr/csharp/how-to/read-micr-cheque/ IronOCR provides a specialized C# solution for reading MICR (Magnetic Ink Character Recognition) lines from check images, automating the extraction of routing numbers, account numbers, and other critical financial data. The library streamlines check processing by eliminating manual data entry errors and improving efficiency. Implementation requires minimal setup - developers simply set the OCR language to MICR, define the rectangular region containing the MICR line, and call the Read() method. The MICR technology uses magnetic ink printed in the E-13B font (in North America), containing 14 characters including digits 0-9 and four special symbols for transit, on-us, amount, and dash separators. These magnetic properties ensure reliable reading even when checks are damaged or folded. IronOCR's MICR reading capability accurately extracts check numbers, routing numbers, and account numbers from the bottom of checks, making it ideal for financial institutions and businesses that need to process checks programmatically. The tutorial demonstrates how to implement MICR reading in just one line of code, providing developers with a quick and reliable solution for automated check processing workflows. ### C# Passport OCR: Extract MRZ Data with IronOCR Tutorial https://ironsoftware.com/ocr/csharp/how-to/read-passport/ IronOCR's ReadPassport method enables efficient extraction of structured data from passport images with a single line of C# code, making it invaluable for immigration and security applications. The library leverages Tesseract 5 with machine learning enhancements to accurately read Machine Readable Zones (MRZ) and extract critical information including given names, surnames, passport numbers, countries, birth dates, and expiry dates. Unlike traditional Tesseract implementations, IronOCR provides a simplified API specifically optimized for document extraction. The process involves loading a passport image using OcrInput and calling ReadPassport(), which returns an OcrPassportResult object containing all extracted data as string properties. This streamlined approach is particularly beneficial for high-volume environments like airport check-in counters and immigration checkpoints where agents process numerous passports daily. The method automatically locates the MRZ area using advanced computer vision techniques, eliminating the need for complex setup or manual configuration. IronOCR's specialized document reading capabilities extend beyond passports to include license plates, MICR cheques, and other structured documents, providing a comprehensive solution for automated document processing in security-critical applications. ### Read Photos in C# - Extract Text from TIFF & GIF | IronOCR https://ironsoftware.com/ocr/csharp/how-to/read-photo/ IronOCR's ReadPhoto method provides specialized OCR functionality for extracting text from complex photo formats like TIFF and GIF files in C#. This method delivers structured results with text regions and confidence scores, making it particularly effective for high-quality scanned documents. The technology automates the conversion of image-based text into searchable, editable digital data, significantly reducing manual processing time and errors. IronOCR handles the unique challenges of these formats, including size, color depth, and compression issues. The ReadPhoto function enables developers to perform advanced operations beyond basic text extraction, such as keyword searching and converting scanned documents into searchable PDFs. This capability proves especially valuable for industries managing large volumes of legal documents, archives, or receipts where efficient data retrieval is critical. The implementation requires installing the IronOcr.Extension.AdvancedScan package and follows a simple workflow: loading images using OcrInput, applying the ReadPhoto method, and accessing the OcrPhotoResult property to manipulate extracted data. The method is optimized specifically for photo formats, distinguishing it from IronOCR's standard Read function used for general image processing. ### C# OCR Results: Extract Text, Coordinates & Metadata https://ironsoftware.com/ocr/csharp/how-to/read-results/ IronOCR's Read method returns an OcrResult object containing extracted text along with comprehensive metadata. This includes precise X/Y coordinates, dimensions (width and height), text direction, and hierarchical document structure organized into paragraphs, lines, words, and individual characters. The OCR engine, built on Tesseract 5, provides structured data extraction capabilities beyond simple text recognition, suitable for processing scanned documents, photos, and screenshots. Each detected element includes a CropRectangle object for location data. The hierarchical structure mirrors natural document organization, allowing developers to work with content at various granularity levels. The OcrResult class enables easy access to text content through collections like Words, where developers can retrieve specific elements (e.g., Words[0].Text for the first word). The system supports multilingual document processing and provides both text extraction and detailed positional information for each recognized element, making it suitable for applications requiring precise text location data or document structure analysis. ### Read Scanned Documents in C# | IronOCR Tutorial https://ironsoftware.com/ocr/csharp/how-to/read-scanned-document/ IronOCR is a C# library that enables developers to extract text from scanned PDFs and images using OCR technology. It converts non-searchable, image-based documents into searchable content with minimal code. The library is particularly valuable for processing business documents, legal papers, and research materials where manual text extraction would be time-consuming and error-prone. IronOCR enhances document accessibility for visually impaired users and streamlines workflows by enabling automated data extraction for analysis and system integration. The tutorial demonstrates using OcrPdfInput methods and requires the IronOcr.Extensions.AdvancedScan package. Developers can quickly implement OCR functionality with a single line of code using LoadPdf or LoadImage methods combined with ReadDocument. The library supports multiple formats including JPG, PNG, GIF, TIFF, BMP for images, and both single and multi-page PDFs. Built on Tesseract 5 technology, IronOCR ensures high accuracy in text recognition. The extracted text can be easily saved or exported for further processing, making it an efficient solution for various applications including content creation, data analysis, and document digitization projects. ### Read Screenshots in C# with IronOCR - OCR Tutorial https://ironsoftware.com/ocr/csharp/how-to/read-screenshot/ IronOCR's `ReadScreenshot` method provides an optimized solution for extracting text from screenshots in C#, addressing common challenges like varying dimensions, noise, and UI-specific content. Unlike standard OCR methods, this specialized function applies preprocessing optimizations including automatic noise reduction and contrast enhancement, making it particularly effective for system fonts, anti-aliased text, and UI elements. The method supports common image formats (PNG, JPG, BMP) and requires the IronOcr.Extension.AdvancedScan package for enhanced computer vision capabilities. Implementation is straightforward - developers load a screenshot into an `OcrInput` object, call `ReadScreenshot`, and access extracted text through the `OcrPhotoResult` object, which provides text content, confidence scores, and text regions. The workflow involves minimal setup: downloading the library, importing screenshots, using the ReadScreenshot method, retrieving data via OcrPhotoResult properties, and saving the extracted text. Advanced features include processing specific image regions, handling multi-language content, and optimizing batch processing performance. This makes IronOCR an efficient solution for converting screenshot images into usable text data with minimal configuration required. ### Extract Table Data from PDFs & Images in C# | IronOCR https://ironsoftware.com/ocr/csharp/how-to/read-table-in-document/ IronOCR is a C# library that enables developers to extract table data from PDFs and images using advanced machine learning models. The library handles both simple tables with basic cell structures and complex tables like invoices with merged cells. For simple tables, developers can use the standard OcrInput class with the ReadDataTables property set to true, which leverages Tesseract for basic table detection. This method works well for spreadsheet exports, basic data tables, and simple inventory lists with clear cell boundaries. For more complex table structures, IronOCR provides the exclusive ReadDocumentAdvanced method, which uses machine learning to understand table layouts, merged cells, and complex formatting that traditional OCR struggles with. The library offers a minimal 5-step workflow: downloading the library, preparing documents, enabling table detection, using ReadDocumentAdvanced for complex tables, and extracting the detected data. The solution addresses the challenge of extracting text from sparsely scattered table cells, providing accurate results for financial reports, inventory lists, and invoice data processing. ### Create Searchable PDFs in C# with IronOCR - Tutorial https://ironsoftware.com/ocr/csharp/how-to/searchable-pdf/ IronOCR is a C# library that enables developers to convert scanned documents and images into searchable PDFs using optical character recognition (OCR) technology. A searchable PDF contains both the original scanned images and machine-readable text overlay, allowing users to select, copy, and search text within the document. The library supports multiple output formats including files, byte arrays, and streams. Implementation is straightforward - developers simply set the RenderSearchablePdf property to true and use the SaveAsSearchablePdf method. IronOCR automatically handles multi-page documents like TIFF files, processing all pages and maintaining proper page ordering and text positioning. The resulting PDFs preserve the visual appearance of the original document while adding an invisible text layer that makes the content searchable and selectable. This functionality is particularly valuable for digitizing paper archives, converting legacy scanned PDFs into searchable formats, and improving document management workflows. The library requires minimal code to implement, with basic functionality achievable in just one line of code, making it an efficient solution for C# developers needing to create searchable PDFs from scanned documents or images. ### C# OCR Confidence Levels: Get Text Recognition Accuracy https://ironsoftware.com/ocr/csharp/how-to/tesseract-result-confidence/ IronOCR provides confidence scoring for OCR results, indicating the reliability of text recognition with values from 0-100. Higher scores represent greater accuracy certainty. The confidence metric is accessible via the `Confidence` property on any `OcrResult` object, helping developers assess recognition quality for scanned documents and photos. Quick implementation requires just one line: `double confidence = new IronOcr.IronTesseract().Read("input.png").Confidence;`. The workflow involves downloading the C# library, preparing images/PDFs, and accessing confidence properties at various text levels (pages, paragraphs, lines, words, characters). Confidence ranges indicate reliability: 90-100 (excellent), 80-89 (good), 70-79 (moderate), and below 70 (low confidence requiring review). IronOCR supports both `OcrImageInput` and `OcrPdfInput` classes for different document types. The confidence scoring helps developers implement appropriate validation logic and error handling in applications where OCR accuracy is critical. Additionally, the system provides a `Choices` property for accessing alternative word recognition options when confidence is lower. ## Code Examples ### C# Tesseract Abort Token | IronOCR https://ironsoftware.com/ocr/csharp/examples/abort-token/ The article titled "C# Tesseract Abort Token | IronOCR" on the Iron Software website provides a detailed guide on using abort tokens within IronOCR for C#. It emphasizes the importance of abort tokens in managing and controlling long-running OCR operations effectively. The feature allows users to suspend the current thread for a specified period in milliseconds. This function is particularly useful when dealing with large input files, as it can help mitigate issues when the program or application encounters a hang or becomes unresponsive. The article also references related documentation and resources, such as GitHub links, related tutorials, how-to guides, class documentation, OCR language packs, and options to download the IronOCR DLL. Additionally, it provides a channel for users to report issues encountered on the page, ensuring a comprehensive support system for developers integrating this feature. Overall, the article serves as a practical resource for developers looking to implement cancellation tokens in their C# projects to enhance the efficiency and reliability of OCR operations. ### C# Tesseract OCR Configuration| IronOCR https://ironsoftware.com/ocr/csharp/examples/csharp-configure-setup-tesseract/ In the article "C# Tesseract OCR Configuration| IronOCR," the process of setting up and configuring Tesseract OCR in C# using IronOCR is outlined. The guide emphasizes the importance of flexibility and options when performing Optical Character Recognition (OCR) to ensure scalability and efficiency in applications. IronTesseract, a feature of IronOCR, provides developers with various properties to customize the OCR process. For instance, users can blacklist certain characters, read barcodes, or adjust how the OCR engine scans documents. The article includes a 5-step guide to using IronOCR with Tesseract, starting with initializing the IronTesseract class and configuring language settings. By default, the language is set to English, but up to 125 languages are supported. Developers can modify the TesseractConfiguration class to improve text block scanning, combining LSTM and OEM strategies for enhanced accuracy. Additionally, settings such as ReadBarCodes can be adjusted, and specific characters can be blacklisted to refine text extraction. The guide also covers disabling parallel processing by setting TesseractVariables["tessedit_parallelize"] to false. This customization allows developers to tailor the Tesseract Engine's behavior, enhancing the OCR's effectiveness. The article provides links to related tutorials, sample code, and documentation for further reference. ### C# OCR with Barcode & QR Reading | IronOCR https://ironsoftware.com/ocr/csharp/examples/csharp-ocr-barcodes/ The article "C# OCR with Barcode & QR Reading | IronOCR" on Iron Software's website provides a comprehensive guide on using IronOCR to perform Optical Character Recognition (OCR) on barcodes and QR codes in C#. The tutorial explains that by setting the `Ocr.Configuration.ReadBarCodes` to true, the Iron Tesseract OcrResult object can read barcodes and QR Codes during OCR. It outlines the steps to install the C# library necessary for this function, instantiate an IronTesseract object, and configure it to read barcodes. Users are guided to import an image or PDF containing QR codes and perform OCR using the Read method. The tutorial includes a basic C# example demonstrating how to extract and display QR code values from an image or PDF. It covers the detailed steps such as installing the IronOCR library via NuGet, configuring the barcode reading capability, setting up the input file, performing OCR, and iterating over the Barcodes property to access QR code data. This process empowers developers to efficiently extract and utilize QR code information in their C# applications using the IronOCR library. ### C# OCR Input Images & PDFs | IronOCR https://ironsoftware.com/ocr/csharp/examples/csharp-ocr-input-for-iron-tesseract/ The article from IronOCR introduces the OcrInput class, designed to enhance OCR applications in C#. This class provides developers with more control and is foundational in building high-performance OCR applications. Key features include automatic or explicit image optimizations, memory leak management, multithreading, and support for multipage documents, PDF, HTML, and TIFF files. The article provides a C# example demonstrating the effective use of the OcrInput class, illustrating how to initialize an OcrInput object, add images for processing, set OCR options like language, and handle errors. This class supports adding multiple images to accommodate multipage documents and allows setting the OCR engine's language. The Process method executes the OCR operation, extracting text from the images. Error handling is emphasized, ensuring the application can manage unexpected issues such as missing files or OCR failures. The article advises replacing placeholder elements like "SomeOcrLibrary" with the actual library namespace being used. Additional resources include related documentation, tutorials, and guides available on GitHub. This guide is intended to facilitate better preparation and management of input formats for OCR processing in C# applications. ### C# OCR PDF [Supports Low DPI Images] | IronOCR https://ironsoftware.com/ocr/csharp/examples/csharp-pdf-ocr/ The article on IronOCR's C# OCR PDF capabilities highlights the advanced text extraction features of Iron Tesseract, a C# library designed for OCR tasks. Unlike conventional Tesseract engines, IronOCR can process low-quality images and PDFs, offering automatic correction for poor scans. Developers can extract text from entire PDFs, selected pages, or specific areas using methods like LoadPdf and Read. IronOCR is praised for its accuracy and stability, built to handle real-world images with up to 99% accuracy. The solution is compatible with .NET platforms, including .NET Framework, .NET Standard, and .NET Core, and supports over 125 languages through downloadable language packs. It provides performance-tuning options to optimize OCR tasks based on image quality, and it supports multiple development platforms like Xamarin, Azure, and Docker. The library also enables the creation of searchable documents from scanned images and PDFs. Installation is straightforward, with cross-platform support on Windows, Linux, and macOS. IronOCR's capabilities include password-protected PDF processing, multithreading, and exporting results to formats like XHTML or searchable PDFs. A free trial license is available, allowing users to explore its features before choosing a suitable license. ### Tesseract 5 in C# | IronOCR https://ironsoftware.com/ocr/csharp/examples/csharp-tesseract-5/ The article titled "Tesseract 5 in C# | IronOCR" on the Iron Software website provides an overview and step-by-step guide on using Tesseract 5 within .NET applications through the IronOCR library. Tesseract 5 is recognized as one of the most advanced OCR (Optical Character Recognition) libraries, capable of handling multiple languages. However, it is often challenging to implement due to its complexity. IronOCR simplifies this process, offering a user-friendly interface for both novice and experienced developers to leverage Tesseract 5 efficiently. This library supports various .NET frameworks, including .NET Framework, Standard, Core, Xamarin, and Mono, making it highly versatile. The article details a five-step process for integrating IronOCR: initializing IronTesseract, managing an OcrInput object, loading an image for OCR processing, executing the OCR operation, and finally, extracting and displaying the recognized text from the image. The guide emphasizes resource management and ease of use, ensuring developers can effectively implement OCR functionalities in their applications. Additionally, the article provides links to further documentation, sample code, and resources for deeper exploration and troubleshooting of IronOCR within .NET ecosystems. ### C# OCR for Multi-Page TIFF files | IronOCR https://ironsoftware.com/ocr/csharp/examples/csharp-tesseract-multipage-tiff/ The article "C# OCR for Multi-Page TIFF files | IronOCR" provides a detailed tutorial on performing Optical Character Recognition (OCR) on multipage TIFF files using the IronOCR library in C#. It introduces the use of the OcrInput object, which can handle input TIFF files that the conventional Tesseract cannot read. Each frame of a TIFF file is imported to create a multipage IronOcr.OcrResult document. To execute OCR on TIFF files, users must first install an OCR library. The process involves constructing an IronTesseract object and an OcrInput object, adding the TIFF file with the LoadImageFrames method, and using the Read method to extract text from the TIFF file. The article provides sample C# code illustrating these steps, where the IronTesseract instance facilitates the OCR process, and the OcrResult object holds the recognized text. The recognized text is then output to the console. The article also explains key components like the IronTesseract instance, OcrInput object, LoadImageFrames method, and OCR operation. By following this guide, users can efficiently perform OCR on multipage TIFF files using IronOCR. ### Multithreaded Tesseract OCR in C#| IronOCR https://ironsoftware.com/ocr/csharp/examples/csharp-tesseract-multithreading-for-speed/ The article discusses the implementation of multithreading in IronOCR for C#, specifically focusing on the Tesseract OCR engine. All IronOCR image processing and OCR reading operations are multithreaded by default, so the legacy ReadMultithreaded method is no longer required and no special API is needed to get started. IronTesseract automatically utilizes the threads available across all cores while considering responsiveness on the main or GUI thread. The guide provides a step-by-step approach to using Tesseract multithreading by first installing the OCR library, then creating an IronTesseract object, and using the LoadImage method to construct an OcrInput object with the image path. The Read method is then called to process the image and extract text, with the recognized text being output to the console. For workloads that need a bounded memory footprint, two properties on IronTesseract control the degree of parallelism: MaxDegreeOfParallelism caps how many pages are OCR'd concurrently within a single Read call, since each concurrent page runs its own native Tesseract engine, and setting MultiThreaded to false reads pages sequentially for the lowest and most predictable memory use, taking precedence over MaxDegreeOfParallelism. Relevant documentation and resources are also linked for further exploration and support. ### Filter Wizard | IronOCR https://ironsoftware.com/ocr/csharp/examples/filter-wizard/ The article "Filter Wizard | IronOCR" provides a comprehensive guide on using the OcrInputFilterWizard for enhancing Optical Character Recognition (OCR) accuracy in C#. It introduces the OcrInputFilterWizard as a tool for selecting and applying appropriate image filters to improve OCR results. A Python code example is provided, demonstrating how to import necessary libraries, such as ocr_filter_wizard and PIL.Image, to handle image files. The example function, apply_ocr_filters, walks through the process of opening an image, instantiating the OcrInputFilterWizard, retrieving suitable filters via the get_suitable_filters method, and applying each filter to the image sequentially. The processed image is then saved, showcasing how to manage image preprocessing for OCR tasks. The article emphasizes the need for error handling, suggesting that developers ensure the validity of the image path, confirm supported file formats, and handle exceptions during filter application. Additionally, it provides links to related documentation, tutorials, and resources for further exploration of IronOCR capabilities. The guide serves as a practical resource for developers aiming to optimize OCR performance by effectively leveraging image filters. ### Fix Image Orientation | IronOCR https://ironsoftware.com/ocr/csharp/examples/fix-image-orientation/ The article "Fix Image Orientation" on IronOCR's website provides a comprehensive guide on correcting image orientation issues using various Python functions, essential for improving OCR results. It details three main functions: Rotate, Deskew, and Scale. The Rotate function allows images to be turned by specified degrees, either clockwise or counterclockwise, using the PIL library. An example demonstrates rotating an image by 45 degrees. The Deskew function corrects image alignment to ensure it is orthogonal, crucial for accurate OCR processing. This involves using OpenCV to determine the skew angle and adjust the image accordingly. A complete example illustrates the process of deskewing an image. Lastly, the Scale function resizes images while maintaining their aspect ratio, vital for processing images of varying sizes consistently. The article provides a practical example of scaling an image to a maximum dimension using PIL. These techniques collectively enhance OCR accuracy by ensuring images are correctly oriented and appropriately sized. The content also references related documentation and resources for further exploration of IronOCR capabilities. ### C# Highlight Texts for Debugging | IronOCR https://ironsoftware.com/ocr/csharp/examples/highlight-texts-for-debugging/ The article "C# Highlight Texts for Debugging" from IronOCR provides a detailed guide on using visual tools to debug Optical Character Recognition (OCR) results in C#. It describes a method to highlight text on a page by drawing red boxes around detected characters, words, lines, or paragraphs, and saving the highlighted content as a .png file for debugging. The article includes a sample Python script using OpenCV that demonstrates creating a fake highlighted text scenario. The script involves loading an image, defining coordinates for rectangles around text areas, drawing the rectangles in red, and saving the modified image. This process helps in visually verifying areas of interest, aiding in debugging OCR tasks. The guide also explains the steps in the script: loading an image with cv2.imread(), defining rectangles with coordinates, drawing them using cv2.rectangle(), saving the image with cv2.imwrite(), and optionally displaying it with cv2.imshow(). It advises ensuring OpenCV is installed in the Python environment with pip. This visual verification tool is useful for debugging tasks like OCR or document layout analysis. Related resources and documentation are available for further reference. ### C# Tesseract OCR Languages | IronOCR https://ironsoftware.com/ocr/csharp/examples/intl-languages/ The article "C# Tesseract OCR Languages | IronOCR" provides a comprehensive guide on performing Optical Character Recognition (OCR) in multiple languages using IronOCR in C#. IronOCR supports 125 international languages, with English being the default. Users can add other language packs to their .NET projects via NuGet or by downloading from IronOCR's Languages Page. The language packs are available in three quality levels: Fast, Standard (recommended), and Best, with the Best option providing the most accurate results at the cost of slower processing times. The article includes sample code for installing and using additional language packs in a C# application. It outlines the necessary steps: installing the IronOcr and IronOcr.Languages.{LanguageName} NuGet packages, defining the file path for the OCR image, selecting the desired language pack, initializing the IronTesseract engine with the chosen language, and using the OcrInput to process the image and extract text. The recognized text is then printed to the console. This setup enables processing of images and recognition of text in various languages with customizable quality and speed. Additional resources and documentation are provided for further guidance. ### Make a PDF searchable in C# | IronOCR https://ironsoftware.com/ocr/csharp/examples/make-pdf-searchable/ The article titled "Make a PDF searchable in C#" on IronOCR's website provides a comprehensive guide on converting scanned PDF documents into searchable PDFs using the IronOCR library. The tutorial demonstrates how to utilize IronOCR's advanced Tesseract engine to make PDF text searchable and copyable, thereby enhancing document utility and accessibility. It provides a Python example where the IronTesseract library is imported to initialize the OCR engine. The core of the tutorial is the make_pdf_searchable function, which takes the input path of a scanned PDF and an output path for the searchable PDF. The function uses OCR to extract text from the scanned document and embeds it back into a new PDF, making it searchable. A try-except block is employed for error handling, ensuring users are informed if any issues arise during the OCR process. The article concludes by emphasizing the efficiency and accessibility improvements that searchable PDFs provide. Additional resources, such as related documentation and guides, are offered for users seeking further information or support. This tutorial is particularly useful for developers looking to enhance the functionality of PDF documents in their applications. ### Tesseract OCR Specifc Area of an Image in C# | IronOCR https://ironsoftware.com/ocr/csharp/examples/net-tesseract-content-area-rectangle-crop/ The article titled "Tesseract OCR Specific Area of an Image in C#" on IronOCR's website provides a detailed guide to improve the efficiency of Optical Character Recognition (OCR) processes in .NET by focusing on specific sections of an image. By targeting designated areas, known as `ContentAreas` or `CropAreas`, users can achieve a 41% speed enhancement. The guide outlines a step-by-step process for implementing this technique in C#. It begins with instructions to download a C# library designed for image cropping. Following this, users are advised to instantiate the `IronTesseract` class and create a `Rectangle` object to define the desired region of the image. The `LoadImage` method is then utilized to incorporate the image and the specified crop details, and the `Read` method is used to execute OCR within this region. This approach not only boosts processing speed but also enhances accuracy by narrowing the focus to relevant parts of the image. The article serves as a practical resource for developers seeking to optimize OCR tasks with IronOCR in C# environments. ### OCR Drawing in C# Tesseract | IronOCR https://ironsoftware.com/ocr/csharp/examples/ocr-drawing/ The article titled "OCR Drawing in C# Tesseract | IronOCR" provides a comprehensive guide on utilizing IronOCR, an open-source library developed by Iron Software, to perform Optical Character Recognition (OCR) on drawings and illustrations in C#. This tool is particularly useful for software engineers working in .NET projects across various platforms, including Windows, macOS, and Linux, who need to replace System.Drawing functionalities. The guide details how IronOCR can effectively extract text from diverse image types, enhancing the capabilities of C# applications in processing visual data. It offers additional resources such as related documentation, tutorials, and how-to guides to facilitate user understanding and implementation. Furthermore, the article links to OCR language packs, the IronOCR DLL for download, and avenues to report issues, ensuring comprehensive support for users. This makes IronOCR a valuable asset for developers aiming to integrate advanced OCR features into their software solutions, leveraging the power of C# and Tesseract technology. The article is not only instructional but also provides access to a broader community and resources for continued learning and troubleshooting. ### C# Tesseract OCR for PDF Stream | IronOCR https://ironsoftware.com/ocr/csharp/examples/ocr-for-pdf-stream/ The article "C# Tesseract OCR for PDF Stream" on IronOCR's website explains how to perform Optical Character Recognition (OCR) on PDF streams using IronOCR within a C# environment. It begins by illustrating how to create a PDF stream with IronPDF, which involves rendering a simple HTML string into a PDF document. This PDF is then saved as a stream by copying it into a MemoryStream, a process necessary for the subsequent OCR operation. The tutorial highlights that IronOCR only accepts streams as input, not output. Using IronOCR's IronTesseract engine, the tutorial demonstrates how to process the PDF stream for text recognition. A crucial aspect of the process is managing memory efficiently, achieved by employing 'using' blocks to ensure all memory streams are properly disposed of. Once the OCR is performed, the recognized text is printed to the console, showcasing the OCR's effectiveness. This example serves as a practical guide for integrating PDF stream processing and text extraction capabilities into .NET applications using IronOCR and IronPDF libraries. It provides a straightforward approach to handling text recognition tasks, leveraging C# to facilitate the development of document processing solutions. ### C# Tesseract Image DPI | IronOCR https://ironsoftware.com/ocr/csharp/examples/ocr-image-dpi-for-tesseract/ The article titled "C# Tesseract Image DPI | IronOCR" on Iron Software's website provides a comprehensive guide on optimizing Optical Character Recognition (OCR) accuracy by adjusting image DPI using IronOCR in C#. The OcrInput class in IronOCR automatically resolves issues with low-resolution images, allowing IronTesseract to achieve over 99% accuracy on 225 DPI scans, effectively doubling OCR speed compared to the typical 300 DPI requirement of Tesseract. The guide explains that setting an appropriate DPI is crucial as too high a DPI slows down the process, while too low a DPI results in inaccuracies. For users unsure about DPI settings, IronTesseract preconfigures these automatically. The article also includes a C# code example demonstrating the process. It shows how to import the IronOcr namespace, create an IronTesseract instance, and use an OcrInput object to specify the image path. The TargetDPI property can be optionally set, but the system's automatic handling often makes this unnecessary. The Read method is then used to extract text from the image, which is subsequently printed to the console. The article provides links to related documentation and tutorials for further assistance. ### OCR Image Optimization Filters | IronOCR https://ironsoftware.com/ocr/csharp/examples/ocr-image-filters-for-net-tesseract/ The article "OCR Image Optimization Filters" on IronOCR's website provides an overview of how C# and .NET developers can utilize the OcrInput class to optimize images for Optical Character Recognition (OCR) processing. Traditionally, tools like Photoshop Batch Scripts or ImageMagick are used for image preparation, but IronOCR offers a more integrated approach. The process begins with installing the IronOcr library from NuGet, followed by creating an OcrInput object using the image path. Developers can preprocess images to enhance OCR accuracy by applying filters such as Contrast() and Sharpen(), which improve image quality by adjusting brightness and sharpness. Once preprocessing is complete, the IronTesseract class is used to perform OCR on the image. The recognized text can then be displayed using the OcrResult's Text property. This method streamlines the preparation and processing of images for OCR, making it suitable for use in C# and .NET applications. The article also provides code examples in both C# and Visual Basic to demonstrate the implementation of these steps, highlighting the efficiency and effectiveness of using IronOCR for image preprocessing in OCR tasks. ### C# Tesseract OCR for Low Quality Scans | IronOCR https://ironsoftware.com/ocr/csharp/examples/ocr-low-quality-scans-tesseract/ The article from Iron Software discusses using the IronTesseract OCR class in C# to enhance OCR performance for low-quality scans and images. It highlights how developers can fine-tune OCR functionality for specific use cases within C# and .NET applications by adjusting various settings. Key configurations include cleaning background noise, enhancing contrast and resolution, specifying language, and strategies for text detection. These settings allow IronTesseract to effectively read low-quality scans that free Tesseract might struggle with. The article provides sample C# and VB code demonstrating the implementation of these settings, such as enabling background noise cleaning, contrast enhancement, and resolution enhancement. It also covers specifying the language for text recognition, using a strategy to detect text in multiple directions, automatically rotating and straightening documents, and detecting white text on dark backgrounds. By utilizing these settings, developers can achieve an optimal balance of speed and accuracy in OCR tasks. The article serves as a practical guide for improving OCR results when dealing with poor-quality images, offering a detailed walkthrough of the IronTesseract OCR engine's capabilities. ### C# Custom Tesseract OCR Dictionaries | IronOCR https://ironsoftware.com/ocr/csharp/examples/ocr-tesseract-custom-languages/ The article from IronOCR provides a comprehensive guide on utilizing custom language dictionaries with Tesseract OCR in C#. Iron Tesseract OCR supports custom or downloaded languages and fonts that follow the Tesseract .traineddata file format standard, version 4 or higher. Users can source these files from platforms like GitHub or create their own custom language packs by following IronOCR's tutorial. To implement custom languages, users need to install an OCR library that allows for Tesseract Language options. They should provide the custom language file using the UseCustomTesseractLanguageFile method. An OcrInput object is created using the image path, which is then passed to the Read method to interpret the text in the specified language. The article includes a C# code example demonstrating these steps: creating an IronTesseract instance, specifying the path to the custom language data file, creating an OcrInput object with the image file path, and using the Read method to process the image and extract text. The extracted text is subsequently output to the console. This detailed guide facilitates developers in leveraging IronTesseract's capabilities to work with multiple languages in OCR tasks. ### Multi Language Tesseract OCR in .NET | IronOCR https://ironsoftware.com/ocr/csharp/examples/ocr-tesseract-multiple-languages/ The article "Multi Language Tesseract OCR in .NET | IronOCR" provides a comprehensive guide on performing Optical Character Recognition (OCR) on documents with multiple languages using IronOCR in C#. IronOCR supports 125 international languages, allowing users to process documents containing multilingual text by utilizing multiple languages simultaneously. The guide includes a detailed example of implementing IronOCR in a C# application to perform OCR on documents containing English and Spanish text. This involves using the IronOCR library, creating an IronTesseract instance, and setting the appropriate languages via the Language property. The article also explains the use of the OcrInput class to load images or documents and the Read method to execute the OCR process. The processed text is then output to the console. Additionally, users can enhance the OCR capabilities by employing custom or proprietary language models following the Tesseract .traineddata file format standard, ensuring broader language support and improved accuracy. The article provides links to related documentation, tutorials, and resources to assist users in implementing and optimizing IronOCR for multilingual text recognition in .NET applications. ### C# convert TIFF to PDF| IronOCR https://ironsoftware.com/ocr/csharp/examples/ocr-tiff-to-searchable-pdf/ The article titled "C# convert TIFF to PDF| IronOCR" provides a comprehensive guide on converting TIFF files to searchable PDFs using the IronOCR library in C#. It details the process of utilizing the IronTesseract class, which is a part of IronOCR, to perform Optical Character Recognition (OCR) on TIFF files. The tutorial begins with instructions on importing and initializing the necessary libraries for the conversion. The main code example demonstrates how to specify the file paths for both the input TIFF file and the output PDF. By creating an OcrInput instance for the TIFF file, the IronTesseract engine reads the input and converts it into a searchable PDF using the Read and SaveAsPdf methods. The article emphasizes the importance of having the IronOCR library properly installed and configured in the project to execute the code successfully. Additionally, it provides links to related documentation, tutorials, language packs, and resources on GitHub for further assistance and troubleshooting. Overall, this guide serves as a practical resource for developers looking to enhance their applications by integrating OCR functionality to convert image files into searchable documents. ### Tracking Tesseract OCR progress and performance in .NET | IronOCR https://ironsoftware.com/ocr/csharp/examples/progress-tracking/ The article from IronOCR provides guidance on tracking the progress and performance of Tesseract OCR operations in .NET using IronOCR. It highlights the use of the IronTesseract object, which features an OcrProgress event to monitor the OCR process. This functionality is beneficial in various application types, such as GUI, web, and CLI, to inform users about the duration of OCR tasks. The guide outlines the steps to implement progress tracking: installing an OCR library, building an IronTesseract object, and using an OcrProgress instance. The process involves setting Tesseract parameters, applying image-processing methods, and reading text from an OcrInput object. The code example demonstrates setting up an IronTesseract object, attaching an event handler to track progress, and processing an image to extract text. The OcrProgressHandler method provides real-time updates by printing the completion percentage to the console, ensuring users stay informed about the OCR operation's status. This functionality enhances user experience by allowing them to track progress in real-time. The article also includes links to related documentation and resources for further exploration. ### How to Read HandWriting Images | IronOCR https://ironsoftware.com/ocr/csharp/examples/read-handwritten-image/ The article "How to Read HandWriting Images | IronOCR" provides a detailed guide for utilizing IronOCR to digitize handwritten documents using C# programming. It highlights the challenges posed by the variability of individual handwriting styles and demonstrates how IronOCR can streamline the process of data entry and digital archiving through OCR technology. The guide outlines a simple, five-step coding process to read handwritten images. First, an IronTesseract engine is instantiated, followed by the creation of an OcrInput object to load the image "handwritten.png". The specialized ReadHandwriting method is then employed to extract textual data from the image. The extracted text is subsequently accessed and printed to the console. The article includes links to related documentation and resources, such as class documentation, OCR language packs, and a downloadable IronOCR DLL. It encourages users to begin their journey with IronOCR by downloading the free NuGet package, which has been downloaded over five million times. This comprehensive guide is an essential resource for developers seeking to implement OCR technology in their applications to efficiently handle handwritten text recognition. ### Read License Plate Code Example | IronOCR https://ironsoftware.com/ocr/csharp/examples/read-license-plate/ The article titled "Read License Plate Code Example | IronOCR" provides a comprehensive guide on utilizing the IronTesseract OCR engine to extract text from license plate images using C#. The process begins with importing the IronOcr namespace and creating an instance of the IronTesseract OCR engine. The image containing the license plate is then loaded through an OcrInput object. The OCR recognition process is executed via the Read method, which analyzes the image to identify and extract text. The code iterates through the recognized words, checking if any are identified as license plates. If a license plate is detected, the text and its bounding box coordinates are printed. This method is particularly beneficial for applications such as parking management, vehicle access control, and automated recognition systems. The page also includes links to related documentation, tutorials, and downloadable resources, enhancing the user’s ability to implement and understand the process. The example emphasizes the importance of adding a reference to the IronOCR library in the project to ensure functionality. Overall, the article serves as a valuable resource for developers looking to incorporate OCR technology into their license plate recognition systems. ### Read MICR Cheque Code Example | IronOCR https://ironsoftware.com/ocr/csharp/examples/read-micr-cheque/ The article, "Read MICR Cheque Code Example | IronOCR," provides a comprehensive guide on using IronOCR in C# to read and extract critical information from E-13B MICR cheques. This functionality is vital for automating financial workflows, such as bank deposits, by accurately retrieving account numbers, routing numbers, and cheque numbers. The guide outlines a straightforward, five-step process for scanning a MICR cheque. First, the OCR language is set to specifically recognize MICR checks, necessitating the installation of the OcrLanguage.MICR package. Next, a specific rectangle region is defined on the cheque image to focus the OCR process on the MICR section, ensuring high accuracy. The guide then details how to load the cheque image and use the Read method to extract the text, which is then printed out for verification. The article emphasizes the reliability and efficiency of IronOCR for processing MICR cheques and provides links to related documentation, tutorials, and resources on GitHub. It encourages users to download the free NuGet package to get started, highlighting its wide adoption with over 6M+ downloads. The guide concludes with an invitation to unlock the potential of MICR cheque recognition using IronOCR’s comprehensive C# solutions. ### Read Passport Code Example | IronOCR https://ironsoftware.com/ocr/csharp/examples/read-passport/ The article "Read Passport Code Example | IronOCR" from Iron Software provides a detailed explanation of how to utilize the IronTesseract OCR engine in C# to extract and process passport information from an image. It begins by initializing the IronTesseract OCR engine and creating an OcrInput object to load a passport image, specifically "passport.jpg", using the LoadImage method. The ReadPassport method processes the image, extracting essential passport details such as given names, surname, country, passport number, date of birth, and date of expiry. These details are then stored in an OcrPassportResult object and can be outputted to the console for verification purposes. The article includes a comprehensive code example demonstrating how to access and print the extracted information using C# and VB.NET languages. This method is particularly useful for automating the extraction and verification of key passport data, streamlining processing tasks. The article also provides links to related documentation, tutorials, and how-to guides, offering additional resources for users interested in OCR processing and implementation using IronOCR. ### Read Photo Code Example | IronOCR https://ironsoftware.com/ocr/csharp/examples/read-photo/ The article titled "Read Photo Code Example | IronOCR" from Iron Software demonstrates how to utilize the IronTesseract OCR engine in C# to extract text and analyze specific regions from a photo. The process begins by creating instances of the IronTesseract OCR engine and an OcrInput object. An image frame from a TIFF file is loaded into the OcrInput object using the AddImage method, with 0 specifying the first frame. The OCR engine processes this image, returning an OcrResult object that contains the recognized text and regions. The code then checks for recognized text regions, and if any are found, it retrieves details such as the frame number, text content, and bounding box coordinates (X, Y, Width, Height) of the first text region. A detailed output string is formatted with this information, including the confidence score and the full OCR result, and is printed to the console. This method allows for a detailed analysis of text regions within an image, making it particularly useful for extracting information from documents or structured photos. The article also provides links to related documentation and resources for further exploration. ### Read Scanned Document Code Example | IronOCR https://ironsoftware.com/ocr/csharp/examples/read-scanned-document/ The article titled "Read Scanned Document Code Example | IronOCR" provides a detailed guide on how to use the IronTesseract OCR engine to extract text from scanned images using C#. The process begins by importing the necessary IronOcr namespace, which provides the OCR classes required for the task. The first step is to create an instance of the IronTesseract OCR engine. Following this, an OcrInput object is initialized by loading the image file (in this case, "potter.tiff") that contains the text to be recognized. The article emphasizes the importance of using a 'using' statement to manage resources effectively during this process. The OCR engine reads the loaded image through the Read method, which employs OCR technology to identify and convert the text within the image. The recognized text is then printed to the console using Console.WriteLine(Result.Text), allowing for further processing or display. This example demonstrates how to programmatically extract readable text from image files using IronTesseract's advanced OCR capabilities. The article also offers links to related documentation, tutorials, how-to guides, class documentation, and language packs, enhancing the reader's understanding and implementation of the IronOCR library. ### Read Screenshot Code Example | IronOCR https://ironsoftware.com/ocr/csharp/examples/read-screenshot/ The article titled "Read Screenshot Code Example | IronOCR" provides a comprehensive guide on using the IronTesseract OCR engine to extract text from a screenshot image using C#. It begins by outlining the necessary namespace imports, such as System.Linq for LINQ operations and IronOcr for OCR functionalities. The process involves creating an instance of the IronTesseract class to leverage its text recognition capabilities. An OcrInput object is then initialized to load the image file ("screenshotOCR.png") for text extraction. The Read method of the IronTesseract instance processes the image and returns an OcrResult object that contains the recognized text and details about the regions where text was identified. Key outputs from this process include the extracted text, the X coordinate of the first recognized text region, the width of the last recognized text region, and an OCR confidence score indicating the accuracy of the text recognition. This method is particularly useful for capturing text in graphical content or user interfaces, enabling users to extract valuable textual information from screenshots effectively. The article also provides links to related documentation, tutorials, and resources for further exploration of IronOCR capabilities. ### Read Table in Document Code Example | IronOCR https://ironsoftware.com/ocr/csharp/examples/read-table-in-document/ The article on IronSoftware's website provides a detailed code example of how to utilize the IronTesseract OCR engine to extract text and table data from a PDF document using C#. The process begins with the creation of an IronTesseract OCR engine instance followed by the initialization of an OcrInput object. A PDF file, specifically "table.pdf," is loaded using the LoadPdf method. The OCR engine processes this document with the ReadDocumentAdvanced method, resulting in a comprehensive OcrResult object. The example focuses on accessing the first table found in the document using the result.Tables.First() method. Cell information from this table is extracted using CellInfos, resulting in a list of cell data that includes the text content and additional details such as cell position and size. This approach is particularly useful for programmatically accessing and processing structured data like tables from PDFs. The code demonstrates how to iterate over each cell to extract and display its text content and associated details, employing namespaces such as IronOcr for OCR functionality and System.Linq for LINQ methods. The example is provided in both C# and VB.NET, showcasing its versatility in different programming environments. ### C# OCR Image Color Editing | IronOCR https://ironsoftware.com/ocr/csharp/examples/replace-color/ The article explores the importance of optimizing image colors to enhance OCR (Optical Character Recognition) performance, emphasizing that reading black text on a white background yields faster and more accurate results. It addresses the challenge of processing images with non-standard color schemes, such as blue text on a pink background, and suggests transforming these colors to black and white respectively before conducting OCR. The IronOCR library simplifies this task through its `OcrInput.ReplaceColor` method, which automates color replacement, overcoming the limitations of manual processes like `System.Drawing`. This method is adaptable, offering a percentage tolerance for matching exact `RGB` colors, thereby eliminating the need for complex tools like Photoshop or ImageMagick scripts. The method accepts parameters including the original color, the desired replacement color, and an optional tolerance level to accommodate color variations. This functionality significantly streamlines the preparation of images for OCR analysis. Readers are encouraged to further explore image color correction techniques in OCR through a provided link to additional resources on the IronOCR website. ### C# Tesseract Results Class | IronOCR https://ironsoftware.com/ocr/csharp/examples/results-objects/ The article on IronOCR's C# Tesseract Results Class provides a comprehensive guide on managing OCR results using the IronOCR library for C#. It outlines the functionality of the OcrResult class, which delivers detailed data for each scanned page using Tesseract 5. This includes information such as location data, images, text, statistical confidence, alternative symbol choices, font details, and character positions. The article offers a practical example demonstrating how to leverage these data points through C#. The process begins by importing the IronOCR library and creating an instance of the IronTesseract engine. The user specifies the file path for the scanned document, and the engine performs OCR on the input image, returning an OcrResult object. The example code iterates through each page, paragraph, line, word, and character, outputting their text to the console. It also detects and outputs barcode values. This iterative and structured approach allows for granular exploration and utilization of the data retrieved by IronOCR. By following this guide, users can effectively manage and manipulate OCR output for various applications. ### C# Tesseract OCR In 1 Line of Code | IronOCR https://ironsoftware.com/ocr/csharp/examples/simple-csharp-ocr-tesseract/ The article, titled "C# Tesseract OCR In 1 Line of Code | IronOCR," provides a beginner's guide to implementing Optical Character Recognition (OCR) using Tesseract in C# with the IronOCR library. IronOCR stands out due to its capability to accurately read text from imperfectly scanned images and PDF documents. It leverages the IronTesseract class, which offers a straightforward API for developers. The article mentions that IronOCR provides the most advanced build of Tesseract, enhancing speed and accuracy, and supports Tesseract versions 3, 4, and 5 across various .NET platforms, including Framework, Standard, Core, Xamarin, and Mono. For VB.NET users, the guide outlines a simple three-step process: instantiating the IronTesseract object, using the Read method to perform OCR on an image or PDF, and accessing the extracted text via the Text property. A practical example is provided, demonstrating the creation of an OCR reader with IronTesseract, processing an image file named "example_document.png," and outputting the extracted text to the console. This method allows for efficient automation of text extraction from documents. The article also includes links to related documentation and resources for further exploration. ### Image to PDF using Tesseract for .NET | IronOCR https://ironsoftware.com/ocr/csharp/examples/tesseract-create-searchable-pdf/ The article, titled "Image to PDF using Tesseract for .NET | IronOCR," provides a comprehensive guide on creating searchable PDFs using Tesseract OCR in C#. The process enhances SEO performance and improves internal search indexing within intranets and databases. The guide starts with the installation of the IronOCR library, followed by the creation of an OcrInput object where the image paths are registered using the LoadImage method. The Read method processes the images, extracting text, and the SaveAsSearchablePdf method saves the images as a single searchable PDF. The article includes a C# code example illustrating these steps, demonstrating how to initialize the IronTesseract class, add image paths, and perform OCR processing to obtain an OcrResult. The recognized text is embedded under the images in the PDF, maintaining the original layout while making the text searchable. The article emphasizes replacing placeholder paths with actual file paths for practical implementation. Additional resources such as related documentation, tutorials, and how-to guides are provided for further reference. The guide is aimed at developers seeking to integrate OCR capabilities into their applications, leveraging the functionality of IronOCR and Tesseract. ### Tesseract OCR Export Images | IronOCR https://ironsoftware.com/ocr/csharp/examples/tesseract-net-export-images/ The article "Tesseract OCR Export Images | IronOCR" provides a comprehensive tutorial on using IronTesseract to perform Optical Character Recognition (OCR) in C#. It focuses on extracting images and text coordinates from documents. The tutorial begins by illustrating the necessary setup, which includes importing the IronOcr library and instantiating the IronTesseract class. Users are guided to load a document or image for OCR processing, ensuring the correct file path is used. The OCR operation is conducted via the Read method, which processes the document and retrieves results. The tutorial meticulously demonstrates how to iterate through the OCR results, covering pages, paragraphs, lines, words, and individual characters. For each character, the tutorial shows how to extract and display its text, position, and bounding rectangle, thereby providing detailed positional and structural information about the recognized text. The tutorial emphasizes the importance of having the IronOcr library installed and referenced correctly to execute the code successfully. Additional resources such as related documentation, tutorials, and how-to guides are suggested for further learning and support. Overall, the article serves as a detailed guide for developers looking to implement OCR image export functionality using IronOCR in C#. ### C# Tesseract Timeouts | IronOCR https://ironsoftware.com/ocr/csharp/examples/timeouts/ The article "C# Tesseract Timeouts | IronOCR" provides a comprehensive guide on managing timeouts in OCR operations using IronOCR in C#. The key feature discussed is the TimeoutMs, which allows developers to specify a timeout duration in milliseconds for OCR read operations, after which the operation will be canceled if not completed. This is crucial for handling large input files and preventing applications from becoming stuck. The article notes that TimeoutMs is not supported in .NET Framework 4.x.x. An example is provided, showcasing how to implement TimeoutMs in a C# program. The example illustrates using a CancellationTokenSource to create a cancellation token that triggers after the specified timeout, with a simulated OCR read operation that supports cancellation. If the operation exceeds the set timeout, it throws a TimeoutException, allowing developers to handle it appropriately. This approach is vital for ensuring application reliability by managing operations that might hang or take too long. The article further explains the components of a timeout operation, including timeout configuration, cancellation token source, simulated OCR read, and exception handling. It emphasizes the importance of these practices for improving the efficiency and reliability of OCR processes in C# applications. ### Faster Tesseract OCR for .NET | IronOCR https://ironsoftware.com/ocr/csharp/examples/tune-tesseract-for-speed-in-dotnet/ The article "Faster Tesseract OCR for .NET" on IronOCR's website provides a guide to optimizing Tesseract OCR for enhanced speed within .NET applications. It outlines a method to achieve over a 35% increase in processing speed with a minimal accuracy trade-off of 0.2%. The article suggests focusing OCR efforts on a specific image area to further improve processing times. Users are guided to install an OCR library that supports Tesseract speed enhancements and to construct an IronTesseract object. The steps include specifying the image path and configuring relevant Tesseract settings, with optional image processing for better results. The Read method is then employed to extract text from an OcrInput object. IronOCR can be downloaded via NuGet or as a direct DLL, with additional resources available, including related documentation, tutorials, and language packs. Furthermore, the page provides various links to related documentation and resources for those interested in exploring further or reporting issues. This guide serves as a practical resource for developers seeking to refine OCR performance in their .NET applications using IronOCR. ## Troubleshooting ### 7 Segment Digital/LCD Displays https://ironsoftware.com/ocr/csharp/troubleshooting/7-segment-digital-lcd-displays/ The article "7 Segment Digital/LCD Displays" on Iron Software's website provides guidance on troubleshooting OCR issues with 7-segment digital LCD displays using IronOCR in C#. Standard OCR programs often struggle with 7-segment displays due to their character separability principle, where characters are presented with multiple breaks. To address this, image pre-processing is recommended, specifically by blurring characters to remove breaks. For deeper processing, the article suggests using ImageMagick for .NET, a free and well-documented tool that offers filters similar to Photoshop. The Magick.NET-Q8-AnyCPU package is recommended for this purpose. Additionally, IronOCR can leverage custom language packs to improve accuracy. The LetsGoDigital Tesseract language pack is specifically tailored for 7-segment displays and can be a valuable resource. The article also provides a link to the IronOCR Language Guide for instructions on adding custom language packs. By following these recommendations, users can enhance the accuracy and performance of OCR when dealing with 7-segment digital displays. ### Advanced Scan on Framework for Visual Studio https://ironsoftware.com/ocr/csharp/troubleshooting/advanced-scan-on-net-framework/ The article "Advanced Scan on Framework for Visual Studio" on Iron Software's website guides users on configuring the Advanced Scan feature using the IronOcr.Extensions.AdvancedScan package within the .NET Framework. It addresses a common runtime issue encountered when using this package in an x32 project, which results in an unhandled exception due to a "System.NotImplementedException." The root cause of this issue is the incompatibility of the package with the x86 architecture, as it relies on Intel’s OpenVINO to compile and make inferences from PaddleOCR models, which require x64 architecture. The article provides a straightforward solution to this problem: users need to adjust their project configuration by unchecking the "Prefer 32-bit" option. This change will allow the project to run on the necessary x64 architecture, thus resolving the runtime issue. The article emphasizes the importance of this configuration adjustment for successful implementation of the Advanced Scan functionality on the .NET Framework. ### Apply a license key in IronOCR https://ironsoftware.com/ocr/csharp/troubleshooting/apply-a-license-key-in-ironocr/ The article "Apply a License Key in IronOCR" provides a step-by-step guide on how to correctly apply a license key to the IronOCR software. A license key is essential for the proper functioning and authorization of the OCR software and is a long string that includes an expiry date. It is crucial to copy the key accurately, avoiding any spaces, to ensure its validity. The article recommends applying the license key directly within the code before the library is utilized. This is demonstrated with a C# code snippet where the license key is set using `IronOcr.Installation.LicenseKey`, followed by the specific key string. Additionally, the article mentions alternative methods for setting the license key through configuration files such as `web.config` and `appsettings.json`. For further details on these methods and additional options, readers are directed to the IronOCR License Keys FAQ page. This resource aims to ensure that users have a seamless experience in licensing their IronOCR software, thus enhancing its functionality and support. ### Arabic Numerals https://ironsoftware.com/ocr/csharp/troubleshooting/arabic-numerals/ The article titled "Arabic Numerals" addresses issues related to Optical Character Recognition (OCR) of Arabic numerals using IronOCR in C#. It highlights a known problem with Tesseract's language packs, which fail to recognize Arabic numerals accurately. To overcome this, the article suggests using Shreeshrii's Tessdata Arabic language pack. It provides a C# code example demonstrating how to implement this solution with IronOCR. The code initializes an IronTesseract instance and loads a custom Tesseract language file to enhance numeral recognition. It then processes an input image to extract and display the recognized text. The article emphasizes that this approach requires the appropriate language pack to be downloaded and correctly placed in the specified directory. Additionally, it notes the importance of installing IronOCR and incorporating error handling in production environments. This guide serves as a practical resource for developers aiming to improve the accuracy of Arabic numeral recognition in their OCR applications using IronOCR and custom language packs. ### IronOCR AWS Lambda Troubleshooting https://ironsoftware.com/ocr/csharp/troubleshooting/aws-lambda-runtime-exited-signal-killed/ The article titled "IronOCR AWS Lambda Troubleshooting" provides a solution to the "Runtime Exited" signal-killed error that users may encounter when running IronOCR in AWS Lambda. This error commonly arises due to insufficient memory allocation, which causes the application to exceed the available memory on the host machine or container environment. Consequently, the process is forcefully terminated, resulting in the "signal: killed" message. To resolve this issue, the article suggests increasing the memory allocation for the AWS Lambda function. The steps to do this include accessing the AWS Management Console, navigating to Lambda Functions, selecting the affected function, and editing the memory settings under the General Configuration tab. By allocating more memory, the function can handle larger tasks, potentially resolving the error. The article emphasizes the importance of testing the function post-adjustment to ensure it operates as expected. These clear steps aim to facilitate a smooth serverless OCR deployment using IronOCR on AWS Lambda without encountering memory-related errors. ### Azure Functions Deployment https://ironsoftware.com/ocr/csharp/troubleshooting/azure-functions-deployment/ The article "Azure Functions Deployment" provides a comprehensive guide on deploying IronOCR applications using Azure Functions, specifically focusing on versions 3 and 4. A crucial point highlighted in the deployment process is the need to ensure that the "Run from package file" option is unchecked in the Azure Publishing Config within Visual Studio. This step is critical to avoid deployment issues. Additionally, the article notes that while .NET 6 is available, it has limited support for image processing on Linux platforms, suggesting that .NET 5 might be a more stable option for such tasks at present. The guide is supplemented with visual aids, including images showing the appropriate settings in Visual Studio Publish configurations. By following these instructions, developers should be able to successfully deploy and run OCR applications on Azure Functions. The article serves as a troubleshooting resource for those encountering issues during the deployment process, offering practical solutions to ensure smooth operation of IronOCR on Azure. ### High Peak Memory During Bulk OCR https://ironsoftware.com/ocr/csharp/troubleshooting/bulk-ocr-peak-memory/ The article "High Peak Memory During Bulk OCR" addresses the memory challenges encountered when running Optical Character Recognition (OCR) over multiple PDF segments simultaneously. Each OCR task processes full-page bitmaps through an `OcrInput` and initializes a new `IronTesseract` engine, which loads language model files anew for each segment. This approach can cause memory spikes into the multi-GB range, especially in memory-constrained environments. The solution involves three key strategies: limiting concurrency, pooling engines, and gating tasks with a semaphore. By capping the number of concurrent OCR tasks, the memory footprint is reduced as fewer bitmaps reside in memory simultaneously. Pre-creating a pool of `IronTesseract` engines and reusing them prevents repeated language model loading, distributing the load cost more efficiently. Gating work with a `SemaphoreSlim` ensures that only a specified number of segments are processed concurrently, further controlling memory usage. Additionally, disposing of `OcrInput` objects per segment promptly releases bitmap memory, preventing accumulation. These strategies collectively mitigate high peak memory usage, enhancing OCR performance in resource-limited settings. ### Captcha https://ironsoftware.com/ocr/csharp/troubleshooting/captcha/ The article titled "Handling CAPTCHAs with IronOCR" from Iron Software discusses the challenges and methods for using IronOCR in C# to read CAPTCHA codes. CAPTCHA images are intentionally designed to be difficult for Optical Character Recognition (OCR) software to interpret, often using various techniques to distort text and add background noise. These challenges make it less likely for OCR engines like IronOCR, which utilizes Tesseract, to accurately read CAPTCHA codes. To improve OCR performance on these images, the article suggests preprocessing techniques such as converting images to grayscale and reducing background noise. It highlights the use of IronOCR's `OcrInput.DeNoise()` and `OcrInput.Despeckle()` methods for noise reduction and `OcrInput.ToGrayScale()` for converting images to grayscale. A sample C# code is provided, demonstrating these preprocessing steps followed by text extraction using IronOCR. The article explains the functionality of each method used, emphasizing that while these techniques can enhance OCR results, success is not guaranteed due to the inherent difficulty of CAPTCHA images. Overall, the guide aims to improve the likelihood of successfully reading CAPTCHA challenges using IronOCR in C# applications. ### Missing Secondary Language Files in ClickOnce Publishes https://ironsoftware.com/ocr/csharp/troubleshooting/clickonce-missing-language-files/ The article addresses a common issue encountered when using IronOCR with a secondary language pack in a .NET 8.0 console app published via ClickOnce. Developers face runtime errors because secondary language `.ocrdata` files, like those for Spanish or Japanese, are not automatically included in the publish output despite being installed. This omission results in an exception indicating missing language files. To resolve this, the article suggests two solutions to ensure these files are included in the deployment. The first option involves marking each `.ocrdata` file as `Content` in the build output and setting them to "Copy if newer" to ensure they are included in the ClickOnce publish process. The second option is more efficient for auto-generated or large folders; it involves editing the `.csproj` file to include all `.ocrdata` files recursively using XML tags. This method automatically synchronizes new language files without requiring manual updates to project references. Both solutions ensure that the necessary language files are bundled and shipped with the application, preventing runtime errors associated with missing files. ### Content Areas & Crop Regions with PDFs https://ironsoftware.com/ocr/csharp/troubleshooting/crop-regions-rectangles/ The article "Content Areas & Crop Regions with PDFs" from Iron Software provides a detailed guide on how to crop specific regions in PDFs for Optical Character Recognition (OCR) using IronOCR in C#. It explains how to set content areas in PDFs, which are not traditionally measured in pixels, but are necessary for precise OCR operations. The guide presents two primary options for determining the size of a content area. The first option utilizes the `OcrInput.TargetDPI`, which defaults to 225, affecting the PDF's pixel representation. The second, more detailed option involves using the `OcrInput.LoadPdf()` method to load a PDF, followed by `OcrInput.GetPages()` to obtain page dimensions, and converting the first page to a bitmap to measure content areas in pixels accurately. This process allows users to define specific OCR regions with targeted coordinates. The article also provides C# code examples demonstrating how to load a PDF, define a content area using pixel coordinates, and perform OCR on that area. The guide is supplemented by references to IronOCR's API, aiding users in implementing these techniques effectively. ### Custom OCR Language Packs https://ironsoftware.com/ocr/csharp/troubleshooting/custom-ocr-language-packs/ The article titled "Custom OCR Language Packs" from Iron Software provides guidance on creating and using custom OCR language packs with IronOCR in C#. It outlines the process of developing a custom language pack by training a new Tesseract 4 LSTM language file or dictionary from a font. The article acknowledges that the procedure is complex, but mentions that there are numerous online tutorials that thoroughly document the necessary steps. It recommends a YouTube tutorial by Gabriel Garcia and a corresponding GitHub repository as starting resources. After completing the training, users will obtain a `.traineddata` file, which can be integrated into IronOCR. The article provides a C# code snippet demonstrating how to use the custom Tesseract language file with IronOCR. The code initializes the IronTesseract OCR engine, loads the custom `.traineddata` file, and processes an image to extract text, which is then output to the console. This guide is useful for developers looking to add new languages and enhance OCR results using IronOCR. For more detailed documentation, the article refers to IronOCR's custom languages documentation page. ### Debugging Azure Functions Project on Local Machine https://ironsoftware.com/ocr/csharp/troubleshooting/debugging-azure-functions-on-local-machine-ironocr/ The article titled "Debugging Azure Functions Project on Local Machine" on IronSoftware's website provides guidance on troubleshooting common issues when running Azure Functions locally using IronOCR. It highlights typical exceptions, such as errors while deploying Tesseract for IronOCR and failure to locate 'libtesseract-5'. These issues often arise due to dependency problems when running Azure Functions locally with tools like Azurite (VS2022) or Azure Storage Emulator (VS2019), which create an additional bin directory that only copies DLL files, omitting necessary runtime files. A recommended solution involves manually copying the runtimes directory into the separate bin directory created by the Storage Emulator, ensuring all required files are present. This can be automated as a post-build event to maintain the setup after each recompile. The article provides a step-by-step guide to setting up a post-build event that uses the XCOPY command to transfer runtime files to the correct directory, allowing the Azure Functions to run locally without issues. It explains the command syntax and options, ensuring developers can efficiently debug and test their Azure Functions projects on their local machines. ### Detecting Dotted Border Tables with ReadDocumentAdvanced https://ironsoftware.com/ocr/csharp/troubleshooting/detect-dotted-border-tables/ In the article "Detecting Dotted Border Tables with ReadDocumentAdvanced," the challenge of extracting table data from documents with dotted or dashed borders using the `ReadDocumentAdvanced` function is addressed. The optical character recognition (OCR) engine fails to identify tables with such borders due to the discontinuity created by the gaps between dots, resulting in an "Unhandled exception. System.InvalidOperationException: Sequence contains no elements" error. To resolve this, the article suggests applying the `Dilate()` filter, which expands dark pixels to close the gaps between dots, effectively converting the dotted borders into solid lines. This allows the engine to recognize the continuous contour of the table boundary and successfully extract cell data. The solution involves enabling table reading with `ReadDataTables`, loading the input image, applying the `Dilate()` filter to merge dotted borders, and then executing `ReadDocumentAdvanced`. The article provides code snippets to guide the implementation and includes images to illustrate the input and output before and after dilation. This method ensures that tables with initially undetectable borders become accessible for data extraction, enhancing the OCR functionality for documents with non-solid border styles. ### Dot Matrix OCR https://ironsoftware.com/ocr/csharp/troubleshooting/dot-matrix-ocr/ The article "Dot Matrix OCR Troubleshooting with IronOCR" provides guidance on enhancing OCR accuracy for dot matrix prints using IronOCR in C#. It confirms that IronOCR can read dot matrix printouts; however, the accuracy is influenced by the quality of the input image. To improve results, the article suggests pre-processing images and recommends a tutorial on enhancing dot matrix OCR performance. For more complex processing, it advocates using ImageMagick for .NET, a free tool with capabilities similar to Photoshop, accessible via NuGet. Additionally, the article suggests considering a dot matrix-specific language pack to potentially increase accuracy, although IronOCR does not currently offer one. It provides a starting point with a GitHub project focused on OCR for expiration dates. To further aid users, a link to instructions for adding custom language packs in IronOCR is also provided. Overall, the article serves as a troubleshooting guide for developers looking to optimize OCR results for dot matrix text using IronOCR, offering practical resources and recommendations to address common challenges in recognition accuracy. ### How to Make an Engineering Support Request for IronOCR https://ironsoftware.com/ocr/csharp/troubleshooting/engineering-request-ocr/ IronOCR's support page outlines how users can effectively submit engineering requests to address technical challenges or seek enhancements. The process emphasizes the importance of clear and concise issue descriptions to aid the engineering team in replicating and resolving problems efficiently. Users are encouraged to read the troubleshooting guides to understand common issues and limitations of IronOCR. A comprehensive bug report should include a detailed symptom description, reproduction information, environment details, code snippets, screenshots, and any exception messages. Including log files can significantly improve the chances of receiving help, and users should configure IronOCR's logging features appropriately by setting the log file path and enabling comprehensive logging. Additionally, providing an example project that replicates the issue is highly valued, as it helps engineers swiftly understand the problem. The preferred format for these projects is a zipped, standalone .NET console or web app project. Users should include input files (both working and non-working) and the expected output. All support requests should be directed to the Iron Software engineering team via email at developers@ironsoftware.com. ### OCR Hangs on Large PDFs with EnglishFast Secondary Language https://ironsoftware.com/ocr/csharp/troubleshooting/englishfast-hang-large-pdfs/ IronOCR may experience a stall during the processing of large PDFs when `OcrLanguage.EnglishFast` is included as a secondary language. This issue, which causes execution to halt indefinitely without throwing an exception or logging an error, has been identified in several IronOCR versions from `2025.12.3` through `2026.7.2`. The problem persists irrespective of the position of `EnglishFast` among other secondary languages. To circumvent this issue, users are advised to remove the `EnglishFast` configuration from the secondary language list and retain `OcrLanguage.English` as the primary language to preserve English text recognition quality. Other secondary languages in the setup remain unaffected by this change. After adjusting the language settings, reprocess the affected PDF document to ensure it completes without interruption. This solution effectively bypasses the problematic fast English model, thus maintaining document processing integrity without sacrificing recognition coverage for English text. ### Equations https://ironsoftware.com/ocr/csharp/troubleshooting/equations/ The article titled "Equations" on Iron Software's website provides a comprehensive guide on using IronOCR to handle optical character recognition (OCR) for mathematical equations in C#. It highlights that IronOCR, which leverages Tesseract 4/5, is capable of reading equations effectively but suggests experimenting with various configuration options to enhance accuracy. Users can explore Tesseract configuration variables and add custom language packs to optimize performance. A specific EQU Equation Detection Language Pack is recommended for improved equation detection. The article includes a C# code example demonstrating how to implement OCR for equations using IronOCR. The example involves importing the IronOcr namespace, creating an IronTesseract object, and loading the EQU language pack to enhance equation recognition. The `ReadEquations` method is outlined to read an image file containing equations, perform OCR, and output the recognized text. This structured approach aims to assist developers in accurately recognizing and processing mathematical expressions from images, facilitating a smoother integration of OCR capabilities for equations in C# applications. ### Fix IronOcrNativeException: 'Error while read' https://ironsoftware.com/ocr/csharp/troubleshooting/error-while-read/ The article titled "Fix IronOcrNativeException: 'Error while read'" is a comprehensive guide aimed at resolving specific native exceptions encountered while using IronOCR in C#. The primary focus is on the error message "IronOcr.Exceptions.IronOcrNativeException: 'Error while read,'" which signifies issues during text extraction from images. This guide suggests practical steps for troubleshooting such exceptions, urging users to verify the validity of input images and parameter values. Users are encouraged to provide the problematic image to Iron Software support, or alternatively, share the image's dimensions if the image cannot be provided. This enables the support team to conduct a thorough investigation and offer targeted solutions. The document underscores the importance of accurate input data to prevent errors and enhance the performance of IronOCR applications. With detailed instructions, this guide equips users with the necessary knowledge to efficiently address and troubleshoot native exceptions in IronOCR, ensuring smoother text extraction processes in their applications. By providing these solutions, Iron Software aims to enhance user experience and minimize disruptions caused by native exceptions during OCR operations. ### Fixing Failed to Locate Tessdata Issue in IronOCR https://ironsoftware.com/ocr/csharp/troubleshooting/failed-to-locate-tessdata-fra-traineddata-even-after-successfully-unpacking-the-language-pack/ The article "Fixing Failed to Locate Tessdata Issue in IronOCR" addresses a common issue encountered when using IronOCR, specifically the failure to locate the 'tessdata\fra.traineddata' file even after the successful unpacking of the language pack. This problem typically arises due to IronOCR's need for permission to write to the runtimes folder during execution. If the application is not granted access to this folder, it results in an exception stating that the 'tessdata\fra.traineddata' file could not be located. The unpacking process involves moving the `.ocrdata` language file from the **OcrData** folder to the **tessdata** folder within the **runtime** directory. However, some antivirus or security applications, notably Windows Ransomware Protection, may restrict these write permissions, causing the unpacking to fail despite having the necessary access through Visual Studio. The guide provides troubleshooting steps to resolve these errors, ensuring that IronOCR can successfully access and write to the required directories, thus preventing the exception from occurring. By addressing these permission issues, users can ensure smoother operation and functionality of the IronOCR tool. ### Financial Language Pack https://ironsoftware.com/ocr/csharp/troubleshooting/financial-language-pack/ The Financial Language Pack is a specialized feature for IronOCR, designed to enhance the accuracy of optical character recognition (OCR) when dealing with financial documents. This tool is particularly effective for reading tables of data and can convert documents into searchable PDFs, improving data accessibility. The implementation involves using IronTesseract, a component of the IronOcr library, and configuring it to utilize the Financial language pack specifically. By doing so, users can process PDFs and apply optional image filters like deskewing and denoising to enhance the readability and accuracy of the OCR results. The example code provided demonstrates the simplicity of setting up an OCR operation: it imports the IronOcr library, initializes IronTesseract, sets the language to Financial, and processes a sample PDF. The processed document is then saved as a searchable PDF, allowing for efficient text extraction and retrieval. This functionality is critical for businesses and individuals needing precise data extraction from complex financial documents. More detailed information and documentation on the Financial Language Pack can be accessed through the provided IronOCR Financial Language Pack Documentation link. ### Quick IronOCR Troubleshooting https://ironsoftware.com/ocr/csharp/troubleshooting/general-troubleshooting-ocr/ The "Quick IronOCR Troubleshooting" guide provides solutions to common issues encountered when using IronOCR in C#. Key recommendations include ensuring the latest version of Microsoft Visual C++ Redistributable for Visual Studio is installed, with specific instructions based on machine architecture—x86 versions for x86 machines and both x86 and x64 versions for x64 machines. For more details, users are directed to Microsoft documentation. The guide emphasizes the importance of internet access for production servers to download necessary components and stresses setting proper permissions for system temp folders and input files, especially for users like AppPool identity/IIS User, NetworkService, and ASPNET. After updating the library or changing license keys, it's advised to redeploy a clean application version to prevent DLL caching. Steps include creating a clean project, deleting IronOcr from temp folders, uninstalling the library with dependencies, and clearing NuGet caches. Users are also encouraged to set new Installation Paths outside standard directories. If issues persist, the guide suggests consulting the Engineering Request list, which outlines information necessary for the engineering team to address technical inquiries efficiently. ### Getting the Best Support for IronOCR https://ironsoftware.com/ocr/csharp/troubleshooting/getting-the-best-support-for-ironocr/ The article "Getting the Best Support for IronOCR" provides a comprehensive guide for users seeking assistance with IronOCR, a powerful Optical Character Recognition software. It highlights the importance of regular updates, which are released every 1 to 2 months on NuGet, to enhance the software's performance. The article categorizes common issues into exceptions and bugs, known deployment issues, and licensing queries, providing specific solutions and resources for each. For exceptions and bugs, users are encouraged to report detailed bug reports via the Exceptions & Bug Reporting Page for quick resolution. Known deployment issues are addressed with specific solutions for Windows, Linux, Docker, and MacOS platforms, such as installing necessary runtimes or libraries like Visual C++ and libgdiplus. Azure Functions v3 and v4 users are guided through resolving "OCRData file not found" exceptions using the Azure function deployment guide. Common licensing questions are also tackled, with resources on obtaining and applying license keys. For unresolved issues, users are advised to request assistance from IronOCR's team of engineers by following specific guidelines, ensuring a swift resolution to their problems. ### Identity Documents https://ironsoftware.com/ocr/csharp/troubleshooting/identity-documents/ The article titled "Identity Documents" on the Iron Software website provides guidance on troubleshooting OCR (Optical Character Recognition) issues specifically related to identity documents using IronOCR in C#. Identity documents often present challenges for OCR systems due to features like holograms, watermarking, and digital noise designed to prevent fraud. To enhance OCR accuracy, the article recommends using high-quality image formats, such as TIFF or PNG, which contain less digital noise compared to lossy formats like JPEG. Additionally, it suggests employing specific image optimization filters to improve the quality of the input images. The "DeNoise" filter is highlighted for removing expected digital noise, and the "Despeckle" filter is suggested for cases with significant background noise, though it should be used cautiously as it may affect the OCR accuracy of clean documents and is resource-intensive. The article also recommends using crop rectangles to focus on specific areas of the document. These strategies are aimed at optimizing the recognition process for identity documents, thereby improving the overall success rate of OCR systems in extracting information from IDs and passports. ### Debugging iOS Apps with Native Libraries on Windows https://ironsoftware.com/ocr/csharp/troubleshooting/ios-debugging-native-libraries-windows/ Debugging iOS applications using .NET MAUI from a Windows environment encounters issues due to the inability to load third-party native libraries like IronOCR's Tesseract. This problem arises because Apple's development ecosystem necessitates apps to be signed with a valid developer certificate and native libraries to be compiled for ARM64 architecture, utilizing Apple's exclusive toolchains which are only accessible on macOS. When debugging from Windows, the essential Tesseract library often ends up missing, unsigned, or obstructed by Apple's strict sandboxing rules, leading to errors like 'Failed to locate libtesseract.5'. Unlike iOS, Android and Windows platforms do not have such stringent signing requirements, allowing IronOCR's Tesseract to function smoothly. To resolve these issues, developers should build through macOS using either direct development or Visual Studio's Pair to Mac feature to ensure the library is correctly signed and compiled. Additionally, allowing IronOCR to manage its library deployment avoids sandbox access errors. Testing should be conducted on real devices or simulators launched from a Mac to accurately reflect the app's performance in a signed and sandboxed environment, which Windows cannot emulate. ### IronOCR Runtimes Folder https://ironsoftware.com/ocr/csharp/troubleshooting/ironocr-runtimes-folder/ The article titled "IronOCR Runtimes Folder" provides a guide on managing the IronOCR runtimes folder in C#, addressing common exceptions such as deployment errors related to Tesseract for IronOcr and issues locating 'libtesseract-5'. Since version 2022.8.7804, IronOCR includes Tesseract within its package, eliminating the need for separate installations. The recommended solutions for managing runtime dependencies include using the Publishing Wizard in Visual Studio with the **Portable** target runtime to ensure the runtimes folder is automatically included. For those unable to use Visual Studio, manually copying the runtimes folder from a development machine to the production machine’s bin folder is advised. Additionally, a Windows Installer is available for deployment assistance. A noted issue for Azure users is the Azure Storage Emulator (Azurite) generating an extra **bin** folder, which can be resolved by referring to a specific debugging guide. The article provides links and resources for further assistance, including a detailed explanation of the Azure-related problem and its workaround. ### IronOCR - Security CVE https://ironsoftware.com/ocr/csharp/troubleshooting/ironocr-security-cve/ IronOCR, a product of Iron Software, emphasizes security and data protection through various measures. The library does not rely on web services or internet data transmission for performing Optical Character Recognition (OCR), ensuring user data remains secure. It is developed in C#, which inherently guards against numerous common security threats. By exposing minimal API entry points and implementing strong naming along with advanced tamper protection, IronOCR maintains robust security protocols. The library undergoes regular scanning by multiple anti-virus and anti-malware tools, employing top-tier security measures and heuristic searches to identify potential vulnerabilities. Each line of code is meticulously reviewed by senior engineers to ensure the highest security standards. Although IronOCR uses unmanaged C++ code through DLLs like `tesseract.dll`, `pdfium.dll`, `leptonica.dll`, and `imagemagick.dll`, no executable entry points are exposed. Additionally, IronOCR incorporates several .NET dependencies such as ZXing.Net, Tesseract.Net, and PdfiumLight, which are internalized within the library to prevent external access. These dependencies are not identified as potential security risks, ensuring that IronOCR remains a secure choice for users requiring OCR capabilities. ### IronOCR Utility | IronOCR https://ironsoftware.com/ocr/csharp/troubleshooting/ironocr-utility/ The IronOCR Utility is a Windows desktop application designed to complement the IronOCR API Library. It allows users to evaluate and test IronOCR's capabilities, visualize files, and determine optimal settings for reading and exporting C# code to their IDE. The utility provides an interactive way to utilize the customized and optimized Tesseract 5, known as Iron Tesseract, enabling users to convert files or images into text and searchable PDFs. Users can download the application, install it, and begin by entering a trial or full license key. The application interface allows users to drag and drop image files or PDFs for processing. It offers features such as highlighting detected words with confidence levels and applying filters to enhance readability by removing noise and correcting image skew. Users can view real-time updates as filters are applied and can export the processed data into their .NET projects by copying generated code from the utility. Additionally, users can create searchable PDFs with the text overlayed on the original images using the export feature. This utility is useful for developers looking to integrate OCR functionalities into their applications, providing a visual method to fine-tune OCR processes and settings. ### leptonica-1.78.0.dll https://ironsoftware.com/ocr/csharp/troubleshooting/leptonica-1-78-0-dll/ The article titled "leptonica-1.78.0.dll" provides a troubleshooting guide for resolving DLL errors associated with the Leptonica-1.78.0.dll in IronOCR. It specifically addresses the common error message: "Could not find or load the native library from any name: [ leptonica-1.78.0.dll, liblept, liblept.dll ]". This issue often arises when a project is transitioned from a development environment to a production setting. The root cause is identified as the absence of Microsoft Visual C++ Redistributables for Visual Studio (2015-2022) on the production machine. The guide emphasizes the necessity of installing both x86 and x64 versions of these redistributables to ensure the smooth operation of IronOCR. For further assistance, the article directs readers to the IronOCR Troubleshooting Guide, which provides additional insights and solutions for resolving related issues. By following the recommended steps, users can effectively resolve DLL-related errors and maintain the proper functionality of their IronOCR implementations. ### libgdiplus https://ironsoftware.com/ocr/csharp/troubleshooting/libgdiplus/ The article titled "libgdiplus" on Iron Software's website provides a comprehensive troubleshooting guide for resolving issues related to libgdiplus in IronOCR on Linux systems. It highlights the necessity of libgdiplus for .NET Core applications that utilize the Microsoft System.Drawing.Common NuGet package. The absence of this library on macOS or Linux can trigger exceptions such as System.DllNotFoundException and System.TypeInitializationException. For Linux users, specifically those on Ubuntu or Debian, the guide advises updating package lists and installing necessary libraries using the command `sudo apt-get update && sudo apt-get install -y apt-utils libgdiplus libc6-dev`. When deploying applications in Docker, it recommends adding a similar command to the Dockerfile to ensure the libraries are included in the Docker image. For macOS, if similar exceptions occur, the guide suggests adding the runtime.osx.10.10-x64.CoreCompat.System.Drawing NuGet package to the .NET solution or manually installing libgdiplus via Homebrew with `brew update && brew install mono-libgdiplus`. Additional guidance can be found on the official .NET documentation. This resource is essential for developers aiming to ensure optimal OCR functionality across different operating systems. ### Fix License Key Issues: IronOCR | IronOCR https://ironsoftware.com/ocr/csharp/troubleshooting/license-key-web.config/ The article titled "Fix License Key Issues: IronOCR | IronOCR" addresses a specific problem encountered with the IronOCR library regarding license key management in ASP.NET projects. This issue affects versions of IronOCR between 2023.4.13 and 2024.3.4 when used in .NET Framework projects version 4.6.2 or higher. The license key, when stored in the Web.config file, is not automatically recognized by these specific versions, leading to a licensing exception. To resolve this, the article suggests a workaround that involves manually retrieving the license key from the Web.config file using the ConfigurationManager in the code. The retrieved key should then be assigned to the IronOcr.License.LicenseKey property to prevent any licensing exceptions. This guidance ensures that developers can properly configure their ASP.NET applications to avoid disruptions due to licensing issues. The problem has been resolved in IronOCR version 2024.3.4, eliminating the need for this workaround in future versions. The article provides both an XML configuration snippet and a C# code example to clarify how to implement the solution effectively. ### Stuck Processes Loading PDF Forms on Linux https://ironsoftware.com/ocr/csharp/troubleshooting/linux-pdf-form-hang/ On Linux platforms, such as Debian with .NET 8, the function `OcrInput.LoadPdf()` can indefinitely hang when attempting to load PDF files containing interactive form fields. This issue does not occur on Windows, and not all PDFs with forms cause this problem, making it particularly challenging to anticipate in production environments. The underlying cause is the interactive form layer present in some PDFs. To resolve this, it is recommended to flatten the PDF before processing it with IronOCR. Flattening the PDF involves converting the interactive form fields into static page content, which eliminates the problematic interactive layer. The recommended solution involves using IronPDF to load the original file, flatten it, and save a new static version. Once flattened, this version can be safely processed with IronOCR without encountering hangs. This approach not only prevents the process from stalling but also ensures consistent cross-platform behavior, removes unnecessary interactive elements, and reduces the file's complexity, leading to faster OCR processing. Therefore, flattening is a crucial step for seamless PDF handling on Linux systems using IronOCR. ### Language Pack Not Found in .NET MAUI Android https://ironsoftware.com/ocr/csharp/troubleshooting/maui-android-language-pack-not-found/ The article addresses a common issue encountered when using IronOCR in .NET MAUI Android projects: the "Language Pack Not Found" error. This occurs because the `.traineddata` language files, although placed in `Assets/tessdata` and marked as `AndroidAsset`, aren't included in the APK during builds executed via Visual Studio Code or command line interface (CLI). As a result, IronOCR fails to load non-English language packs at runtime. The article outlines a comprehensive solution to resolve this error. It recommends building the project in the full Visual Studio 2022 IDE to ensure dependencies are correctly packaged. Additionally, it suggests moving the `OcrData` folder to the project root post-build and registering the trained data as Android assets in the `.csproj` file. Furthermore, incorporating a suitable font like Noto Sans SC in the `Resources/Fonts` directory is essential for rendering recognized text. For debugging, the article advises verifying the installation of the `IronOcr.Android` NuGet package and enabling logging to track the search paths used by IronOCR. These steps ensure the proper inclusion of language packs and help in troubleshooting related issues. ### Missing Function RenderPageBitmapHighQuality https://ironsoftware.com/ocr/csharp/troubleshooting/missing-function-RenderPageBitmapHighQuality/ In the latest update of IronOCR, version 2025.4.4, a new internal method was introduced for converting to Bitmaps. However, users who upgraded from previous versions may encounter an exception: `System.InvalidOperationException: 'No function was found with the name RenderPageBitmapHighQuality with error code (127).'` This error indicates that the function is missing from the internal API. The root cause of this issue is a version mismatch, where the `IronOcrInterop.dll` was not updated to align with the new IronOCR version. Consequently, the library continues to reference an outdated API set, which lacks the `RenderPageBitmapHighQuality` function. The recommended solution is to delete the existing bin folder and rebuild the project. Rebuilding ensures that a new `IronOcrInterop.dll` is generated, compatible with the updated version. Once the project is rebuilt, rerunning it should resolve the error, allowing the function to be recognized and utilized correctly. This troubleshooting step addresses the version discrepancy and restores functionality, ensuring seamless operation of the updated IronOCR library. ### Optical Mark Recognition (OMR) Support https://ironsoftware.com/ocr/csharp/troubleshooting/optical-mark-recognition-omr/ IronOCR, a tool for reading printed and handwritten text from various formats like PDFs, images, and scanned documents, currently does not support Optical Mark Recognition (OMR). OMR is distinct from Optical Character Recognition (OCR) and specializes in detecting the presence or absence of marks such as ticked checkboxes, filled bubbles, and selected radio buttons on forms. It is crucial for applications like multiple-choice exams, surveys, and feedback forms, offering a boolean output that identifies whether a specific zone is filled. Unlike OCR, which reads and converts text into characters, OMR focuses on predefined, consistent form layouts with clearly defined zones. While OCR handles documents with text, OMR is tailored for forms requiring mark detection. Currently, IronOCR does not include OMR capabilities, although there is increasing demand for this feature from users. The IronOCR team has acknowledged this demand and has logged multiple feature requests, exploring options to integrate OMR into their library. This development is on the roadmap, and users who require OMR are encouraged to share their use cases with Iron Software support to aid in prioritizing its development. ### Page Orientation and Rotation in PDFs https://ironsoftware.com/ocr/csharp/troubleshooting/page-orientation-and-rotation/ The webpage "Page Orientation and Rotation in PDFs" explores methods to determine a PDF page's orientation (portrait or landscape) and its content rotation. It distinguishes between page orientation, defined by layout dimensions, and rotation angle, which indicates how content is positioned relative to conventional reading direction. Two primary methods are discussed: using PDF metadata and OCR-based detection. The `PdfDocument.Pages[i].PageRotation` method retrieves rotation information from the PDF's metadata, making it ideal for well-structured PDFs with reliable data. In contrast, the `OcrInput.DetectPageOrientation()` method visually assesses the page, making it suitable for scanned or image-based PDFs where metadata might be missing or inaccurate. The article suggests using metadata for digital PDFs and OCR for scanned documents, but recommends employing both techniques for critical tasks to ensure accuracy, especially when discrepancies arise. Ultimately, the choice of method depends on the nature of the PDF and the reliability of its metadata, with OCR offering a robust alternative for visually analyzing pages lacking proper metadata. ### OcrInternals Deployment Error in x86 Applications https://ironsoftware.com/ocr/csharp/troubleshooting/readscreenshot-x86-x64-helper/ The article titled "OcrInternals Deployment Error in x86 Applications" addresses a common issue encountered when using the ReadScreenShot() function in Windows x86 processes. This function often throws an OcrInternals deployment error due to compatibility issues inherent in 32-bit (x86) applications. The article suggests two effective solutions to resolve this problem. The first approach involves reconfiguring the application to target the x64 architecture, thus bypassing the limitations of the x86 environment. The second solution recommends routing the ReadScreenShot() call through an x64 helper process, which acts as an intermediary to ensure proper functionality. This latter method allows users to maintain their existing x86 application architecture while leveraging the capabilities of the x64 process. By following these guidelines, developers can overcome the deployment error, optimizing their application's performance and ensuring seamless OCR functionality. The article serves as a valuable resource for developers facing deployment challenges, providing clear and actionable steps to improve application reliability and efficiency. By implementing these strategies, developers can enhance their software's compatibility with modern systems, ultimately delivering a better user experience. ### Reduce file size of output PDF in IronOcr https://ironsoftware.com/ocr/csharp/troubleshooting/reduce-file-size-of-output-pdf-in-ironocr/ The article provides guidance on reducing the file size of output PDFs generated by IronOCR, a tool that performs optical character recognition (OCR). IronOCR automatically enhances inputs identified as low quality, specifically those below 150 DPI, to ensure accurate OCR results by upscaling them to a default TargetDPI of 225. To minimize the file size of PDFs, users can manually set a lower TargetDPI, with recommended values being 96, 72, or 48 DPI. The article provides examples using C# code snippets to demonstrate how to adjust the TargetDPI to 96 or 72, thereby creating smaller PDF files. It emphasizes the importance of balancing file size and OCR performance since lowering the DPI excessively can compromise recognition accuracy. Additionally, users have the option to disable automatic upscaling entirely by setting the TargetDPI to 0, allowing the input file to remain unchanged. For further details on the TargetDPI settings and additional capabilities, users are referred to the IronOCR API Reference. The guidance is particularly useful for developers seeking to optimize PDF document size while maintaining OCR effectiveness. ### Save image with different image processing applied https://ironsoftware.com/ocr/csharp/troubleshooting/save-image-with-different-image-processing-applied/ The article titled "Save image with different image processing applied" from Iron Software provides a guide on how to save images with various image processing techniques using IronOCR in C#. It begins by explaining how to create a new instance of `OcrInput` by taking a file path from a text box input. The article then demonstrates the application of a grayscale filter to the image. It provides a code example where each page in the `OcrInput` object is iterated over, and each processed page is saved as an image with a unique timestamped filename. This ensures that each image is distinct and can be easily identified. The article further directs readers to a full list of available image optimization filters, offering a resource for developers seeking to apply different image processing techniques. Additionally, it includes links to MSDN-style class documentation for `OcrInput` methods, providing further technical support and reference material for developers. This guide serves as a practical resource for customizing image outputs in C# using IronOCR, focusing on straightforward implementation and flexibility in image processing. ### SEHException with non-AVX CPUs https://ironsoftware.com/ocr/csharp/troubleshooting/sehexception-avx-support/ The article "SEHException with non-AVX CPUs" addresses troubleshooting the SEHException error related to AVX support in IronOCR. This issue typically arises on machines with older processors, such as Xeon, Celeron, Pentium, or Atom, which lack AVX support. The article suggests upgrading to IronOCR version 2022.8.7804 or later, as these versions include support for non-AVX processors. An example code snippet is provided to help users programmatically check for AVX support using C#. The code utilizes the `System.Runtime.Intrinsics.X86.Avx.IsSupported` property to determine AVX support. If AVX is unsupported, the program advises updating to a compatible version of IronOCR. This guide is a helpful resource for developers experiencing compatibility issues with IronOCR on older hardware, ensuring their applications run smoothly without encountering unhandled exceptions related to AVX instructions. ### Slashed zeros https://ironsoftware.com/ocr/csharp/troubleshooting/slashed-zeros/ In the article "Handling Slashed Zeros in IronOCR," the challenge of accurately recognizing slashed zeros in Optical Character Recognition (OCR) processes is addressed. This issue often arises due to the limitations of Tesseract language packs, leading to misinterpretation of slashed zeros as characters like 'g', '6', or '8'. To resolve this, the article suggests employing a specialized language pack called SlashedZeroOCR, which can be found on GitHub. This language pack can be integrated with IronOCR, a C# OCR library, by loading it as a custom language pack. The article provides a code example demonstrating how to implement this solution using IronOCR. The example includes initializing the IronTesseract class, loading the custom Tesseract language file specifically designed to handle slashed zeros, and processing an input image to perform OCR. The recognized text is then output to the console. By following these guidelines, developers can enhance the accuracy of OCR systems when dealing with documents or images that contain slashed zeros, ensuring that these characters are correctly identified and reducing errors in text recognition. ### OCR of TIFFs Over 2 GB with LibTiff.NET https://ironsoftware.com/ocr/csharp/troubleshooting/split-large-tiffs-for-ocr/ The article on Iron Software's website addresses the challenge of performing Optical Character Recognition (OCR) on TIFF files larger than 2 GB using IronOCR. The problem arises due to the AnyBitmap library's single-buffer limit, which prevents the loading of TIFFs exceeding this size. As a solution, the article recommends using LibTiff.NET, a powerful library for handling TIFF files. The suggested approach involves splitting the large TIFF file into smaller, manageable chunks, each under 2 GB. Once split, each chunk can be processed individually through OCR. The article provides a step-by-step guide on implementing this method, ensuring that users can efficiently handle extensive TIFF files without compromising the accuracy or performance of OCR operations. By leveraging LibTiff.NET, developers can bypass the limitations imposed by AnyBitmap, allowing for seamless processing of large-scale TIFF documents. This solution is particularly beneficial for industries dealing with extensive document digitization where file size can be a significant hurdle. The article serves as an essential resource for developers facing similar challenges, offering a practical workaround to enhance their document management and OCR capabilities. ### IronOCR - Alternative to System.Drawing.Common https://ironsoftware.com/ocr/csharp/troubleshooting/system-drawing-common-ironocr/ The article from Iron Software addresses the challenges developers face when using the System.Drawing.Common library on non-Windows platforms, particularly with .NET 6 and .NET 7. It explains that Microsoft has ceased support for System.Drawing.Common on Linux and macOS since .NET 6, with further limitations in .NET 7. On these platforms, attempts to use the library result in a PlatformNotSupportedException, and in .NET 6, compile-time warnings and runtime exceptions occur unless the System.Drawing.EnableUnixSupport configuration is set to true. The article recommends using IronSoftware.Drawing as an alternative, an open-source library compatible with .NET 7, which replaces System.Drawing.Common for non-Windows systems. This alternative can be found on NuGet and GitHub. The guide provides steps to enable Unix support in .NET 6 via runtime configuration settings, which is no longer applicable in .NET 7. By adopting IronSoftware.Drawing, developers can overcome the limitations imposed by Microsoft’s decision, ensuring their applications remain functional across all platforms. The documentation and resources for IronSoftware.Drawing are accessible for developers seeking further guidance. ### System.Memory Exception https://ironsoftware.com/ocr/csharp/troubleshooting/system-memory-exception/ The article, titled "System.Memory Exception," addresses a common issue developers encounter when using IronOCR on the .NET Framework, where a `System.Memory Exception` occurs due to version conflicts. This problem arises when dependencies enforce strict version binding, requiring a specific version of System.Memory, which can persist even if newer, compatible versions are installed. To resolve this, the article provides a solution involving the modification of the `App.config` file. The suggested changes include adding a `runtime` section with `assemblyBinding` directives to redirect old versions of System.Memory and System.Runtime.CompilerServices.Unsafe to their desired versions. This configuration helps prevent version conflicts by ensuring that all components use the appropriate assembly version at runtime, thus eliminating the exception. The article encourages developers to test the application after making these changes to confirm the fix. For additional insights and community discussions, a link to a relevant GitHub page is provided. This guidance aims to assist developers in troubleshooting and resolving the System.Memory Exception effectively, ensuring smooth operation of IronOCR applications. ### Tesseract Fallback Logic https://ironsoftware.com/ocr/csharp/troubleshooting/tesseract-fallback-logic/ The article titled "Tesseract Fallback Logic" provides guidance on implementing fallback logic in IronOCR to ensure reliable Optical Character Recognition (OCR) results. A specific error, "Could not initialize Tesseract. The fallback logic failed," is highlighted, which occurs when the Microsoft Visual C++ Redistributable for Visual Studio is not installed on target machines. The article suggests checking a linked Knowledge Base article for more detailed information on this issue. Additionally, it provides a direct link to download the latest supported Visual C++ Redistributable from Microsoft. By addressing this common problem, users can enhance the reliability and functionality of IronOCR, ensuring that the fallback mechanisms operate correctly and the OCR processes run smoothly. This troubleshooting guide is essential for developers and users who rely on IronOCR for their text recognition needs, as it helps prevent disruptions caused by missing software dependencies. ### Tiff Compression Warning https://ironsoftware.com/ocr/csharp/troubleshooting/tiff-compression-warning/ The article titled "Tiff Compression Warning" addresses common warnings encountered when using IronOCR for processing TIFF files. Users may notice warnings such as "incorrect count for field 'JpegQTables'," "JpegDcTables," and "JpegAcTables," which indicate discrepancies in expected data counts during image processing. These warnings are generated by ImageMagick via libtiff and typically occur due to older JPEG compression methods used in some TIFF images. The article reassures users that these warnings do not disrupt the Optical Character Recognition (OCR) process, which continues to function as normal. The warnings serve as informational alerts and suggest transitioning to newer JPEG compression styles for improved compatibility. Additionally, the article provides a link to a discussion on GitHub for more in-depth information. Looking ahead, the developers plan to disable these warnings in future IronOCR versions (v2025.5.x) to reduce unnecessary alerts and streamline user experience. Overall, the guide offers valuable insights into handling TIFF compression warnings effectively, ensuring seamless text extraction from images. ### Always Use 64-Bit Architecture with IronOCR https://ironsoftware.com/ocr/csharp/troubleshooting/use-64-bit-architecture/ The article addresses the significant memory limitations encountered when using IronOCR on 32-bit architecture. IronOCR's processes, which involve high-resolution image rendering, rasterization, and machine learning-based text extraction, are highly memory-intensive, often exceeding the ~2GB memory cap inherent to 32-bit systems. These limitations manifest as System.OutOfMemoryException errors, deadlocks, and crashes during OCR operations. To overcome these issues, transitioning to a 64-bit architecture is recommended. This can be achieved by altering the platform target settings in Visual Studio or configuring the .csproj file to target x64. The guide also warns against using the "AnyCPU" configuration with "Prefer 32-bit" enabled, as it secretly enforces the 2GB memory ceiling. For robust performance in production environments, the article advocates for developing and deploying projects on 64-bit systems, including Docker images. If transitioning to x64 is not feasible, a compromise in document size and resolution is suggested, though this may impact performance and accuracy. The article emphasizes the importance of targeting x64 for efficient OCR workloads to prevent unexpected stalls or crashes in high-volume document processing. ### Troubleshooting older version of System.Drawing https://ironsoftware.com/ocr/csharp/troubleshooting/using-older-version-of-system-drawing/ The article "Troubleshooting older version of System.Drawing" addresses the challenges of using the outdated System.Drawing version 4.0.0, which is part of .NET 4.6.1 to .NET 4.8, with IronOCR. This outdated version is unsupported and potentially vulnerable. Users attempting to use System.Drawing.Image with IronOCR's OcrInput encounter exceptions, as IronOCR does not recognize System.Drawing.Image as a valid input type, resulting in errors such as "Unable to parse Object [] as a valid image file." Additionally, specifying an Image input type results in conversion errors due to incompatibility with SixLabors.ImageSharp.Image. To resolve these issues, the article suggests two primary solutions. First, updating System.Drawing.Common to version 6.0.0 to address security and compatibility concerns. Second, utilizing SixLabors.ImageSharp version 2.1.3, which allows OcrInput to be instantiated with SixLabors.ImageSharp.Image. The article provides a code example demonstrating how to use SixLabors.ImageSharp to load an image and process it with IronOCR. This approach involves initializing an IronTesseract instance, loading an image, and performing OCR to extract text, offering a modern, compatible solution for handling images in legacy systems. ### Visual C++ Redistributable for Visual Studio https://ironsoftware.com/ocr/csharp/troubleshooting/visual-c-redistributable-for-visual-studio-ironocr/ The article titled "Visual C++ Redistributable for Visual Studio" provides a comprehensive guide on installing and configuring the necessary Visual C++ Redistributable for running IronOCR efficiently on Windows operating systems. It emphasizes the importance of having the latest version (2015-2022) of the Microsoft Visual C++ Redistributable installed, as it is a critical system component for IronOCR and other modern software. The guide details the installation process, recommending downloading the appropriate version for the system architecture—x86 for 32-bit machines and both x86 and x64 for 64-bit machines. Links to the official Microsoft support CDN for downloading the installers are provided. Additionally, the article highlights the advantage for "SaaS/OEM Redistribution" customers to package the C++ runtime within an MSI or executable installer. An alternative method through Windows Update is also discussed, which is particularly beneficial for older operating systems like Windows Server 2012, Windows 8, and Windows Vista. This method involves installing the Windows Update for Universal C++ Runtimes, as recommended by Microsoft, to ensure a successful fix for runtime dependencies. ### Why IronOCR and not Tesseract https://ironsoftware.com/ocr/csharp/troubleshooting/why-ironocr-and-not-tesseract/ The article "Why IronOCR and not Tesseract" on IronSoftware's website highlights the advantages of using IronOCR over Tesseract for C# projects. IronOCR offers superior accuracy, handling image pre-processing and applying filters automatically, achieving up to 100% accuracy with minimal configuration. It supports a wide range of image formats and memory-managed images, eliminating the memory leak issues associated with Tesseract's Leptonica PIX format. IronOCR's performance is enhanced by multithreading capabilities, requiring no pre-processing or fine-tuning, unlike Tesseract, which demands clean documents for accuracy. The IronOCR API is user-friendly and well-documented, including support from a team of engineers, contrasting with Tesseract's complicated interop layers and deployment challenges. Additionally, IronOCR supports over 125 languages with custom language pack options, compared to Tesseract's 100 languages. The article concludes that while Tesseract is beneficial for C++ developers, IronOCR is a more complete OCR solution for .NET, efficiently handling scanned or photographed images without extensive pre-processing. It integrates a refined version of Tesseract's engine, optimized for C#, providing enhanced performance and features. ### X and Y coordinates change in OcrResult Class https://ironsoftware.com/ocr/csharp/troubleshooting/x-and-y-coordinates-change/ The article "X and Y coordinates change in OcrResult Class" from Iron Software addresses the issue of changing X and Y coordinates within the IronOCR software. This fluctuation occurs because images are upscaled when their resolution is deemed insufficient for effective OCR processing. Upscaling enhances image clarity, allowing for more precise text recognition by the OCR engine. This process is detailed via the `OcrInput.GetPages()` method and the `OcrResult.Pages` object, which provide metadata and results related to page processing during OCR. Users can export the upscaled images using the `ContentAreaToBitmap` method to obtain a bitmap of the OCR content area. For those who prefer to maintain the original image resolution and avoid upscaling, the article suggests setting the `TargetDPI` property of the `OcrInput` object to zero. This configuration disables automatic DPI adjustments, which are otherwise intended to improve OCR quality by enhancing resolution. The article provides links to documentation for further guidance on these methods and properties, aiding users in troubleshooting and managing coordinate adjustments to ensure accurate OCR results. ## Product Updates ### IronOCR Changelog & Updates | IronOCR https://ironsoftware.com/ocr/csharp/product-updates/changelog/ The IronOCR Changelog provides updates on the continuous enhancements and fixes implemented in the IronOCR product for C#. IronOCR is continuously developed by integrating community-driven feature requests and Google's Tesseract technology, ensuring high accuracy and stability. Recent updates have focused on improving the image filters, computer vision, and machine learning capabilities. The latest versions as of June 2025 include updates such as IronOCR v2025.6.2, which addressed memory leaks and improved PDF text layer alignment. The roadmap includes plans to expand IronOCR to multiple programming languages. Notable releases include the release of `IronOcr.Extensions.AdvancedScan` for Linux and macOS, enhancements in PDF processing, and performance optimizations in speed and memory management. The changelog also highlights the addition of new OCR methods like `ReadDocumentAdvanced`, improved language support, and bug fixes addressing various issues from memory leaks to compatibility across different platforms. Each release is detailed with version-specific improvements, bug fixes, and new features aimed at advancing the capabilities of OCR technology within the .NET ecosystem. ### Milestone: Up to 98% Memory Reduction for TIFF Processing | IronOCR https://ironsoftware.com/ocr/csharp/product-updates/ironocr-2025-9-memory-reduction-milestone/ IronOCR has achieved a significant milestone with its 2025.9 update, dramatically reducing memory usage for TIFF processing by up to 98%. Previously, the process required up to 3.7 GB of memory, which has now been slashed to just 77 MB. This substantial reduction not only enhances efficiency but also improves the overall performance and scalability of the software. The update addresses the needs of developers and businesses who manage large volumes of TIFF files, ensuring faster processing times and eliminating crashes commonly associated with high memory usage. Beyond reducing memory load, the update also optimizes processing speed, allowing for a more streamlined workflow. This advancement underscores IronOCR’s commitment to providing robust, reliable, and efficient OCR solutions. The development team has focused on refining the software’s architecture to support high-performance computing environments, making it a preferred choice for industries relying on document digitization and data extraction. By enhancing memory efficiency, IronOCR positions itself as a leader in OCR technology, offering significant benefits to users who demand high performance and stability in their document processing workflows. This milestone is a testament to IronOCR's innovation in OCR technology. ### Milestone: Introduces New Methods IronOcr.Extension.AdvancedScan package | IronOCR https://ironsoftware.com/ocr/csharp/product-updates/milestones-advancedscan-extension/ IronOCR has made significant advancements in optical character recognition (OCR) with the release of the IronOCR.Extension.AdvancedScan package. This latest update enhances text recognition capabilities for complex documents such as receipts, license plates, and passports. The AdvancedScan feature improves OCR accuracy for documents with varied layouts and image quality, ensuring precise data capture. Specifically, the ReadLicensePlate function simplifies vehicle identification by extracting license plate numbers, making it beneficial for parking and security systems. Additionally, the ReadPassport feature efficiently extracts essential information from the Machine Readable Zone of passports, aiding in identity verification and travel management. The new ReadDocumentAdvanced feature, launched in September 2023, offers advanced processing for complex and text-heavy documents, using computer vision to improve accuracy across various formats. It detects structured data within tables and allows for customized OCR in unstructured data areas with the NoOutlineRegion function. Furthermore, IronOCR provides a targeted re-read option to refine OCR accuracy by focusing on specific document areas, which is particularly useful for intricate layouts. These enhancements establish IronOCR as a leading OCR solution, offering unmatched accuracy and flexibility for industries like finance, logistics, identity verification, and security. Developers can try IronOCR for free to experience its capabilities. ### Milestone: Enables Precision with Passport Scanning | IronOCR https://ironsoftware.com/ocr/csharp/product-updates/milestones-passport-scanning/ IronOCR's latest release, version 2024.5, marks a significant milestone in optical character recognition (OCR) technology by transitioning from basic Tesseract OCR to advanced machine learning models. This update, highlighted by the IronOcr.Extension.AdvancedScan package, enhances text recognition capabilities, enabling IronOCR to handle complex tasks with greater accuracy. The upgrade allows for efficient processing of real-world images, including vehicle license plates and passport machine-readable zones, overcoming previous challenges with complex backgrounds and irregular text arrangements. The integration of machine learning empowers IronOCR to interpret text amidst diverse and noisy environments, making it particularly beneficial for industries requiring precision, such as security, transportation, and international travel. This advancement streamlines operations for sectors like government, finance, and HR by automating data extraction and minimizing human error. The introduction of passport scanning capabilities enhances KYC checks and identity verification, crucial for finance and travel industries. IronOCR's user-centric design ensures seamless integration into existing workflows, whether through API, standalone software, or cloud services, allowing customers to leverage its capabilities with minimal disruption. This development reflects the importance of interdisciplinary collaboration and marks a significant stride in document recognition technology, promising improved accuracy, adaptability, and speed for diverse applications.