Pular para o conteúdo principal
Este cenário é usado para processar documentos em papel e salvá-los em um arquivo digital, especialmente na criação de um arquivo de contratos, documentação de projetos, faturas, certificados etc. Neste cenário de processamento, documentos em papel são convertidos em cópias digitais não editáveis que contêm todas as informações do documento em um formato pesquisável. Como resultado desse processamento, as cópias digitais dos documentos podem ser facilmente encontradas em um arquivo eletrônico usando a pesquisa de texto completo, trechos de texto do documento podem ser copiados, e os documentos podem ser enviados por e-mail ou impressos. Para criar uma cópia digital, o documento primeiro precisa passar por várias etapas de processamento, cada uma com suas próprias particularidades:
  1. Pré-processamento de imagens digitalizadas
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 simultâneo de um grande volume de documentos
Para extrair dados textuais de um documento, ele precisa ser reconhecido. Ao processar um grande volume de documentos, o processamento simultâneo de documentos pode ser útil. Nesse caso, a carga de trabalho de análise e reconhecimento pode ser distribuída entre os núcleos do processador, o que permite acelerar o processamento.
  1. Exportação para um formato de arquivamento
O documento reconhecido é salvo em um formato de armazenamento adequado. Os formatos mais convenientes para armazenar documentos são PDF, PDF/A, PDF e PDF/A com MRC. Ao salvar nesses formatos, pode-se usar um modo no qual o texto é colocado sob a imagem do documento — isso permite preservar integralmente a formatação do documento e viabiliza a pesquisa de texto completo. As configurações de MRC permitem reduzir significativamente o tamanho do arquivo sem perda de qualidade visual. Além disso, ao salvar no formato PDF, é possível personalizar as configurações de segurança do documento, protegendo-o contra visualização e impressão não autorizadas.

​
Implementação do cenário

Os exemplos de código fornecidos neste tópico são específicos para Windows.
Abaixo está uma descrição detalhada da maneira recomendada de usar o ABBYY FineReader Engine 12 para criar cópias digitais de documentos para arquivamento. O método proposto usa as configurações de processamento mais adequadas para essa finalidade. Nesta implementação, a etapa de digitalização dos documentos foi omitida. Consulte Otimização adicional para tarefas específicas abaixo para obter dicas sobre como implementar a digitalização.
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 você 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;
    }
    // Primeira etapa: 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";
        }
    }
    // Segunda etapa: 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";
    }
}
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.O ABBYY FineReader Engine oferece suporte a 2 variantes de configuração para este cenário:

Nome do perfil

Descrição

DocumentArchiving_Accuracy

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

  • Permite detectar o máximo de texto em uma imagem, incluindo texto incorporado à imagem.
  • 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. Use os perfis de conversão de documentos para essa finalidade.

DocumentArchiving_Speed

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

  • Permite detectar o máximo de texto em uma imagem, incluindo texto incorporado à imagem.
  • A correção de inclinação não é realizada.
  • 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. Use os perfis de conversão de documentos para essa finalidade.

​
C#

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

​
C++ (COM)

// Carregar um perfil predefinido
Engine->LoadPredefinedProfile( L"DocumentArchiving_Accuracy" );
Se quiser alterar as configurações de processamento, use os objetos de parâmetro apropriados. Consulte Otimização adicional para tarefas específicas para mais informações.
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.Para carregar imagens de um único documento e pré-processá-las, você deve criar o objeto FRDocument e adicionar imagens a ele. Você pode fazer uma das opções a seguir:

​
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 );
Para reconhecer um documento, recomendamos usar os métodos de análise e reconhecimento do objeto FRDocument. Esse objeto oferece uma ampla variedade de métodos para análise, reconhecimento e síntese de documentos. O método mais prático, que permite executar a análise, o reconhecimento e a síntese do documento em uma única chamada, é o método Process. Ele também aproveita da forma mais eficiente os recursos de processamento simultâneo de sistemas multiprocessador e multinúcleo. No entanto, você também pode executar em sequência o pré-processamento, a análise, o reconhecimento e a síntese 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
// Não há necessidade de parâmetros adicionais, pois eles são definidos pelo perfil de processamento
frDocument->Process( 0 );
Para salvar um documento reconhecido, você pode usar o método Export do objeto FRDocument, passando a constante FileExportFormatEnum como um dos parâmetros. Nesse cenário, por exemplo, é possível salvar o documento no formato PDF usando MRC no modo de exportação PEM_ImageOnText (propriedade TextExportMode do objeto PDFExportParams). 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 um documento reconhecido em um formato de arquivamento (por exemplo, PDF)
// Cria um objeto PDFExportParams
FREngine.PDFExportParams exportParams = engine.CreatePDFExportParams();
// Define os parâmetros necessários
exportParams.MRCMode = FREngine.PDFMRCModeEnum.MRC_Auto;
exportParams.TextExportMode = FREngine.PDFExportModeEnum.PEM_ImageOnText;
// Usa os parâmetros durante a exportação
frDocument.Export( "C:\\MyText.pdf", FREngine.FileExportFormatEnum.FEF_PDF, exportParams );
// Libera o objeto FRDocument
frDocument.Close();

​
C++ (COM)

// Salva um documento reconhecido em um formato de arquivamento (por exemplo, PDF)
// Cria um objeto PDFExportParams
FREngine::IPDFExportParamsPtr params = Engine->CreatePDFExportParams();
// Define os parâmetros necessários
params->MRCMode = FREngine::MRC_Auto;
params->TextExportMode = FREngine::PEM_ImageOnText;
// Usa os parâmetros durante a exportação
frDocument->Export(L"C:\\MyText.pdf", FREngine::FEF_PDF, params);
// Libera o objeto FRDocument
frDocument->Close();
Depois de concluir o trabalho com o ABBYY FineReader Engine, você precisa descarregar o objeto Engine. Para fazer isso, use a função exportada DeinitializeEngine.

​
C#

public class EngineLoader : IDisposable
{
    // Descarregar o FineReader Engine
    public void Dispose()
    {
        if (engine == null)
        {
            // O Engine não foi carregado
            return;
        }
        engine = null;
        // Liberando 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çando exceção após a limpeza
        Marshal.ThrowExceptionForHR(hresult);
    }
    // Funções da 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 da 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 da 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 o objeto Engine
 Engine = 0;
 // Desinicializar o FineReader Engine
 typedef HRESULT ( STDAPICALLTYPE* DeinitializeEngineFunc )();
 DeinitializeEngineFunc pDeinitializeEngine =
  ( DeinitializeEngineFunc )GetProcAddress( libraryHandle, "DeinitializeEngine" );
 if( pDeinitializeEngine == 0 || pDeinitializeEngine() != S_OK ) {
  throw L"Error while unloading 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 Export Export, Processing Export.Pdf Export.Pdf, Opening.Pdf Se você modificar o cenário padrão, altere 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 precisar abrir arquivos PDF, ou Processing.OCR.CJK se precisar reconhecer textos 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 do processamento de documentos:
  • Digitalização - somente para Windows
    • Digitalização
      Descrição do cenário de digitalização de documentos no ABBYY FineReader Engine.
  • Reconhecimento
  • Reconhecer texto manuscrito
    Os perfis DocumentArchiving_*** não incluem o reconhecimento de texto manuscrito nem de texto escrito à mão em letras de forma. Se você precisar reconhecer texto manuscrito, defina a propriedade DetectHandwritten do objeto PageAnalysisParams como TRUE.
  • Objeto PageProcessingParams
    Este objeto permite configurar os parâmetros de análise e reconhecimento. Com este objeto, você pode indicar quais características da imagem e do texto devem ser detectadas (imagem invertida, orientação, códigos de barras, idioma para reconhecimento, margem de erro no reconhecimento).
  • SynthesisParamsForPage Object
    Este objeto inclui parâmetros responsáveis por restaurar a formatação de uma página durante a síntese.
  • Objeto SynthesisParamsForDocument
    Este objeto permite personalizar a síntese do documento, restaurando sua estrutura e formatação.
  • Objeto MultiProcessingParams - Implementado para Linux e Windows
    O processamento simultâneo pode ser útil ao processar um grande volume 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, o reconhecimento e a exportação, o que pode acelerar o processamento.
    Os modos de leitura (simultâneo ou sequencial) são definidos pela propriedade MultiProcessingMode, e a propriedade RecognitionProcessesCount controla o número de processos que podem ser iniciados.
  • Exportação
    • Ajuste de parâmetros de exportação
      Personalização da exportação de documentos com objetos de parâmetros de exportação.
    • Objeto PDFExportParams
      Esse objeto permite ajustar a exportação para PDF (PDF/A) com apenas alguns parâmetros.
    • Para personalizar o modo de exportação no formato PDF (PDF/A), use a propriedade TextExportMode do objeto PDFExportParams e, para personalizar as configurações de MRC, use a propriedade MRCMode.
    • Além disso, você pode personalizar as configurações de exportação de imagens para garantir um processamento mais rápido, maior redução do tamanho do arquivo etc. Por exemplo, você pode salvar uma imagem colorida como imagem em escala de cinza ou em preto e branco, se isso atender ao seu cenário (use a propriedade Colority do objeto PDFExportParams).
    • Você pode alterar a resolução da imagem para que a cópia eletrônica resultante possa ser impressa posteriormente em uma impressora ou visualizada na tela de um computador, ou selecionar uma baixa resolução que permita apenas a leitura do texto e ofereça qualidade gráfica muito baixa (use as propriedades Resolution e ResolutionType do objeto PDFExportParams).
  • Separação de documentos
    • Nesse cenário, talvez seja necessário separar o lote de imagens em documentos. O ABBYY FineReader Engine 12 não oferece suporte à separação automática de documentos. No entanto, você pode usar o ABBYY FlexiCapture Engine para implementar essa separação automática. Os documentos podem ser separados, por exemplo, com base no número de páginas de um documento ou em páginas com códigos de barras separadores. Ao implementar a separação por código de barras, você pode usar o cenário para extrair apenas os valores de código de barras do documento.

​
Veja também

Cenários básicos de implementação de uso