API OCR Microsoft Azure vs IronOCR para España: AEAT, Facturae y LOPDGDD

La brecha del preprocesamiento

El preprocesamiento no es una opción de configuración que se pueda omitir. Es la diferencia entre la precisión en producción y un resultado inutilizable en documentos reales. El archivo fuente image-preprocessing-tesseract.cs para este envoltorio documenta el flujo de trabajo manual completo:

// Tesseract requires every one of these steps to be written manually
public static string ExtractWithPreprocessing(string imagePath)
{
    using (var original = new Bitmap(imagePath))
    {
        // Step 2: Convert to grayscale (~25 lines)
        using (var grayscale = ConvertToGrayscale(original))
        {
            // Step 3: Apply contrast enhancement (~15 lines)
            using (var enhanced = EnhanceContrast(grayscale))
            {
                // Step 4: Binarize — convert to black and white (~15 lines)
                using (var binarized = Binarize(enhanced, 128))
                {
                    // Step 5: Remove noise (~25 lines)
                    using (var denoised = RemoveNoise(binarized))
                    {
                        // Step 6: Inclinación if rotated (~50 lines, simplified)
                        using (var deskewed = Deskew(denoised))
                        {
                            // Step 7: Scale to 300 DPI (~20 lines)
                            using (var scaled = ScaleToDpi(deskewed, 300))
                            {
                                return RunTesseract(scaled);  // Save to temp file, load Pix, process
                            }
                        }
                    }
                }
            }
        }
    }
}

// Tesseract requires every one of these steps to be written manually
public static string ExtractWithPreprocessing(string imagePath)
{
    using (var original = new Bitmap(imagePath))
    {
        // Step 2: Convert to grayscale (~25 lines)
        using (var grayscale = ConvertToGrayscale(original))
        {
            // Step 3: Apply contrast enhancement (~15 lines)
            using (var enhanced = EnhanceContrast(grayscale))
            {
                // Step 4: Binarize — convert to black and white (~15 lines)
                using (var binarized = Binarize(enhanced, 128))
                {
                    // Step 5: Remove noise (~25 lines)
                    using (var denoised = RemoveNoise(binarized))
                    {
                        // Step 6: Inclinación if rotated (~50 lines, simplified)
                        using (var deskewed = Deskew(denoised))
                        {
                            // Step 7: Scale to 300 DPI (~20 lines)
                            using (var scaled = ScaleToDpi(deskewed, 300))
                            {
                                return RunTesseract(scaled);  // Save to temp file, load Pix, process
                            }
                        }
                    }
                }
            }
        }
    }
}

Imports System.Drawing

Public Class ImageProcessor
    Public Shared Function ExtractWithPreprocessing(imagePath As String) As String
        Using original As New Bitmap(imagePath)
            ' Step 2: Convert to grayscale (~25 lines)
            Using grayscale As Bitmap = ConvertToGrayscale(original)
                ' Step 3: Apply contrast enhancement (~15 lines)
                Using enhanced As Bitmap = EnhanceContrast(grayscale)
                    ' Step 4: Binarize — convert to black and white (~15 lines)
                    Using binarized As Bitmap = Binarize(enhanced, 128)
                        ' Step 5: Remove noise (~25 lines)
                        Using denoised As Bitmap = RemoveNoise(binarized)
                            ' Step 6: Deskew if rotated (~50 lines, simplified)
                            Using deskewed As Bitmap = Deskew(denoised)
                                ' Step 7: Scale to 300 DPI (~20 lines)
                                Using scaled As Bitmap = ScaleToDpi(deskewed, 300)
                                    Return RunTesseract(scaled)  ' Save to temp file, load Pix, process
                                End Using
                            End Using
                        End Using
                    End Using
                End Using
            End Using
        End Using
    End Function

    ' Placeholder methods for the image processing steps
    Private Shared Function ConvertToGrayscale(original As Bitmap) As Bitmap
        ' Implementation goes here
        Return original
    End Function

    Private Shared Function EnhanceContrast(grayscale As Bitmap) As Bitmap
        ' Implementation goes here
        Return grayscale
    End Function

    Private Shared Function Binarize(enhanced As Bitmap, threshold As Integer) As Bitmap
        ' Implementation goes here
        Return enhanced
    End Function

    Private Shared Function RemoveNoise(binarized As Bitmap) As Bitmap
        ' Implementation goes here
        Return binarized
    End Function

    Private Shared Function Deskew(denoised As Bitmap) As Bitmap
        ' Implementation goes here
        Return denoised
    End Function

    Private Shared Function ScaleToDpi(deskewed As Bitmap, dpi As Integer) As Bitmap
        ' Implementation goes here
        Return deskewed
    End Function

    Private Shared Function RunTesseract(scaled As Bitmap) As String
        ' Implementation goes here
        Return String.Empty
    End Function
End Class

Esa estructura interna de using no es un modelo — cada paso es una implementación real: una matriz de color para escala de grises, iteración de píxeles para contraste, otra iteración de píxeles para binarización, un filtro de mediana para ruido, y un sustituto de transformación Hough para corregir la desviación. Las notas fuente de image-preprocessing-tesseract.cs directas: "Corrección de desviación simplificada — la implementación real necesita transformación Hough. Esto normalmente requiere OpenCV o una biblioteca similar."

En total: aproximadamente 180 líneas antes de que se lea una sola palabra. La tabla de precisión que aparece en ese mismo archivo muestra por qué es necesaria la inversión: Tesseract, sin preprocesamiento, en un documento con una inclinación de 5 grados produce una precisión del 60-70%, mientras que los datos de entrada preprocesados ​​correctamente alcanzan más del 90%.

Comparación detallada de características

Enfoque del teseracto

El flujo de preprocesamiento completo mostrado en image-preprocessing-tesseract.cs requiere System.Drawing.Common (solo Windows) o una biblioteca adicional multiplataforma como ImageSharp. La implementación de Inclinación nota por sí sola que está simplificada — un algoritmo de detección de desviación en grado de producción requiere una transformación de líneas Hough, lo cual típicamente significa incluir OpenCvSharp4 como una dependencia adicional:

// image-preprocessing-tesseract.cs — the actual implementation pattern
private static Bitmap ConvertToGrayscale(Bitmap original)
{
    var result = new Bitmap(original.Width, original.Height);
    using (var graphics = Graphics.FromImage(result))
    {
        var colorMatrix = new ColorMatrix(new float[][]
        {
            new float[] { 0.299f, 0.299f, 0.299f, 0, 0 },
            new float[] { 0.587f, 0.587f, 0.587f, 0, 0 },
            new float[] { 0.114f, 0.114f, 0.114f, 0, 0 },
            new float[] { 0, 0, 0, 1, 0 },
            new float[] { 0, 0, 0, 0, 1 }
        });
        using (var attributes = new ImageAttributes())
        {
            attributes.SetColorMatrix(colorMatrix);
            graphics.DrawImage(original,
                new Rectangle(0, 0, original.Width, original.Height),
                0, 0, original.Width, original.Height,
                GraphicsUnit.Pixel, attributes);
        }
    }
    return result;
}

private static Bitmap EnhanceContrast(Bitmap image)
{
    var result = new Bitmap(image.Width, image.Height);
    float contrast = 1.5f;
    for (int y = 0; y < image.Height; y++)
    {
        for (int x = 0; x < image.Width; x++)
        {
            var pixel = image.GetPixel(x, y);
            int r = Clamp((int)((pixel.R - 128) * contrast + 128));
            int g = Clamp((int)((pixel.G - 128) * contrast + 128));
            int b = Clamp((int)((pixel.B - 128) * contrast + 128));
            result.SetPixel(x, y, Color.FromArgb(r, g, b));
        }
    }
    return result;
}

private static Bitmap RemoveNoise(Bitmap image)
{
    var result = new Bitmap(image.Width, image.Height);
    int kernelSize = 3;
    int radius = kernelSize / 2;
    for (int y = radius; y < image.Height - radius; y++)
    {
        for (int x = radius; x < image.Width - radius; x++)
        {
            var pixels = new List<int>();
            for (int ky = -radius; ky <= radius; ky++)
                for (int kx = -radius; kx <= radius; kx++)
                    pixels.Add(image.GetPixel(x + kx, y + ky).R);
            pixels.Sort();
            int median = pixels[pixels.Count / 2];
            result.SetPixel(x, y, Color.FromArgb(median, median, median));
        }
    }
    return result;
}

// After all preprocessing, save to temp file — Tesseract requires a file path
private static string RunTesseract(Bitmap preprocessed)
{
    string tempPath = Path.GetTempFileName() + ".png";
    try
    {
        preprocessed.Save(tempPath, ImageFormat.Png);
        using (var engine = new TesseractEngine(TessDataPath, "eng", EngineMode.Default))
        using (var img = Pix.LoadFromFile(tempPath))
        using (var page = engine.Process(img))
            return page.GetText();
    }
    finally
    {
        if (File.Exists(tempPath)) File.Delete(tempPath);
    }
}

// image-preprocessing-tesseract.cs — the actual implementation pattern
private static Bitmap ConvertToGrayscale(Bitmap original)
{
    var result = new Bitmap(original.Width, original.Height);
    using (var graphics = Graphics.FromImage(result))
    {
        var colorMatrix = new ColorMatrix(new float[][]
        {
            new float[] { 0.299f, 0.299f, 0.299f, 0, 0 },
            new float[] { 0.587f, 0.587f, 0.587f, 0, 0 },
            new float[] { 0.114f, 0.114f, 0.114f, 0, 0 },
            new float[] { 0, 0, 0, 1, 0 },
            new float[] { 0, 0, 0, 0, 1 }
        });
        using (var attributes = new ImageAttributes())
        {
            attributes.SetColorMatrix(colorMatrix);
            graphics.DrawImage(original,
                new Rectangle(0, 0, original.Width, original.Height),
                0, 0, original.Width, original.Height,
                GraphicsUnit.Pixel, attributes);
        }
    }
    return result;
}

private static Bitmap EnhanceContrast(Bitmap image)
{
    var result = new Bitmap(image.Width, image.Height);
    float contrast = 1.5f;
    for (int y = 0; y < image.Height; y++)
    {
        for (int x = 0; x < image.Width; x++)
        {
            var pixel = image.GetPixel(x, y);
            int r = Clamp((int)((pixel.R - 128) * contrast + 128));
            int g = Clamp((int)((pixel.G - 128) * contrast + 128));
            int b = Clamp((int)((pixel.B - 128) * contrast + 128));
            result.SetPixel(x, y, Color.FromArgb(r, g, b));
        }
    }
    return result;
}

private static Bitmap RemoveNoise(Bitmap image)
{
    var result = new Bitmap(image.Width, image.Height);
    int kernelSize = 3;
    int radius = kernelSize / 2;
    for (int y = radius; y < image.Height - radius; y++)
    {
        for (int x = radius; x < image.Width - radius; x++)
        {
            var pixels = new List<int>();
            for (int ky = -radius; ky <= radius; ky++)
                for (int kx = -radius; kx <= radius; kx++)
                    pixels.Add(image.GetPixel(x + kx, y + ky).R);
            pixels.Sort();
            int median = pixels[pixels.Count / 2];
            result.SetPixel(x, y, Color.FromArgb(median, median, median));
        }
    }
    return result;
}

// After all preprocessing, save to temp file — Tesseract requires a file path
private static string RunTesseract(Bitmap preprocessed)
{
    string tempPath = Path.GetTempFileName() + ".png";
    try
    {
        preprocessed.Save(tempPath, ImageFormat.Png);
        using (var engine = new TesseractEngine(TessDataPath, "eng", EngineMode.Default))
        using (var img = Pix.LoadFromFile(tempPath))
        using (var page = engine.Process(img))
            return page.GetText();
    }
    finally
    {
        if (File.Exists(tempPath)) File.Delete(tempPath);
    }
}

Imports System.Drawing
Imports System.Drawing.Imaging
Imports Tesseract
Imports System.IO

' image-preprocessing-tesseract.vb — the actual implementation pattern
Private Shared Function ConvertToGrayscale(original As Bitmap) As Bitmap
    Dim result As New Bitmap(original.Width, original.Height)
    Using graphics As Graphics = Graphics.FromImage(result)
        Dim colorMatrix As New ColorMatrix(New Single()() {
            New Single() {0.299F, 0.299F, 0.299F, 0, 0},
            New Single() {0.587F, 0.587F, 0.587F, 0, 0},
            New Single() {0.114F, 0.114F, 0.114F, 0, 0},
            New Single() {0, 0, 0, 1, 0},
            New Single() {0, 0, 0, 0, 1}
        })
        Using attributes As New ImageAttributes()
            attributes.SetColorMatrix(colorMatrix)
            graphics.DrawImage(original, New Rectangle(0, 0, original.Width, original.Height), 0, 0, original.Width, original.Height, GraphicsUnit.Pixel, attributes)
        End Using
    End Using
    Return result
End Function

Private Shared Function EnhanceContrast(image As Bitmap) As Bitmap
    Dim result As New Bitmap(image.Width, image.Height)
    Dim contrast As Single = 1.5F
    For y As Integer = 0 To image.Height - 1
        For x As Integer = 0 To image.Width - 1
            Dim pixel As Color = image.GetPixel(x, y)
            Dim r As Integer = Clamp(CInt((pixel.R - 128) * contrast + 128))
            Dim g As Integer = Clamp(CInt((pixel.G - 128) * contrast + 128))
            Dim b As Integer = Clamp(CInt((pixel.B - 128) * contrast + 128))
            result.SetPixel(x, y, Color.FromArgb(r, g, b))
        Next
    Next
    Return result
End Function

Private Shared Function RemoveNoise(image As Bitmap) As Bitmap
    Dim result As New Bitmap(image.Width, image.Height)
    Dim kernelSize As Integer = 3
    Dim radius As Integer = kernelSize \ 2
    For y As Integer = radius To image.Height - radius - 1
        For x As Integer = radius To image.Width - radius - 1
            Dim pixels As New List(Of Integer)()
            For ky As Integer = -radius To radius
                For kx As Integer = -radius To radius
                    pixels.Add(image.GetPixel(x + kx, y + ky).R)
                Next
            Next
            pixels.Sort()
            Dim median As Integer = pixels(pixels.Count \ 2)
            result.SetPixel(x, y, Color.FromArgb(median, median, median))
        Next
    Next
    Return result
End Function

' After all preprocessing, save to temp file — Tesseract requires a file path
Private Shared Function RunTesseract(preprocessed As Bitmap) As String
    Dim tempPath As String = Path.GetTempFileName() & ".png"
    Try
        preprocessed.Save(tempPath, ImageFormat.Png)
        Using engine As New TesseractEngine(TessDataPath, "eng", EngineMode.Default)
            Using img As Pix = Pix.LoadFromFile(tempPath)
                Using page As Page = engine.Process(img)
                    Return page.GetText()
                End Using
            End Using
        End Using
    Finally
        If File.Exists(tempPath) Then File.Delete(tempPath)
    End Try
End Function

Private Shared Function Clamp(value As Integer) As Integer
    Return Math.Max(0, Math.Min(255, value))
End Function

Private Const TessDataPath As String = "path_to_tessdata" ' Define the path to tessdata directory

Este es código real de los archivos fuente, no un caso extremo artificial. El método de iteración de píxeles para la eliminación de contraste y ruido se ejecuta en O(n²) sobre cada píxel. La función de guardar y cargar archivos temporales no es opcional; Pix.LoadFromFile requiere una ruta de archivo en disco. Para una aplicación que procesa 1.000 documentos escaneados al día, esto supone una sobrecarga cuantificable que se suma al tiempo de OCR.

Enfoque de IronOCR

El mismo preprocesamiento en IronOCR es una secuencia de llamadas de métodos en OcrInput:

// dotnet add package IronOcr
using IronOcr;

using var input = new OcrInput();
input.LoadImage("low-quality-scan.jpg");

input.Deskew();           // Detects and corrects skew angle automatically
input.DeNoise();          // Removes scanner artifacts and specks
input.Contrast();         // Enhances contrast for character separation
input.Binarize();         // Converts to black and white with adaptive threshold
input.EnhanceResolution(300);  // Scales to 300 DPI for optimal recognition

var result = new IronTesseract().Read(input);
Console.WriteLine($"Confidence: {result.Confidence}%");
Console.WriteLine(result.Text);

// dotnet add package IronOcr
using IronOcr;

using var input = new OcrInput();
input.LoadImage("low-quality-scan.jpg");

input.Deskew();           // Detects and corrects skew angle automatically
input.DeNoise();          // Removes scanner artifacts and specks
input.Contrast();         // Enhances contrast for character separation
input.Binarize();         // Converts to black and white with adaptive threshold
input.EnhanceResolution(300);  // Scales to 300 DPI for optimal recognition

var result = new IronTesseract().Read(input);
Console.WriteLine($"Confidence: {result.Confidence}%");
Console.WriteLine(result.Text);

Imports IronOcr

Dim input As New OcrInput()
input.LoadImage("low-quality-scan.jpg")

input.Deskew()           ' Detects and corrects skew angle automatically
input.DeNoise()          ' Removes scanner artifacts and specks
input.Contrast()         ' Enhances contrast for character separation
input.Binarize()         ' Converts to black and white with adaptive threshold
input.EnhanceResolution(300)  ' Scales to 300 DPI for optimal recognition

Using input
    Dim result = New IronTesseract().Read(input)
    Console.WriteLine($"Confidence: {result.Confidence}%")
    Console.WriteLine(result.Text)
End Using

No se permiten archivos temporales. Sin iteración de píxeles. No depende de System.Drawing.Common ni de OpenCvSharp4. La guía de corrección de la calidad de imagen y la guía de corrección de la orientación de la imagen cubren todo el catálogo de filtros; hay más de 15 disponibles. El ejemplo de filtros de imagen muestra el proceso de escaneo de baja calidad de principio a fin.

Para la mayoría de los documentos del mundo real, la lectura predeterminada aplica un preprocesamiento automático inteligente sin ninguna llamada explícita a filtros:

// Automatic preprocessing applied internally — no explicit filter calls needed
var text = new IronTesseract().Read("scanned-invoice.jpg").Text;

// Automatic preprocessing applied internally — no explicit filter calls needed
var text = new IronTesseract().Read("scanned-invoice.jpg").Text;

Imports IronTesseract

' Automatic preprocessing applied internally — no explicit filter calls needed
Dim text As String = New IronTesseract().Read("scanned-invoice.jpg").Text

Con una entrada limpia y de alta resolución (DPI), esto no tiene ningún coste. En una fotografía tomada con un teléfono móvil a 72 ppp, el motor de procesamiento ajusta la escala, mejora y normaliza la imagen antes de reconocer el texto.

Enfoque del teseracto

El archivo pdf-ocr-processing-tesseract.cs documenta tres opciones de bibliotecas de renderizado PDF separadas — PdfiumViewer, PDFtoImage, y Docnet.Core — cada una con diferentes cadenas de dependencias y compensaciones. El patrón de PdfiumViewer que se muestra en ese archivo es representativo:

// Tesseract PDF processing — from pdf-ocr-processing-tesseract.cs
// Requires: PdfiumViewer NuGet + pdfium native DLL deployed to application directory
// NuGet: PdfiumViewer, PdfiumViewer.Native.x64

using PdfiumViewer;

public static string ExtractFromPdfWithPdfium(string pdfPath)
{
    var results = new List<string>();

    using (var document = PdfDocument.Load(pdfPath))
    {
        using (var engine = new TesseractEngine(TessDataPath, "eng", EngineMode.Default))
        {
            for (int pageIndex = 0; pageIndex < document.PageCount; pageIndex++)
            {
                // Render page to image at 300 DPI
                using (var pageImage = document.Render(pageIndex, 300, 300,
                    PdfRenderFlags.CorrectFromDpi))
                {
                    // Tesseract requires a file path — must write to disk first
                    string tempPath = Path.GetTempFileName() + ".png";
                    try
                    {
                        pageImage.Save(tempPath);
                        using (var img = Pix.LoadFromFile(tempPath))
                        using (var page = engine.Process(img))
                            results.Add(page.GetText());
                    }
                    finally
                    {
                        File.Delete(tempPath);  // Must clean up or disk fills
                    }
                }
            }
        }
    }

    return string.Join("\n\n--- Page Break ---\n\n", results);
}

// Tesseract PDF processing — from pdf-ocr-processing-tesseract.cs
// Requires: PdfiumViewer NuGet + pdfium native DLL deployed to application directory
// NuGet: PdfiumViewer, PdfiumViewer.Native.x64

using PdfiumViewer;

public static string ExtractFromPdfWithPdfium(string pdfPath)
{
    var results = new List<string>();

    using (var document = PdfDocument.Load(pdfPath))
    {
        using (var engine = new TesseractEngine(TessDataPath, "eng", EngineMode.Default))
        {
            for (int pageIndex = 0; pageIndex < document.PageCount; pageIndex++)
            {
                // Render page to image at 300 DPI
                using (var pageImage = document.Render(pageIndex, 300, 300,
                    PdfRenderFlags.CorrectFromDpi))
                {
                    // Tesseract requires a file path — must write to disk first
                    string tempPath = Path.GetTempFileName() + ".png";
                    try
                    {
                        pageImage.Save(tempPath);
                        using (var img = Pix.LoadFromFile(tempPath))
                        using (var page = engine.Process(img))
                            results.Add(page.GetText());
                    }
                    finally
                    {
                        File.Delete(tempPath);  // Must clean up or disk fills
                    }
                }
            }
        }
    }

    return string.Join("\n\n--- Page Break ---\n\n", results);
}

Imports PdfiumViewer
Imports Tesseract

Public Shared Function ExtractFromPdfWithPdfium(pdfPath As String) As String
    Dim results As New List(Of String)()

    Using document = PdfDocument.Load(pdfPath)
        Using engine = New TesseractEngine(TessDataPath, "eng", EngineMode.Default)
            For pageIndex As Integer = 0 To document.PageCount - 1
                ' Render page to image at 300 DPI
                Using pageImage = document.Render(pageIndex, 300, 300, PdfRenderFlags.CorrectFromDpi)
                    ' Tesseract requires a file path — must write to disk first
                    Dim tempPath As String = Path.GetTempFileName() & ".png"
                    Try
                        pageImage.Save(tempPath)
                        Using img = Pix.LoadFromFile(tempPath)
                            Using page = engine.Process(img)
                                results.Add(page.GetText())
                            End Using
                        End Using
                    Finally
                        File.Delete(tempPath)  ' Must clean up or disk fills
                    End Try
                End Using
            Next
        End Using
    End Using

    Return String.Join(vbCrLf & vbCrLf & "--- Page Break ---" & vbCrLf & vbCrLf, results)
End Function

Las notas fuente de pdf-ocr-processing-tesseract.cs de manera directa apuntan a la cadena de dependencias: "Tesseract: Apache 2.0, PdfiumViewer: BSD, iText: AGPL o comercial, GhostScript: AGPL o comercial." Ese último elemento importa en contextos empresariales — la licencia AGPL de GhostScript requiere que su aplicación sea de código abierto a menos que compre una licencia comercial de GhostScript.

Los archivos PDF protegidos con contraseña añaden una capa adicional de seguridad. La clase PasswordProtectedPdf en el mismo archivo arroja NotImplementedException con el comentario: "Requiere biblioteca PDF con soporte de cifrado (iText, PDFSharp). Tesseract no puede descifrar archivos PDF. Por lo tanto, la protección con contraseña implica una cuarta dependencia con sus propias consideraciones de licencia.

Enfoque de IronOCR

IronOCR lee archivos PDF de forma nativa, incluidos los PDF escaneados, los PDF de texto digital, los PDF de contenido mixto y los PDF protegidos con contraseña:

// dotnet add package IronOcr
using IronOcr;

// Scanned PDF — direct load, no rendering library required
var result = new IronTesseract().Read("scanned-contract.pdf");
Console.WriteLine(result.Text);

// Password-protected PDF — one additional parameter
using var input = new OcrInput();
input.LoadPdf("encrypted.pdf", Password: "secret");
var protectedResult = new IronTesseract().Read(input);

// Specific page range from a 200-page document
using var rangeInput = new OcrInput();
rangeInput.LoadPdfPages("large-report.pdf", 1, 10);
var rangeResult = new IronTesseract().Read(rangeInput);

// Create searchable PDF with embedded text layer
var searchable = new IronTesseract().Read("scanned-invoice.pdf");
searchable.SaveAsSearchablePdf("searchable-invoice.pdf");

// dotnet add package IronOcr
using IronOcr;

// Scanned PDF — direct load, no rendering library required
var result = new IronTesseract().Read("scanned-contract.pdf");
Console.WriteLine(result.Text);

// Password-protected PDF — one additional parameter
using var input = new OcrInput();
input.LoadPdf("encrypted.pdf", Password: "secret");
var protectedResult = new IronTesseract().Read(input);

// Specific page range from a 200-page document
using var rangeInput = new OcrInput();
rangeInput.LoadPdfPages("large-report.pdf", 1, 10);
var rangeResult = new IronTesseract().Read(rangeInput);

// Create searchable PDF with embedded text layer
var searchable = new IronTesseract().Read("scanned-invoice.pdf");
searchable.SaveAsSearchablePdf("searchable-invoice.pdf");

Imports IronOcr

' Scanned PDF — direct load, no rendering library required
Dim result = New IronTesseract().Read("scanned-contract.pdf")
Console.WriteLine(result.Text)

' Password-protected PDF — one additional parameter
Using input As New OcrInput()
    input.LoadPdf("encrypted.pdf", Password:="secret")
    Dim protectedResult = New IronTesseract().Read(input)
End Using

' Specific page range from a 200-page document
Using rangeInput As New OcrInput()
    rangeInput.LoadPdfPages("large-report.pdf", 1, 10)
    Dim rangeResult = New IronTesseract().Read(rangeInput)
End Using

' Create searchable PDF with embedded text layer
Dim searchable = New IronTesseract().Read("scanned-invoice.pdf")
searchable.SaveAsSearchablePdf("searchable-invoice.pdf")

No dispone de biblioteca de renderizado de PDF. No se permiten archivos temporales. No se tienen en cuenta las licencias AGPL. La guía práctica para la entrada de archivos PDF abarca todas las variantes de entrada de archivos PDF. El PDF con instrucciones y función de búsqueda explica la salida de la capa de texto. Para los equipos que desarrollan flujos de procesamiento de documentos, la página de casos de uso de OCR para PDF proporciona patrones de arquitectura de producción.

Los métodos de preprocesamiento funcionan de manera idéntica en la entrada de PDF, permitiendo las mismas llamadas de input.Deskew(), input.DeNoise(), input.EnhanceResolution() en PDFs escaneados sin ningún paso de conversión intermedio.

Enfoque del teseracto

El archivo multi-language-tesseract.cs documenta los tamaños de archivos de idioma y el proceso de gestión:

// Must exist before initialization:
// ./tessdata/eng.traineddata   (~15 MB)
// ./tessdata/fra.traineddata   (~15 MB)
// ./tessdata/deu.traineddata   (~15 MB)
// ./tessdata/chi_sim.traineddata  (~45 MB)
// ./tessdata/jpn.traineddata   (~40 MB)
// 10 languages = 200-300 MB to download and manage

public string SafeMultiLanguageOcr(string imagePath, string[] languages)
{
    // Check presence before attempting — runtime failures are worse
    foreach (var lang in languages)
    {
        if (!File.Exists(Path.Combine(TessDataPath, $"{lang}.traineddata")))
        {
            throw new FileNotFoundException(
                $"Missing {lang}.traineddata in {TessDataPath}. " +
                "Download from https://github.com/tesseract-ocr/tessdata");
        }
    }

    var langString = string.Join("+", languages);  // e.g., "eng+fra+deu"
    using var engine = new TesseractEngine(TessDataPath, langString, EngineMode.Default);
    using var img = Pix.LoadFromFile(imagePath);
    using var page = engine.Process(img);
    return page.GetText();
}

// Must exist before initialization:
// ./tessdata/eng.traineddata   (~15 MB)
// ./tessdata/fra.traineddata   (~15 MB)
// ./tessdata/deu.traineddata   (~15 MB)
// ./tessdata/chi_sim.traineddata  (~45 MB)
// ./tessdata/jpn.traineddata   (~40 MB)
// 10 languages = 200-300 MB to download and manage

public string SafeMultiLanguageOcr(string imagePath, string[] languages)
{
    // Check presence before attempting — runtime failures are worse
    foreach (var lang in languages)
    {
        if (!File.Exists(Path.Combine(TessDataPath, $"{lang}.traineddata")))
        {
            throw new FileNotFoundException(
                $"Missing {lang}.traineddata in {TessDataPath}. " +
                "Download from https://github.com/tesseract-ocr/tessdata");
        }
    }

    var langString = string.Join("+", languages);  // e.g., "eng+fra+deu"
    using var engine = new TesseractEngine(TessDataPath, langString, EngineMode.Default);
    using var img = Pix.LoadFromFile(imagePath);
    using var page = engine.Process(img);
    return page.GetText();
}

Imports System.IO
Imports Tesseract

Public Function SafeMultiLanguageOcr(imagePath As String, languages As String()) As String
    ' Check presence before attempting — runtime failures are worse
    For Each lang In languages
        If Not File.Exists(Path.Combine(TessDataPath, $"{lang}.traineddata")) Then
            Throw New FileNotFoundException(
                $"Missing {lang}.traineddata in {TessDataPath}. " &
                "Download from https://github.com/tesseract-ocr/tessdata")
        End If
    Next

    Dim langString = String.Join("+", languages)  ' e.g., "eng+fra+deu"
    Using engine As New TesseractEngine(TessDataPath, langString, EngineMode.Default)
        Using img As Pix = Pix.LoadFromFile(imagePath)
            Using page As Page = engine.Process(img)
                Return page.GetText()
            End Using
        End Using
    End Using
End Function

La comprobación de existencia de archivo defensiva no es paranoia — un archivo .traineddata faltante arroja TesseractException: Failed to initialise tesseract engine con un mensaje que no siempre identifica claramente qué archivo falta. La fuente basic-text-extraction-tesseract.cs documenta las excepciones comunes de tiempo de ejecución: System.DllNotFoundException por binarios Leptonica faltantes, TesseractException por falta de tessdata, BadImageFormatException por incompatibilidades de 32/64 bits.

En las implementaciones de Docker, los archivos tessdata deben copiarse en la imagen del contenedor. Para tres idiomas de 15 MB cada uno más los modelos best de 50-100 MB cada uno, las imágenes de contenedor se expanden por varios cientos de megabytes. Los pipelines de CI/CD deben almacenar en caché estas descargas o aceptar tiempos de compilación lentos cuando la caché no esté disponible.

Enfoque de IronOCR

La compatibilidad con idiomas en IronOCR es una referencia de paquete NuGet :

// Install once: dotnet add package IronOcr.Languages.French
// Install once: dotnet add package IronOcr.Languages.German
using IronOcr;

var ocr = new IronTesseract();
ocr.Language = OcrLanguage.French;
ocr.AddSecondaryLanguage(OcrLanguage.German);

var result = ocr.Read("multilingual-document.jpg");

// Install once: dotnet add package IronOcr.Languages.French
// Install once: dotnet add package IronOcr.Languages.German
using IronOcr;

var ocr = new IronTesseract();
ocr.Language = OcrLanguage.French;
ocr.AddSecondaryLanguage(OcrLanguage.German);

var result = ocr.Read("multilingual-document.jpg");

Imports IronOcr

' Install once: dotnet add package IronOcr.Languages.French
' Install once: dotnet add package IronOcr.Languages.German

Dim ocr As New IronTesseract()
ocr.Language = OcrLanguage.French
ocr.AddSecondaryLanguage(OcrLanguage.German)

Dim result = ocr.Read("multilingual-document.jpg")

Los datos de idioma están integrados en el paquete NuGet . No hay que crear ninguna carpeta, ni configurar ninguna ruta, ni descargar ningún archivo de GitHub para verificarlo. Agregar un idioma a Dockersignifica agregar una línea PackageReference al .csproj. La guía práctica para trabajar con varios idiomas abarca el catálogo completo de más de 125 idiomas, y la entrada del blog sobre varios idiomas explica los flujos de trabajo de producción en varios idiomas, incluidos los conjuntos de caracteres CJK.

Se alcanza el hito del preprocesamiento.

Todo proyecto de Tesseract comienza con imágenes de prueba limpias. Facturas de muestra, documentos escaneados con claridad, archivos PNG a 300 ppp que se visualizan correctamente a la primera lectura. La cuestión del preprocesamiento se pospone. Luego llega el primer lote de producción: órdenes de compra enviadas por fax a 150 ppp, contratos escaneados con una inclinación de 3 grados y fotografías de recibos tomadas bajo iluminación fluorescente. La precisión disminuye al 60-70%. El equipo ahora se enfrenta al reto de implementar el proceso de preprocesamiento que se había pospuesto, descubriendo que la conversión a escala de grises y la mejora del contraste son manejables, pero la corrección de la inclinación requiere una transformada de Hough y la eliminación de ruido requiere un filtro de mediana, y ninguna de las dos tareas lleva dos horas. Los equipos en este hito — donde la deuda de preprocesamiento se convierte en un elemento de la acumulación del sprint — frecuentemente evalúan IronOCR porque el costo de la licencia es más bajo que dos semanas de trabajo de procesamiento de imágenes que no fueron contratados para hacer.

Aparece el requisito de PDF

Las aplicaciones de procesamiento de documentos casi siempre terminan necesitando compatibilidad con PDF. La primera respuesta suele ser "añadir PdfiumViewer"; está bien documentado y maneja bien muchos casos. Los problemas emergen en producción: el pdfium.dll nativo debe estar presente en el directorio de la aplicación con la bitness correcta, las imágenes de contenedor requieren pasos COPY explícitos en los Dockerfiles, las implementaciones en Linuxnecesitan el archivo .so correspondiente, y los PDFs protegidos con contraseña requieren una biblioteca de desencriptación separada con su propia licencia. Los equipos que gestionan tres cadenas de dependencias distintas —bibliotecas nativas de Tesseract, Leptonica y pdfium— en cuatro entornos (Windows, Linux, Docker, CI) alcanzan un umbral de mantenimiento en el que merece la pena evaluar una alternativa de un solo paquete.

Procesamiento paralelo a gran escala

Un proceso de OCR por lotes que procesa 500 facturas se beneficia del paralelismo. Con el envoltorio charlesw, el patrón de procesamiento paralelo seguro crea una instancia de motor por hilo, cargando entre 40 y 100 MB de datos del modelo de lenguaje cada una. Con ocho hilos de procesamiento, eso supone entre 320 y 800 MB de memoria del motor antes de que se cargue cualquier documento. Los equipos que analizan el rendimiento de sus servicios de OCR y descubren que la presión sobre la memoria se concentra en la inicialización del motor, en lugar de en el contenido del documento, encuentran que el modelo de instancia única y seguro para subprocesos de IronOCR aborda directamente la causa raíz. El ejemplo de multihilo demuestra el patrón.

Los entornos de implementación se multiplican

Un proyecto que comenzó en Windowsañade un contenedor Linuxpara su implementación en la nube. Ahora es necesario añadir al Dockerfile los pasos de instalación de la biblioteca nativa, copiar los archivos tessdata en el contenedor y configurar correctamente la variable de entorno de la ruta tessdata. Entonces, un desarrollador de macOSse une al equipo. Entonces alguien quiere implementarlo en AWS Lambda. Cada plataforma añade una superficie de configuración adicional que puede fallar silenciosamente: la falta de una biblioteca nativa en tiempo de ejecución en un contenedor de producción es un resultado peor que un coste ligeramente superior del paquete NuGet . La guía de implementación de IronOCR Docker muestra el contraste: sin paquetes del sistema, sin paso de copia de datos de prueba, sin variables de entorno.

La versión del Teseracto importa.

Tesseract 5.x introdujo mejoras en la precisión de LSTM que se pueden medir en ciertos tipos de documentos. El wrapper charlesw está dirigido a Tesseract 4.1.1. Para los equipos donde la precisión del OCR en documentos difíciles es una métrica de calidad del producto, la diferencia de versiones es un factor importante a considerar, especialmente cuando la alternativa es un paquete comercial con mantenimiento que sigue la versión actual del motor.

Eliminación de la carpeta Tessdata

El primer paso de limpieza tras migrar a IronOCR es eliminar la carpeta tessdata y eliminar los elementos <Content Include="tessdata\**"> correspondientes del archivo del proyecto. Cualquier código de validación de ruta codificada — la guardia Directory.Exists(TessDataPath) presente en basic-text-extraction-tesseract.cs — también desaparece. Las referencias de espacio de nombres using Tesseract; y las referencias de tipo TesseractEngine, Pix, y Page necesitan reemplazo con using IronOcr;, IronTesseract, OcrInput, y OcrResult.

Eliminación de la biblioteca de PDF

Cualquier biblioteca de renderizado de PDF añadida únicamente para admitir el procesamiento de PDF de Tesseract (PdfiumViewer, PDFtoImage, Docnet.Core) puede eliminarse. Las dependencias binarias nativas que esos paquetes requerían (pdfium.dll, binarios GhostScript) también desaparecen. Las líneas COPY y apt-get de Dockerfile para esas dependencias ya no son necesarias. La guía de entrada de PDF de IronOCR abarca todas las variantes de entrada de PDF que manejaban esas bibliotecas, incluida la selección de rangos de páginas y los documentos protegidos con contraseña. Todo el bloque de renderizado y luego OCR — típicamente 50-80 líneas que abarcan tres bibliotecas — colapsa a input.LoadPdf(path) seguido de una única llamada Read().

Reemplazo de código de preprocesamiento

Los métodos de preprocesamiento existentes — ConvertToGrayscale, EnhanceContrast, Binarize, RemoveNoise, Deskew, ScaleToDpi — se asignan directamente a métodos de filtro de IronOCR. El patrón de guardar y cargar archivos temporales desaparece por completo. Consulte la guía de corrección de color de la imagen para obtener información sobre transformaciones específicas de color y la guía de configuración de DPI para la gestión de la resolución.

Cambio de modelo de hilo

El código que crea TesseractEngine dentro de un bucle Parallel.ForEach — uno por hilo — cambia a crear IronTesseract una vez antes del bucle y compartirlo entre todos los hilos. Se trata de un cambio de corrección, no solo de una refactorización: el patrón anterior consistía en una programación defensiva en torno a una API que no era segura para subprocesos; El nuevo patrón consiste en el uso previsto de una API segura para subprocesos. La sobrecarga de inicialización del motor por hilo —entre 40 y 100 MB de datos del modelo de lenguaje por hilo— desaparece con este cambio, ya que IronOCR mantiene un grupo interno compartido en lugar de cargar el estado completo del modelo por cada instancia del motor.