Enterprise Document OCR

Pode usar o Enterprise Document OCR como parte da Document AI para detetar e extrair texto e informações de esquema de vários documentos. Com funcionalidades configuráveis, pode adaptar o sistema para cumprir requisitos específicos de processamento de documentos.

Vista geral

Pode usar o OCR de documentos empresariais para tarefas como a introdução de dados com base em algoritmos ou aprendizagem automática, bem como para melhorar e validar a precisão dos dados. Também pode usar o Enterprise Document OCR para processar tarefas como as seguintes:

  • Digitalizar texto: extraia texto e dados de esquemas de documentos para pesquisa, pipelines de processamento de documentos baseados em regras ou criação de modelos personalizados.
  • Usar aplicações de modelos de linguagem (conteúdo extenso): use a compreensão contextual dos GMLs e as capacidades de extração de texto e esquemas da ROC para automatizar perguntas e respostas. Descubra estatísticas a partir de dados e simplifique fluxos de trabalho.
  • Arquivo: converta documentos em papel em texto legível por máquina para melhorar a acessibilidade dos documentos.

Escolher o melhor OCR para o seu exemplo de utilização

Solução Produto Descrição Exemplo de utilização
Document AI Enterprise Document OCR Modelo especializado para exemplos de utilização de documentos. As funcionalidades avançadas incluem a classificação da qualidade da imagem, sugestões de idiomas e correção da rotação. Recomendado quando extrai texto de documentos. Os exemplos de utilização incluem PDFs, documentos digitalizados como imagens ou ficheiros Microsoft DocX.
Document AI Suplementos de OCR Funcionalidades premium para requisitos específicos. Apenas compatível com a versão 2.0 e posterior do Enterprise Document OCR. Precisam de detetar e reconhecer fórmulas matemáticas, receber informações de estilo de letra ou ativar a extração de caixas de verificação.
API Cloud Vision Deteção de texto API REST disponível globalmente baseada no Google Cloud modelo de ROC padrão. Quota predefinida de 1800 pedidos por minuto. Exemplos de utilização gerais de extração de texto que requerem baixa latência e alta capacidade.
Cloud Vision OCR Google Distributed Cloud (descontinuado) Aplicação do Google Cloud Marketplace que pode ser implementada como um contentor em qualquer cluster do GKE através do GKE Enterprise. Para cumprir os requisitos de residência ou conformidade dos dados.

Deteção e extração

O Enterprise Document OCR pode detetar blocos, parágrafos, linhas, palavras e símbolos em PDFs e imagens, bem como corrigir a distorção de documentos para uma maior precisão.

Atributos de deteção e extração de esquemas suportados:

Texto impresso Escrita manual Parágrafo Bloquear Linha Palavra Nível do símbolo Número da página
Predefinição Predefinição Predefinição Predefinição Predefinição Predefinição Configurável Predefinição

As funcionalidades configuráveis do Enterprise Document OCR incluem o seguinte:

  • Extraia texto incorporado ou nativo de PDFs digitais: esta funcionalidade extrai texto e símbolos exatamente como aparecem nos documentos de origem, mesmo para textos rodados, tamanhos ou estilos de letra extremos e texto parcialmente oculto.

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

  • Classificação da qualidade da imagem: receba métricas de qualidade que podem ajudar no encaminhamento de documentos. A classificação da qualidade da imagem fornece-lhe métricas de qualidade ao nível da página em oito dimensões, incluindo o efeito de desfocagem, a presença de tipos de letra mais pequenos do que o habitual e o brilho excessivo.

  • Especificar intervalo de páginas: especifica o intervalo das páginas num documento de entrada para OCR. Isto poupa o tempo de processamento e os gastos em páginas desnecessárias.

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

  • Sugestões de idioma e caligrafia: melhore a precisão fornecendo ao modelo de OCR uma sugestão de idioma ou caligrafia com base nas caraterísticas conhecidas do seu conjunto de dados.

Para saber como ativar as configurações de OCR, consulte o artigo Ative as configurações de OCR.

Suplementos OCR

O Enterprise Document OCR oferece capacidades de análise opcionais que podem ser ativadas em pedidos de processamento individuais, conforme necessário.

As seguintes capacidades de suplementos estão disponíveis para as versões estável pretrained-ocr-v2.0-2023-06-02 e pretrained-ocr-v2.1-2024-08-07, e para a versão Release Candidate pretrained-ocr-v2.1.1-2025-01-31.

  • OCR matemático: identifique e extraia fórmulas de documentos no formato LaTeX.
  • Extração de caixas de verificação: detete caixas de verificação e extraia o respetivo estado (marcado/não marcado) na resposta do Enterprise Document OCR.
  • Deteção do estilo do tipo de letra: identifique as propriedades do tipo de letra ao nível da palavra, incluindo o tipo de letra, o estilo do tipo de letra, a caligrafia, a espessura e a cor.

Para saber como ativar os suplementos indicados, consulte o artigo Ative suplementos de OCR.

Formatos de ficheiros suportados

O OCR de documentos empresariais suporta os formatos de ficheiros PDF, GIF, TIFF, JPEG, PNG, BMP e WebP. Para mais informações, consulte o artigo Ficheiros suportados.

O Enterprise Document OCR também suporta ficheiros DocX até 15 páginas em modo síncrono e 30 páginas em modo assíncrono. Para fazer um pedido de aumento da quota (QIR), siga os passos em Peça um ajuste da quota. O suporte de DocX está em pré-visualização privada. Para solicitar acesso, contacte a equipa da sua Conta Google.

Controlo de versões avançado

O controlo de versões avançado está em pré-visualização. As atualizações aos modelos de OCR de IA/ML subjacentes podem levar a alterações no comportamento do OCR. Se for necessária uma consistência rigorosa, use uma versão do modelo congelada para fixar o comportamento a um modelo de OCR antigo durante um período máximo de 18 meses. Isto garante o mesmo resultado da função de OCR para a mesma imagem. Consulte a tabela sobre as versões do processador.

Versões do processador

As seguintes versões de processador são compatíveis com esta funcionalidade. Para mais informações, consulte o artigo Gerir versões do processador.

ID da versão Canal de lançamento Descrição
pretrained-ocr-v1.2-2022-11-10 Estável Versão do modelo congelada da v1.0: ficheiros de modelo, configurações e binários de um resumo da versão congelado numa imagem de contentor durante um máximo de 18 meses.
pretrained-ocr-v2.0-2023-06-02 Estável Modelo pronto para produção especializado em exemplos de utilização de documentos. Inclui acesso a todos os suplementos de OCR.
pretrained-ocr-v2.1-2024-08-07 Estável As principais áreas de melhoria da versão 2.1 são: melhor reconhecimento de texto impresso, deteção mais precisa de caixas de verificação e ordem de leitura mais precisa.
pretrained-ocr-v2.1.1-2025-01-31 Candidato a lançamento A versão 2.1.1 é semelhante à versão 2.1 e está disponível em todas as regiões, exceto: US, EU e asia-southeast1.

Use o Enterprise Document OCR para processar documentos

Este início rápido apresenta o Enterprise Document OCR. Mostra como otimizar os resultados do OCR de documentos para o 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.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  3. Verify that billing is enabled for your Google Cloud project.

  4. Enable the Document AI API.

    Roles required to enable APIs

    To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

    Enable the API

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

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  6. Verify that billing is enabled for your Google Cloud project.

  7. Enable the Document AI API.

    Roles required to enable APIs

    To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

    Enable the API

    8.

    Crie um processador Enterprise Document OCR

    Primeiro, crie um processador Enterprise Document OCR. Para mais informações, consulte o artigo sobre como criar e gerir processadores.

    Configurações de OCR

    Pode ativar todas as configurações de OCR definindo os campos respetivos em ProcessOptions.ocrConfig no ProcessDocumentRequest ou BatchProcessDocumentsRequest.

    Para mais informações, consulte o artigo Envie um pedido de processamento.

    Análise da qualidade da imagem

    A análise inteligente da qualidade dos documentos usa a aprendizagem automática para realizar a avaliação da qualidade de um documento com base na legibilidade do respetivo conteúdo. Esta avaliação de qualidade é devolvida como um índice de qualidade [0, 1], em que 1 significa qualidade perfeita. Se o Índice de qualidade detetado for inferior a 0.5, também é devolvida uma lista de motivos de qualidade negativos (ordenados por probabilidade). Uma probabilidade superior a 0.5 é considerada uma deteção positiva.

    Se o documento for considerado defeituoso, a API devolve os seguintes oito tipos de defeitos de documentos:

    • 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

    Existem algumas limitações com a análise de qualidade de documentos atual:

    • Pode devolver deteções de falsos positivos com documentos digitais sem defeitos. A funcionalidade é melhor usada em documentos digitalizados ou fotografados.

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

    Entrada

    Ative-o definindo ProcessOptions.ocrConfig.enableImageQualityScores como true no pedido de processamento. Esta funcionalidade adicional adiciona uma latência comparável ao processamento de OCR à chamada de processo.

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

    Resultado

    Os resultados da deteção de defeitos são apresentados 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 ver exemplos de saída completos.

    Sugestões de idioma

    O processador de OCR suporta sugestões de idiomas que define para melhorar o desempenho do motor de OCR. A aplicação de uma sugestão de idioma permite que o OCR seja otimizado para um idioma selecionado em vez de um idioma inferido.

    Entrada

    Ative-o 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 ver exemplos de saída completos.

    Deteção de símbolos

    Preencher dados ao nível do símbolo (ou da letra individual) na resposta do documento.

    Entrada

    Ative-o definindo ProcessOptions.ocrConfig.enableSymbol como true no pedido de processamento.

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

    Resultado

    Se esta funcionalidade estiver ativada, o campo Document.pages[].symbols[] é preenchido.

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

    Análise de PDFs incorporada

    Extrair texto incorporado de ficheiros PDF digitais. Quando ativado, se existir texto digital, o modelo de PDF digital incorporado é usado automaticamente. Se houver texto não digital, o modelo de OCR ótico é usado automaticamente. O utilizador recebe os resultados de texto combinados.

    Entrada

    Ative-o definindo ProcessOptions.ocrConfig.enableNativePdfParsing como true no pedido de processamento.

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

    Deteção de personagem na caixa

    Por predefinição, o Enterprise Document OCR tem um detetor ativado para melhorar a qualidade da extração de texto de carateres que se encontram numa caixa. Vejamos um exemplo:

    enterprise-document-ocr-1

    Se estiver a ter problemas de qualidade de ROC com carateres dentro de caixas, pode desativá-lo.

    Entrada

    Desative-o definindo ProcessOptions.ocrConfig.disableCharacterBoxesDetection como true no pedido de processamento.

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

    Esquema antigo

    Se precisar de um algoritmo de deteção de esquemas heurístico, pode ativar o esquema antigo, que funciona como uma alternativa ao algoritmo de deteção de esquemas atual baseado em AA. Esta não é a configuração recomendada. Os clientes podem escolher o algoritmo de esquema mais adequado com base no fluxo de trabalho do documento.

    Entrada

    Ative-o definindo ProcessOptions.ocrConfig.advancedOcrOptions como ["legacy_layout"] no pedido de processamento.

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

    Especifique um intervalo de páginas

    Por predefinição, o OCR extrai texto e informações de esquema de todas as páginas nos documentos. Pode selecionar números de páginas ou intervalos de páginas específicos e extrair apenas texto dessas páginas.

    Existem três formas de configurar esta opção 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 últimas quatro páginas:
      {
    "fromEnd": 4
  }

    Na resposta, cada Document.pages[].pageNumber corresponde às mesmas páginas especificadas no pedido.

    Usos dos suplementos OCR

    Estas capacidades de análise opcionais do Enterprise Document OCR podem ser ativadas em pedidos de processamento individuais, conforme necessário.

    OCR de matemática

    O OCR de matemática deteta, reconhece e extrai fórmulas, como equações matemáticas representadas como LaTeX, juntamente com as coordenadas da caixa delimitadora.

    Segue-se um exemplo de representação em LaTeX:

    • Imagem detetada

      enterprise-document-ocr-2

    • Conversão para LaTeX

      enterprise-document-ocr-3

    Entrada

    Ative-o definindo ProcessOptions.ocrConfig.premiumFeatures.enableMathOcr como true no pedido de processamento.

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

    Resultado

    O resultado do OCR de matemática é apresentado 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"
  }
]

    Pode verificar o resultado JSON completo Document neste link .

    Extração de marcas de seleção

    Se estiver ativado, o modelo tenta extrair todas as caixas de verificação e botões de opção no documento, juntamente com as coordenadas da caixa delimitadora.

    Entrada

    Ative-o definindo ProcessOptions.ocrConfig.premiumFeatures.enableSelectionMarkDetection como true no pedido de processamento.

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

    Resultado

    O resultado da caixa de verificação é apresentado 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"
  }
],

    Pode verificar o resultado JSON completo Document neste link .

    Deteção de estilo do tipo de letra

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

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

    • Deteção de escrita manual
    • Estilo do tipo de letra
    • Tamanho do tipo de letra
    • Tipo de letra
    • Cor do tipo de letra
    • Espessura do tipo de letra
    • Espaçamento entre letras
    • Negrito
    • Itálico
    • Sublinhado
    • Cor do texto (RGBa)

    • Cor de fundo (RGBa)

    Entrada

    Ative-o definindo ProcessOptions.ocrConfig.premiumFeatures.computeStyleInfo como true no pedido de processamento.

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

    Resultado

    O resultado de font-style é apresentado 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
      }
    }
  },
  ...
]

    Pode verificar o resultado JSON completo Document neste link .

    Converta objetos de documentos para o formato da API Vision AI

    A caixa de ferramentas do Document AI inclui uma ferramenta que converte o formato Document da API Document AI no formato AnnotateFileResponse da API Vision AI, o que permite aos utilizadores comparar as respostas entre o processador de OCR de documentos e a API Vision AI. Segue-se um exemplo de código.

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

    • A resposta da API Vision AI preenche apenas vertices para pedidos de imagens e apenas normalized_vertices para pedidos de PDF. A resposta da Document AI 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 preenche sempre os campos de símbolos. Por predefinição, a resposta da Document AI não preenche os campos de símbolos. Para garantir que a resposta da IA Documentos e o conversor preenchem os campos de símbolos, defina a funcionalidade enable_symbol como detalhada.

    Exemplos de código

    Os exemplos de código seguintes demonstram como enviar um pedido de processamento que ativa as configurações de OCR e os suplementos, e, em seguida, lê e imprime os campos no terminal:

    REST

    Antes de usar qualquer um dos dados do pedido, faça as seguintes substituições:

    • LOCATION: a localização do seu processador, por exemplo:
      • us – Estados Unidos
      • eu - União Europeia
    • PROJECT_ID: o ID do seu Google Cloud projeto.
    • PROCESSOR_ID: o ID do seu processador personalizado.
    • PROCESSOR_VERSION: o identificador da versão do processador. Consulte o artigo Selecione uma versão do processador para mais informações. Por exemplo:
      • pretrained-TYPE-vX.X-YYYY-MM-DD
      • stable
      • rc
    • skipHumanReview: um valor booleano para desativar a revisão humana (apenas suportado por processadores humanos no circuito).
      • true – Ignora a revisão humana
      • false: ativa a revisão humana (predefinição)
    • MIME_TYPE†: Uma das opções de tipo MIME válidas.
    • IMAGE_CONTENT†: um dos seguintes elementos válidos: conteúdo do documento inline, representado como uma stream de bytes. Para representações JSON, a codificação base64 (string ASCII) dos dados da imagem binária. Esta string deve ser semelhante à seguinte string:
      • /9j/4QAYRXhpZgAA...9tAVx/zDQDlGxn//2Q==
      Visite o tópico Codificação Base64 para mais informações.
    • FIELD_MASK: especifica os campos a incluir na saída Document. Esta é uma lista separada por vírgulas de nomes totalmente qualificados de campos 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 classificações de qualidade de documentos inteligentes.
      • ENABLE_SYMBOL: (Booleano) Inclui informações de OCR de símbolos (letras).
      • DISABLE_CHARACTER_BOXES_DETECTION: (Booleano) Desative o detetor de caixa de carateres no motor de OCR.
      • LANGUAGE_HINTS: lista de códigos de idioma BCP-47 a usar para OCR.
      • ADVANCED_OCR_OPTIONS: uma lista de opções avançadas de OCR para otimizar ainda mais o comportamento do OCR. Os valores válidos atuais são:
        • legacy_layout: um algoritmo de deteção de esquemas heurístico, que serve como alternativa ao algoritmo de deteção de esquemas baseado em aprendizagem automática atual.
    • Suplementos de OCR premium
      • ENABLE_SELECTION_MARK_DETECTION: (Booleano) Ative o detetor de marcas de seleção no motor de OCR.
      • COMPUTE_STYLE_INFO (Booleano) Ative o modelo de identificação de tipos de letra e devolva informações de estilo de tipo de letra.
      • ENABLE_MATH_OCR: (Booleano) Ative o modelo que pode extrair fórmulas matemáticas LaTeX.
    • INDIVIDUAL_PAGES: uma lista de páginas individuais a processar.
      • Em alternativa, indique o campo fromStart ou fromEnd para processar uma quantidade específica de páginas a partir do início ou do fim do documento.

    † Também pode especificar este conteúdo através de 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 do pedido: 

    {
  "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 o seu pedido, escolha uma destas opções:

    curl

    Guarde o corpo do pedido num ficheiro com o nome request.json, e execute o seguinte comando: 

    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

    Guarde o corpo do pedido num ficheiro com o nome request.json, e execute o seguinte comando: 

    $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

    Se o pedido for bem-sucedido, o servidor devolve um código de estado 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 Python Document AI.

    Para se autenticar no Document AI, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure 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
    )

    O que se segue?