Conversión de documentos

El resultado de este escenario es una versión editable de un documento.

En este escenario, se reconocen imágenes de documentos y se conserva intacto todo el formato original; luego, los datos se guardan en un formato de archivo editable. Como resultado, obtiene versiones editables de sus documentos, que pueden revisarse fácilmente para detectar errores y modificarse. También podrá copiar todo o parte del texto para reutilizarlo.

Un documento pasa por varias etapas de procesamiento, que en algunos aspectos difieren ligeramente de las de otros escenarios habituales:

1. Preprocesamiento de imágenes escaneadas o fotografías

Las imágenes obtenidas con un escáner o una cámara digital pueden requerir algunos ajustes antes de poder reconocerse ópticamente. Por ejemplo, las imágenes con ruido o con líneas de texto distorsionadas necesitarán cierta corrección para que el reconocimiento óptico se realice correctamente.

2. Reconocimiento con restauración completa de la estructura y el formato del documento

Al reconocer un documento, se identifican varios elementos de diseño del documento (texto, tablas, imágenes, separadores, etc.). Durante la síntesis del documento, se restaura su estructura lógica, mientras que la síntesis de la página permite recuperar por completo el formato del documento (fuentes, estilos, etc.).

3. Exportación a un formato editable

El documento reconocido se guarda en un formato editable, como RTF o DOCX.

​

Implementación del escenario

Los ejemplos de código proporcionados en este tema son específicos de Windows.

A continuación, encontrará una descripción detallada del método recomendado para usar ABBYY FineReader Engine 12 para convertir documentos. El método propuesto utiliza la configuración de procesamiento más adecuada para este propósito.

Paso 1. Cargar ABBYY FineReader Engine

Para comenzar a trabajar con ABBYY FineReader Engine, es necesario crear el objeto Engine. El objeto Engine es el objeto de nivel superior en la jerarquía de objetos de ABBYY FineReader Engine y proporciona diversas configuraciones globales, algunos métodos de procesamiento y métodos para crear los demás objetos.

Para crear el objeto Engine, puede usar la función InitializeEngine. Consulte también otras formas de cargar el objeto Engine (Win).

​

C#

public class EngineLoader : IDisposable
{
    public EngineLoader()
    {
        // Inicialice estas variables con la ruta completa a FREngine.dll, su Customer Project ID,
        // y, si corresponde, la ruta al archivo de token de su licencia en línea y la contraseña de la licencia en línea
        string enginePath = "";
        string customerProjectId = "";
        string licensePath = "";
        string licensePassword = "";
        // Cargar la biblioteca FREngine.dll
        dllHandle = LoadLibraryEx(enginePath, IntPtr.Zero, LOAD_WITH_ALTERED_SEARCH_PATH);
           
        try
        {
            if (dllHandle == IntPtr.Zero)
            {
                throw new Exception("No se puede cargar " + enginePath);
            }
            IntPtr initializeEnginePtr = GetProcAddress(dllHandle, "InitializeEngine");
            if (initializeEnginePtr == IntPtr.Zero)
            {
                throw new Exception("No se encuentra la función InitializeEngine");
            }
            IntPtr deinitializeEnginePtr = GetProcAddress(dllHandle, "DeinitializeEngine");
            if (deinitializeEnginePtr == IntPtr.Zero)
            {
                throw new Exception("No se encuentra la función DeinitializeEngine");
            }
            IntPtr dllCanUnloadNowPtr = GetProcAddress(dllHandle, "DllCanUnloadNow");
            if (dllCanUnloadNowPtr == IntPtr.Zero)
            {
                throw new Exception("No se encuentra la función DllCanUnloadNow");
            }
            // Convertir punteros en delegados
            initializeEngine = (InitializeEngine)Marshal.GetDelegateForFunctionPointer(
                initializeEnginePtr, typeof(InitializeEngine));
            deinitializeEngine = (DeinitializeEngine)Marshal.GetDelegateForFunctionPointer(
                deinitializeEnginePtr, typeof(DeinitializeEngine));
            dllCanUnloadNow = (DllCanUnloadNow)Marshal.GetDelegateForFunctionPointer(
                dllCanUnloadNowPtr, typeof(DllCanUnloadNow));
            // Llamar a la función InitializeEngine 
            // pasando la ruta al archivo de licencia en línea y la contraseña de la licencia en línea
            int hresult = initializeEngine(customerProjectId, licensePath, licensePassword, 
                "", "", false, ref engine);
            Marshal.ThrowExceptionForHR(hresult);
        }
        catch (Exception)
        {
            // Liberar la biblioteca FREngine.dll
            engine = null;
            // Eliminar todos los objetos antes de llamar a FreeLibrary
            GC.Collect();
            GC.WaitForPendingFinalizers();
            GC.Collect();
            FreeLibrary(dllHandle);
            dllHandle = IntPtr.Zero;
            initializeEngine = null;
            deinitializeEngine = null;
            dllCanUnloadNow = null;
            throw;
        }
    }
    // Funciones de Kernel32.dll
    [DllImport("kernel32.dll")]
    private static extern IntPtr LoadLibraryEx(string dllToLoad, IntPtr reserved, uint flags);
    private const uint LOAD_WITH_ALTERED_SEARCH_PATH = 0x00000008;
    [DllImport("kernel32.dll")]
    private static extern IntPtr GetProcAddress(IntPtr hModule, string procedureName);
    [DllImport("kernel32.dll")]
    private static extern bool FreeLibrary(IntPtr hModule);
    // Funciones de FREngine.dll
    [UnmanagedFunctionPointer(CallingConvention.StdCall, CharSet = CharSet.Unicode)]
    private delegate int InitializeEngine(string customerProjectId, string licensePath, 
        string licensePassword, string tempFolder, string dataFolder, bool isSharedCPUCoresMode, 
        ref FREngine.IEngine engine);
    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    private delegate int DeinitializeEngine();
    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    private delegate int DllCanUnloadNow();
    // Variables privadas
    private FREngine.IEngine engine = null;
    // Handle de FREngine.dll
    private IntPtr dllHandle = IntPtr.Zero;
    private InitializeEngine initializeEngine = null;
    private DeinitializeEngine deinitializeEngine = null;
    private DllCanUnloadNow dllCanUnloadNow = null;
}

​

C++ (COM)

// Inicialice estas variables con la ruta a FREngine.dll, el Customer Project ID de FineReader Engine,
// y, si corresponde, la ruta al token de licencia en línea y la contraseña de la licencia en línea
wchar_t* FreDllPath;
wchar_t* CustomerProjectId;
wchar_t* LicensePath;  // si no usa una licencia en línea, asigne cadenas vacías a estas variables
wchar_t* LicensePassword;
// HANDLE de FREngine.dll
static HMODULE libraryHandle = 0;
// Objeto global de FineReader Engine
FREngine::IEnginePtr Engine;
void LoadFREngine()
{
    if( Engine != 0 ) {
    // Ya cargado
    return;
    }
    // Primer paso: cargar FREngine.dll
    if( libraryHandle == 0 ) {
        libraryHandle = LoadLibraryEx( FreDllPath, 0, LOAD_WITH_ALTERED_SEARCH_PATH );
        if( libraryHandle == 0 ) {
            throw L"Error al cargar ABBYY FineReader Engine";
        }
    }
    // Segundo paso: obtener el objeto Engine
    typedef HRESULT ( STDAPICALLTYPE* InitializeEngineFunc )( BSTR, BSTR, BSTR, BSTR, 
        BSTR, VARIANT_BOOL, FREngine::IEngine** );
    InitializeEngineFunc pInitializeEngine =
    ( InitializeEngineFunc )GetProcAddress( libraryHandle, "InitializeEngine" );
    if( pInitializeEngine == 0 || pInitializeEngine( CustomerProjectId, LicensePath, 
        LicensePassword, L"", L"", VARIANT_FALSE, &Engine ) != S_OK ) {
    UnloadFREngine();
    throw L"Error al cargar ABBYY FineReader Engine";
    }
}

Paso 2. Carga de la configuración para este escenario

ABBYY FineReader Engine permite cargar la configuración más adecuada para este escenario mediante el método LoadPredefinedProfile del objeto Engine. Este método recibe el nombre del perfil como parámetro de entrada. Consulte Uso de perfiles para obtener más información.

ABBYY FineReader Engine admite 2 variantes de configuración para este escenario:

Nombre del perfil	Descripción
DocumentConversion_Accuracy	La configuración se ha optimizado para la precisión: Máxima calidad. Habilita la detección del estilo de fuente y la síntesis completa de la estructura lógica de un documento.
DocumentConversion_Normal	La configuración se ha optimizado para la velocidad de procesamiento: Máxima calidad. Habilita la detección del estilo de fuente y la síntesis completa de la estructura lógica de un documento. No se corrige la orientación de la imagen. Se acelera el proceso de análisis del documento.

​

C#

// Cargar un perfil predefinido
engine.LoadPredefinedProfile("DocumentConversion_Normal");

​

C++ (COM)

// Cargar un perfil predefinido
Engine->LoadPredefinedProfile( L"DocumentConversion_Normal" );

Si desea cambiar la configuración de procesamiento, use los objetos Parameter adecuados. Consulte Optimización adicional para tareas específicas más abajo para obtener más información.

Paso 3. Carga y preprocesamiento de imágenes

ABBYY FineReader Engine proporciona el objeto FRDocument, que permite procesar documentos de varias páginas. El uso de este objeto le permite conservar la organización lógica del documento y mantener el texto original, las columnas, las fuentes, los estilos, etc.

Para cargar imágenes de un solo documento y preprocesarlas, debe crear el objeto FRDocument y agregarle imágenes. Puede realizar una de las siguientes acciones:

• Cree el objeto FRDocument mediante el método CreateFRDocumentFromImage del objeto Engine. Este método crea el objeto FRDocument y carga imágenes desde el archivo especificado.
• Cree el objeto FRDocument con el método CreateFRDocument del objeto Engine y, a continuación, agregue imágenes al objeto FRDocument creado desde un archivo (use el método AddImageFile, AddImageFileWithPassword o AddImageFileWithPasswordCallback del objeto FRDocument).

​

C#

// Crear el objeto FRDocument a partir de un archivo de imagen
FREngine.IFRDocument frDocument = engine.CreateFRDocumentFromImage( "C:\\MyImage.tif", null );

​

C++ (COM)

// Crear el objeto FRDocument a partir de un archivo de imagen
FREngine::IFRDocumentPtr frDocument = Engine->CreateFRDocumentFromImage( L"C:\\MyImage.tif", 0 );

El preprocesamiento de imágenes con el perfil DocumentConversion_Normal cargado no incluye la detección de la orientación. Si desea que la orientación de la imagen se detecte automáticamente, deberá configurar parámetros adicionales y pasar el objeto correspondiente a la función de preprocesamiento. Consulte Optimización adicional para tareas específicas más abajo para obtener más información.

Paso 4. Reconocimiento de documentos

Para reconocer un documento, le recomendamos usar los métodos de análisis y reconocimiento del objeto FRDocument. Este objeto ofrece toda una gama de métodos para el análisis, reconocimiento y síntesis de documentos. El método más práctico, que combina el análisis, el reconocimiento y la síntesis de documentos en una sola operación, es Process. Además, aprovecha de la forma más eficiente las funciones de procesamiento simultáneo de los sistemas multiprocesador y multinúcleo. No obstante, también puede realizar de forma secuencial el preprocesamiento, el análisis, el reconocimiento y la síntesis mediante los métodos Preprocess, Analyze, Recognize y Synthesize.

​

C#

// Analiza, reconoce y sintetiza el documento
// No se necesitan parámetros adicionales porque están configurados por el perfil de procesamiento
frDocument.Process( null );

​

C++ (COM)

// Analiza, reconoce y sintetiza el documento
// No se necesitan parámetros adicionales porque están configurados por el perfil de procesamiento
frDocument->Process( 0 );

Paso 5. Exportación de documentos

Para guardar un documento reconocido, puede usar el método Export del objeto FRDocument y especificar la constante FileExportFormatEnum como uno de los parámetros. Puede cambiar los parámetros predeterminados de exportación mediante el objeto de exportación correspondiente. Consulte Optimización adicional para tareas específicas más abajo para obtener más información.

Cuando haya terminado de trabajar con el objeto FRDocument, libere todos los recursos utilizados por este objeto. Use el método IFRDocument::Close.

​

C#

// Guarda el documento reconocido en un formato editable (por ejemplo, RTF)
frDocument.Export( "C:\\MyText.rtf", FREngine.FileExportFormatEnum.FEF_RTF, null );
// Libera el objeto FRDocument
frDocument.Close();

​

C++ (COM)

// Guarda el documento reconocido en un formato editable (por ejemplo, RTF)
frDocument->Export( L"C:\\MyText.rtf", FREngine::FEF_RTF, 0 );
// Libera el objeto FRDocument
frDocument->Close();

Paso 6. Descarga de ABBYY FineReader Engine

Después de terminar de trabajar con ABBYY FineReader Engine, debe descargar el objeto Engine. Para ello, use la función exportada DeinitializeEngine.

​

C#

public class EngineLoader : IDisposable
{
    // Descargar FineReader Engine
    public void Dispose()
    {
        if (engine == null)
        {
            // Engine no se cargó
            return;
        }
        engine = null;
        // Eliminar todos los objetos antes de llamar a FreeLibrary
        GC.Collect();
        GC.WaitForPendingFinalizers();
        GC.Collect();
        int hresult = deinitializeEngine();
 
        hresult = dllCanUnloadNow();
        if (hresult == 0)
        {
            FreeLibrary(dllHandle);
        }
        dllHandle = IntPtr.Zero;
        initializeEngine = null;
        deinitializeEngine = null;
        dllCanUnloadNow = null;
        // lanzar una excepción después de la limpieza
        Marshal.ThrowExceptionForHR(hresult);
    }
    // Funciones de Kernel32.dll
    [DllImport("kernel32.dll")]
    private static extern IntPtr LoadLibraryEx(string dllToLoad, IntPtr reserved, uint flags);
    private const uint LOAD_WITH_ALTERED_SEARCH_PATH = 0x00000008;
    [DllImport("kernel32.dll")]
    private static extern IntPtr GetProcAddress(IntPtr hModule, string procedureName);
    [DllImport("kernel32.dll")]
    private static extern bool FreeLibrary(IntPtr hModule);
    // Funciones de FREngine.dll
    [UnmanagedFunctionPointer(CallingConvention.StdCall, CharSet = CharSet.Unicode)]
    private delegate int InitializeEngine( string customerProjectId, string LicensePath, string LicensePassword, , , , ref FREngine.IEngine engine);
    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    private delegate int DeinitializeEngine();
    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    private delegate int DllCanUnloadNow();
    // Variables privadas
    private FREngine.IEngine engine = null;
    // Identificador de FREngine.dll
    private IntPtr dllHandle = IntPtr.Zero;
    private InitializeEngine initializeEngine = null;
    private DeinitializeEngine deinitializeEngine = null;
    private DllCanUnloadNow dllCanUnloadNow = null;
}

​

C++ (COM)

void UnloadFREngine()
{
 if( libraryHandle == 0 ) {
  return;
 }
 // Liberar el objeto Engine
 Engine = 0;
 // Desinicializar FineReader Engine
 typedef HRESULT ( STDAPICALLTYPE* DeinitializeEngineFunc )();
 DeinitializeEngineFunc pDeinitializeEngine =
  ( DeinitializeEngineFunc )GetProcAddress( libraryHandle, "DeinitializeEngine" );
 if( pDeinitializeEngine == 0 || pDeinitializeEngine() != S_OK ) {
  throw L"Error al descargar ABBYY FineReader Engine";
 }
 // Ahora ya es seguro liberar la biblioteca FREngine.dll
 FreeLibrary( libraryHandle );
 libraryHandle = 0;
}

​

Recursos necesarios

Puede usar el archivo FREngineDistribution.csv para crear automáticamente una lista de los archivos necesarios para que su aplicación funcione. Para procesar con este escenario, seleccione en la columna 5 (RequiredByModule) los siguientes valores:

Core

Core.Resources

Opening

Opening, Processing

Processing

Processing.OCR

Processing.OCR, Processing.ICR

Processing.OCR.NaturalLanguages

Processing.OCR.NaturalLanguages, Processing.ICR.NaturalLanguages

Export

Export, Processing

Si modifica el escenario estándar, cambie los módulos necesarios según corresponda. También debe especificar los idiomas de la interfaz, los idiomas de reconocimiento y cualquier funcionalidad adicional que use su aplicación (como, por ejemplo, Opening.PDF si necesita abrir archivos PDF, o Processing.OCR.CJK si necesita reconocer texto en idiomas CJK). Consulte Working with the FREngineDistribution.csv File para obtener más información.

​

Optimización adicional para tareas específicas

A continuación se presenta una descripción general de los temas de Ayuda que contienen información adicional sobre cómo personalizar la configuración en las distintas etapas de la conversión de documentos a un formato editable:

• Escaneo - Solo Windows
  • Escaneo
    Descripción del escenario de ABBYY FineReader Engine para el escaneo de documentos.
• Reconocimiento
  • Ajuste de los parámetros de preprocesamiento, análisis, reconocimiento y síntesis
    Personalización del procesamiento de documentos mediante objetos de parámetros de análisis, reconocimiento y síntesis.
  • Reconocer escritura a mano
    Los perfiles DocumentConversion_*** no incluyen el reconocimiento de texto manuscrito ni escrito a mano en letra de molde. Si necesita reconocer escritura a mano, establezca la propiedad DetectHandwritten del objeto PageAnalysisParams en TRUE.
  • PageProcessingParams Object
    Este objeto permite personalizar los parámetros de análisis y reconocimiento. Con este objeto, puede indicar qué características de la imagen y del texto deben detectarse (imagen invertida, orientación, códigos de barras, idioma de reconocimiento, margen de error de reconocimiento).
  • SynthesisParamsForPage Object
    Este objeto incluye los parámetros responsables de restaurar el formato de una página durante la síntesis.
  • SynthesisParamsForDocument Object
    Este objeto permite personalizar la síntesis del documento: la restauración de su estructura y formato.
  • MultiProcessingParams Object - Implementado para Linux y Windows
    El procesamiento simultáneo puede ser útil al procesar una gran cantidad de imágenes. En este caso, la carga de procesamiento se distribuirá entre los núcleos del procesador durante la apertura y el preprocesamiento de imágenes, el análisis del diseño, el reconocimiento y la exportación, lo que permitirá acelerar el procesamiento.
    Los modos de procesamiento (simultáneo o consecutivo) se establecen mediante la propiedad MultiProcessingMode. La propiedad RecognitionProcessesCount controla la cantidad de procesos que pueden iniciarse.
• Exportación
  • Ajuste de los parámetros de exportación
    Personalización de la exportación de documentos mediante objetos de parámetros de exportación.
  • RTFExportParams Object
    Este objeto permite personalizar los parámetros del formato de guardado RTF/DOCX/ODT.
  • HTMLExportParams Object
    Este objeto permite personalizar la exportación al formato HTML.
  • PPTExportParams Object
    Objeto para personalizar los parámetros del formato de guardado PPTX.

​

Consulte también

Implementación de escenarios de uso básicos