COMPARACIóN CON OTROS COMPONENTES

Comparación entre IronOCR y PDFTRON OCR

Actualizado 5 de septiembre, 2022
Compartir:

OCR son las siglas de "Optical Character Recognition" (reconocimiento óptico de caracteres). Es el proceso de convertir documentos en papel o imágenes en texto legible. Existen varios métodos para hacerlo, como el escaneado o la introducción manual a través de un teclado. Esto se hace para convertir cualquier archivo escaneado, PDF o documento manuscrito a su formato de texto original. Este proceso ha demostrado ser inestimable en casos penales en los que los documentos están demasiado dañados para la transcripción manual, pero pueden ser escaneados e interpretados por el software OCR.

Con el avance de la tecnología y la adopción omnipresente de herramientas digitales, el OCR también se ha implantado en otros campos, como la conversión de documentos en aplicaciones como Google Docs, así como en el mundo académico y empresarial. Existen dos tipos principales de OCR: "estático" y "dinámico". El tipo más común es el OCR estático, en el que se escanea todo el documento a la vez. El OCR dinámico, por su parte, escanea línea por línea y puede procesar diseños más sofisticados, como datos tabulares.

Este artículo tratará la comparación entre dos de las aplicaciones y bibliotecas de documentos más extendidas para OCR y PDF. Estos son:

  • PDFTron OCR
  • IronOCR

1.0 Introducción

1.1 Introducción y características de PDFTron OCR

Para utilizar OCR con PDFTron SDK, tenemos que instalar una utilidad adicional de módulo OCR independiente. Esto ayuda al SDK a detectar el texto de los documentos. Puede hacer que el texto se pueda seleccionar y buscar. El SDK de PDFTron admite hasta 100 idiomas. El motor de OCR PDFTron se apoya en una red neuronal LSTM de código abierto de Tesseract. PDFTron OCR admite varios tipos de formatos de imagen para la detección de texto. Los archivos PDF que sólo contienen imágenes rasterizadas también se aceptan para el OCR, con una calidad de salida que depende de la imagen de entrada. Las mejores imágenes para OCR son las de escala de grises con una resolución de 300 DPI.

Características de PDFTron OCR

  • Búsqueda de imágenes en documentos impresos.
  • Convertir un PDF simple en un PDF con capacidad de búsqueda.
  • Detección de información importante en documentos empresariales.
  • Facilitar el escaneado de libros.
  • Detección de números de vehículos a partir de imágenes de vehículos.
  • Ayudar a los usuarios con discapacidad visual.
  • Resulta fácil introducir datos en varios documentos a partir de archivos mediante OCR.
  • Transfiera fácilmente información de tarjetas de visita a listas de datos de contacto.

1.2 IronOCR — Introducción y características

Iron Software proporciona a los ingenieros de software IronOCR for .NET para leer contenido de texto de fotos y PDF en aplicaciones y sitios web .NET. El software ayuda a escanear fotos en busca de texto y códigos de barras, es compatible con numerosos idiomas de todo el mundo y genera salidas como texto sin formato o datos estructurados. La biblioteca OCR de Iron Software puede utilizarse en aplicaciones Web, de consola, MVC y numerosas aplicaciones de escritorio .NET. En el caso de la implantación comercial, se proporciona asistencia directa del equipo de desarrollo junto con las licencias adquiridas.

  • IronOCR utiliza el último motor Tesseract 5 que lee texto, códigos QR y códigos de barras, desde cualquier formato PDF o. Añadir OCR al escritorio, a las aplicaciones web y a la consola con esta biblioteca garantiza una rápida integración.
  • IronOCR admite 127 idiomas internacionales. También admite idiomas personalizados y listas de palabras.
  • IronOCR puede leer más de 20 formatos de códigos de barras y códigos QR.
  • Admite los formatos de imagen GIF y TIFF multipágina.
  • Corrige escaneos e imágenes de baja calidad.
  • Admite multihilo. Puede ejecutar uno o varios procesos a la vez.
  • IronOCR puede proporcionar salida de datos estructurados a páginas, párrafos, líneas, palabras, caracteres, etc.
  • IronOCR es compatible con sistemas operativos como Windows, Linux, macOS, etc.

2. Creación de un nuevo proyecto en Visual Studio

Abra Visual Studio y vaya al menú Archivo. Seleccione nuevo proyecto y, a continuación, seleccione Aplicación de consola. Para generar documentos PDF, en este artículo utilizaremos la aplicación de consola.

Introduzca el nombre del proyecto y seleccione la ruta del archivo en el cuadro de texto correspondiente. A continuación, haga clic en el botón Crear. Seleccione también el .NET Framework necesario.

El proyecto de Visual Studio generará ahora la estructura para la aplicación seleccionada.

Visual Studio generará ahora la estructura del proyecto. El archivo program.cs se abrirá si has seleccionado Windows, consola y aplicación web para que puedas introducir el código y construir/ejecutar tu aplicación.

Para el siguiente paso, tenemos que añadir la biblioteca para probar el código.

3.0 Instalación

3.1 Instalar PDFtron OCR

La instalación de PDFTron OCR se realiza manualmente y puede descargarse como archivo zip desde la dirección indicada enlace. Descomprímelo y configúralo con el proyecto. La guía le ayudará a ejecutar muestras de PDFTron utilizando la versión de prueba integrada gratuita del SDK de PDFTron en una aplicación .NET Framework con Windows. La prueba gratuita incluye la asistencia de los ingenieros de la solución y un uso ilimitado.

Requisitos previos

Visual Studio: Asegúrate de que la carga de trabajo de .NET Desktop Development y .NET Framework 4.5.1+ development tools forma parte de tu instalación. Esta guía utilizará Visual Studio 2017 y la biblioteca PDF C# .NET de PDFTron para Windows. Descargue la biblioteca a través de este enlace, .NET PDF SDK Descargar.

Configuración inicial

Extraiga la carpeta del archivo .zip. PDFNET_BASE se utiliza en esta guía para seleccionar la ruta de la carpeta que ha extraído.

PDFNET_BASE = path/to/extraction/folder/PDFNetDotNet4/
PDFNET_BASE = path/to/extraction/folder/PDFNetDotNet4/
'INSTANT VB TODO TASK: The following line uses invalid syntax:
'PDFNET_BASE = path/@to/extraction/folder/PDFNetDotNet4/
VB   C#

Ejecutar las muestras

Navegue hasta la ubicación de los contenidos extraídos. Busca y entra en la carpeta Samples (PDFNET_BASE/Muestras). Esta carpeta contiene numerosos códigos de ejemplo de funciones compatibles con el SDK de PDFTron.

  1. Abra Samples_20XX.sln en Visual Studio. Elija una versión adecuada para su instalación de Visual Studio.
  2. Seleccione el código de muestra y establézcalo como proyecto de inicio para la solución.
  3. Ejecuta el proyecto.

Integración en su aplicación

Se trata de la aplicación "PDFTron Hello World". Es fácil integrar el resto del SDK de PDFTron si puede abrir, guardar y cerrar un documento PDF.

  1. En Visual Studio, cree un proyecto de aplicación de consola .NET Framework en su idioma preferido. Puede encontrarlos en la categoría Visual C# o Visual Basic.
  2. Navegue hasta la carpeta de su proyecto. Por defecto, la ruta debe ser similar a: C:/Usuarios/Nombre_del_usuario/fuente/repositorios/miApp
  3. De PDFNET_BASE a la carpeta de su proyecto (esta carpeta tendrá su archivo .csproj o .vbproj)Copie la carpeta Lib.
  4. Busque el Explorador de soluciones en la parte derecha. Seleccione la opción Añadir referencia haciendo clic con el botón derecho en Referencias. Se abre un cuadro de diálogo Administrador de referencias.
  5. En la parte inferior del cuadro de diálogo, seleccione Examinar. Busque en la carpeta Lib copiada para añadir PDFNetLoader.dll a las referencias
  6. Además, desde la carpeta x86 añada la versión adecuada de PDFNet.dll como otra referencia (path/to/your/project/folder/Lib/PDFNet/x86/PDFNet.dll). Esto garantizará que la aplicación funcione tanto en sistemas operativos de 32 bits como de 64 bits.
  7. Haga clic en PDFNet.dll. Asegúrese de establecer su propiedad Copy Local en False.

3.2 Instalación de IronOCR

La biblioteca IronOCR puede instalarse de cuatro maneras.

Estos son:

  • Utilización de Visual Studio.
  • Uso de la línea de comandos de Visual Studio.
  • Descarga directa desde el sitio web de NuGet.
  • Descarga directa desde el sitio web de IronPDF.

3.2.1 Utilización de Visual Studio

El software Visual Studio ofrece la opción del gestor de paquetes NuGet para instalar el paquete directamente en la solución. La captura de pantalla muestra cómo abrir el Gestor de paquetes NuGet.

Esto proporcionará un cuadro de búsqueda para mostrar la lista de los paquetes del sitio web de NuGet. En el gestor de paquetes, tenemos que buscar la palabra clave "IronOCR", como en la siguiente captura de pantalla:

En la imagen anterior, podemos ver la lista de los resultados de búsqueda relacionados. Para instalar el paquete en la solución, debemos seleccionar la opción requerida.

3.2.2 Uso de la línea de comandos de Visual Studio

  • En Visual Studio: Vaya a Herramientas-> Administrador de paquetes NuGet -> Consola del administrador de paquetes
  • Introduzca el siguiente fragmento de código en la pestaña de la consola del gestor de paquetes.

Install-Package IronOcr


El paquete se instalará directamente en el proyecto actual, que estará listo para su uso.

### 3.2.3 Descarga directa desde el sitio web de NuGet

Para el tercer método, podemos descargar el paquete NuGet directamente del sitio web

* Navegue hasta [Enlace](https://www.nuget.org/packages/Ironocr).
* En el menú de la derecha, seleccione la opción de descarga de paquetes.
* Haga doble clic en el paquete descargado. Se instalará automáticamente.
* A continuación, vuelva a cargar la solución y comience a utilizarla en el proyecto.

### 3.2.4 Descarga directa desde el sitio web de IronOCR

Puede descargar directamente el último paquete desde el sitio web haciendo clic aquí [enlace](https://ironsoftware.com/csharp/ocr/packages/IronOcr.zip). Siga las instrucciones proporcionadas para añadir el paquete al proyecto una vez descargado el último paquete.

* Haga clic con el botón derecho del ratón en el proyecto de la ventana de la solución.
* Seleccione Opción Referencia para buscar la ubicación de la referencia descargada.
* A continuación, haga clic en Aceptar para añadir la referencia.

### 4.0 Imagen OCR

Tanto IronOCR como **PDFtron OCR** disponen de tecnología OCR que convertirá las imágenes en texto para su búsqueda.

### 4.1 Utilizar **PDFTron**

Convierte PDF a DOCX, DOC, HTML, SVG, TIFF, PNG, JPEG, XPS, EPUB, TXT y muchos otros formatos.

``` cs

PDFDoc doc = nuevo PDFDoc(nombre de archivo);

// Convertir un documento PDF en SVG

Convertir.ToSvg(doc, nombre_archivo_salida + ".svg");

// Convertir un documento PDF en XPS

Convertir.ToXps(nombre_archivo, nombre_archivo_salida + ".xps");

// Convertir documento PDF a TIFF multipágina

Convert.TiffOutputOptions tiff_options = new Convert.TiffOutputOptions();

tiff_options.SetDPI(200);

tiff_options.SetDither(verdadero);

tiff_options.SetMono(verdadero);

Convertir.ToTiff(nombre_archivo, nombre_archivo_salida + ".tiff", opciones_tiff);

// Convertir PDF a XOD

Convertir.ToXod(nombre_archivo, nombre_archivo_salida + ".xod");

// Convertir PDF a HTML

Convertir.ToHtml(nombre_archivo, nombre_archivo_salida + ".html");

4.2 Utilización de IronOCR

var Ocr = new IronTesseract(); //  nada que configurar
Ocr.Language = OcrLanguage.EnglishBest;
Ocr.Configuration.TesseractVersion = TesseractVersion.Tesseract5;
using (var Input = new OcrInput())
{
    Input.AddImage(@"3.png");
    var Result = Ocr.Read(Input);
    Console.WriteLine(Result.Text);
    Console.ReadKey();
}
var Ocr = new IronTesseract(); //  nada que configurar
Ocr.Language = OcrLanguage.EnglishBest;
Ocr.Configuration.TesseractVersion = TesseractVersion.Tesseract5;
using (var Input = new OcrInput())
{
    Input.AddImage(@"3.png");
    var Result = Ocr.Read(Input);
    Console.WriteLine(Result.Text);
    Console.ReadKey();
}
Dim Ocr = New IronTesseract() '  nada que configurar
Ocr.Language = OcrLanguage.EnglishBest
Ocr.Configuration.TesseractVersion = TesseractVersion.Tesseract5
Using Input = New OcrInput()
	Input.AddImage("3.png")
	Dim Result = Ocr.Read(Input)
	Console.WriteLine(Result.Text)
	Console.ReadKey()
End Using
VB   C#

Arriba se muestra el proceso de conversión de archivos de imagen en texto con la API Tesseract 5. La línea de código anterior se utilizó para crear un objeto para Iron Tesseract. Además, para asegurarnos de que podemos añadir uno o más archivos de imagen, producimos un objeto OcrInput que requerirá la ruta de la imagen disponible. En el objeto Iron Tesseract, la función "Read" puede utilizarse para obtener las imágenes analizando el archivo de imagen y extrayendo el resultado producido en el resultado OCR. Es capaz de extraer texto de fotos y convertirlo en una cadena.

Tesseract puede ser utilizado para añadir imágenes multi-frame utilizando el método "AddMultiFrameTiff" para este proceso. La biblioteca Tesseract lee y trata cada fotograma de la imagen como una página distinta. Cada fotograma de la imagen se lee antes de pasar al fotograma siguiente hasta que cada fotograma se haya escaneado correctamente. El formato de imagen TIFF es el único compatible con este método.

La conversión satisfactoria de los datos en texto editable se muestra en la imagen superior, resultado de la precisión de IronOCR.

5.0 Archivo PDF OCR

IronOCR y PDFTron OCR convierten archivos PDF en texto editable. PDFTron OCR proporciona una lista de opciones al usuario como guardar la página, editar la imagen, reconocer la página, etc. Además puede proporcionar opciones de guardado como documento, texto, formato HTML, etc. IronOCR también nos permite guardar un archivo OCR convertido en HTML, texto, PDF, etc.

5.1 Utilizar PDFTron OCR

El código de ejemplo completo muestra cómo utilizar PDFTron OCR para la conversión directa y de alta calidad entre PDF, XPS, EMF, SVG, TIFF, PNG, JPEG y otros formatos de imagen.

//  Copyright (c) 2001-2021 por PDFTron Systems Inc. Todos los derechos reservados.

using System;
using System.Drawing;
using System.Drawing.Drawing2D;
using pdftron;
using pdftron.Common;
using pdftron.Filters;
using pdftron.SDF;
using pdftron.PDF;

//  El siguiente código muestra la conversión de documentos a formatos // como SVG, PDF, EMF o XPS.

namespace ConvertTestCS
{
    class Testfile
    {
        public string inputFile, outputFile;
        public bool requiresWindowsPlatform;
        public Testfile(string inFile, string outFile, bool requiresWindowsPlatform_)
        {
            inputFile = inFile;
            outputFile = outFile;
            requiresWindowsPlatform = requiresWindowsPlatform_;
        }
    };

    class Class1
    {
        private static pdftron.PDFNetLoader pdfNetLoader = pdftron.PDFNetLoader.Instance();
        static Class1() {}

        //  Ruta relativa a la carpeta que contiene los archivos de prueba.
        const string inputPath = "../../../../TestFiles/";
        const string outputPath = "../../../../TestFiles/Output/";

        static bool ConvertSpecificFormats()
        {
            bool err = false;
            try
            {
                using (PDFDoc pdfdoc = new PDFDoc())
                {
                    Console.WriteLine("Converting from XPS");
                    pdftron.PDF.Convert.FromXps(pdfdoc, inputPath + "simple-xps.xps");
                    pdfdoc.Save(outputPath + "xps2pdf v2.pdf", SDFDoc.SaveOptions.e_remove_unused);
                    Console.WriteLine("Saved xps2pdf v2.pdf");
                }
            }
            catch (PDFNetException e)
            {
                Console.WriteLine(e.Message);
                err = true;
            }

    /////////////////////////////////////////////
    if (Environment.OSVersion.Platform == PlatformID.Win32NT) {
                try
                {
                    using (PDFDoc pdfdoc = new PDFDoc())
                    {
                        Console.WriteLine("Converting from EMF");
                        pdftron.PDF.Convert.FromEmf(pdfdoc, inputPath + "simple-emf.emf");
                        pdfdoc.Save(outputPath + "emf2pdf v2.pdf", SDFDoc.SaveOptions.e_remove_unused);
                        Console.WriteLine("Saved emf2pdf v2.pdf");
                    }
                }
                catch (PDFNetException e)
                {
                    Console.WriteLine(e.Message);
                    err = true;
                }
            }

        ///////////////////////////////////////////
            try
            {
                using (PDFDoc pdfdoc = new PDFDoc())
                {
                    //  Añadir un diccionario
                    ObjSet set = new ObjSet();
                    Obj options = set.CreateDict();

                    //  Opciones de venta
                    options.PutNumber("FontSize", 15);
                    options.PutBool("UseSourceCodeFormatting", true);
                    options.PutNumber("PageWidth", 12);
                    options.PutNumber("PageHeight", 6);

                    //  Convertir desde archivo .txt
                    Console.WriteLine("Converting from txt");
                    pdftron.PDF.Convert.FromText(pdfdoc, inputPath + "simple-text.txt", options);
                    pdfdoc.Save(outputPath + "simple-text.pdf", SDFDoc.SaveOptions.e_remove_unused);
                    Console.WriteLine("Saved simple-text.pdf");
                }
            }
            catch (PDFNetException e)
            {
                Console.WriteLine(e.Message);
                err = true;
            }

    ///////////////////////////////////////////
            try
            {
                using (PDFDoc pdfdoc = new PDFDoc(inputPath + "newsletter.pdf"))
                {
                    //  Convertir un documento PDF en SVG
                    Console.WriteLine("Converting pdfdoc to SVG");
                    pdftron.PDF.Convert.ToSvg(pdfdoc, outputPath + "pdf2svg v2.svg");
                    Console.WriteLine("Saved pdf2svg v2.svg");
                }
            }
            catch (PDFNetException e)
            {
                Console.WriteLine(e.Message);
                err = true;
            }

    /////////////////////////////////////////////////
            try
            {
                //  Convertir una imagen PNG en XPS
                Console.WriteLine("Converting PNG to XPS");
                pdftron.PDF.Convert.ToXps(inputPath + "butterfly.png", outputPath + "butterfly.xps");
                Console.WriteLine("Saved butterfly.xps");
            }
            catch (PDFNetException e)
            {
                Console.WriteLine(e.Message);
                err = true;
            }
    ///////////////////////////////////////////
            if (Environment.OSVersion.Platform == PlatformID.Win32NT)
            {
                try
                {
                    //  Convertir un documento MSWord a XPS
                    Console.WriteLine("Converting DOCX to XPS");
                    pdftron.PDF.Convert.ToXps(inputPath + "simple-word_2007.docx", outputPath + "simple-word_2007.xps");
                    Console.WriteLine("Saved simple-word_2007.xps");
                }
                catch (PDFNetException e)
                {
                    Console.WriteLine(e.Message);
                    err = true;
                }
            }
            ////////////////////////////////////////////////////////////////////
            try
            {
                //  Convertir un documento PDF en XPS
                Console.WriteLine("Converting PDF to XPS");
                pdftron.PDF.Convert.ToXps(inputPath + "newsletter.pdf", outputPath + "newsletter.xps");
                Console.WriteLine("Saved newsletter.xps");
            }
            catch (PDFNetException e)
            {
                Console.WriteLine(e.Message);
                err = true;
            }

            //////////////////////////////////////////////////////////////////////
            try
            {
                //  Convertir un documento PDF en HTML
                Console.WriteLine("Converting PDF to HTML");
                pdftron.PDF.Convert.ToHtml(inputPath + "newsletter.pdf", outputPath + "newsletter");
                Console.WriteLine("Saved newsletter as HTML");
            }
            catch (PDFNetException e)
            {
                Console.WriteLine(e.Message);
                err = true;
            }

            //////////////////////////////////////////////////////////////////////
            try
            {
                //  Convertir un documento PDF en EPUB
                Console.WriteLine("Converting PDF to EPUB");
                pdftron.PDF.Convert.ToEpub(inputPath + "newsletter.pdf", outputPath + "newsletter.epub");
                Console.WriteLine("Saved newsletter.epub");
            }
            catch (PDFNetException e)
            {
                Console.WriteLine(e.Message);
                err = true;
            }

            /////////////////////////////////////////////////////////////////////
            try
            {
                //  Convertir un documento PDF en TIFF multipágina
                Console.WriteLine("Converting PDF to multipage TIFF");
                pdftron.PDF.Convert.TiffOutputOptions tiff_options = new pdftron.PDF.Convert.TiffOutputOptions();
                tiff_options.SetDPI(200);
                tiff_options.SetDither(true);
                tiff_options.SetMono(true);
                pdftron.PDF.Convert.ToTiff(inputPath + "newsletter.pdf", outputPath + "newsletter.tiff", tiff_options);
                Console.WriteLine("Saved newsletter.tiff");
            }
            catch (PDFNetException e)
            {
                Console.WriteLine(e.Message);
                err = true;
            }

            return err;
        }

        static Boolean ConvertToPdfFromFile()
        {
            System.Collections.ArrayList testfiles = new System.Collections.ArrayList();
            testfiles.Add(new ConvertTestCS.Testfile("simple-word_2007.docx", "docx2pdf.pdf", false));
            testfiles.Add(new ConvertTestCS.Testfile("simple-powerpoint_2007.pptx", "pptx2pdf.pdf", false));
            testfiles.Add(new ConvertTestCS.Testfile("simple-excel_2007.xlsx", "xlsx2pdf.pdf", false));
            testfiles.Add(new ConvertTestCS.Testfile("simple-publisher.pub", "pub2pdf.pdf", true));
            testfiles.Add(new ConvertTestCS.Testfile("simple-text.txt", "txt2pdf.pdf", false));
            testfiles.Add(new ConvertTestCS.Testfile("simple-rtf.rtf", "rtf2pdf.pdf", true));
            testfiles.Add(new ConvertTestCS.Testfile("butterfly.png", "png2pdf.pdf", false));
            testfiles.Add(new ConvertTestCS.Testfile("simple-emf.emf", "emf2pdf.pdf", true));
            testfiles.Add(new ConvertTestCS.Testfile("simple-xps.xps", "xps2pdf.pdf", false));
            //  testfiles.Add(new ConvertTestCS.Testfile("simple-webpage.mht", "mht2pdf.pdf", true));
            testfiles.Add(new ConvertTestCS.Testfile("simple-webpage.html", "html2pdf.pdf", true));

            bool err = false;
            if (Environment.OSVersion.Platform == PlatformID.Win32NT)
            {
                try
                {
                    if (pdftron.PDF.Convert.Printer.IsInstalled("PDFTron PDFNet"))
                    {
                        pdftron.PDF.Convert.Printer.SetPrinterName("PDFTron PDFNet");
                    }
                    else if (!pdftron.PDF.Convert.Printer.IsInstalled())
                    {
                        try
                        {
                            Console.WriteLine("Installing printer (requires Windows platform and administrator)");
                            pdftron.PDF.Convert.Printer.Install();
                            Console.WriteLine("Installed printer " + pdftron.PDF.Convert.Printer.GetPrinterName());
                            //  la función ConvertToXpsFromFile puede requerir la impresora así que déjela instalada
                            //  uninstallPrinterWhenDone = true;
                        }
                        catch (PDFNetException e)
                        {
                            Console.WriteLine("ERROR: Unable to install printer.");
                            Console.WriteLine(e.Message);
                            err = true;
                        }
                        catch
                        {
                            Console.WriteLine("ERROR: Unable to install printer. Make sure that the package's bitness matches your operating system's bitness and that you are running with administrator privileges.");
                        }
                    }
                }
                catch (PDFNetException e)
                {
                    Console.WriteLine("ERROR: Unable to install printer.");
                    Console.WriteLine(e.Message);
                    err = true;
                }
            }
            foreach (Testfile file in testfiles)
            {
                if ( Environment.OSVersion.Platform != PlatformID.Win32NT)
                {
                    if (file.requiresWindowsPlatform)
                    {
                        continue;
                    }
                }
                try
                {
                    using (pdftron.PDF.PDFDoc pdfdoc = new PDFDoc())
                    {

                        if (pdftron.PDF.Convert.RequiresPrinter(inputPath + file.inputFile))
                        {
                            Console.WriteLine("Using PDFNet printer to convert file " + file.inputFile);
                        }
                        pdftron.PDF.Convert.ToPdf(pdfdoc, inputPath + file.inputFile);
                        pdfdoc.Save(outputPath + file.outputFile, SDFDoc.SaveOptions.e_linearized);
                        Console.WriteLine("Converted file: " + file.inputFile);
                        Console.WriteLine("to: " + file.outputFile);
                    }
                }
                catch (PDFNetException e)
                {
                    Console.WriteLine("ERROR: on input file " + file.inputFile);
                    Console.WriteLine(e.Message);
                    err = true;
                }
            }

            return err;
        }
        [STAThread]
        static void Main(string [] args)
        {
            PDFNet.Initialize(PDFTronLicense.Key);
            bool err = false;

            err = ConvertToPdfFromFile();
            if (err)
            {
                Console.WriteLine("ConvertFile failed");
            }
            else
            {
                Console.WriteLine("ConvertFile succeeded");
            }

            err = ConvertSpecificFormats();
            if (err)
            {
                Console.WriteLine("ConvertSpecificFormats failed");
            }
            else
            {
                Console.WriteLine("ConvertSpecificFormats succeeded");
            }

            if (Environment.OSVersion.Platform == PlatformID.Win32NT)
            {
                if (pdftron.PDF.Convert.Printer.IsInstalled())
                {
                    try
                    {
                        Console.WriteLine("Uninstalling printer (requires Windows platform and administrator)");
                        pdftron.PDF.Convert.Printer.Uninstall();
                        Console.WriteLine("Uninstalled Printer " + pdftron.PDF.Convert.Printer.GetPrinterName());
                    }
                    catch
                    {
                        Console.WriteLine("Unable to uninstall printer");
                    }
                }
            }
            PDFNet.Terminate();
            Console.WriteLine("Done.");
        }
    }
}
//  Copyright (c) 2001-2021 por PDFTron Systems Inc. Todos los derechos reservados.

using System;
using System.Drawing;
using System.Drawing.Drawing2D;
using pdftron;
using pdftron.Common;
using pdftron.Filters;
using pdftron.SDF;
using pdftron.PDF;

//  El siguiente código muestra la conversión de documentos a formatos // como SVG, PDF, EMF o XPS.

namespace ConvertTestCS
{
    class Testfile
    {
        public string inputFile, outputFile;
        public bool requiresWindowsPlatform;
        public Testfile(string inFile, string outFile, bool requiresWindowsPlatform_)
        {
            inputFile = inFile;
            outputFile = outFile;
            requiresWindowsPlatform = requiresWindowsPlatform_;
        }
    };

    class Class1
    {
        private static pdftron.PDFNetLoader pdfNetLoader = pdftron.PDFNetLoader.Instance();
        static Class1() {}

        //  Ruta relativa a la carpeta que contiene los archivos de prueba.
        const string inputPath = "../../../../TestFiles/";
        const string outputPath = "../../../../TestFiles/Output/";

        static bool ConvertSpecificFormats()
        {
            bool err = false;
            try
            {
                using (PDFDoc pdfdoc = new PDFDoc())
                {
                    Console.WriteLine("Converting from XPS");
                    pdftron.PDF.Convert.FromXps(pdfdoc, inputPath + "simple-xps.xps");
                    pdfdoc.Save(outputPath + "xps2pdf v2.pdf", SDFDoc.SaveOptions.e_remove_unused);
                    Console.WriteLine("Saved xps2pdf v2.pdf");
                }
            }
            catch (PDFNetException e)
            {
                Console.WriteLine(e.Message);
                err = true;
            }

    /////////////////////////////////////////////
    if (Environment.OSVersion.Platform == PlatformID.Win32NT) {
                try
                {
                    using (PDFDoc pdfdoc = new PDFDoc())
                    {
                        Console.WriteLine("Converting from EMF");
                        pdftron.PDF.Convert.FromEmf(pdfdoc, inputPath + "simple-emf.emf");
                        pdfdoc.Save(outputPath + "emf2pdf v2.pdf", SDFDoc.SaveOptions.e_remove_unused);
                        Console.WriteLine("Saved emf2pdf v2.pdf");
                    }
                }
                catch (PDFNetException e)
                {
                    Console.WriteLine(e.Message);
                    err = true;
                }
            }

        ///////////////////////////////////////////
            try
            {
                using (PDFDoc pdfdoc = new PDFDoc())
                {
                    //  Añadir un diccionario
                    ObjSet set = new ObjSet();
                    Obj options = set.CreateDict();

                    //  Opciones de venta
                    options.PutNumber("FontSize", 15);
                    options.PutBool("UseSourceCodeFormatting", true);
                    options.PutNumber("PageWidth", 12);
                    options.PutNumber("PageHeight", 6);

                    //  Convertir desde archivo .txt
                    Console.WriteLine("Converting from txt");
                    pdftron.PDF.Convert.FromText(pdfdoc, inputPath + "simple-text.txt", options);
                    pdfdoc.Save(outputPath + "simple-text.pdf", SDFDoc.SaveOptions.e_remove_unused);
                    Console.WriteLine("Saved simple-text.pdf");
                }
            }
            catch (PDFNetException e)
            {
                Console.WriteLine(e.Message);
                err = true;
            }

    ///////////////////////////////////////////
            try
            {
                using (PDFDoc pdfdoc = new PDFDoc(inputPath + "newsletter.pdf"))
                {
                    //  Convertir un documento PDF en SVG
                    Console.WriteLine("Converting pdfdoc to SVG");
                    pdftron.PDF.Convert.ToSvg(pdfdoc, outputPath + "pdf2svg v2.svg");
                    Console.WriteLine("Saved pdf2svg v2.svg");
                }
            }
            catch (PDFNetException e)
            {
                Console.WriteLine(e.Message);
                err = true;
            }

    /////////////////////////////////////////////////
            try
            {
                //  Convertir una imagen PNG en XPS
                Console.WriteLine("Converting PNG to XPS");
                pdftron.PDF.Convert.ToXps(inputPath + "butterfly.png", outputPath + "butterfly.xps");
                Console.WriteLine("Saved butterfly.xps");
            }
            catch (PDFNetException e)
            {
                Console.WriteLine(e.Message);
                err = true;
            }
    ///////////////////////////////////////////
            if (Environment.OSVersion.Platform == PlatformID.Win32NT)
            {
                try
                {
                    //  Convertir un documento MSWord a XPS
                    Console.WriteLine("Converting DOCX to XPS");
                    pdftron.PDF.Convert.ToXps(inputPath + "simple-word_2007.docx", outputPath + "simple-word_2007.xps");
                    Console.WriteLine("Saved simple-word_2007.xps");
                }
                catch (PDFNetException e)
                {
                    Console.WriteLine(e.Message);
                    err = true;
                }
            }
            ////////////////////////////////////////////////////////////////////
            try
            {
                //  Convertir un documento PDF en XPS
                Console.WriteLine("Converting PDF to XPS");
                pdftron.PDF.Convert.ToXps(inputPath + "newsletter.pdf", outputPath + "newsletter.xps");
                Console.WriteLine("Saved newsletter.xps");
            }
            catch (PDFNetException e)
            {
                Console.WriteLine(e.Message);
                err = true;
            }

            //////////////////////////////////////////////////////////////////////
            try
            {
                //  Convertir un documento PDF en HTML
                Console.WriteLine("Converting PDF to HTML");
                pdftron.PDF.Convert.ToHtml(inputPath + "newsletter.pdf", outputPath + "newsletter");
                Console.WriteLine("Saved newsletter as HTML");
            }
            catch (PDFNetException e)
            {
                Console.WriteLine(e.Message);
                err = true;
            }

            //////////////////////////////////////////////////////////////////////
            try
            {
                //  Convertir un documento PDF en EPUB
                Console.WriteLine("Converting PDF to EPUB");
                pdftron.PDF.Convert.ToEpub(inputPath + "newsletter.pdf", outputPath + "newsletter.epub");
                Console.WriteLine("Saved newsletter.epub");
            }
            catch (PDFNetException e)
            {
                Console.WriteLine(e.Message);
                err = true;
            }

            /////////////////////////////////////////////////////////////////////
            try
            {
                //  Convertir un documento PDF en TIFF multipágina
                Console.WriteLine("Converting PDF to multipage TIFF");
                pdftron.PDF.Convert.TiffOutputOptions tiff_options = new pdftron.PDF.Convert.TiffOutputOptions();
                tiff_options.SetDPI(200);
                tiff_options.SetDither(true);
                tiff_options.SetMono(true);
                pdftron.PDF.Convert.ToTiff(inputPath + "newsletter.pdf", outputPath + "newsletter.tiff", tiff_options);
                Console.WriteLine("Saved newsletter.tiff");
            }
            catch (PDFNetException e)
            {
                Console.WriteLine(e.Message);
                err = true;
            }

            return err;
        }

        static Boolean ConvertToPdfFromFile()
        {
            System.Collections.ArrayList testfiles = new System.Collections.ArrayList();
            testfiles.Add(new ConvertTestCS.Testfile("simple-word_2007.docx", "docx2pdf.pdf", false));
            testfiles.Add(new ConvertTestCS.Testfile("simple-powerpoint_2007.pptx", "pptx2pdf.pdf", false));
            testfiles.Add(new ConvertTestCS.Testfile("simple-excel_2007.xlsx", "xlsx2pdf.pdf", false));
            testfiles.Add(new ConvertTestCS.Testfile("simple-publisher.pub", "pub2pdf.pdf", true));
            testfiles.Add(new ConvertTestCS.Testfile("simple-text.txt", "txt2pdf.pdf", false));
            testfiles.Add(new ConvertTestCS.Testfile("simple-rtf.rtf", "rtf2pdf.pdf", true));
            testfiles.Add(new ConvertTestCS.Testfile("butterfly.png", "png2pdf.pdf", false));
            testfiles.Add(new ConvertTestCS.Testfile("simple-emf.emf", "emf2pdf.pdf", true));
            testfiles.Add(new ConvertTestCS.Testfile("simple-xps.xps", "xps2pdf.pdf", false));
            //  testfiles.Add(new ConvertTestCS.Testfile("simple-webpage.mht", "mht2pdf.pdf", true));
            testfiles.Add(new ConvertTestCS.Testfile("simple-webpage.html", "html2pdf.pdf", true));

            bool err = false;
            if (Environment.OSVersion.Platform == PlatformID.Win32NT)
            {
                try
                {
                    if (pdftron.PDF.Convert.Printer.IsInstalled("PDFTron PDFNet"))
                    {
                        pdftron.PDF.Convert.Printer.SetPrinterName("PDFTron PDFNet");
                    }
                    else if (!pdftron.PDF.Convert.Printer.IsInstalled())
                    {
                        try
                        {
                            Console.WriteLine("Installing printer (requires Windows platform and administrator)");
                            pdftron.PDF.Convert.Printer.Install();
                            Console.WriteLine("Installed printer " + pdftron.PDF.Convert.Printer.GetPrinterName());
                            //  la función ConvertToXpsFromFile puede requerir la impresora así que déjela instalada
                            //  uninstallPrinterWhenDone = true;
                        }
                        catch (PDFNetException e)
                        {
                            Console.WriteLine("ERROR: Unable to install printer.");
                            Console.WriteLine(e.Message);
                            err = true;
                        }
                        catch
                        {
                            Console.WriteLine("ERROR: Unable to install printer. Make sure that the package's bitness matches your operating system's bitness and that you are running with administrator privileges.");
                        }
                    }
                }
                catch (PDFNetException e)
                {
                    Console.WriteLine("ERROR: Unable to install printer.");
                    Console.WriteLine(e.Message);
                    err = true;
                }
            }
            foreach (Testfile file in testfiles)
            {
                if ( Environment.OSVersion.Platform != PlatformID.Win32NT)
                {
                    if (file.requiresWindowsPlatform)
                    {
                        continue;
                    }
                }
                try
                {
                    using (pdftron.PDF.PDFDoc pdfdoc = new PDFDoc())
                    {

                        if (pdftron.PDF.Convert.RequiresPrinter(inputPath + file.inputFile))
                        {
                            Console.WriteLine("Using PDFNet printer to convert file " + file.inputFile);
                        }
                        pdftron.PDF.Convert.ToPdf(pdfdoc, inputPath + file.inputFile);
                        pdfdoc.Save(outputPath + file.outputFile, SDFDoc.SaveOptions.e_linearized);
                        Console.WriteLine("Converted file: " + file.inputFile);
                        Console.WriteLine("to: " + file.outputFile);
                    }
                }
                catch (PDFNetException e)
                {
                    Console.WriteLine("ERROR: on input file " + file.inputFile);
                    Console.WriteLine(e.Message);
                    err = true;
                }
            }

            return err;
        }
        [STAThread]
        static void Main(string [] args)
        {
            PDFNet.Initialize(PDFTronLicense.Key);
            bool err = false;

            err = ConvertToPdfFromFile();
            if (err)
            {
                Console.WriteLine("ConvertFile failed");
            }
            else
            {
                Console.WriteLine("ConvertFile succeeded");
            }

            err = ConvertSpecificFormats();
            if (err)
            {
                Console.WriteLine("ConvertSpecificFormats failed");
            }
            else
            {
                Console.WriteLine("ConvertSpecificFormats succeeded");
            }

            if (Environment.OSVersion.Platform == PlatformID.Win32NT)
            {
                if (pdftron.PDF.Convert.Printer.IsInstalled())
                {
                    try
                    {
                        Console.WriteLine("Uninstalling printer (requires Windows platform and administrator)");
                        pdftron.PDF.Convert.Printer.Uninstall();
                        Console.WriteLine("Uninstalled Printer " + pdftron.PDF.Convert.Printer.GetPrinterName());
                    }
                    catch
                    {
                        Console.WriteLine("Unable to uninstall printer");
                    }
                }
            }
            PDFNet.Terminate();
            Console.WriteLine("Done.");
        }
    }
}
'  Copyright (c) 2001-2021 por PDFTron Systems Inc. Todos los derechos reservados.

Imports System
Imports System.Drawing
Imports System.Drawing.Drawing2D
Imports pdftron
Imports pdftron.Common
Imports pdftron.Filters
Imports pdftron.SDF
Imports pdftron.PDF

'  El siguiente código muestra la conversión de documentos a formatos // como SVG, PDF, EMF o XPS.

Namespace ConvertTestCS
	Friend Class Testfile
		Public inputFile, outputFile As String
		Public requiresWindowsPlatform As Boolean
		Public Sub New(ByVal inFile As String, ByVal outFile As String, ByVal requiresWindowsPlatform_ As Boolean)
			inputFile = inFile
			outputFile = outFile
			requiresWindowsPlatform = requiresWindowsPlatform_
		End Sub
	End Class

	Friend Class Class1
		Private Shared pdfNetLoader As pdftron.PDFNetLoader = pdftron.PDFNetLoader.Instance()
		Shared Sub New()
		End Sub

		'  Ruta relativa a la carpeta que contiene los archivos de prueba.
		Private Const inputPath As String = "../../../../TestFiles/"
		Private Const outputPath As String = "../../../../TestFiles/Output/"

		Private Shared Function ConvertSpecificFormats() As Boolean
			Dim err As Boolean = False
			Try
				Using pdfdoc As New PDFDoc()
					Console.WriteLine("Converting from XPS")
					pdftron.PDF.Convert.FromXps(pdfdoc, inputPath & "simple-xps.xps")
					pdfdoc.Save(outputPath & "xps2pdf v2.pdf", SDFDoc.SaveOptions.e_remove_unused)
					Console.WriteLine("Saved xps2pdf v2.pdf")
				End Using
			Catch e As PDFNetException
				Console.WriteLine(e.Message)
				err = True
			End Try

	'///////////////////////////////////////////
	If Environment.OSVersion.Platform = PlatformID.Win32NT Then
				Try
					Using pdfdoc As New PDFDoc()
						Console.WriteLine("Converting from EMF")
						pdftron.PDF.Convert.FromEmf(pdfdoc, inputPath & "simple-emf.emf")
						pdfdoc.Save(outputPath & "emf2pdf v2.pdf", SDFDoc.SaveOptions.e_remove_unused)
						Console.WriteLine("Saved emf2pdf v2.pdf")
					End Using
				Catch e As PDFNetException
					Console.WriteLine(e.Message)
					err = True
				End Try
	End If

		'/////////////////////////////////////////
			Try
				Using pdfdoc As New PDFDoc()
					'  Añadir un diccionario
					Dim [set] As New ObjSet()
					Dim options As Obj = [set].CreateDict()

					'  Opciones de venta
					options.PutNumber("FontSize", 15)
					options.PutBool("UseSourceCodeFormatting", True)
					options.PutNumber("PageWidth", 12)
					options.PutNumber("PageHeight", 6)

					'  Convertir desde archivo .txt
					Console.WriteLine("Converting from txt")
					pdftron.PDF.Convert.FromText(pdfdoc, inputPath & "simple-text.txt", options)
					pdfdoc.Save(outputPath & "simple-text.pdf", SDFDoc.SaveOptions.e_remove_unused)
					Console.WriteLine("Saved simple-text.pdf")
				End Using
			Catch e As PDFNetException
				Console.WriteLine(e.Message)
				err = True
			End Try

	'/////////////////////////////////////////
			Try
				Using pdfdoc As New PDFDoc(inputPath & "newsletter.pdf")
					'  Convertir un documento PDF en SVG
					Console.WriteLine("Converting pdfdoc to SVG")
					pdftron.PDF.Convert.ToSvg(pdfdoc, outputPath & "pdf2svg v2.svg")
					Console.WriteLine("Saved pdf2svg v2.svg")
				End Using
			Catch e As PDFNetException
				Console.WriteLine(e.Message)
				err = True
			End Try

	'///////////////////////////////////////////////
			Try
				'  Convertir una imagen PNG en XPS
				Console.WriteLine("Converting PNG to XPS")
				pdftron.PDF.Convert.ToXps(inputPath & "butterfly.png", outputPath & "butterfly.xps")
				Console.WriteLine("Saved butterfly.xps")
			Catch e As PDFNetException
				Console.WriteLine(e.Message)
				err = True
			End Try
	'/////////////////////////////////////////
			If Environment.OSVersion.Platform = PlatformID.Win32NT Then
				Try
					'  Convertir un documento MSWord a XPS
					Console.WriteLine("Converting DOCX to XPS")
					pdftron.PDF.Convert.ToXps(inputPath & "simple-word_2007.docx", outputPath & "simple-word_2007.xps")
					Console.WriteLine("Saved simple-word_2007.xps")
				Catch e As PDFNetException
					Console.WriteLine(e.Message)
					err = True
				End Try
			End If
			'//////////////////////////////////////////////////////////////////
			Try
				'  Convertir un documento PDF en XPS
				Console.WriteLine("Converting PDF to XPS")
				pdftron.PDF.Convert.ToXps(inputPath & "newsletter.pdf", outputPath & "newsletter.xps")
				Console.WriteLine("Saved newsletter.xps")
			Catch e As PDFNetException
				Console.WriteLine(e.Message)
				err = True
			End Try

			'////////////////////////////////////////////////////////////////////
			Try
				'  Convertir un documento PDF en HTML
				Console.WriteLine("Converting PDF to HTML")
				pdftron.PDF.Convert.ToHtml(inputPath & "newsletter.pdf", outputPath & "newsletter")
				Console.WriteLine("Saved newsletter as HTML")
			Catch e As PDFNetException
				Console.WriteLine(e.Message)
				err = True
			End Try

			'////////////////////////////////////////////////////////////////////
			Try
				'  Convertir un documento PDF en EPUB
				Console.WriteLine("Converting PDF to EPUB")
				pdftron.PDF.Convert.ToEpub(inputPath & "newsletter.pdf", outputPath & "newsletter.epub")
				Console.WriteLine("Saved newsletter.epub")
			Catch e As PDFNetException
				Console.WriteLine(e.Message)
				err = True
			End Try

			'///////////////////////////////////////////////////////////////////
			Try
				'  Convertir un documento PDF en TIFF multipágina
				Console.WriteLine("Converting PDF to multipage TIFF")
				Dim tiff_options As New pdftron.PDF.Convert.TiffOutputOptions()
				tiff_options.SetDPI(200)
				tiff_options.SetDither(True)
				tiff_options.SetMono(True)
				pdftron.PDF.Convert.ToTiff(inputPath & "newsletter.pdf", outputPath & "newsletter.tiff", tiff_options)
				Console.WriteLine("Saved newsletter.tiff")
			Catch e As PDFNetException
				Console.WriteLine(e.Message)
				err = True
			End Try

			Return err
		End Function

		Private Shared Function ConvertToPdfFromFile() As Boolean
			Dim testfiles As New System.Collections.ArrayList()
			testfiles.Add(New ConvertTestCS.Testfile("simple-word_2007.docx", "docx2pdf.pdf", False))
			testfiles.Add(New ConvertTestCS.Testfile("simple-powerpoint_2007.pptx", "pptx2pdf.pdf", False))
			testfiles.Add(New ConvertTestCS.Testfile("simple-excel_2007.xlsx", "xlsx2pdf.pdf", False))
			testfiles.Add(New ConvertTestCS.Testfile("simple-publisher.pub", "pub2pdf.pdf", True))
			testfiles.Add(New ConvertTestCS.Testfile("simple-text.txt", "txt2pdf.pdf", False))
			testfiles.Add(New ConvertTestCS.Testfile("simple-rtf.rtf", "rtf2pdf.pdf", True))
			testfiles.Add(New ConvertTestCS.Testfile("butterfly.png", "png2pdf.pdf", False))
			testfiles.Add(New ConvertTestCS.Testfile("simple-emf.emf", "emf2pdf.pdf", True))
			testfiles.Add(New ConvertTestCS.Testfile("simple-xps.xps", "xps2pdf.pdf", False))
			'  testfiles.Add(new ConvertTestCS.Testfile("simple-webpage.mht", "mht2pdf.pdf", true));
			testfiles.Add(New ConvertTestCS.Testfile("simple-webpage.html", "html2pdf.pdf", True))

			Dim err As Boolean = False
			If Environment.OSVersion.Platform = PlatformID.Win32NT Then
				Try
					If pdftron.PDF.Convert.Printer.IsInstalled("PDFTron PDFNet") Then
						pdftron.PDF.Convert.Printer.SetPrinterName("PDFTron PDFNet")
					ElseIf Not pdftron.PDF.Convert.Printer.IsInstalled() Then
						Try
							Console.WriteLine("Installing printer (requires Windows platform and administrator)")
							pdftron.PDF.Convert.Printer.Install()
							Console.WriteLine("Installed printer " & pdftron.PDF.Convert.Printer.GetPrinterName())
							'  la función ConvertToXpsFromFile puede requerir la impresora así que déjela instalada
							'  uninstallPrinterWhenDone = true;
						Catch e As PDFNetException
							Console.WriteLine("ERROR: Unable to install printer.")
							Console.WriteLine(e.Message)
							err = True
						Catch
							Console.WriteLine("ERROR: Unable to install printer. Make sure that the package's bitness matches your operating system's bitness and that you are running with administrator privileges.")
						End Try
					End If
				Catch e As PDFNetException
					Console.WriteLine("ERROR: Unable to install printer.")
					Console.WriteLine(e.Message)
					err = True
				End Try
			End If
			For Each file As Testfile In testfiles
				If Environment.OSVersion.Platform <> PlatformID.Win32NT Then
					If file.requiresWindowsPlatform Then
						Continue For
					End If
				End If
				Try
					Using pdfdoc As pdftron.PDF.PDFDoc = New PDFDoc()

						If pdftron.PDF.Convert.RequiresPrinter(inputPath & file.inputFile) Then
							Console.WriteLine("Using PDFNet printer to convert file " & file.inputFile)
						End If
						pdftron.PDF.Convert.ToPdf(pdfdoc, inputPath & file.inputFile)
						pdfdoc.Save(outputPath & file.outputFile, SDFDoc.SaveOptions.e_linearized)
						Console.WriteLine("Converted file: " & file.inputFile)
						Console.WriteLine("to: " & file.outputFile)
					End Using
				Catch e As PDFNetException
					Console.WriteLine("ERROR: on input file " & file.inputFile)
					Console.WriteLine(e.Message)
					err = True
				End Try
			Next file

			Return err
		End Function
		<STAThread>
		Shared Sub Main(ByVal args() As String)
			PDFNet.Initialize(PDFTronLicense.Key)
			Dim err As Boolean = False

			err = ConvertToPdfFromFile()
			If err Then
				Console.WriteLine("ConvertFile failed")
			Else
				Console.WriteLine("ConvertFile succeeded")
			End If

			err = ConvertSpecificFormats()
			If err Then
				Console.WriteLine("ConvertSpecificFormats failed")
			Else
				Console.WriteLine("ConvertSpecificFormats succeeded")
			End If

			If Environment.OSVersion.Platform = PlatformID.Win32NT Then
				If pdftron.PDF.Convert.Printer.IsInstalled() Then
					Try
						Console.WriteLine("Uninstalling printer (requires Windows platform and administrator)")
						pdftron.PDF.Convert.Printer.Uninstall()
						Console.WriteLine("Uninstalled Printer " & pdftron.PDF.Convert.Printer.GetPrinterName())
					Catch
						Console.WriteLine("Unable to uninstall printer")
					End Try
				End If
			End If
			PDFNet.Terminate()
			Console.WriteLine("Done.")
		End Sub
	End Class
End Namespace
VB   C#

5.2 Utilización de IronOCR

La gestión de archivos PDF puede completarse utilizando la función OCRInput. Cada página de un documento será leída por la clase Iron Tesseract. A continuación, se extraerá el texto de las páginas. Una segunda función llamada "AddPDF" nos permitirá abrir documentos protegidos y nos asegura que podemos añadir PDFs a nuestra lista de documentos (contraseña si está protegido). Para abrir un documento PDF protegido por contraseña, utilice el siguiente fragmento de código:

var Ocr = new IronTesseract(); //  nada que configurar
using (var Input = new OcrInput())
{
    Input.AddPdf("example.pdf", "password");
    var Result = Ocr.Read(Input);
    Console.WriteLine(Result.Text);
}
var Ocr = new IronTesseract(); //  nada que configurar
using (var Input = new OcrInput())
{
    Input.AddPdf("example.pdf", "password");
    var Result = Ocr.Read(Input);
    Console.WriteLine(Result.Text);
}
Dim Ocr = New IronTesseract() '  nada que configurar
Using Input = New OcrInput()
	Input.AddPdf("example.pdf", "password")
	Dim Result = Ocr.Read(Input)
	Console.WriteLine(Result.Text)
End Using
VB   C#

La lectura y extracción del contenido de una página de un archivo PDF puede realizarse utilizando la función "Addpdfpage". Especifique únicamente el número exacto de la página de la que queremos extraer el texto. "AddPdfPage" te permitirá extraer texto de varias páginas que especifiques. IEnumerablele permitirá especificar eficazmente numerosas páginas. También debe incluir la ubicación y la extensión del archivo. El siguiente fragmento de código lo demuestra:

IEnumerable<int> numbers = new List<int> {2,8,10 };
 var Ocr = new IronTesseract();
using (var Input = new OcrInput())
{
    //una sola página
    Input.AddPdfPage("example.pdf",10);
    //Varias páginas
    Input.AddPdfPages("example.pdf", numbers);
    var Result = Ocr.Read(Input);
    Console.WriteLine(Result.Text);
    Result.SaveAsTextFile("ocrtext.txt");
}
IEnumerable<int> numbers = new List<int> {2,8,10 };
 var Ocr = new IronTesseract();
using (var Input = new OcrInput())
{
    //una sola página
    Input.AddPdfPage("example.pdf",10);
    //Varias páginas
    Input.AddPdfPages("example.pdf", numbers);
    var Result = Ocr.Read(Input);
    Console.WriteLine(Result.Text);
    Result.SaveAsTextFile("ocrtext.txt");
}
Dim numbers As IEnumerable(Of Integer) = New List(Of Integer) From {2, 8, 10}
 Dim Ocr = New IronTesseract()
Using Input = New OcrInput()
	'una sola página
	Input.AddPdfPage("example.pdf",10)
	'Varias páginas
	Input.AddPdfPages("example.pdf", numbers)
	Dim Result = Ocr.Read(Input)
	Console.WriteLine(Result.Text)
	Result.SaveAsTextFile("ocrtext.txt")
End Using
VB   C#

Utilice la función GuardarComoArchivoDeTexto para almacenar directamente el resultado en un formato de archivo de texto, de modo que pueda descargar directamente el archivo en la ruta del directorio de salida. Para guardar el archivo en formato HTML utilice SaveAsHocrFile.

6.1 Utilización de PDFTron

Podemos utilizar el SDK PDFTron para extraer imágenes de archivos PDF, junto con su información de posicionamiento y DPI. En lugar de convertir las imágenes PDF en un mapa de bits, también puede extraer directamente los datos de la imagen sin comprimir/comprimida utilizando elements.GetImageData() (descrito en el ejemplo de código de extracción de datos PDF). Obtenga más información sobre nuestra biblioteca PDF C# y la biblioteca de análisis y extracción de contenido PDF.

6.2 Utilización de IronOCR

IronOCR cuenta con un impresionante número de funciones que le permitirán leer códigos QR y códigos de barras directamente desde documentos escaneados. El siguiente fragmento de código muestra cómo se puede escanear el código de barras de una imagen o documento determinado.

var Ocr = new IronTesseract(); //  nada que configurar
Ocr.Language = OcrLanguage.EnglishBest;
Ocr.Configuration.ReadBarCodes = true;
Ocr.Configuration.TesseractVersion = TesseractVersion.Tesseract5;
using (var Input = new OcrInput())
{
    Input.AddImage("barcode.gif");
    var Result = Ocr.Read(Input);

    foreach (var Barcode in Result.Barcodes)
    {
        Console.WriteLine(Barcode.Value);
    }
}
var Ocr = new IronTesseract(); //  nada que configurar
Ocr.Language = OcrLanguage.EnglishBest;
Ocr.Configuration.ReadBarCodes = true;
Ocr.Configuration.TesseractVersion = TesseractVersion.Tesseract5;
using (var Input = new OcrInput())
{
    Input.AddImage("barcode.gif");
    var Result = Ocr.Read(Input);

    foreach (var Barcode in Result.Barcodes)
    {
        Console.WriteLine(Barcode.Value);
    }
}
Dim Ocr = New IronTesseract() '  nada que configurar
Ocr.Language = OcrLanguage.EnglishBest
Ocr.Configuration.ReadBarCodes = True
Ocr.Configuration.TesseractVersion = TesseractVersion.Tesseract5
Using Input = New OcrInput()
	Input.AddImage("barcode.gif")
	Dim Result = Ocr.Read(Input)

	For Each Barcode In Result.Barcodes
		Console.WriteLine(Barcode.Value)
	Next Barcode
End Using
VB   C#

Lo anterior es el código que ayuda a leer el código de barras de una imagen dada o documento PDF. Se pueden leer numerosos códigos de barras al mismo tiempo en una sola imagen o página. IronOCR tiene un método distintivo que leerá el código de barras, Ocr.Configuration.ReadBarCodes.

Los datos se almacenan en un objeto llamado OCRResult después de escanear la entrada. La propiedad en OCRResult se llama Barcodes que tendrá una lista de todos los datos de código de barras disponibles. Podemos obtener cada dato individual relacionado con los detalles del código de barras utilizando un bucle for-each. Se realizan dos operaciones en un solo proceso: el escaneado y la lectura del valor del código de barras.

También admite opciones de enhebrado y permite realizar varios procesos de OCR al mismo tiempo. Además, IronOCR puede reconocer un área precisa de una región especificada.

var Ocr = new IronTesseract();
using (var Input = new OcrInput())
{
    var ContentArea = new System.Drawing.Rectangle() { X = 215, Y = 1250, Height = 280, Width = 1335 };
    Input.Add("document.png", ContentArea);
    var Result = Ocr.Read(Input);
    Console.WriteLine(Result.Text);
}
var Ocr = new IronTesseract();
using (var Input = new OcrInput())
{
    var ContentArea = new System.Drawing.Rectangle() { X = 215, Y = 1250, Height = 280, Width = 1335 };
    Input.Add("document.png", ContentArea);
    var Result = Ocr.Read(Input);
    Console.WriteLine(Result.Text);
}
Dim Ocr = New IronTesseract()
Using Input = New OcrInput()
	Dim ContentArea = New System.Drawing.Rectangle() With {
		.X = 215,
		.Y = 1250,
		.Height = 280,
		.Width = 1335
	}
	Input.Add("document.png", ContentArea)
	Dim Result = Ocr.Read(Input)
	Console.WriteLine(Result.Text)
End Using
VB   C#

El fragmento de código anterior muestra cómo realizar el OCR en una región determinada. Sólo es necesario especificar la región rectangular en el PDF/imagen, ya que el motor IronOCRs Tesseract ayudará a reconocer el texto.

Modelos de licencia y precios de IronOCR y PDFtron OCR

Modelos de licencia y precios de IronOCR

Garantía de devolución del dinero de 30 días: Una vez adquirida la licencia, obtendrá una garantía de devolución del dinero de 30 días. En el plazo de 30 días, si desea devolver el producto, se le devolverá el dinero.

Fácil integración: La integración de IronOCR con cualquier proyecto y entorno es tan sencilla que se puede conseguir en una sola línea de código simplemente añadiéndolo como un NuGet Paquete. Por otro lado, otra forma de integrar el entorno es descargarlo directamente de la web.

Licencia perpetua: Cada licencia adquirida no requiere renovación.

Soporte gratuito y actualizaciones del producto: Cada licencia tendrá soporte directamente del grupo detrás del producto y vendrá con un año de actualizaciones gratuitas del producto. Las extensiones de compra están disponibles en cualquier momento.

Licencias inmediatas: Una vez recibido el pago, se enviarán inmediatamente las claves de licencia registradas.

Todas las licencias son perpetuas y se aplican al desarrollo, la puesta en marcha y la producción.

La licencia Lite

  • 1 promotor
  • 1 ubicación
  • 1 proyecto
  • Licencia perpetua

    Este paquete permite a un único desarrollador de software de una organización utilizar Iron Software en una única ubicación. Iron Software puede utilizarse en una única aplicación de intranet, aplicación web o programa de software de escritorio. Está prohibido compartir licencias fuera de una organización o de una relación agencia/cliente, ya que son intransferibles. Este tipo de licencia, al igual que todos los demás tipos de licencia, excluye expresamente todos los derechos no concedidos expresamente en virtud del Acuerdo sin la redistribución OEM y la utilización del Software Iron como SaaS sin adquirir cobertura adicional.

    Precios: Desde $599 al año.

La licencia profesional

  • 10 promotores
  • 10 emplazamientos
  • 10 proyectos
  • Licencia perpetua

    Esta licencia permite a un número predeterminado de desarrolladores de software de una organización utilizar Iron Software en numerosas ubicaciones, con un máximo de diez. Iron Software puede utilizarse en tantos sitios web, aplicaciones de intranet o aplicaciones de software de escritorio como se desee. Las licencias son intransferibles y no pueden compartirse fuera de una organización o de una relación agencia/cliente. Este tipo de licencia, al igual que todos los demás tipos de licencia, excluye expresamente todos los derechos no concedidos expresamente en virtud del Acuerdo, incluida la redistribución OEM y la utilización del Software Iron como SaaS sin adquirir cobertura adicional. Esta licencia puede integrarse en un solo proyecto hasta un máximo de 10.

    Precios: Desde 999 $ al año.

La licencia ilimitada

  • Desarrolladores ilimitados
  • Ubicaciones ilimitadas
  • Proyectos ilimitados
  • Licencia perpetua

    Esto permite que un número ilimitado de desarrolladores de software de una organización utilicen Iron Software en un número ilimitado de ubicaciones. Iron Software puede utilizarse en tantas aplicaciones de intranet, aplicaciones de software de escritorio o sitios web como se desee. Las licencias son intransferibles y no pueden compartirse fuera de una organización o de una relación agencia/cliente. Este tipo de licencia, como todos los demás tipos de licencia, excluye expresamente todos los derechos no concedidos en virtud del Acuerdo, incluida la redistribución OEM y la utilización del Software Iron como SaaS sin adquirir cobertura adicional.

    Precios: Desde $2,399 al año.

    Redistribución libre de regalías — Esto le permite distribuir el software Iron como parte de varios productos comerciales empaquetados de forma diferente (sin tener que pagar derechos de autor) en función del número de proyectos cubiertos por la licencia base. Esto permitirá el despliegue de Iron Software dentro de los servicios de software SaaS, que se basa en el número de proyectos cubiertos por la licencia base.

    Precios: Desde 1.599 $ al año.

Modelos de licencia y precios de PDFTron

Paquetes PDFTron (licencias personalizadas)

  • Los precios de las licencias personalizadas varían: solicite un presupuesto ajustado a sus necesidades.
  • Implemente la potente tecnología de visualización y edición de documentos de PDFTron para la representación y el procesamiento de documentos en plataformas web, móviles y de escritorio.
  • Preparado para la integración, la redistribución de OEM y las organizaciones con grandes volúmenes de documentos o requisitos exclusivos.
  • Precios multidominio y descuentos multianuales favorables
  • Compatible con operaciones fuera de línea y en entornos aislados
  • Condiciones contractuales personalizadas y completas
  • Servicios de consultoría y formación

    Las licencias personalizadas de PDFTron se adaptan a los requisitos de su aplicación y empresa. El precio depende del alcance de sus funciones.

    La licencia IronOCR Lite es un paquete indefinido que incluye un desarrollador con un año de soporte, y cuesta alrededor de $599. La licencia profesional de IronOCR, que incluye 10 paquetes para desarrolladores y un año de asistencia, cuesta 999 dólares, mientras que, de nuevo, los paquetes de PDFTron no están definidos. Para comprar un paquete, debe ponerse en contacto con el centro de asistencia para obtener un presupuesto.

Los paquetes IronOCR Lite y Professional incluyen servicio OEM o SaaS con una opción de soporte de 5 años. La versión Lite incluye un paquete para un desarrollador con 5 años de asistencia y servicio Saas y OEM cuesta 2.897 dólares con una opción de asistencia personalizada. La versión Professional de IronOCR incluye un paquete de 10 desarrolladores con 5 años de soporte, Saas y servicio OEM y cuesta 3.397 dólares. El paquete de 10 desarrolladores de PDFTron con un año de asistencia, Saas y servicio OEM no tiene un precio definido.

7.0 Conclusión

IronOCR en el contexto de .NET Framework suministra Tesseract que es fácil de usar con el apoyo de fotos y documentos PDF logrado de numerosas maneras. También proporciona varios ajustes para mejorar el rendimiento de la biblioteca Tesseract OCRs. Admite un gran número de idiomas, con la posibilidad de tener varios idiomas en una sola operación. Visite su sitio web para obtener más información sobre Tesseract OCR.

PDFTron es una aplicación que utiliza diferentes motores para reconocer imágenes y documentos PDF. También ofrece varios ajustes para mejorar el rendimiento del proceso de OCR y la posibilidad de seleccionar varios idiomas. PDFTron tiene limitaciones en el uso de conversiones de páginas. También tiene varios precios para distintos sistemas operativos.

IronOCR es un producto de software competitivo y puede ofrecer mayor precisión que las marcas de la competencia. Otros productos similares han fallado en ocasiones a la hora de reconocer imágenes de baja calidad, dando como resultado caracteres desconocidos. Por otro lado, IronOCR no sólo proporciona resultados precisos, sino que nos permite reconocer datos de códigos de barras y leer el valor de los mismos a partir de imágenes.

Los paquetes IronOCR ofrecen licencias y asistencia competitivas a un precio único para todas las plataformas. En comparación, los productos OCR de PDFtrons son todos exclusivamente de selección personalizada, por lo que tienden a ser más caros. Los precios varían entre ambos productos: IronOCR comienza con un precio de $599, mientras que, debido a la selección personalizada, el precio inicial de PDFTron es indefinido. En conclusión, IronOCR ofrece una mayor variedad de funciones por un precio inferior.

¿A qué espera? La prueba gratuita está abierta a todos. Obtener el Licencia aquí y comience inmediatamente!

< ANTERIOR
Alternativas a Tesseract (actualización de 2022)
SIGUIENTE >
Comparación entre IronOCR y Tesseract.NET

¿Listo para empezar? Versión: 2024.6 recién publicada

Comenzar prueba gratuita Descargas totales: 1,860,811
Ver licencias >