Reconocimiento de códigos de barras

En este escenario, ABBYY FineReader Engine se utiliza para leer códigos de barras. Puede ser necesario leer códigos de barras, por ejemplo, para separar documentos automáticamente, para procesar documentos mediante un sistema de gestión documental o para indexarlos y clasificarlos.

Este escenario puede utilizarse como parte de otros escenarios. Por ejemplo, los documentos escaneados con escáneres de producción de alta velocidad pueden separarse mediante códigos de barras, o los documentos preparados para su almacenamiento a largo plazo pueden incorporarse a sistemas de gestión documental de archivo en función de los valores de sus códigos de barras.

Al extraer códigos de barras de textos, el sistema puede detectar todos los códigos de barras o solo los de un tipo determinado con un valor determinado. El sistema puede obtener el valor de un código de barras y calcular su suma de comprobación. Para obtener los resultados más rápidos y de mayor calidad en el reconocimiento de códigos de barras:

1. Utilice imágenes en color con una resolución óptima de 300 dpi.

2. Ajuste la velocidad de reconocimiento mediante perfiles (consulte Uso de perfiles para obtener más información).

Los valores reconocidos de los códigos de barras pueden guardarse en los formatos más adecuados para su posterior procesamiento, por ejemplo, en TXT.

​

Implementación del escenario

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

A continuación, se ofrece una descripción detallada del método recomendado para utilizar ABBYY FineReader Engine 12 en este escenario. Este método utiliza la configuración de procesamiento considerada más adecuada para este escenario.

Paso 1. Carga de 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 licencia en línea y la contraseña de 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 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;
    // Identificador 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 licencia en línea
wchar_t* FreDllPath;
wchar_t* CustomerProjectId;
wchar_t* LicensePath;  // si no utiliza 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 el escenario

La configuración más adecuada puede seleccionarse mediante el método LoadPredefinedProfile del objeto Engine. Este método acepta como parámetro de entrada el nombre del perfil de configuración que se va a utilizar. Para obtener más información sobre los perfiles, consulte Uso de perfiles.

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

Nombre del perfil	Descripción
BarcodeRecognition_Accuracy	Extrae solo códigos de barras (no detecta texto, imágenes ni tablas). La configuración se ha optimizado para la precisión. Este perfil requiere que el módulo Barcode Autolocation esté disponible en la licencia.
BarcodeRecognition_Speed	Extrae solo códigos de barras (no detecta texto, imágenes ni tablas). La configuración se ha optimizado para la velocidad de procesamiento. Este perfil requiere que el módulo Barcode Autolocation esté disponible en la licencia.

​

C#

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

​

C++ (COM)

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

Si desea cambiar la configuración utilizada para el procesamiento, use los objetos Parameter correspondientes. Consulte la sección Optimización adicional más abajo para obtener más información.

Paso 3. Carga y preprocesamiento de las imágenes

ABBYY FineReader Engine proporciona un objeto FRDocument para procesar documentos de varias páginas. Para cargar las imágenes de un documento y preprocesarlas, debe crear el objeto FRDocument y añadirle imágenes. Puede hacer una de las siguientes cosas:

• Crear un objeto FRDocument mediante el método CreateFRDocumentFromImage del objeto Engine. Este método crea un objeto FRDocument y carga imágenes desde un archivo especificado.
• Crear un objeto FRDocument con el método CreateFRDocument del objeto Engine y, después, agregar 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)

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

Paso 4. Extracción de códigos de barras

Si el perfil BarcodeRecognition está cargado, puede usar el método Process del objeto FRDocument para extraer únicamente códigos de barras. En este caso, ABBYY FineReader Engine detecta solo bloques con códigos de barras. No detecta ningún otro bloque. Puede acceder a los bloques de códigos de barras reconocidos mediante el objeto Layout, que es un subobjeto del objeto FRPage que representa una página del documento.

Para leer códigos de barras de un tipo específico, especifique los parámetros correspondientes del objeto BarcodeParams y pase el objeto BarcodeParams como parámetro a una de las funciones anteriores.

​

C#

// Mientras el perfil BarcodeRecognition esté cargado,
// no es necesario pasar parámetros adicionales al método de procesamiento
// si los códigos de barras cumplen las especificaciones
frDocument.Process( null );
// Si necesita leer códigos de barras de un tipo específico
// Cree un objeto DocumentProcessingParams
FREngine.IDocumentProcessingParams dpp = engine.CreateDocumentProcessingParams();
// Especifique los parámetros necesarios
dpp.PageProcessingParams.PageAnalysisParams.BarcodeParams.Type = ( int )FREngine.BarcodeTypeEnum.BT_Code39;
// Ahora reconozca códigos de barras con estos parámetros
frDocument.Process( dpp );

​

C++ (COM)

// Mientras el perfil BarcodeRecognition esté cargado,
// no es necesario pasar parámetros adicionales al método de procesamiento
// si los códigos de barras cumplen las especificaciones
frDocument->Process( 0 );
// Si necesita leer códigos de barras de un tipo específico
// Cree un objeto DocumentProcessingParams
FREngine::IDocumentProcessingParamsPtr params = Engine->CreateDocumentProcessingParams();
// Especifique los parámetros necesarios
params->PageProcessingParams->PageAnalysisParams->BarcodeParams->Type = FREngine::BT_Code39;
// Ahora reconozca códigos de barras con estos parámetros
frDocument->Process( params );

Paso 5. Exportación de los datos reconocidos

Para guardar en un archivo los valores de los códigos de barras reconocidos, puede usar el método Export del objeto FRDocument y asignar la constante FileExportFormatEnum como uno de los parámetros. Por ejemplo, en este escenario se puede exportar a TXT. Puede cambiar los parámetros de exportación predeterminados 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#

// Guarde los códigos de barras reconocidos en algún formato (por ejemplo, TXT)
frDocument.Export( "C:\\barcodes.txt", FREngine.FileExportFormatEnum.FEF_TextUnicodeDefaults, null );
// Libere el objeto FRDocument
frDocument.Close();

​

C++ (COM)

// Guarde los códigos de barras reconocidos en algún formato (por ejemplo, TXT)
frDocument->Export( L"C:\\barcodes.txt", FREngine::FEF_TextUnicodeDefaults, 0 );
// Libere 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;
        // generar 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 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 función 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

Estas son las secciones del archivo de ayuda donde puede encontrar información adicional sobre cómo configurar los parámetros para las distintas etapas de procesamiento:

• Extracción y lectura de códigos de barras
  • BarcodeParams Object
    Este objeto le permite configurar los parámetros de análisis y lectura de códigos de barras.
  • Recognizing Barcodes
    Aborda casos especiales del reconocimiento de códigos de barras y ofrece sugerencias para trabajar con ellos.
  • Barcode Types
    La lista de códigos de barras admitidos en ABBYY FineReader Engine 12 y una breve descripción de cada uno.
  • FRDocument Object
    Además de los valores de los códigos de barras, puede que necesite extraer otra información contenida en el documento. En ese caso, puede utilizar los métodos del objeto FRDocument.
  • PageProcessingParams Object
    Este objeto le permite configurar los parámetros de análisis y reconocimiento para todo el documento. Con este objeto, puede especificar si deben reconocerse los valores de los códigos de barras. Se puede acceder a los parámetros de lectura de códigos de barras a través de las propiedades BarcodeParams y DetectBarcodes del subobjeto PageAnalysisParams.
  • Working with Layout and Blocks
    También puede marcar manualmente bloques de códigos de barras y especificar sus parámetros de análisis y lectura. En esta sección se proporciona información detallada sobre el trabajo con bloques.
• Trabajo con los valores reconocidos de los códigos de barras
  • BarcodeBlock Object
    Las propiedades Text y BarcodeText de este objeto contienen el valor del código de barras obtenido mediante el reconocimiento. Las demás propiedades de este objeto pueden utilizarse para obtener el tipo de código de barras, su orientación y otros parámetros.
• Exportación
  • Tuning Export Parameters
    Configuración de la exportación mediante objetos de parámetros de exportación.
  • TextExportParams Object
    Este objeto le permite configurar el guardado de los resultados del reconocimiento en archivos TXT.

​

Consulte también

Implementación de escenarios de uso básicos