Enterprise Document OCR

Você pode usar o OCR de documentos corporativos como parte da Document AI para detectar e extrair informações de texto e layout de vários documentos. Com os recursos configuráveis, você pode adaptar o sistema para atender a requisitos específicos de processamento de documentos.

Visão geral

É possível usar o OCR de documentos corporativos para tarefas como entrada de dados com base em algoritmos ou machine learning, além de melhorar e verificar a precisão dos dados. Também é possível usar o OCR de documentos corporativos para tarefas como:

  • Digitalização de texto:extraia dados de texto e layout de documentos para pesquisa, pipelines de processamento de documentos com base em regras ou criação de modelos personalizados.
  • Como usar aplicativos de modelos de linguagem grandes:use o entendimento contextual de LLMs e os recursos de extração de texto e layout do OCR para automatizar perguntas e respostas. Extraia insights dos dados e simplifique os fluxos de trabalho.
  • Arquivamento:digitalize documentos em papel em texto legível por máquina para melhorar a acessibilidade dos documentos.

Como escolher o melhor OCR para seu caso de uso

Solução Produto Descrição Caso de uso
Document AI OCR de documentos corporativos Modelo especializado para casos de uso de documentos. Os recursos avançados incluem pontuação de qualidade da imagem, dicas de idioma e correção de rotação. Recomendado para extrair texto de documentos. Os casos de uso incluem PDFs, documentos digitalizados como imagens ou arquivos Microsoft DocX.
Document AI Complementos de OCR Recursos premium para requisitos específicos. Compatível apenas com a versão 2.0 e mais recentes do OCR de documentos corporativos. Precisa detectar e reconhecer fórmulas matemáticas, receber informações de estilo de fonte ou ativar a extração de caixas de seleção.
API Cloud Vision Detecção de texto API REST disponível globalmente com base no modelo de OCR padrão do Google Cloud . cota padrão de 1.800 solicitações por minuto. Casos de uso gerais de extração de texto que exigem baixa latência e alta capacidade.
Cloud Vision OCR Google Distributed Cloud (descontinuado) Um aplicativo do Google Cloud Marketplace que pode ser implantado como um contêiner em qualquer cluster do GKE usando o GKE Enterprise. Para atender aos requisitos de residência de dados ou compliance.

Detecção e extração

O Enterprise Document OCR pode detectar blocos, parágrafos, linhas, palavras e símbolos em PDFs e imagens, além de corrigir a inclinação de documentos para maior precisão.

Atributos de detecção e extração de layout compatíveis:

Texto impresso Escrita à mão Parágrafo Bloquear Linha Word No nível do símbolo Número da página
Padrão Padrão Padrão Padrão Padrão Padrão Configurável Padrão

Os recursos configuráveis do Enterprise Document OCR incluem:

  • Extrair texto incorporado ou nativo de PDFs digitais:esse recurso extrai texto e símbolos exatamente como aparecem nos documentos de origem, mesmo para textos girados, tamanhos ou estilos de fonte extremos e texto parcialmente oculto.

  • Correção de rotação:use o OCR de documentos corporativos para pré-processar imagens de documentos e corrigir problemas de rotação que podem afetar a qualidade da extração ou o processamento.

  • Pontuação de qualidade da imagem:receba métricas de qualidade que podem ajudar no roteamento de documentos. O Índice de qualidade da imagem fornece métricas de qualidade no nível da página em oito dimensões, incluindo desfoque, presença de fontes menores do que o normal e brilho.

  • Especificar intervalo de páginas:especifica o intervalo de páginas em um documento de entrada para OCR. Isso economiza tempo de processamento e gastos em páginas desnecessárias.

  • Detecção de idioma:detecta os idiomas usados nos textos extraídos.

  • Dicas de idioma e escrita à mão:melhore a precisão fornecendo ao modelo de OCR uma dica de idioma ou escrita à mão com base nas características conhecidas do seu conjunto de dados.

Para saber como ativar as configurações de OCR, consulte Ativar configurações de OCR.

Complementos de OCR

O OCR de documentos corporativos oferece recursos de análise opcionais que podem ser ativados em solicitações de processamento individuais conforme necessário.

Os seguintes recursos de complemento estão disponíveis para a versão estável pretrained-ocr-v2.0-2023-06-02 e a versão candidata pretrained-ocr-v2.1-2024-08-07:

  • OCR de matemática: identifica e extrai fórmulas de documentos no formato LaTeX.
  • Extração de caixas de seleção: detecte caixas de seleção e extraia o status delas (marcada/desmarcada) na resposta do OCR de documentos empresariais.
  • Detecção de estilo da fonte: identifique propriedades de fonte no nível da palavra, incluindo tipo de fonte, estilo, caligrafia, peso e cor.

Para saber como ativar os complementos listados, consulte Ativar complementos de OCR.

Formatos de arquivo compatíveis

O OCR de documentos corporativos oferece suporte aos formatos de arquivo PDF, GIF, TIFF, JPEG, PNG, BMP e WebP. Para mais informações, consulte Arquivos compatíveis.

O Enterprise Document OCR também oferece suporte a arquivos DocX de até 15 páginas em sincronização e 30 páginas em modo assíncrono. O suporte a DocX está em visualização particular. Para solicitar acesso, envie o formulário de solicitação de suporte do DocX .

Controle de versões avançado

A versão avançada está em pré-lançamento. Os upgrades nos modelos de OCR de IA/ML podem levar a mudanças no comportamento do OCR. Se for necessário manter a consistência estrita, use uma versão do modelo congelada para fixar o comportamento em um modelo OCR legado por até 18 meses. Isso garante que a mesma imagem seja o resultado da função OCR. Consulte a tabela sobre versões do processador.

Versões do processador

As versões de processador a seguir são compatíveis com esse recurso. Para mais informações, consulte Como gerenciar versões de processadores.

ID da versão Canal de lançamento Descrição
pretrained-ocr-v1.0-2020-09-23 Estável Não é recomendado para uso e será descontinuado nos Estados Unidos (EUA) e na União Europeia (UE) a partir de 30 de abril de 2025.
pretrained-ocr-v1.1-2022-09-12 Estável Não é recomendado para uso e será descontinuado nos Estados Unidos (EUA) e na União Europeia (UE) a partir de 30 de abril de 2025.
pretrained-ocr-v1.2-2022-11-10 Estável Versão do modelo congelada da v1.0: arquivos de modelo, configurações e binários de um snapshot da versão congelados em uma imagem de contêiner por até 18 meses.
pretrained-ocr-v2.0-2023-06-02 Estável Modelo pronto para Production especializado em casos de uso de documentos. Inclui acesso a todos os complementos de OCR.
pretrained-ocr-v2.1-2024-08-07 Versão candidata a lançamento As principais áreas de melhoria da v2.1 são: melhor reconhecimento de texto impresso, detecção de caixa de seleção mais precisa e ordem de leitura mais precisa.

Usar o Enterprise Document OCR para processar documentos

Este guia de início rápido apresenta o OCR de documentos corporativos. Ele mostra como otimizar os resultados de OCR de documentos para seu fluxo de trabalho ativando ou desativando qualquer uma das configurações de OCR disponíveis.

  1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  3. Make sure that billing is enabled for your Google Cloud project.

  4. Enable the Document AI API.

    Enable the API

    5.

  5. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  6. Make sure that billing is enabled for your Google Cloud project.

  7. Enable the Document AI API.

    Enable the API

    8.

Criar um processador de OCR de documentos corporativos

Primeiro, crie um processador de OCR de documentos corporativos. Para mais informações, consulte Como criar e gerenciar processadores.

Configurações de OCR

Todas as configurações de OCR podem ser ativadas definindo os campos correspondentes em ProcessOptions.ocrConfig no ProcessDocumentRequest ou BatchProcessDocumentsRequest.

Para mais informações, consulte Enviar uma solicitação de processamento.

Análise da qualidade da imagem

A análise inteligente de qualidade de documentos usa o aprendizado de máquina para avaliar a qualidade de um documento com base na legibilidade do conteúdo. Essa avaliação é retornada como um índice de qualidade [0, 1], em que 1 significa qualidade perfeita. Se o Índice de qualidade detectado for menor que 0.5, uma lista de motivos negativos de qualidade (ordenados pela probabilidade) também será retornada. Uma probabilidade maior que 0.5 é considerada uma detecção positiva.

Se o documento for considerado com defeito, a API vai retornar os oito tipos de defeito de documento a seguir:

  • quality/defect_blurry
  • quality/defect_noisy
  • quality/defect_dark
  • quality/defect_faint
  • quality/defect_text_too_small
  • quality/defect_document_cutoff
  • quality/defect_text_cutoff
  • quality/defect_glare

Há algumas limitações na análise atual de qualidade do documento:

  • Ele pode retornar detecções de falsos positivos com documentos digitais sem defeitos. O recurso é melhor usado em documentos digitalizados ou fotografados.

  • Os defeitos de reflexo são locais. A presença deles pode não prejudicar a legibilidade geral do documento.

Entrada

Ative definindo ProcessOptions.ocrConfig.enableImageQualityScores como true na solicitação de processamento. Esse recurso extra adiciona à chamada do processo uma latência comparável ao processamento de OCR.

  {
    "rawDocument": {
      "mimeType": "MIME_TYPE",
      "content": "IMAGE_CONTENT"
    },
    "processOptions": {
      "ocrConfig": {
        "enableImageQualityScores": true
      }
    }
  }

Saída

Os resultados da detecção de defeitos aparecem em Document.pages[].imageQualityScores[].

  {
    "pages": [
      {
        "imageQualityScores": {
          "qualityScore": 0.7811847,
          "detectedDefects": [
            {
              "type": "quality/defect_document_cutoff",
              "confidence": 1.0
            },
            {
              "type": "quality/defect_glare",
              "confidence": 0.97849524
            },
            {
              "type": "quality/defect_text_cutoff",
              "confidence": 0.5
            }
          ]
        }
      }
    ]
  }

Consulte Exemplo de saída do processador para conferir exemplos completos de saída.

Dicas de idioma

O processador de OCR oferece suporte a dicas de idioma que você define para melhorar o desempenho do mecanismo de OCR. A aplicação de uma dica de idioma permite que o OCR seja otimizado para um idioma selecionado em vez de um idioma inferido.

Entrada

Ative definindo ProcessOptions.ocrConfig.hints[].languageHints[] com uma lista de códigos de idioma BCP-47.

  {
    "rawDocument": {
      "mimeType": "MIME_TYPE",
      "content": "IMAGE_CONTENT"
    },
    "processOptions": {
      "ocrConfig": {
        "hints": {
          "languageHints": ["en", "es"]
        }
      }
    }
  }

Consulte Exemplo de saída do processador para conferir exemplos completos de saída.

Detecção de símbolos

Preencha os dados no nível do símbolo (ou letra individual) na resposta do documento.

Entrada

Ative definindo ProcessOptions.ocrConfig.enableSymbol como true na solicitação de processamento.

  {
    "rawDocument": {
      "mimeType": "MIME_TYPE",
      "content": "IMAGE_CONTENT"
    },
    "processOptions": {
      "ocrConfig": {
        "enableSymbol": true
      }
    }
  }

Saída

Se esse recurso estiver ativado, o campo Document.pages[].symbols[] será preenchido.

Consulte Exemplo de saída do processador para conferir exemplos completos de saída.

Análise de PDF integrada

Extraia texto incorporado de arquivos PDF digitais. Quando ativado, se houver texto digital, o modelo de PDF digital integrado será usado automaticamente. Se houver texto não digital, o modelo de OCR óptico será usado automaticamente. O usuário recebe os dois resultados de texto mesclados.

Entrada

Ative definindo ProcessOptions.ocrConfig.enableNativePdfParsing como true na solicitação de processamento.

  {
    "rawDocument": {
      "mimeType": "MIME_TYPE",
      "content": "IMAGE_CONTENT"
    },
    "processOptions": {
      "ocrConfig": {
        "enableNativePdfParsing": true
      }
    }
  }

Detecção de caracteres na caixa

Por padrão, o OCR de documentos corporativos tem um detector ativado para melhorar a qualidade da extração de texto de caracteres que estão em uma caixa. Veja um exemplo:

enterprise-document-ocr-1

Se você estiver com problemas de qualidade do OCR com caracteres dentro de caixas, desative essa opção.

Entrada

Desative definindo ProcessOptions.ocrConfig.disableCharacterBoxesDetection como true na solicitação de processamento.

  {
    "rawDocument": {
      "mimeType": "MIME_TYPE",
      "content": "IMAGE_CONTENT"
    },
    "processOptions": {
      "ocrConfig": {
        "disableCharacterBoxesDetection": true
      }
    }
  }

Layout legado

Se você precisar de um algoritmo de detecção de layout heurístico, ative o layout legado, que serve como uma alternativa ao algoritmo atual de detecção de layout baseado em ML. Essa não é a configuração recomendada. Os clientes podem escolher o algoritmo de layout mais adequado com base no fluxo de documentos.

Entrada

Ative definindo ProcessOptions.ocrConfig.advancedOcrOptions como ["legacy_layout"] na solicitação de processamento.

  {
    "rawDocument": {
      "mimeType": "MIME_TYPE",
      "content": "IMAGE_CONTENT"
    },
    "processOptions": {
      "ocrConfig": {
          "advancedOcrOptions": ["legacy_layout"]
      }
    }
  }

Especificar um intervalo de páginas

Por padrão, o OCR extrai informações de texto e layout de todas as páginas dos documentos. Você pode selecionar números de página ou intervalos específicos e extrair apenas o texto dessas páginas.

Há três maneiras de configurar isso no ProcessOptions:

  • Para processar apenas a segunda e a quinta página:
  {
    "individualPageSelector": {"pages": [2, 5]}
  }
  • Para processar apenas as três primeiras páginas:
  {
    "fromStart": 3
  }
  • Para processar apenas as quatro últimas páginas:
  {
    "fromEnd": 4
  }

Na resposta, cada Document.pages[].pageNumber corresponde às mesmas páginas especificadas na solicitação.

Uso de complementos de OCR

Esses recursos de análise opcional do OCR de documentos empresariais podem ser ativados em solicitações de processamento individuais, conforme necessário.

OCR matemático

O OCR matemático detecta, reconhece e extrai fórmulas, como equações matemáticas representadas como LaTeX, com coordenadas da caixa delimitadora.

Confira um exemplo de representação em LaTeX:

  • Imagem detectada

    enterprise-document-ocr-2

  • Conversão para LaTeX

    enterprise-document-ocr-3

Entrada

Ative definindo ProcessOptions.ocrConfig.premiumFeatures.enableMathOcr como true na solicitação de processamento.

  {
    "rawDocument": {
      "mimeType": "MIME_TYPE",
      "content": "IMAGE_CONTENT"
    },
    "processOptions": {
      "ocrConfig": {
          "premiumFeatures": {
            "enableMathOcr": true
          }
      }
    }
  }

Saída

A saída do OCR de matemática aparece em Document.pages[].visualElements[] com "type": "math_formula".

"visualElements": [
  {
    "layout": {
      "textAnchor": {
        "textSegments": [
          {
            "endIndex": "46"
          }
        ]
      },
      "confidence": 1,
      "boundingPoly": {
        "normalizedVertices": [
          {
            "x": 0.14662756,
            "y": 0.27891156
          },
          {
            "x": 0.9032258,
            "y": 0.27891156
          },
          {
            "x": 0.9032258,
            "y": 0.8027211
          },
          {
            "x": 0.14662756,
            "y": 0.8027211
          }
        ]
      },
      "orientation": "PAGE_UP"
    },
    "type": "math_formula"
  }
]

Confira a saída JSON completa de Document neste link .

Extração de marca de seleção

Se ativado, o modelo tenta extrair todas as caixas de seleção e botões de opção no documento, além das coordenadas da caixa delimitadora.

Entrada

Ative definindo ProcessOptions.ocrConfig.premiumFeatures.enableSelectionMarkDetection como true na solicitação de processamento.

  {
    "rawDocument": {
      "mimeType": "MIME_TYPE",
      "content": "IMAGE_CONTENT"
    },
    "processOptions": {
      "ocrConfig": {
          "premiumFeatures": {
            "enableSelectionMarkDetection": true
          }
      }
    }
  }

Saída

A saída da caixa de seleção aparece em Document.pages[].visualElements[] com "type": "unfilled_checkbox" ou "type": "filled_checkbox".

"visualElements": [
  {
    "layout": {
      "confidence": 0.89363575,
      "boundingPoly": {
        "vertices": [
          {
            "x": 11,
            "y": 24
          },
          {
            "x": 37,
            "y": 24
          },
          {
            "x": 37,
            "y": 56
          },
          {
            "x": 11,
            "y": 56
          }
        ],
        "normalizedVertices": [
          {
            "x": 0.017488075,
            "y": 0.38709676
          },
          {
            "x": 0.05882353,
            "y": 0.38709676
          },
          {
            "x": 0.05882353,
            "y": 0.9032258
          },
          {
            "x": 0.017488075,
            "y": 0.9032258
          }
        ]
      }
    },
    "type": "unfilled_checkbox"
  },
  {
    "layout": {
      "confidence": 0.9148201,
      "boundingPoly": ...
    },
    "type": "filled_checkbox"
  }
],

Confira a saída JSON completa de Document neste link .

Detecção de estilo de fonte

Com a detecção de estilo de fonte ativada, o Enterprise Document OCR extrai atributos de fonte, que podem ser usados para um melhor pós-processamento.

No nível do token (palavra), os seguintes atributos são detectados:

  • Detecção de escrita à mão
  • Estilo da fonte
  • Tamanho da fonte
  • Tipo da fonte
  • Cor da fonte
  • Espessura da fonte
  • Espaçamento entre letras
  • Negrito
  • Itálico
  • Sublinhado
  • Cor do texto (RGBa)

  • Cor do plano de fundo (RGBa)

Entrada

Ative definindo ProcessOptions.ocrConfig.premiumFeatures.computeStyleInfo como true na solicitação de processamento.

  {
    "rawDocument": {
      "mimeType": "MIME_TYPE",
      "content": "IMAGE_CONTENT"
    },
    "processOptions": {
      "ocrConfig": {
          "premiumFeatures": {
            "computeStyleInfo": true
          }
      }
    }
  }

Saída

A saída do estilo de fonte aparece em Document.pages[].tokens[].styleInfo com o tipo StyleInfo.

"tokens": [
  {
    "styleInfo": {
      "fontSize": 3,
      "pixelFontSize": 13,
      "fontType": "SANS_SERIF",
      "bold": true,
      "fontWeight": 564,
      "textColor": {
        "red": 0.16862746,
        "green": 0.16862746,
        "blue": 0.16862746
      },
      "backgroundColor": {
        "red": 0.98039216,
        "green": 0.9882353,
        "blue": 0.99215686
      }
    }
  },
  ...
]

Confira a saída JSON completa de Document neste link .

Converter objetos de documentos para o formato da API Vision AI

O Document AI Toolbox inclui uma ferramenta que converte o formato Document da API Document AI para o formato AnnotateFileResponse da API Vision AI, permitindo que os usuários comparem as respostas entre o processador de OCR de documentos e a API Vision AI. Confira um exemplo de código.

Discrepâncias conhecidas entre a resposta da API Vision AI e a resposta e o conversor da API Document AI:

  • A resposta da API Vision AI preenche apenas vertices para solicitações de imagem e normalized_vertices para solicitações de PDF. A resposta da IA de documentos e o conversor preenchem vertices e normalized_vertices.
  • A resposta da API Vision AI preenche o detected_break no último símbolo da palavra. A resposta da API Document AI e o conversor preenchem detected_break na palavra e no último símbolo da palavra.
  • A resposta da API Vision AI sempre preenche os campos de símbolos. Por padrão, a resposta da Document AI não preenche os campos de símbolos. Para garantir que a resposta da Document AI e os campos de símbolos do conversor sejam preenchidos, defina o recurso enable_symbol como detalhado.

Amostras de código

Os exemplos de código a seguir demonstram como enviar uma solicitação de processamento para ativar configurações e complementos de OCR e, em seguida, ler e imprimir os campos no terminal:

REST

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

  • LOCATION: o local do processador, por exemplo:
    • us - Estados Unidos
    • eu - União Europeia
  • PROJECT_ID: o ID do projeto do Google Cloud .
  • PROCESSOR_ID: o ID do processador personalizado.
  • PROCESSOR_VERSION: o identificador da versão do processador. Consulte Selecionar uma versão do processador para mais informações. Por exemplo:
    • pretrained-TYPE-vX.X-YYYY-MM-DD
    • stable
    • rc
  • skipHumanReview: um booleano para desativar a revisão humana (compatível apenas com processadores human-in-the-loop).
    • true: pula a revisão humana
    • false: ativa a revisão humana (padrão)
  • MIME_TYPE†: uma das opções válidas de tipo MIME.
  • IMAGE_CONTENT†: um dos conteúdos de documento inline válidos, representado como um fluxo de bytes. Para representações JSON, a codificação base64 (string ASCII) dos dados da imagem binária. Essa string precisa ser semelhante à seguinte:
    • /9j/4QAYRXhpZgAA...9tAVx/zDQDlGxn//2Q==
    Confira mais informações no tópico Codificação Base64.
  • FIELD_MASK: especifica quais campos incluir na saída Document. É uma lista separada por vírgulas de nomes de campos totalmente qualificados no formato FieldMask.
    • Exemplo: text,entities,pages.pageNumber
  • Configurações de OCR
    • ENABLE_NATIVE_PDF_PARSING: (booleano) extrai texto incorporado de PDFs, se disponível.
    • ENABLE_IMAGE_QUALITY_SCORES: (booleano) ativa as pontuações inteligentes de qualidade de documentos.
    • ENABLE_SYMBOL: (booleano) inclui informações de OCR de símbolo (letra).
    • DISABLE_CHARACTER_BOXES_DETECTION: (booleano) desativa o detector de caixa de caracteres no mecanismo de OCR.
    • LANGUAGE_HINTS: lista de códigos de idioma BCP-47 para usar no OCR.
    • ADVANCED_OCR_OPTIONS: uma lista de opções avançadas de OCR para ajustar ainda mais o comportamento do OCR. Os valores válidos atuais são:
      • legacy_layout: um algoritmo de detecção de layout heurístico, que serve como uma alternativa ao algoritmo atual de detecção de layout baseado em ML.
  • Complementos premium de OCR
    • ENABLE_SELECTION_MARK_DETECTION: (booleano) ativa o detector de marca de seleção no mecanismo de OCR.
    • COMPUTE_STYLE_INFO (booleano) Ativa o modelo de identificação de fonte e retorna as informações de estilo de fonte.
    • ENABLE_MATH_OCR: (booleano) ativa o modelo que pode extrair fórmulas matemáticas LaTeX.
  • INDIVIDUAL_PAGES: uma lista de páginas individuais a serem processadas.
    • Como alternativa, forneça o campo fromStart ou fromEnd para processar uma quantidade específica de páginas do início ou do fim do documento.

† Esse conteúdo também pode ser especificado usando conteúdo codificado em base64 no objeto inlineDocument.

Método HTTP e URL: 

POST https://LOCATION-documentai.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/processors/PROCESSOR_ID/processorVersions/PROCESSOR_VERSION:process

Corpo JSON da solicitação:

{
  "skipHumanReview": skipHumanReview,
  "rawDocument": {
    "mimeType": "MIME_TYPE",
    "content": "IMAGE_CONTENT"
  },
  "fieldMask": "FIELD_MASK",
  "processOptions": {
    "ocrConfig": {
      "enableNativePdfParsing": ENABLE_NATIVE_PDF_PARSING,
      "enableImageQualityScores": ENABLE_IMAGE_QUALITY_SCORES,
      "enableSymbol": ENABLE_SYMBOL,
      "disableCharacterBoxesDetection": DISABLE_CHARACTER_BOXES_DETECTION,
      "hints": {
        "languageHints": [
          "LANGUAGE_HINTS"
        ]
      },
      "advancedOcrOptions": ["ADVANCED_OCR_OPTIONS"],
      "premiumFeatures": {
        "enableSelectionMarkDetection": ENABLE_SELECTION_MARK_DETECTION,
        "computeStyleInfo": COMPUTE_STYLE_INFO,
        "enableMathOcr": ENABLE_MATH_OCR,
      }
    },
    "individualPageSelector" {
      "pages": [INDIVIDUAL_PAGES]
    }
  }
}

Para enviar a solicitação, escolha uma destas opções:

curl

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir: 

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION-documentai.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/processors/PROCESSOR_ID/processorVersions/PROCESSOR_VERSION:process"

PowerShell

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir: 

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION-documentai.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/processors/PROCESSOR_ID/processorVersions/PROCESSOR_VERSION:process" | Select-Object -Expand Content

Quando a solicitação é bem-sucedida, o servidor retorna um código de status HTTP 200 OK e a resposta no formato JSON. O corpo da resposta contém uma instância de Document.

Python

Para mais informações, consulte a documentação de referência da API Document AI Python.

Para autenticar na Document AI, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local. 


from typing import Optional, Sequence

from google.api_core.client_options import ClientOptions
from google.cloud import documentai

# TODO(developer): Uncomment these variables before running the sample.
# project_id = "YOUR_PROJECT_ID"
# location = "YOUR_PROCESSOR_LOCATION" # Format is "us" or "eu"
# processor_id = "YOUR_PROCESSOR_ID" # Create processor before running sample
# processor_version = "rc" # Refer to https://cloud.google.com/document-ai/docs/manage-processor-versions for more information
# file_path = "/path/to/local/pdf"
# mime_type = "application/pdf" # Refer to https://cloud.google.com/document-ai/docs/file-types for supported file types


def process_document_ocr_sample(
    project_id: str,
    location: str,
    processor_id: str,
    processor_version: str,
    file_path: str,
    mime_type: str,
) -> None:
    # Optional: Additional configurations for Document OCR Processor.
    # For more information: https://cloud.google.com/document-ai/docs/enterprise-document-ocr
    process_options = documentai.ProcessOptions(
        ocr_config=documentai.OcrConfig(
            enable_native_pdf_parsing=True,
            enable_image_quality_scores=True,
            enable_symbol=True,
            # OCR Add Ons https://cloud.google.com/document-ai/docs/ocr-add-ons
            premium_features=documentai.OcrConfig.PremiumFeatures(
                compute_style_info=True,
                enable_math_ocr=False,  # Enable to use Math OCR Model
                enable_selection_mark_detection=True,
            ),
        )
    )
    # Online processing request to Document AI
    document = process_document(
        project_id,
        location,
        processor_id,
        processor_version,
        file_path,
        mime_type,
        process_options=process_options,
    )

    text = document.text
    print(f"Full document text: {text}\n")
    print(f"There are {len(document.pages)} page(s) in this document.\n")

    for page in document.pages:
        print(f"Page {page.page_number}:")
        print_page_dimensions(page.dimension)
        print_detected_languages(page.detected_languages)

        print_blocks(page.blocks, text)
        print_paragraphs(page.paragraphs, text)
        print_lines(page.lines, text)
        print_tokens(page.tokens, text)

        if page.symbols:
            print_symbols(page.symbols, text)

        if page.image_quality_scores:
            print_image_quality_scores(page.image_quality_scores)

        if page.visual_elements:
            print_visual_elements(page.visual_elements, text)


def print_page_dimensions(dimension: documentai.Document.Page.Dimension) -> None:
    print(f"    Width: {str(dimension.width)}")
    print(f"    Height: {str(dimension.height)}")


def print_detected_languages(
    detected_languages: Sequence[documentai.Document.Page.DetectedLanguage],
) -> None:
    print("    Detected languages:")
    for lang in detected_languages:
        print(f"        {lang.language_code} ({lang.confidence:.1%} confidence)")


def print_blocks(blocks: Sequence[documentai.Document.Page.Block], text: str) -> None:
    print(f"    {len(blocks)} blocks detected:")
    first_block_text = layout_to_text(blocks[0].layout, text)
    print(f"        First text block: {repr(first_block_text)}")
    last_block_text = layout_to_text(blocks[-1].layout, text)
    print(f"        Last text block: {repr(last_block_text)}")


def print_paragraphs(
    paragraphs: Sequence[documentai.Document.Page.Paragraph], text: str
) -> None:
    print(f"    {len(paragraphs)} paragraphs detected:")
    first_paragraph_text = layout_to_text(paragraphs[0].layout, text)
    print(f"        First paragraph text: {repr(first_paragraph_text)}")
    last_paragraph_text = layout_to_text(paragraphs[-1].layout, text)
    print(f"        Last paragraph text: {repr(last_paragraph_text)}")


def print_lines(lines: Sequence[documentai.Document.Page.Line], text: str) -> None:
    print(f"    {len(lines)} lines detected:")
    first_line_text = layout_to_text(lines[0].layout, text)
    print(f"        First line text: {repr(first_line_text)}")
    last_line_text = layout_to_text(lines[-1].layout, text)
    print(f"        Last line text: {repr(last_line_text)}")


def print_tokens(tokens: Sequence[documentai.Document.Page.Token], text: str) -> None:
    print(f"    {len(tokens)} tokens detected:")
    first_token_text = layout_to_text(tokens[0].layout, text)
    first_token_break_type = tokens[0].detected_break.type_.name
    print(f"        First token text: {repr(first_token_text)}")
    print(f"        First token break type: {repr(first_token_break_type)}")
    if tokens[0].style_info:
        print_style_info(tokens[0].style_info)

    last_token_text = layout_to_text(tokens[-1].layout, text)
    last_token_break_type = tokens[-1].detected_break.type_.name
    print(f"        Last token text: {repr(last_token_text)}")
    print(f"        Last token break type: {repr(last_token_break_type)}")
    if tokens[-1].style_info:
        print_style_info(tokens[-1].style_info)


def print_symbols(
    symbols: Sequence[documentai.Document.Page.Symbol], text: str
) -> None:
    print(f"    {len(symbols)} symbols detected:")
    first_symbol_text = layout_to_text(symbols[0].layout, text)
    print(f"        First symbol text: {repr(first_symbol_text)}")
    last_symbol_text = layout_to_text(symbols[-1].layout, text)
    print(f"        Last symbol text: {repr(last_symbol_text)}")


def print_image_quality_scores(
    image_quality_scores: documentai.Document.Page.ImageQualityScores,
) -> None:
    print(f"    Quality score: {image_quality_scores.quality_score:.1%}")
    print("    Detected defects:")

    for detected_defect in image_quality_scores.detected_defects:
        print(f"        {detected_defect.type_}: {detected_defect.confidence:.1%}")


def print_style_info(style_info: documentai.Document.Page.Token.StyleInfo) -> None:
    """
    Only supported in version `pretrained-ocr-v2.0-2023-06-02`
    """
    print(f"           Font Size: {style_info.font_size}pt")
    print(f"           Font Type: {style_info.font_type}")
    print(f"           Bold: {style_info.bold}")
    print(f"           Italic: {style_info.italic}")
    print(f"           Underlined: {style_info.underlined}")
    print(f"           Handwritten: {style_info.handwritten}")
    print(
        f"           Text Color (RGBa): {style_info.text_color.red}, {style_info.text_color.green}, {style_info.text_color.blue}, {style_info.text_color.alpha}"
    )


def print_visual_elements(
    visual_elements: Sequence[documentai.Document.Page.VisualElement], text: str
) -> None:
    """
    Only supported in version `pretrained-ocr-v2.0-2023-06-02`
    """
    checkboxes = [x for x in visual_elements if "checkbox" in x.type]
    math_symbols = [x for x in visual_elements if x.type == "math_formula"]

    if checkboxes:
        print(f"    {len(checkboxes)} checkboxes detected:")
        print(f"        First checkbox: {repr(checkboxes[0].type)}")
        print(f"        Last checkbox: {repr(checkboxes[-1].type)}")

    if math_symbols:
        print(f"    {len(math_symbols)} math symbols detected:")
        first_math_symbol_text = layout_to_text(math_symbols[0].layout, text)
        print(f"        First math symbol: {repr(first_math_symbol_text)}")




def process_document(
    project_id: str,
    location: str,
    processor_id: str,
    processor_version: str,
    file_path: str,
    mime_type: str,
    process_options: Optional[documentai.ProcessOptions] = None,
) -> documentai.Document:
    # You must set the `api_endpoint` if you use a location other than "us".
    client = documentai.DocumentProcessorServiceClient(
        client_options=ClientOptions(
            api_endpoint=f"{location}-documentai.googleapis.com"
        )
    )

    # The full resource name of the processor version, e.g.:
    # `projects/{project_id}/locations/{location}/processors/{processor_id}/processorVersions/{processor_version_id}`
    # You must create a processor before running this sample.
    name = client.processor_version_path(
        project_id, location, processor_id, processor_version
    )

    # Read the file into memory
    with open(file_path, "rb") as image:
        image_content = image.read()

    # Configure the process request
    request = documentai.ProcessRequest(
        name=name,
        raw_document=documentai.RawDocument(content=image_content, mime_type=mime_type),
        # Only supported for Document OCR processor
        process_options=process_options,
    )

    result = client.process_document(request=request)

    # For a full list of `Document` object attributes, reference this page:
    # https://cloud.google.com/document-ai/docs/reference/rest/v1/Document
    return result.document




def layout_to_text(layout: documentai.Document.Page.Layout, text: str) -> str:
    """
    Document AI identifies text in different parts of the document by their
    offsets in the entirety of the document"s text. This function converts
    offsets to a string.
    """
    # If a text segment spans several lines, it will
    # be stored in different text segments.
    return "".join(
        text[int(segment.start_index) : int(segment.end_index)]
        for segment in layout.text_anchor.text_segments
    )

A seguir