Pular para o conteúdo principal
Este cenário permite extrair o texto principal de um documento, bem como textos presentes em logotipos, selos e quaisquer outros elementos além do corpo do texto. A ordem natural do texto, “como um ser humano o leria”, é preservada. Em seguida, você pode encaminhar os documentos para mecanismos de processamento de linguagem natural (NLP) no seu ambiente, por exemplo, para resumi-los rapidamente, pesquisar informações sensíveis ou submetê-los a uma análise de sentimentos. Para extrair o texto principal do documento, os arquivos de imagem obtidos por digitalização ou salvos em formato eletrônico normalmente passam por várias etapas de processamento, cada uma com suas próprias particularidades:
  1. Pré-processamento das imagens digitalizadas ou fotos
As imagens digitalizadas podem exigir algum pré-processamento antes do reconhecimento, por exemplo, se os documentos digitalizados contiverem ruído de fundo, texto inclinado, cores invertidas, margens pretas, orientação incorreta ou resolução inadequada.
  1. Reconhecimento da maior quantidade possível de texto em uma imagem de documento
O reconhecimento é realizado com configurações que garantem que todo o texto possível seja encontrado e extraído de uma imagem de documento.

​
Implementação do cenário

Os exemplos de código fornecidos neste tópico são específicos para Windows.
A seguir, apresentamos uma descrição detalhada do método recomendado para usar o ABBYY FineReader Engine 12 neste cenário. O método proposto utiliza as configurações de processamento mais adequadas para esse caso.
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";
    }
}
As configurações mais adequadas para este cenário podem ser selecionadas no ABBYY FineReader Engine 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.O ABBYY FineReader Engine oferece suporte a 2 opções de configuração para este cenário:

Nome do perfil

Descrição

TextExtraction_Accuracy

As configurações foram otimizadas para precisão:

  • Permite detectar todo o texto em uma imagem, incluindo pequenas áreas de texto de baixa qualidade (imagens e tabelas não são detectadas).
  • A síntese completa da estrutura lógica de um documento não é realizada.
O perfil não se destina à conversão de um documento em RTF, DOCX ou PDF somente texto. Para isso, use os perfis de conversão de documentos.

TextExtraction_Speed

As configurações foram otimizadas para velocidade de processamento:

  • Permite detectar todo o texto em uma imagem, incluindo pequenas áreas de texto de baixa qualidade (imagens e tabelas não são detectadas).
  • A síntese completa da estrutura lógica de um documento não é realizada.
  • Os processos de análise e reconhecimento de documentos são acelerados.
O perfil não se destina à conversão de um documento em RTF, DOCX ou PDF somente texto. Para isso, use os perfis de conversão de documentos.

​
C#

// Carrega um perfil predefinido
engine.LoadPredefinedProfile("TextExtraction_Accuracy");

​
C++ (COM)

// Carrega um perfil predefinido
Engine->LoadPredefinedProfile( L"TextExtraction_Accuracy" );
Se quiser alterar as configurações de processamento, use os objetos Parameter adequados. Consulte Additional optimization for specific tasks abaixo para mais informações.
O ABBYY FineReader Engine fornece o objeto FRDocument, que permite processar documentos com várias páginas.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 o seguinte:

​
C#

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

​
C++ (COM)

// Abre um arquivo de imagem e cria o objeto FRDocument
FREngine::IFRDocumentPtr frDocument = Engine->CreateFRDocumentFromImage( L"C:\\MyImage.tif", 0 );
Para reconhecer o documento, você deve usar os métodos de análise e reconhecimento do objeto FRDocument. Esse objeto oferece uma ampla gama de métodos para análise e reconhecimento de documentos. O método mais conveniente, que permite analisar, reconhecer e sintetizar o documento com uma única chamada, é o Process. Ele também aproveita da forma mais eficiente os recursos de processamento simultâneo de sistemas multiprocessados e multicore. No entanto, você também pode executar o pré-processamento, a análise, o reconhecimento e a síntese de forma sequencial usando os métodos Preprocess, Analyze, Recognize e Synthesize.

​
C#

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

​
C++ (COM)

// Analisa, reconhece e sintetiza o documento
// Com o perfil carregado, não é necessário passar parâmetros adicionais para o método de processamento
frDocument->Process( 0 );
Durante a análise, o ABBYY FineReader Engine seleciona blocos de imagem que contêm texto, tabelas, imagens etc. Durante o reconhecimento, os blocos que contêm dados de texto são preenchidos com o texto reconhecido.No ABBYY FineReader Engine, o objeto Layout serve como repositório para blocos e texto reconhecido. O principal cenário de processamento de documentos trabalha com o layout dentro do objeto FRDocument, que representa o documento em processamento. Para acessar o layout de uma página do documento, use a propriedade IFRPage::Layout.Para localizar palavras-chave, você pode visualizar o texto reconhecido usando o objeto Text, que pode ser acessado por meio das propriedades dos blocos de texto, tabela ou código de barras.Os dados importantes encontrados podem ser salvos ou processados conforme necessário. Consulte Additional optimization for specific tasks abaixo para obter informações mais detalhadas.
Como alternativa, talvez você queira armazenar o texto extraído em um formato facilmente pesquisável, como TXT, ou em um formato estruturado que permita recuperar facilmente as informações necessárias mais tarde, como JSON.Use o método Export do objeto FRDocument com uma constante FileExportFormatEnum correspondente como um dos parâmetros. Você pode alterar os parâmetros padrão de exportação usando o objeto de exportação correspondente. Consulte Additional optimization for specific tasks abaixo para mais informações.Depois de concluir seu trabalho com o objeto FRDocument, libere todos os recursos usados por ele. Use o método IFRDocument::Close.

​
C#

// Salva o texto do documento reconhecido no formato TXT
frDocument.Export( "C:\\MyText.txt", FREngine.FileExportFormatEnum.FEF_TextUnicodeDefaults, null );
// Libera o objeto FRDocument
frDocument.Close();

​
C++ (COM)

// Salva o texto do documento reconhecido no formato TXT
frDocument->Export( L"C:\\MyText.txt", FREngine::FEF_TextUnicodeDefaults, 0 );
// Libera o objeto FRDocument
frDocument->Close();
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 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;
    // Handle 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 seu aplicativo funcione. Para o processamento neste 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 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 funcionalidades adicionais que seu aplicativo use (como, por exemplo, Opening.PDF se você precisar abrir arquivos PDF, ou Processing.OCR.CJK se precisar reconhecer textos em idiomas CJK). Consulte Trabalhando com o arquivo FREngineDistribution.csv para mais detalhes.

​
Otimização adicional para tarefas específicas

  • Digitalização - somente Windows
    • Digitalização
      Descrição do cenário do ABBYY FineReader Engine para digitalização de documentos.
  • Reconhecimento
  • Reconhecimento de texto manuscrito
    Os perfis TextExtraction_*** não incluem o reconhecimento de texto manuscrito ou de texto em letra de forma escrito à mão. Se você precisar reconhecer texto manuscrito, defina a propriedade DetectHandwritten do objeto PageAnalysisParams como TRUE.
  • Objeto PageProcessingParams
    Este objeto permite personalizar os parâmetros de análise e reconhecimento. Com este objeto, você pode indicar quais características de imagem e 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 de documentos: restaurar sua estrutura e formatação.
  • Objeto MultiProcessingParams - somente Linux e 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 das imagens, a análise de layout e o reconhecimento, o que permite acelerar o processamento.
    Os modos de leitura (simultâneo ou sequencial) são definidos usando a propriedade MultiProcessingMode. A propriedade RecognitionProcessesCount controla o número de processos que podem ser iniciados.
  • Busca de informações importantes
    • Trabalhando com Layout e Blocos
      Sobre o layout da página, os tipos de bloco e como trabalhar com eles.
    • Objeto Layout
      Os parâmetros deste objeto fornecem acesso ao layout da página e ao texto reconhecido após o reconhecimento do documento.
    • Trabalhando com texto
      Trabalhando com texto reconhecido, parágrafos, palavras e símbolos.
  • Releitura do documento usando parâmetros especiais para o tipo de dado especificado
  • Salvamento de dados

​
Veja também

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