Get Started with OCR in C# and VB.NET

// Import the necessary libraries
using System;
using IronOcr;  // Ensure the IronOCR library is installed for OCR functionality

namespace OCRExample
{
    public class Program
    {
        public static void Main(string[] args)
        {
            // Create an instance of the IronTesseract class for OCR processing
            var Ocr = new IronTesseract();

            // Define the path to the image that we want to process
            string imagePath = @"img\Screenshot.png";

            // Attempt to read text from the specified image using OCR
            try
            {
                // Read method performs the OCR operation on the image
                var result = Ocr.Read(imagePath);

                // Retrieve the text that was recognized from the image
                string text = result.Text;

                // Output the recognized text to the console
                Console.WriteLine("Extracted Text:");
                Console.WriteLine(text);
            }
            catch (Exception ex)
            {
                // Handle any exceptions that might occur during the OCR process
                // Output the exception message to the console for debugging purposes
                Console.WriteLine("An error occurred during OCR processing: " + ex.Message);
            }
        }
    }
}

using IronOcr;

// Initialize the IronTesseract OCR engine
var ocr = new IronTesseract();

// Create an OcrInput object for processing images
using var input = new OcrInput();

// Load an image or multiple images for OCR processing
// Ensure the image path is correct and accessible
input.AddImage("images/sample.jpeg");

// Perform OCR on the loaded images
OcrResult result = ocr.Read(input);

// Output the extracted text to the console
Console.WriteLine(result.Text);

// Import the necessary namespace from IronOcr.
using IronOcr;

// Create an instance of the IronTesseract class from IronOcr.
// This is the main class for performing OCR operations.
IronTesseract ocr = new IronTesseract();

// Create an instance of the OcrInput class using a 'using' statement.
// This ensures that the OcrInput is disposed of properly, freeing up resources.
using (OcrInput input = new OcrInput())
{
    try
    {
        // Load a PDF document into the OCR input.
        // "example.pdf" is the path to the PDF file.
        // "password" is used if the PDF is password protected.
        input.LoadPdf("example.pdf", "password");

        // Perform OCR on the input document.
        // The Read() method performs the optical character recognition.
        OcrResult result = ocr.Read(input);

        // Output the recognized text to the console.
        Console.WriteLine(result.Text);

        // Output the number of pages in the PDF document that were processed by OCR.
        Console.WriteLine($"{result.Pages.Count} Pages");
    }
    catch (Exception ex)
    {
        // If an error occurs (like file not found or wrong password), it will be caught here.
        Console.WriteLine($"An error occurred: {ex.Message}");
    }
}

// Note: This code snippet assumes that the IronOcr library is installed
// and properly referenced in the project. Ensure that you have
// the necessary licenses for using IronOcr if required.

// Importing the required IronOcr namespace to work with OCR functionalities
using IronOcr;

// Initialize an instance of IronTesseract for OCR processing
var ocr = new IronTesseract();

// Using statement to ensure that OcrInput resources are properly disposed of after use
using (var input = new OcrInput())
{
    // Specify the indices of the image frames to load from the TIFF file
    // Note: Indices are usually 0-based. If your library uses 1-based indices, adjust accordingly.
    int[] pageIndices = new int[] { 0, 1 };

    // Load specific frames of the multi-frame TIFF file for OCR processing
    // "multi-frame.tiff" is the file path; replace it with the actual path if different
    input.LoadImageFrames("multi-frame.tiff", pageIndices);

    // Perform OCR reading on the input frames and store the result
    OcrResult result = ocr.Read(input);

    // Output the recognized text to the console
    Console.WriteLine(result.Text);
}

using IronOcr;

// Initialize an instance of IronTesseract
IronTesseract ocr = new IronTesseract();

// Enable barcode reading functionality
ocr.Configuration.ReadBarCodes = true;

// Create an instance of OcrInput to load images for processing
using (OcrInput input = new OcrInput())
{
    // Load the image containing barcodes. Ensure the file path is correct.
    input.AddImage("img/Barcode.png");

    // Process the input image to extract text and barcode information
    OcrResult result = ocr.Read(input);

    // Iterate over the extracted barcodes and print their values
    foreach (var barcode in result.Barcodes)
    {
        // Output the value of the detected barcode
        Console.WriteLine(barcode.Value);

        // Optionally, more properties of the barcode, such as type and location, can be accessed and printed
        // Example:
        // Console.WriteLine($"Type: {barcode.Type}, Location: {barcode.Location}");
    }
}

using IronOcr;
using System;

// This code snippet demonstrates how to perform Optical Character Recognition (OCR) 
// on a specified area of an image using the IronTesseract library.

// Create a new instance of IronTesseract which is the core OCR engine
IronTesseract ocr = new IronTesseract();

// Create a new OCR input object. The 'using' statement ensures that resources are disposed of correctly.
using OcrInput input = new OcrInput();

// Define a rectangle to specify the content area to be read by OCR within the image.
// Dimensions are in pixels: X and Y are the top-left coordinates, Width and Height define the rectangle size.
var contentArea = new System.Drawing.Rectangle
{
    X = 215,        // Horizontal offset from the left of the image
    Y = 1250,       // Vertical offset from the top of the image
    Width = 1335,   // Width of the area to be scanned
    Height = 280    // Height of the area to be scanned
};

// Load the image into the OCR input object, using the defined content area.
// The image file name is "document.png". Ensure the file is in the correct path.
input.AddImage("document.png", contentArea);

// Perform OCR on the input using the IronTesseract engine.
// The 'Read' method processes the input and returns an OcrResult object which contains the recognized text.
OcrResult result = ocr.Read(input);

// Output the recognized text from the OCR result to the console.
Console.WriteLine(result.Text);

// Import the IronOcr library to utilize OCR functionalities
using IronOcr;

// Create an instance of IronTesseract to perform OCR
var ocr = new IronTesseract();

// Create an OcrInput for processing images. This needs to be disposed of appropriately.
using (var input = new OcrInput())
{
    // Specify the page indices for frames we want to load from a multi-page image
    int[] pageIndices = new int[] { 1, 2 };

    // Load specified image frames from the given multi-page TIFF image
    input.LoadImageFrames(@"img\Potter.tiff", pageIndices);

    // Improve image quality by removing digital noise
    input.DeNoise();

    // Correct any skewness or rotation in the image for better OCR accuracy
    input.Deskew();

    // Perform OCR on the input and get the result
    OcrResult result = ocr.Read(input);

    // Print the recognized text to the console
    Console.WriteLine(result.Text);
}

using IronOcr;

// Initialize the OCR engine
IronTesseract ocr = new IronTesseract();

// Using statement for OcrInput ensures resources are disposed of properly
using (OcrInput input = new OcrInput())
{
    // Set the title of the OCR input set
    input.Title = "Quarterly Report";

    // Load individual images for OCR processing
    input.AddImage("image1.jpeg");
    input.AddImage("image2.png");

    // Load specific frames from a GIF for OCR processing
    // The indices here specify the frames to be extracted
    int[] pageIndices = { 1, 2 };
    input.AddPdfPages("image3.gif", pageIndices);
    
    // Perform OCR on the input images
    OcrResult result = ocr.Read(input);

    // Save the OCR output as a searchable PDF
    result.SaveAsSearchablePdf("searchable.pdf");
}

using IronOcr;

// This script performs Optical Character Recognition (OCR) on specific pages of a multi-page TIFF file 
// and converts them into a searchable PDF using the IronOCR library.

// Create an instance of IronTesseract for OCR processing.
var ocr = new IronTesseract();

// Initialize OCR input processing. The OcrInput class is a disposable resource.
using (var input = new OcrInput())
{
    // Specify the image frames to load from the multi-page TIFF file.
    // Here, we are loading the first and second pages (1-based index).
    var pageIndices = new int[] { 1, 2 };

    // Load specified frames from the TIFF image into the OCR input.
    // This method will extract the specified frames and prepare them for OCR.
    input.LoadImageFrames("example.tiff", pageIndices);

    // Perform OCR on the loaded frames.
    // The result is then saved as a searchable PDF, where the text content can be searched.
    var result = ocr.Read(input);
    result.SaveAsSearchablePdf("searchable.pdf");
}

// This code demonstrates the use of the IronOcr library to perform OCR (Optical Character Recognition)
// on an image file and save the result in the HOCR format, which is an HTML-based representation
// of the OCR data.

using IronOcr;

// Instantiate an IronTesseract object, which is the main class for OCR functionality.
var ocr = new IronTesseract();

// Create an OcrInput object, which represents the input data for OCR.
// Use a 'using' statement for automatic disposal of resources once processing is complete.
using (var input = new OcrInput())
{
    // Optionally set the title of the input, which can be used for referencing in output.
    input.Title = "Html Title";
    
    // Load the image file that you want to process with OCR.
    input.AddImage("image1.jpeg");

    // Perform OCR on the input data, obtaining an OcrResult object.
    OcrResult result = ocr.Read(input);
    
    // Save the OCR result as an HOCR file.
    // HOCR is an HTML-based format that includes OCR text positions and content.
    result.SaveAsHocrFile("results.html");
}

// Import the necessary namespace for OCR functionality.
using IronOcr;

// Create a new instance of the IronTesseract for optical character recognition (OCR).
var ocr = new IronTesseract();

// Properly manage the OcrInput object within a using block to ensure resources are released after use.
using (var input = new OcrInput())
{
    // Load the image from which text needs to be extracted.
    // Ensure the image path is correct and the file exists at the given location.
    input.AddImage("LowQuality.jpeg");

    // Apply digital noise reduction to improve OCR accuracy.
    input.DeNoise();

    // Correct the rotation and perspective of the image if needed.
    // Deskewing is useful for images that are slightly rotated or skewed.
    input.Deskew();

    // Perform OCR on the input image to extract text.
    OcrResult result = ocr.Read(input);

    // Output the recognized text to the console.
    // Check if OCR extraction was successful and result is not null to avoid runtime exceptions.
    if (result != null)
    {
        Console.WriteLine(result.Text);
    }
    else
    {
        Console.WriteLine("OCR failed to recognize the text.");
    }
}

// Reference to the path of the source file that demonstrates setting language packs for OCR
using IronOcr;

// PM> Install IronOcr.Languages.Arabic
// Ensure you have the necessary NuGet package for Arabic language support.

// Create a new instance of IronTesseract for Optical Character Recognition (OCR)
IronTesseract ocr = new IronTesseract();

// Set the language to Arabic
ocr.Language = OcrLanguage.Arabic;

// Initialize a new OcrInput instance
using (OcrInput input = new OcrInput())
{
    // Define the indices of the image frames to be loaded (in this example, frame indices start at 1 not 0)
    var pageIndices = new int[] { 1, 2 };

    // Load specific frames of a multi-frame image from the specified path using the defined indices
    input.LoadImageFrames("img/arabic.gif", pageIndices);

    // Note: Add image filters if needed to improve OCR accuracy; for this example, no filters are added
    // Even though the input is of very low quality, IronTesseract can read what conventional Tesseract cannot.

    // Perform the OCR reading process on the input image
    OcrResult result = ocr.Read(input);

    // Save the OCR result, which cannot be easily printed to console due to Windows limitations with Arabic text, to a file
    result.SaveAsTextFile("arabic.txt");
}

// Reference to the path of the source file that demonstrates multi-language OCR
using IronOcr;

// IronOCR provides OCR (Optical Character Recognition) capabilities for .NET applications.

// To use the Chinese Simplified language pack, uncomment and run the following command in the Package Manager Console:
// PM> Install-Package IronOcr.Languages.ChineseSimplified

// Create a new instance of IronTesseract to perform OCR operations.
IronTesseract ocr = new IronTesseract();

// Set the primary language for OCR to Chinese Simplified.
ocr.Language = OcrLanguage.ChineseSimplified;

// Add a secondary language (English) to improve recognition for documents with mixed languages.
ocr.AddSecondaryLanguage(OcrLanguage.English);

// Use the "using" statement to ensure that resources are disposed of correctly after usage.
using (OcrInput input = new OcrInput())
{
    // Load a PDF document for OCR processing.
    input.AddPdf("multi-language.pdf");

    // Perform OCR on the loaded PDF and store the result.
    OcrResult result = ocr.Read(input);

    // Check if OCR is successful before saving the result
    if (result.Success)
    {
        // Save the recognized text to a text file.
        result.SaveAsTextFile("results.txt");
    } 
    else
    {
        // Handle the OCR failure case, e.g., log or provide feedback.
        Console.WriteLine("OCR failed to recognize the text.");
    }
}

// Reference to the path of the source file demonstrating detailed OCR result object usage
using IronOcr;

// Initialize IronTesseract for OCR tasks
IronTesseract ocr = new IronTesseract();

// Enable reading barcodes from images
ocr.Configuration.ReadBarCodes = true;

// Using statement ensures OcrInput is disposed correctly after use
using (OcrInput input = new OcrInput())
{
    // Specify frames/pages of the multi-frame image to analyze (1-based index)
    int[] pageIndices = new int[] { 1, 2 };

    // Load specified pages of the image from a TIFF file
    input.LoadImageFrames(@"img\sample.tiff", pageIndices);

    // Perform OCR on the input image(s) and get the results
    OcrResult result = ocr.Read(input);

    // Access recognized pages from the OCR result
    var pages = result.Pages;

    // Check if any pages were recognized to avoid errors while accessing
    if (pages.Count > 0)
    {
        // Access words on the first recognized page
        var words = pages[0].Words;
        // Add logic here to process the words if needed
    }

    // Access recognized barcodes from the OCR result
    var barcodes = result.Barcodes;

    // Add logic here to process the barcodes if needed

    // Explore a detailed API offering various OCR result details:
    // - Pages, Blocks, Paragraphs, Lines, Words, Chars
    // - Image Export, Font Coordinates, Statistical Data, Tables
}