Enterprise Document OCR

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

Visão geral

É possível usar o Enterprise Document OCR para tarefas como entrada de dados com base em algoritmos ou machine learning e para melhorar e verificar a acurácia dos dados. Você também pode usar o Enterprise Document OCR para lidar com tarefas como as seguintes:

• Digitalização de texto:extraia dados de texto e layout de documentos para pesquisa, pipelines de processamento de documentos baseados em regras ou criação de modelos personalizados.
• Usar aplicativos de modelos de linguagem grandes:use a compreensão contextual dos LLMs e os recursos de extração de texto e layout da OCR para automatizar perguntas e respostas. Receba insights dos dados e simplifique os fluxos de trabalho.
• Arquivamento:digitalizar documentos em papel para texto legível por máquina e melhorar a acessibilidade.

Como escolher o melhor OCR para seu caso de uso

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 distorção dos documentos para melhorar a precisão.

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

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 Enterprise Document OCR 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 encaminhamento de documentos. A pontuação 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 gastos e tempo de processamento 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 complementares estão disponíveis para as versões Stable 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 de matemática: identifica e extrai fórmulas de documentos no formato LaTeX.
• Extração de caixas de seleção: detecta caixas de seleção e extrai o status delas (marcadas/desmarcadas) na resposta do Enterprise Document OCR.
• Detecção de estilo de fonte: identifica propriedades de fonte no nível da palavra, incluindo tipo, estilo, escrita à mão, peso e cor.

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

Formatos de arquivo compatíveis

O OCR de documentos empresariais é compatível com os 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 é compatível com arquivos DocX de até 15 páginas no modo síncrono e 30 páginas no modo assíncrono. O suporte a DocX está em pré-lançamento particular. Para solicitar acesso, envie o formulário de solicitação de suporte do DocX .

Controle de versões avançado

O controle de versões avançado 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ária consistência estrita, use uma versão de modelo congelada para fixar o comportamento em um modelo de OCR legado por até 18 meses. Isso garante o mesmo resultado da função de OCR da imagem. Consulte a tabela sobre versões do processador.

Versões do processador

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

Usar o Enterprise Document OCR para processar documentos

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

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.

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

Go to project selector

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

Enable the Document AI API.

Enable the API

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

Go to project selector

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

Enable the Document AI API.

Enable the API

Criar um processador Enterprise Document OCR

Primeiro, crie um processador Enterprise Document OCR. 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 respectivos 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 da 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 de qualidade é 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 de qualidade negativa (classificados por probabilidade) também será retornada. Uma probabilidade maior que 0.5 é considerada uma detecção positiva.

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

• 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 de qualidade do documento atual:

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

• Os defeitos de brilho são locais. A presença deles não prejudica a legibilidade geral do documento.

Entrada

Para ativar, defina 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 ver exemplos completos de saída.

Dicas de idioma

O processador de OCR é compatível com dicas de idioma definidas para melhorar a performance do mecanismo de OCR. Ao aplicar uma dica de idioma, o OCR pode otimizar para um idioma selecionado em vez de um idioma inferido.

Entrada

Para ativar, defina 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 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

Para ativar, defina 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 ver exemplos completos de saída.

Análise de PDF integrada

Extrair 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 óptico de OCR será usado automaticamente. O usuário recebe os dois resultados de texto mesclados.

Entrada

Para ativar, defina ProcessOptions.ocrConfig.enableNativePdfParsing como true na solicitação de processamento.

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

Detecção de personagem na caixa

Por padrão, o Enterprise Document OCR tem um detector ativado para melhorar a qualidade da extração de texto de caracteres dentro de uma caixa. Veja um exemplo:



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

Entrada

Para desativar, defina 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 heurístico de detecção de layout, ative o layout legado, que serve como 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 trabalho de documentos.

Entrada

Para ativar, defina 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 texto e informações de layout de todas as páginas dos documentos. Você pode selecionar números ou intervalos de páginas específicos e extrair apenas o texto delas.

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 últimas quatro páginas:

  {
    "fromEnd": 4
  }

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

Usos de complementos de OCR

Esses recursos opcionais de análise do Enterprise Document OCR 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, além de coordenadas de caixa delimitadora.

Confira um exemplo de representação em LaTeX:

• Imagem detectada

  

• Conversão para LaTeX

  

Entrada

Para ativar, defina 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 reconhecimento óptico de caracteres 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 do 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

Para ativar, defina 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 do 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

Para ativar, defina 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 de font-style 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 do Document neste link .

Converter objetos de documento 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. Assim, os usuários podem comparar 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 imagens e apenas normalized_vertices para solicitações 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 dela.
• 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 o conversor tenham os campos de símbolos preenchidos, defina o recurso enable_symbol conforme detalhado.

Amostras de código

Os exemplos de código a seguir mostram como enviar uma solicitação de processamento ativando 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: a localização do seu processador, por exemplo:
  • us: Estados Unidos
  • eu: União Europeia
• PROJECT_ID: o ID do projeto do Google Cloud .
• PROCESSOR_ID: o ID do seu 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 - ignora 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 stream 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==
  Consulte o tópico Codificação Base64 para mais informações.
• 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 pontuações inteligentes de qualidade de documentos.
  • ENABLE_SYMBOL: (booleano) inclui informações de OCR de símbolos (letras).
  • 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 a serem usados para 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 alternativa ao algoritmo atual de detecção de layout baseado em ML.
• Complementos premium de OCR
  • ENABLE_SELECTION_MARK_DETECTION: (booleano) ative o detector de marca de seleção no mecanismo de OCR.
  • COMPUTE_STYLE_INFO (booleano): ative o modelo de identificação de fonte e solicite o retorno das informações de estilo de fonte.
  • ENABLE_MATH_OCR: (booleano) ative 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 Python da Document AI.

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

• Consulte a lista de processadores.
• Separe documentos em partes legíveis com o Layout Parser.
• Crie um classificador personalizado.