Pular para o conteúdo principal
Cartões de visita contêm informações comerciais sobre uma empresa ou uma pessoa. Eles podem incluir o nome da pessoa, empresa, números de telefone, fax, e-mail, endereços de site e informações semelhantes. Talvez seja necessário capturar essas informações de cartões de visita em papel e salvá-las em formato eletrônico. Isso pode ser um catálogo de endereços eletrônico de um celular, um cliente de e-mail ou qualquer outro sistema de armazenamento de dados. Por exemplo, cartões de visita costumam ser enviados por e-mail ou pela rede no formato vCard. As principais etapas que você precisa executar neste cenário:
  1. Obter uma cópia digital de um cartão de visita
Você pode escanear ou tirar uma foto de um cartão de visita. Fotos tiradas com câmeras digitais de dispositivos móveis podem ter baixa resolução e baixa qualidade. Portanto, pode ser necessário preparar as imagens adicionalmente.
  1. Reconhecer cartões de visita
Páginas digitalizadas podem conter vários cartões de visita por página. O reconhecimento deve ter alta qualidade; todas as informações devem ser extraídas com precisão.
  1. Salvar os dados reconhecidos em um formato adequado
Você pode salvar os dados reconhecidos em diferentes sistemas de armazenamento de dados ou exportá-los para o formato vCard e enviá-los por e-mail.

​
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 neste 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 superior na hierarquia de objetos do ABBYY FineReader Engine e fornece várias 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 maneiras 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 = "";
        // Carrega a biblioteca FREngine.dll
        dllHandle = LoadLibraryEx(enginePath, IntPtr.Zero, LOAD_WITH_ALTERED_SEARCH_PATH);
           
        try
        {
            if (dllHandle == IntPtr.Zero)
            {
                throw new Exception("Can't load " + enginePath);
            }
            IntPtr initializeEnginePtr = GetProcAddress(dllHandle, "InitializeEngine");
            if (initializeEnginePtr == IntPtr.Zero)
            {
                throw new Exception("Can't find InitializeEngine function");
            }
            IntPtr deinitializeEnginePtr = GetProcAddress(dllHandle, "DeinitializeEngine");
            if (deinitializeEnginePtr == IntPtr.Zero)
            {
                throw new Exception("Can't find DeinitializeEngine function");
            }
            IntPtr dllCanUnloadNowPtr = GetProcAddress(dllHandle, "DllCanUnloadNow");
            if (dllCanUnloadNowPtr == IntPtr.Zero)
            {
                throw new Exception("Can't find DllCanUnloadNow function");
            }
            // Converte os 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 da Online License e a senha da Online License
            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 a FreeLibrary
            GC.Collect();
            GC.WaitForPendingFinalizers();
            GC.Collect();
            FreeLibrary(dllHandle);
            dllHandle = IntPtr.Zero;
            initializeEngine = null;
            deinitializeEngine = null;
            dllCanUnloadNow = null;
            throw;
        }
    }
    // 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, 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 de FREngine.dll
    private IntPtr dllHandle = IntPtr.Zero;
    private InitializeEngine initializeEngine = null;
    private DeinitializeEngine deinitializeEngine = null;
    private DllCanUnloadNow dllCanUnloadNow = null;
}
Você pode carregar as configurações de processamento adequadas para este cenário usando o método LoadPredefinedProfile do objeto Engine. Esse método usa o nome de um perfil de configurações como parâmetro de entrada. Consulte Trabalhando com perfis para mais informações.As configurações para este cenário estão disponíveis no perfil predefinido BusinessCardsProcessing:
  • Detecta apenas cartões de visita (define a propriedade SynthesizeBusinessCards do objeto SynthesisParamsForPage como TRUE).
  • Habilita a detecção de todo o texto em uma imagem, incluindo pequenas áreas de texto de baixa qualidade (figuras e tabelas não são detectadas).
  • A correção da resolução é realizada.
  • A síntese completa da estrutura lógica de um documento não é realizada.

​
C#

// Carregar o perfil predefinido
engine.LoadPredefinedProfile("BusinessCardsProcessing");
Se quiser alterar as configurações de processamento, use os objetos Parameter adequados. Consulte Otimização adicional para tarefas específicas abaixo para mais informações.
Para carregar imagens no FineReader Engine, você pode usar os métodos destes objetos:
Usuários de Linux e Windows podem conhecer as vantagens e desvantagens de cada abordagem em Processamento paralelo com ABBYY FineReader Engine. Este tópico se concentra em FRDocument.
Para carregar imagens no objeto FRDocument, faça um dos seguintes procedimentos:Todos esses métodos usam o objeto PrepareImageMode como parâmetro, o que permite especificar diferentes parâmetros de pré-processamento da imagem. Crie esse objeto chamando a função IEngine::CreatePrepareImageMode, depois altere suas propriedades conforme necessário e, em seguida, passe-o para uma função que o exija.

​
C#

FREngine.IEngine engine;
string imagePath;
FREngine.IPrepareImageMode pim = engine.CreatePrepareImageMode();
pim.DocumentType = FREngine.DocumentTypeEnum.DT_BusinessCard;
FREngine.IFRDocument frDoc = engine.CreateFRDocument();
frDoc.AddImageFile(imagePath, pim, null);
Para reconhecer cartões de visita:
  1. Especifique o idioma dos cartões de visita usando o método SetPredefinedTextLanguage do objeto RecognizerParams. Consulte a lista de idiomas predefinidos disponível para o reconhecimento de cartões de visita.
  2. Defina outros parâmetros de processamento, se necessário. Consulte Ajuste dos parâmetros de pré-processamento, análise, reconhecimento e síntese de páginas.
  3. Passe os parâmetros para qualquer um dos métodos de processamento (por exemplo, o método Process do objeto FRDocument). O método preenche as coleções de cartões de visita do documento e de suas páginas (IFRDocument::BusinessCards, IFRPage::BusinessCards).
Você também pode sintetizar um cartão de visita com base na página inteira ou em uma região de cada página usando o método SynthesizeBusinessCard ou SynthesizeBusinessCardEx do objeto FRPage. O método retorna um objeto BusinessCard. Observe que, nesse caso, um cartão de visita não é adicionado à coleção de cartões de visita da página. Essa abordagem é especialmente útil se você optar pelo processamento com o Batch Processor.

​
C#

// Criar parâmetros de processamento de documento
FREngine.IDocumentProcessingParams dpp = engine.CreateDocumentProcessingParams();
// Executar o reconhecimento com os parâmetros especificados
frDoc.Process( dpp );
// Acessar um cartão de visita
FREngine.IBusinessCard card = frDoc.BusinessCards[0];
Um cartão de visita reconhecido (o objeto BusinessCard) pode conter os seguintes campos:

BusinessCard_pict

  • Nome
  • Nome da empresa
  • Cargo na empresa
  • Endereço da empresa
  • Telefone
  • Fax
  • Celular
  • E-mail
  • Site
Você pode acessar cada campo por tipo (propriedade FieldByType) ou por seu índice na coleção de campos (propriedade Field). Cada campo tem a propriedade Value, que permite acessar o valor do campo em formato string. Para cada caractere do campo, as variantes de reconhecimento ficam disponíveis (método GetCharParams).Alguns campos podem ser compostos por vários componentes; por exemplo, o campo de endereço pode conter código postal, país, estado dos USA, cidade e logradouro. Para acessar um componente do campo, você pode usar a propriedade Component ou o método FindComponent. A primeira permite acessar o componente por índice; a segunda localiza o componente por tipo. Para cada componente, você pode ver seu tipo e valor, além de obter parâmetros e variantes de reconhecimento para cada caractere (método GetCharParams).

​
C#

// Obter o campo de nome
FREngine.IBusinessCardField nameField = card.FieldByType( FREngine.BusinessCardFieldTypeEnum.BCFT_Name, 0 );
// Obter o componente que contém o primeiro nome
FREngine.IBusinessCardFieldComponent firstNameComponent =
  nameField.FindComponent( FREngine.BusinessCardFieldComponentTypeEnum.BCFCT_FirstName );
// O primeiro nome reconhecido
string firstName = firstNameComponent.Value;
O objeto BusinessCard fornece o método especial ExportToVCard para salvar um cartão de visita no formato vCard. O caminho do arquivo é informado como parâmetro.Você pode salvar o cartão de visita em qualquer outro formato de exportação disponível, por exemplo, em XML.

​
C#

// Salvar os dados reconhecidos no formato vCard
card.ExportToVCard("D:\\sample.vcf");
// Salvar em XML
frDoc.Export("D:\\Demo.xml", FREngine.FileExportFormatEnum.FEF_XML, null);
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
{
    // Descarregar o FineReader Engine
    public void Dispose()
    {
        if (engine == null)
        {
            // O Engine não foi carregado
            return;
        }
        engine = null;
        // Excluindo todos os objetos antes da chamada de 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;
        // gerando 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;
}

​
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 o processamento neste cenário, selecione na coluna 5 (RequiredByModule) os seguintes valores: Core Core.Resources Opening Opening, Processing Processing Processing.BCR 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 o caso. 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 textos em idiomas CJK). Consulte Como trabalhar com o arquivo FREngineDistribution.csv para mais detalhes.

​
Otimização adicional

Estas são as seções do arquivo de ajuda em que você pode encontrar informações adicionais sobre a configuração dos parâmetros para os vários estágios do processamento:

​
Veja também

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