Pular para o conteúdo principal
Neste cenário, o ABBYY FineReader Engine é usado para ler códigos de barras. A leitura de códigos de barras pode ser necessária, por exemplo, para separação automática de documentos, para o processamento de documentos por um Sistema de Gerenciamento de Documentos ou para a indexação e classificação de documentos. Este cenário pode ser usado como parte de outros cenários. Por exemplo, documentos digitalizados com scanners de produção de alta velocidade podem ser separados por meio de códigos de barras, ou documentos preparados para armazenamento de longo prazo podem ser enviados para Sistemas de Gerenciamento de Documentos de arquivamento com base nos valores de seus códigos de barras. Ao extrair códigos de barras de textos, o sistema pode detectar todos os códigos de barras ou apenas códigos de barras de determinado tipo com um determinado valor. O sistema pode obter o valor de um código de barras e calcular seu dígito verificador. Para obter os resultados mais rápidos e de melhor qualidade no reconhecimento de códigos de barras:
  1. Use imagens coloridas com resolução ideal de 300 dpi.
  2. Ajuste a velocidade de reconhecimento usando perfis (consulte Trabalhando com perfis para mais detalhes).
Os valores dos códigos de barras reconhecidos podem ser salvos nos formatos mais adequados para processamento posterior, por exemplo, em TXT.

​
Implementação do cenário

Os exemplos de código fornecidos neste tópico são específicos do Windows.
A seguir, é apresentada uma descrição detalhada do método recomendado para usar o ABBYY FineReader Engine 12 neste cenário. O método sugerido utiliza as configurações de processamento consideradas mais adequadas para este cenário.
Para começar a trabalhar com o ABBYY FineReader Engine, você precisa criar o objeto Engine. O objeto Engine é o objeto de nível mais alto na hierarquia de objetos do ABBYY FineReader Engine e fornece diversas configurações globais, alguns métodos de processamento e métodos para criar os demais objetos.Para criar o objeto Engine, você pode usar a função InitializeEngine. Consulte também outras formas de carregar o objeto Engine (Win).

​
C#

public class EngineLoader : IDisposable
{
    public EngineLoader()
    {
        // Inicialize estas variáveis com o caminho completo para FREngine.dll, seu ID do projeto do cliente,
        // e, se aplicável, o caminho para o arquivo de token da Online License e a senha da Online License
        string enginePath = "";
        string customerProjectId = "";
        string licensePath = "";
        string licensePassword = "";
        // Carregue a biblioteca FREngine.dll
        dllHandle = LoadLibraryEx(enginePath, IntPtr.Zero, LOAD_WITH_ALTERED_SEARCH_PATH);
           
        try
        {
            if (dllHandle == IntPtr.Zero)
            {
                throw new Exception("Não foi possível carregar " + enginePath);
            }
            IntPtr initializeEnginePtr = GetProcAddress(dllHandle, "InitializeEngine");
            if (initializeEnginePtr == IntPtr.Zero)
            {
                throw new Exception("Não foi possível encontrar a função InitializeEngine");
            }
            IntPtr deinitializeEnginePtr = GetProcAddress(dllHandle, "DeinitializeEngine");
            if (deinitializeEnginePtr == IntPtr.Zero)
            {
                throw new Exception("Não foi possível encontrar a função DeinitializeEngine");
            }
            IntPtr dllCanUnloadNowPtr = GetProcAddress(dllHandle, "DllCanUnloadNow");
            if (dllCanUnloadNowPtr == IntPtr.Zero)
            {
                throw new Exception("Não foi possível encontrar a função DllCanUnloadNow");
            }
            // Converter ponteiros em delegates
            initializeEngine = (InitializeEngine)Marshal.GetDelegateForFunctionPointer(
                initializeEnginePtr, typeof(InitializeEngine));
            deinitializeEngine = (DeinitializeEngine)Marshal.GetDelegateForFunctionPointer(
                deinitializeEnginePtr, typeof(DeinitializeEngine));
            dllCanUnloadNow = (DllCanUnloadNow)Marshal.GetDelegateForFunctionPointer(
                dllCanUnloadNowPtr, typeof(DllCanUnloadNow));
            // Chamar a função InitializeEngine
            // passando o caminho para o arquivo da Online License e a senha da Online License
            int hresult = initializeEngine(customerProjectId, licensePath, licensePassword, 
                "", "", false, ref engine);
            Marshal.ThrowExceptionForHR(hresult);
        }
        catch (Exception)
        {
            // Liberar a biblioteca FREngine.dll
            engine = null;
            // Excluindo todos os objetos antes da chamada de FreeLibrary
            GC.Collect();
            GC.WaitForPendingFinalizers();
            GC.Collect();
            FreeLibrary(dllHandle);
            dllHandle = IntPtr.Zero;
            initializeEngine = null;
            deinitializeEngine = null;
            dllCanUnloadNow = null;
            throw;
        }
    }
    // Funções do 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);
    // Funções do 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();
    // variáveis privadas
    private FREngine.IEngine engine = null;
    // Handle para FREngine.dll
    private IntPtr dllHandle = IntPtr.Zero;
    private InitializeEngine initializeEngine = null;
    private DeinitializeEngine deinitializeEngine = null;
    private DllCanUnloadNow dllCanUnloadNow = null;
}

​
C++ (COM)

// Inicialize estas variáveis com o caminho para FREngine.dll, o ID do projeto do cliente do FineReader Engine,
// e, se aplicável, o caminho para o token da Online License e a senha da Online License
wchar_t* FreDllPath;
wchar_t* CustomerProjectId;
wchar_t* LicensePath;  // se você não usar uma Online License, atribua strings vazias a estas variáveis
wchar_t* LicensePassword;
// HANDLE para FREngine.dll
static HMODULE libraryHandle = 0;
// Objeto global do FineReader Engine
FREngine::IEnginePtr Engine;
void LoadFREngine()
{
    if( Engine != 0 ) {
    // Já carregado
    return;
    }
    // Primeiro passo: carregar FREngine.dll
    if( libraryHandle == 0 ) {
        libraryHandle = LoadLibraryEx( FreDllPath, 0, LOAD_WITH_ALTERED_SEARCH_PATH );
        if( libraryHandle == 0 ) {
            throw L"Erro ao carregar o ABBYY FineReader Engine";
        }
    }
    // Segundo passo: obter o 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"Erro ao carregar o ABBYY FineReader Engine";
    }
}
As configurações mais adequadas podem ser selecionadas usando o método LoadPredefinedProfile do objeto Engine. Esse método recebe como parâmetro de entrada o nome do perfil de configurações em uso. Para saber mais sobre perfis, consulte Trabalhando com perfis.O ABBYY FineReader Engine oferece suporte a 2 opções de configuração para este cenário:
Nome do perfilDescrição
BarcodeRecognition_AccuracyExtrai apenas códigos de barras (textos, imagens e tabelas não são detectados). As configurações foram otimizadas para precisão. <Warning> Este perfil requer o módulo Barcode Autolocation disponível na licença. </Warning>
BarcodeRecognition_SpeedExtrai apenas códigos de barras (textos, imagens e tabelas não são detectados). As configurações foram otimizadas para velocidade de processamento. <Warning> Este perfil requer o módulo Barcode Autolocation disponível na licença. </Warning>

​
C#

// Carregar um perfil predefinido
engine.LoadPredefinedProfile("BarcodeRecognition_Speed");

​
C++ (COM)

// Carregar um perfil predefinido
Engine->LoadPredefinedProfile( L"BarcodeRecognition_Speed" );
Se quiser alterar as configurações usadas no processamento, use os objetos Parameter correspondentes. Consulte a seção Otimização adicional abaixo para mais informações.
O ABBYY FineReader Engine fornece um objeto FRDocument para processar documentos com várias páginas. Para carregar as imagens de um documento e pré-processá-las, você deve criar o objeto FRDocument e adicionar imagens a ele. Você pode fazer uma das seguintes ações:

​
C#

// Criar o objeto FRDocument a partir de um arquivo de imagem
FREngine.IFRDocument frDocument = engine.CreateFRDocumentFromImage( "C:\\MyImage.tif", null );

​
C++ (COM)

// Abrir um arquivo de imagem e criar o objeto FRDocument
FREngine::IFRDocumentPtr frDocument = Engine->CreateFRDocumentFromImage( L"C:\\MyImage.tif", 0 );
Se o perfil BarcodeRecognition estiver carregado, você poderá usar o método Process do objeto FRDocument para extrair somente códigos de barras. Nesse caso, o ABBYY FineReader Engine detecta apenas blocos com códigos de barras. Nenhum outro bloco é detectado. Os blocos de códigos de barras reconhecidos podem ser acessados por meio do objeto Layout, que é um subobjeto do objeto FRPage, que representa uma página do documento.Para ler códigos de barras de um tipo específico, especifique os parâmetros apropriados do objeto BarcodeParams e passe o objeto BarcodeParams como parâmetro para uma das funções acima.

​
C#

// Enquanto o perfil BarcodeRecognition estiver carregado,
// você não precisará passar parâmetros adicionais para o método de processamento,
// se os códigos de barras estiverem em conformidade com a especificação
frDocument.Process( null );
// Se você precisar ler códigos de barras de um tipo específico
// Crie um objeto DocumentProcessingParams
FREngine.IDocumentProcessingParams dpp = engine.CreateDocumentProcessingParams();
// Especifique os parâmetros necessários
dpp.PageProcessingParams.PageAnalysisParams.BarcodeParams.Type = ( int )FREngine.BarcodeTypeEnum.BT_Code39;
// Agora reconheça os códigos de barras com esses parâmetros
frDocument.Process( dpp );

​
C++ (COM)

// Enquanto o perfil BarcodeRecognition estiver carregado,
// você não precisará passar parâmetros adicionais para o método de processamento,
// se os códigos de barras estiverem em conformidade com a especificação
frDocument->Process( 0 );
// Se você precisar ler códigos de barras de um tipo específico
// Crie um objeto DocumentProcessingParams
FREngine::IDocumentProcessingParamsPtr params = Engine->CreateDocumentProcessingParams();
// Especifique os parâmetros necessários
params->PageProcessingParams->PageAnalysisParams->BarcodeParams->Type = FREngine::BT_Code39;
// Agora reconheça os códigos de barras com esses parâmetros
frDocument->Process( params );
Para salvar os valores dos códigos de barras reconhecidos em um arquivo, você pode usar o método Export do objeto FRDocument, atribuindo a constante FileExportFormatEnum como um dos parâmetros. Nesse cenário, é possível exportar, por exemplo, para TXT. Você pode alterar os parâmetros padrão de exportação usando o respectivo objeto de exportação. Consulte Otimização adicional para tarefas específicas abaixo para mais informações.Depois de concluir o trabalho com o objeto FRDocument, libere todos os recursos usados por ele. Use o método IFRDocument::Close.

​
C#

// Salve os códigos de barras reconhecidos em algum formato (por exemplo, TXT)
frDocument.Export( "C:\\barcodes.txt", FREngine.FileExportFormatEnum.FEF_TextUnicodeDefaults, null );
// Libere o objeto FRDocument
frDocument.Close();

​
C++ (COM)

// Salve os códigos de barras reconhecidos em algum formato (por exemplo, TXT)
frDocument->Export( L"C:\\barcodes.txt", FREngine::FEF_TextUnicodeDefaults, 0 );
// Libere o objeto FRDocument
frDocument->Close();
Depois de terminar de usar o ABBYY FineReader Engine, você precisa descarregar o objeto Engine. Para isso, use a função exportada DeinitializeEngine.

​
C#

public class EngineLoader : IDisposable
{
    // Descarrega o FineReader Engine
    public void Dispose()
    {
        if (engine == null)
        {
            // O Engine não foi carregado
            return;
        }
        engine = null;
        // Exclui todos os objetos antes da chamada 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;
        // lança exceção após a limpeza
        Marshal.ThrowExceptionForHR(hresult);
    }
    // Funções 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);
    // Funções 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();
    // variáveis 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;
 }
 // Libera o objeto Engine
 Engine = 0;
 // Desinicializa o FineReader Engine
 typedef HRESULT ( STDAPICALLTYPE* DeinitializeEngineFunc )();
 DeinitializeEngineFunc pDeinitializeEngine =
  ( DeinitializeEngineFunc )GetProcAddress( libraryHandle, "DeinitializeEngine" );
 if( pDeinitializeEngine == 0 || pDeinitializeEngine() != S_OK ) {
  throw L"Erro ao descarregar o ABBYY FineReader Engine";
 }
 // Agora é seguro liberar a biblioteca FREngine.dll
 FreeLibrary( libraryHandle );
 libraryHandle = 0;
}

​
Recursos necessários

Você pode usar o arquivo FREngineDistribution.csv para criar automaticamente uma lista dos arquivos necessários para que sua aplicação funcione. Para processar com este cenário, selecione na coluna 5 (RequiredByModule) os seguintes 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 Se você modificar o cenário padrão, ajuste os módulos necessários conforme apropriado. Você também precisa especificar os idiomas da interface, os idiomas de reconhecimento e quaisquer recursos adicionais usados pela sua aplicação (como, por exemplo, Opening.PDF se precisar abrir arquivos PDF, ou Processing.OCR.CJK se precisar reconhecer textos em idiomas CJK). Consulte Trabalhando com o arquivo FREngineDistribution.csv para obter mais detalhes.

​
Otimização adicional

Estas são as seções do arquivo de ajuda onde você pode encontrar informações adicionais sobre como configurar os parâmetros para os vários estágios de processamento:
  • Extração e leitura de códigos de barras
    • Objeto BarcodeParams
      Este objeto permite configurar os parâmetros de análise e leitura de códigos de barras.
    • Reconhecimento de códigos de barras
      Discute casos especiais no reconhecimento de códigos de barras e fornece dicas para trabalhar com códigos de barras.
    • Tipos de códigos de barras
      A lista de códigos de barras compatíveis com o ABBYY FineReader Engine 12 e suas breves descrições.
    • Objeto FRDocument
      Além dos valores de códigos de barras, talvez você precise extrair outras informações contidas no documento. Nesse caso, pode ser útil usar os métodos do objeto FRDocument.
    • Objeto PageProcessingParams
      Este objeto permite configurar os parâmetros de análise e reconhecimento para o documento inteiro. Com ele, você pode especificar se os valores dos códigos de barras devem ser reconhecidos. Os parâmetros de leitura de códigos de barras podem ser acessados por meio das propriedades BarcodeParams e DetectBarcodes do subobjeto PageAnalysisParams.
    • Trabalhando com Layout e blocos
      Você também pode marcar manualmente blocos de código de barras e especificar os respectivos parâmetros de análise e leitura. Esta seção fornece informações detalhadas sobre como trabalhar com blocos.
  • Trabalhando com os valores reconhecidos dos códigos de barras
    • Objeto BarcodeBlock
      As propriedades Text e BarcodeText deste objeto contêm o valor do código de barras obtido pelo reconhecimento. As outras propriedades deste objeto podem ser usadas para obter o tipo do código de barras, sua orientação e outros parâmetros.
  • Exportação

​
Veja também

Implementação de cenários básicos de uso