Extração de Dados

Este cenário é usado para extrair o máximo possível de dados de um documento e armazená-los de forma estruturada. O resultado é um arquivo JSON que representa a estrutura do documento. Ele armazena todos os objetos do documento: texto impresso e manuscrito, tabelas, códigos de barras, marcas de seleção e imagens, com suas localizações e atributos. Esse formato é ideal para processamento posterior, armazenamento em banco de dados ou integração com outro aplicativo. Um documento passa por várias etapas de processamento neste cenário:

Pré-processamento de imagens digitalizadas ou fotos

Imagens obtidas por meio de um scanner ou de uma câmera digital podem precisar de alguns ajustes antes de serem reconhecidas opticamente. Por exemplo, imagens com ruído ou com linhas de texto distorcidas precisarão de correções para que o reconhecimento óptico seja bem-sucedido.

Extração de todos os dados do documento de forma estruturada

Durante a análise de layout, vários objetos são detectados na imagem e agrupados em blocos do tipo correspondente. Os blocos são reconhecidos de acordo com as configurações ideais para cada tipo. Durante a síntese, a estrutura lógica do documento é reconstruída de forma consistente. A ordem do texto, mesmo em layouts complexos, é preservada para se aproximar da forma como um ser humano o leria. Isso garante que um novo reconhecimento do mesmo documento resulte na mesma ordem do texto.

Exportação para um formato estruturado

O documento reconhecido é salvo em JSON ou XML.

Implementação do cenário

Os exemplos de código fornecidos neste tópico são específicos do Windows.

A seguir, você encontrará uma descrição detalhada do método recomendado para usar o ABBYY FineReader Engine 12 na extração de dados de documentos. O método proposto usa as configurações de processamento mais adequadas para essa finalidade.

Etapa 1. Carregar o ABBYY FineReader Engine

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 Licença Online e a senha da Licença Online
        string enginePath = "";
        string customerProjectId = "";
        string licensePath = "";
        string licensePassword = "";
        // Carrega 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");
            }
            // Converte ponteiros em delegates
            initializeEngine = (InitializeEngine)Marshal.GetDelegateForFunctionPointer(
                initializeEnginePtr, typeof(InitializeEngine));
            deinitializeEngine = (DeinitializeEngine)Marshal.GetDelegateForFunctionPointer(
                deinitializeEnginePtr, typeof(DeinitializeEngine));
            dllCanUnloadNow = (DllCanUnloadNow)Marshal.GetDelegateForFunctionPointer(
                dllCanUnloadNowPtr, typeof(DllCanUnloadNow));
            // Chama a função InitializeEngine
            // passando o caminho para o arquivo de Licença Online e a senha da Licença Online
            int hresult = initializeEngine(customerProjectId, licensePath, licensePassword, 
                "", "", false, ref engine);
            Marshal.ThrowExceptionForHR(hresult);
        }
        catch (Exception)
        {
            // Libera a biblioteca FREngine.dll
            engine = null;
            // Exclui 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 Licença Online e a senha da Licença Online
wchar_t* FreDllPath;
wchar_t* CustomerProjectId;
wchar_t* LicensePath;  // se não usar uma Licença Online, 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";
    }
}

Etapa 2. Carregando as configurações do cenário

O ABBYY FineReader Engine permite carregar todas as configurações de processamento mais adequadas para este cenário usando o método LoadPredefinedProfile do objeto Engine. Esse método recebe o nome do perfil como parâmetro de entrada. Consulte Working with Profiles para mais informações.As configurações para este cenário estão disponíveis no perfil predefinido DataExtraction:

A análise de layout e o reconhecimento priorizam a precisão em vez da velocidade.
Detecta todo o texto da imagem, incluindo texto manuscrito e pequenas áreas de texto de baixa qualidade.
Detecta tabelas, marcas de seleção e códigos de barras.
A síntese completa da estrutura lógica de um documento é realizada.

C#

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

C++ (COM)

// Carregar um perfil predefinido
Engine->LoadPredefinedProfile( L"DataExtraction" );

Se quiser alterar as configurações de processamento, use os objetos de parâmetro correspondentes. Consulte a seção Additional optimization abaixo para mais informações.

Etapa 3. Carregando e pré-processando as imagens

O ABBYY FineReader Engine fornece o objeto FRDocument, que permite processar documentos com várias páginas. O uso desse objeto permite preservar a organização lógica do documento, mantendo o texto original, as colunas, as fontes, os estilos etc.Para carregar imagens de um único documento e pré-processá-las, você deve criar o objeto FRDocument e adicionar as imagens a ele. Você pode fazer uma das opções a seguir:

Criar o objeto FRDocument usando o método CreateFRDocumentFromImage do objeto Engine. Esse método cria o objeto FRDocument e carrega imagens do arquivo especificado.
Criar o objeto FRDocument com a ajuda do método CreateFRDocument do objeto Engine e, em seguida, adicionar imagens do arquivo ao objeto FRDocument criado (use o método AddImageFile, AddImageFileWithPassword ou AddImageFileWithPasswordCallback do objeto FRDocument).

C#

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

C++ (COM)

// Criar o objeto FRDocument a partir de um arquivo de imagem
FREngine::IFRDocumentPtr frDocument = Engine->CreateFRDocumentFromImage( L"C:\\MyImage.tif", 0 );

Etapa 4. Reconhecimento de documentos

Para reconhecer um documento, sugerimos usar os métodos de análise e reconhecimento do objeto FRDocument. Esse objeto oferece um conjunto completo de métodos para análise, reconhecimento e síntese de documentos. O método mais conveniente, que reúne análise, reconhecimento e síntese em uma única operação, é o método Process. Ele também aproveita da forma mais eficiente os recursos de processamento simultâneo de sistemas multiprocessados e multinúcleo. No entanto, também é possível executar o pré-processamento, a análise, o reconhecimento e a síntese em sequência usando os métodos Preprocess, Analyze, Recognize e Synthesize.

C#

// Analisa, reconhece e sintetiza o documento
// Não são necessários parâmetros adicionais, porque eles são definidos pelo perfil de processamento
frDocument.Process( null );

C++ (COM)

// Analisa, reconhece e sintetiza o documento
// Não são necessários parâmetros adicionais, porque eles são definidos pelo perfil de processamento
frDocument->Process( 0 );

Etapa 5. Exportação de documentos

Para salvar um documento reconhecido, você pode usar o método Export do objeto FRDocument, passando a constante FileExportFormatEnum como um dos parâmetros. Você pode alterar os parâmetros padrão de exportação usando o objeto de exportação correspondente. 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#

// Salva o documento reconhecido em um formato estruturado
frDocument.Export( "C:\\Data.json", FREngine.FileExportFormatEnum.FEF_JSON, null );
// Libera o objeto FRDocument
frDocument.Close();

C++ (COM)

// Salva o documento reconhecido em um formato estruturado
frDocument->Export( L"C:\\Data.json", FREngine::FEF_JSON, 0 );
// Libera o objeto FRDocument
frDocument->Close();

Etapa 6. Descarregando o ABBYY FineReader Engine

Depois de concluir o trabalho com 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;
        // gera 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 o funcionamento do seu aplicativo. 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 todos os recursos adicionais usados pelo seu aplicativo (como, por exemplo, Opening.PDF, se você precisar abrir arquivos PDF, ou Processing.OCR.CJK, se precisar reconhecer texto em idiomas CJK). Consulte Working with the FREngineDistribution.csv File para mais detalhes.

Otimização adicional para tarefas específicas

Abaixo está uma visão geral dos tópicos da Ajuda que contêm informações adicionais sobre a personalização das configurações em diferentes etapas da conversão de documentos para um formato editável:

Digitalização - somente no Windows
- Digitalização
  Descrição do cenário do ABBYY FineReader Engine para digitalização de documentos.
Reconhecimento
- Ajuste dos parâmetros de pré-processamento, análise, reconhecimento e síntese
  Personalização do processamento de documentos usando objetos de parâmetros de análise, reconhecimento e síntese.
- Objeto PageProcessingParams
  Este objeto permite personalizar os parâmetros de análise e reconhecimento. Com ele, você pode indicar quais características da imagem e do texto devem ser detectadas (imagem invertida, orientação, códigos de barras, idioma de reconhecimento, margem de erro de reconhecimento).
- Objeto SynthesisParamsForPage
  Este objeto inclui parâmetros responsáveis pela restauração da formatação de uma página durante a síntese.
- Objeto SynthesisParamsForDocument
  Este objeto permite personalizar a síntese do documento: restauração de sua estrutura e formatação.
- Objeto MultiProcessingParams - Implementado no Linux e no Windows
  O processamento simultâneo pode ser útil ao processar um grande número de imagens. Nesse caso, a carga de processamento será distribuída entre os núcleos do processador durante a abertura e o pré-processamento de imagens, a análise de layout, o reconhecimento e a exportação, o que permite acelerar o processamento.
  Os modos de leitura (simultâneo ou consecutivo) são definidos usando a propriedade MultiProcessingMode. A propriedade RecognitionProcessesCount controla o número de processos que podem ser iniciados.
Exportação
- Ajuste dos parâmetros de exportação
  Personalização da exportação de documentos usando objetos de parâmetros de exportação.
- Objeto XMLExportParams
  Este objeto fornece as configurações de exportação para o formato XML.
- Objeto JsonExportParams
  Este objeto fornece as configurações de exportação para o formato JSON.

Veja também

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

Visão geral

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

Técnicas avançadas

Implementação do cenário

C#

C++ (COM)

C#

C++ (COM)

C#

C++ (COM)

C#

C++ (COM)

C#

C++ (COM)

C#

C++ (COM)

Recursos necessários

Otimização adicional para tarefas específicas

Veja também

Visão geral

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

Técnicas avançadas

​Implementação do cenário

​C#

​C++ (COM)

​C#

​C++ (COM)

​C#

​C++ (COM)

​C#

​C++ (COM)

​C#

​C++ (COM)

​C#

​C++ (COM)

​Recursos necessários

​Otimização adicional para tarefas específicas

​Veja também

Implementação do cenário

C#

C++ (COM)

C#

C++ (COM)

C#

C++ (COM)

C#

C++ (COM)

C#

C++ (COM)

C#

C++ (COM)

Recursos necessários

Otimização adicional para tarefas específicas

Veja também