Enterprise Document OCR

Puoi utilizzare la funzionalità Enterprise Document OCR all'interno di Document AI per rilevare ed estrarre informazioni su testo e layout da vari documenti. Con le funzionalità configurabili, puoi personalizzare il sistema in base a requisiti specifici di elaborazione dei documenti.

Panoramica

Puoi utilizzare la funzionalità OCR di documenti aziendali per attività come l'inserimento di dati in base ad algoritmi o machine learning, nonché per migliorare e verificare l'accuratezza dei dati. Puoi anche utilizzare Enterprise Document OCR per gestire attività come le seguenti:

  • Digitalizzazione del testo:estrazione di dati di testo e layout dai documenti per la ricerca, le pipeline di elaborazione dei documenti basate su regole o la creazione di modelli personalizzati.
  • Utilizzo di applicazioni di modelli linguistici di grandi dimensioni: utilizza la comprensione contestuale dei LLM e le funzionalità di estrazione di testo e layout dell'OCR per automatizzare domande e risposte. Ottieni insight dai dati e semplifica i flussi di lavoro.
  • Archiviazione:digitalizza i documenti cartacei in testo leggibile dalla macchina per migliorare l'accessibilità dei documenti.

Scegliere il miglior OCR per il tuo caso d'uso

Soluzione: Prodotto Descrizione Caso d'uso
Document AI Enterprise Document OCR Modello specializzato per casi d'uso relativi ai documenti. Le funzionalità avanzate includono il punteggio della qualità dell'immagine, i suggerimenti per la lingua e la correzione della rotazione. Consigliato per l'estrazione del testo dai documenti. I casi d'uso includono PDF, documenti scansionati come immagini o file Microsoft DocX.
Document AI Componenti aggiuntivi OCR Funzionalità premium per requisiti specifici. Compatibile solo con Enterprise Document OCR versione 2.0 e successive. Devi rilevare e riconoscere formule matematiche, ricevere informazioni sullo stile dei caratteri o attivare l'estrazione delle caselle di controllo.
API Cloud Vision Rilevamento del testo API REST disponibile a livello globale basata sul modello OCR standard di Google Cloud . Quota predefinita di 1800 richieste al minuto. Casi d'uso generici per l'estrazione del testo che richiedono bassa latenza e capacità elevata.
Cloud Vision OCR Google Distributed Cloud (rivendicato) Un'applicazione di Google Cloud Marketplace che può essere di cui è possibile eseguire il deployment come container in qualsiasi cluster GKE utilizzando GKE Enterprise. Per soddisfare i requisiti di residenza dei dati o di conformità.

Rilevamento ed estrazione

Enterprise Document OCR può rilevare blocchi, paragrafi, righe, parole e simboli da PDF e immagini, nonché raddrizzare i documenti per una maggiore precisione.

Attributi di rilevamento ed estrazione del layout supportati:

Testo stampato Scrittura a mano libera Paragrafo Blocca Linea Word A livello di simbolo Numero di pagina
Predefinito Predefinito Predefinito Predefinito Predefinito Predefinito Configurabile Predefinito

Le funzionalità di Enterprise Document OCR configurabili includono:

  • Estrai testo incorporato o nativo dai PDF digitali:questa funzionalità estrae testo e simboli esattamente come appaiono nei documenti di origine, anche per testi ruotati, stili o dimensioni dei caratteri estremi e testo parzialmente nascosto.

  • Correzione della rotazione:utilizza Enterprise Document OCR per eseguire la preelaborazione delle immagini dei documenti al fine di correggere i problemi di rotazione che possono influire sulla qualità o sull'elaborazione dell'estrazione.

  • Punteggio di qualità dell'immagine:ricevi metriche sulla qualità che possono essere utili per il routing dei documenti. Il punteggio di qualità delle immagini fornisce metriche sulla qualità a livello di pagina in otto dimensioni, tra cui sfocatura, presenza di caratteri più piccoli del solito e riflessi.

  • Specifica l'intervallo di pagine:specifica l'intervallo di pagine di un documento di input per l'OCR. In questo modo risparmierai sui costi e sui tempi di elaborazione rispetto alle pagine non necessarie.

  • Rilevamento della lingua:rileva le lingue utilizzate nei testi estratti.

  • Suggerimenti per lingua e scrittura a mano: migliora l'accuratezza fornendo al modello OCR un suggerimento per lingua o scrittura a mano in base alle caratteristiche note del tuo set di dati.

Per scoprire come attivare le configurazioni OCR, consulta Attivare le configurazioni OCR.

Componenti aggiuntivi OCR

Enterprise Document OCR offre funzionalità di analisi facoltative che possono essere attivate su singole richieste di elaborazione in base alle esigenze.

Le seguenti funzionalità dei componenti aggiuntivi sono disponibili per la versione stabilepretrained-ocr-v2.0-2023-06-02 e la versione Release Candidatepretrained-ocr-v2.1-2024-08-07:

  • OCR matematico: identifica ed estrae le formule dai documenti in formato LaTeX.
  • Estrazione delle caselle di controllo: rileva le caselle di controllo ed estrai il relativo stato (selezionata/non selezionata) nella risposta di Enterprise Document OCR.
  • Rilevamento dello stile del carattere: identifica le proprietà dei caratteri a livello di parola, tra cui tipo di carattere, stile, scrittura a mano, spessore e colore.

Per scoprire come attivare i componenti aggiuntivi elencati, consulta Attivare i componenti aggiuntivi OCR.

Formati di file supportati

L'OCR di Documenti aziendali supporta i formati di file PDF, GIF, TIFF, JPEG, PNG, BMP e WebP. Per ulteriori informazioni, consulta File supportati.

Enterprise Document OCR supporta anche i file DocX con un massimo di 15 pagine in modalità sincrona e 30 pagine in modalità asincrona. Il supporto di DocX è in anteprima privata. Per richiedere l'accesso, invia il modulo di richiesta di assistenza per DocX .

Controllo versioni avanzato

Il controllo delle versioni avanzate è in anteprima. Gli upgrade ai modelli OCR IA/ML sottostanti potrebbero comportare modifiche al comportamento dell'OCR. Se è necessaria una coerenza rigorosa, utilizza una versione del modello bloccata per bloccare il comportamento su un modello OCR precedente per un massimo di 18 mesi. In questo modo viene garantito lo stesso risultato della funzione di OCR per l'immagine. Consulta la tabella relativa alle versioni del processore.

Versioni del processore

Le seguenti versioni del processore sono compatibili con questa funzionalità. Per ulteriori informazioni, consulta Gestione delle versioni del processore.

ID versione Canale di rilascio Descrizione
pretrained-ocr-v1.0-2020-09-23 Stabile Non è consigliato per l'uso e non sarà più disponibile negli Stati Uniti (US) e nell'Unione Europea (UE) a partire dal 30 aprile 2025.
pretrained-ocr-v1.1-2022-09-12 Stabile Non è consigliato per l'uso e non sarà più disponibile negli Stati Uniti (US) e nell'Unione Europea (UE) a partire dal 30 aprile 2025.
pretrained-ocr-v1.2-2022-11-10 Stabile Versione del modello bloccata della versione 1.0: file del modello, configurazioni e file binari di un'istantanea della versione bloccati in un'immagine container per un massimo di 18 mesi.
pretrained-ocr-v2.0-2023-06-02 Stabile Modello pronto per la produzione specializzato per i casi d'uso dei documenti. Include l'accesso a tutti i componenti aggiuntivi OCR.
pretrained-ocr-v2.1-2024-08-07 Candidato per la release Le principali aree di miglioramento della versione 2.1 sono: un migliore riconoscimento del testo stampato, un rilevamento più preciso delle caselle di controllo e un ordine di lettura più accurato.

Utilizza Enterprise Document OCR per elaborare i documenti

Questa guida rapida descrive la funzionalità OCR di Document AI Enterprise. Ti mostra come ottimizzare i risultati dell'OCR dei documenti per il tuo flusso di lavoro attivando o disattivando una delle configurazioni OCR disponibili.

  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.

Creare un processore Enterprise Document OCR

Innanzitutto, crea un processore Enterprise Document OCR. Per saperne di più, consulta la sezione Creare e gestire i processori.

Configurazioni OCR

Tutte le configurazioni OCR possono essere attivate impostando i rispettivi campi in ProcessOptions.ocrConfig in ProcessDocumentRequest o BatchProcessDocumentsRequest.

Per ulteriori informazioni, consulta Inviare una richiesta di elaborazione.

Analisi della qualità delle immagini

L'analisi della qualità dei documenti intelligente utilizza il machine learning per valutare la qualità di un documento in base alla leggibilità dei suoi contenuti. Questa valutazione della qualità viene restituita come punteggio di qualità [0, 1], dove 1 indica una qualità perfetta. Se il punteggio di qualità rilevato è inferiore a 0.5, viene restituito anche un elenco di motivi di qualità negativi (ordinati in base alla probabilità). Una probabilità maggiore di 0.5 è considerata un rilevamento positivo.

Se il documento è considerato difettoso, l'API restituisce i seguenti otto tipi di difetti del documento:

  • 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

L'attuale analisi della qualità dei documenti presenta alcune limitazioni:

  • Può restituire rilevamenti di falsi positivi con documenti digitali senza difetti. La funzionalità è ideale per i documenti scansionati o fotografati.

  • I difetti di abbagliamento sono locali. La loro presenza potrebbe non ostacolare la leggibilità complessiva del documento.

Input

Attiva impostando ProcessOptions.ocrConfig.enableImageQualityScores su true nella richiesta di elaborazione. Questa funzionalità aggiuntiva aggiunge alla chiamata di processo una latenza paragonabile a quella dell'elaborazione OCR.

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

Output

I risultati del rilevamento dei difetti vengono visualizzati in 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
            }
          ]
        }
      }
    ]
  }

Per esempi completi dell'output, consulta Esempio di output del processore.

Suggerimenti per le lingue

Il processore OCR supporta gli indicatori di lingua che definisci per migliorare le prestazioni del motore OCR. L'applicazione di un suggerimento di lingua consente all'OCR di eseguire l'ottimizzazione in base a una lingua selezionata anziché a una lingua dedotta.

Input

Attiva impostando ProcessOptions.ocrConfig.hints[].languageHints[] con un elenco di codici lingua BCP-47.

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

Per esempi completi dell'output, consulta Esempio di output del processore.

Rilevamento di simboli

Compila i dati a livello di simbolo (o singola lettera) nella risposta del documento.

Input

Attiva impostando ProcessOptions.ocrConfig.enableSymbol su true nella richiesta di elaborazione.

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

Output

Se questa funzionalità è attivata, il campo Document.pages[].symbols[] viene compilato.

Per esempi completi dell'output, consulta Esempio di output del processore.

Analisi PDF integrata

Estrai il testo incorporato dai file PDF digitali. Se è attivato e se è presente del testo digitale, viene utilizzato automaticamente il modello PDF digitale integrato. Se è presente del testo non digitale, viene utilizzato automaticamente il modello OCR ottico. L'utente riceve entrambi i risultati di testo uniti.

Input

Attiva impostando ProcessOptions.ocrConfig.enableNativePdfParsing su true nella richiesta di elaborazione.

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

Rilevamento di personaggi all'interno di una scatola

Per impostazione predefinita, in Enterprise Document OCR è attivato un rilevatore per migliorare la qualità dell'estrazione del testo dei caratteri all'interno di una casella. Ecco un esempio:

enterprise-document-ocr-1

Se riscontri problemi di qualità dell'OCR con i caratteri all'interno delle caselle, puoi disattivare questa opzione.

Input

Per disattivarlo, imposta ProcessOptions.ocrConfig.disableCharacterBoxesDetection su true nella richiesta di elaborazione.

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

Layout legacy

Se hai bisogno di un algoritmo di rilevamento del layout basato su regole, puoi attivare il layout precedente, che funge da alternativa all'attuale algoritmo di rilevamento del layout basato su ML. Questa non è la configurazione consigliata. I clienti possono scegliere l'algoritmo di layout più adatto in base al flusso di lavoro dei documenti.

Input

Attiva impostando ProcessOptions.ocrConfig.advancedOcrOptions su ["legacy_layout"] nella richiesta di elaborazione.

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

Specificare un intervallo di pagine

Per impostazione predefinita, l'OCR estrae informazioni su testo e layout da tutte le pagine dei documenti. Puoi selezionare numeri di pagina o intervalli di pagine specifici ed estrarre solo il testo da queste pagine.

Esistono tre modi per configurare questa opzione in ProcessOptions:

  • Per elaborare solo la seconda e la quinta pagina:
  {
    "individualPageSelector": {"pages": [2, 5]}
  }
  • Per elaborare solo le prime tre pagine:
  {
    "fromStart": 3
  }
  • Per elaborare solo le ultime quattro pagine:
  {
    "fromEnd": 4
  }

Nella risposta, ogni Document.pages[].pageNumber corrisponde alle stesse pagine specificate nella richiesta.

Utilizzo dei componenti aggiuntivi OCR

Queste funzionalità di analisi facoltative di Enterprise Document OCR possono essere attivate su singole richieste di elaborazione in base alle esigenze.

OCR matematico

L'OCR matematico rileva, riconosce ed estrae formule, ad esempio equazioni matematiche rappresentate come LaTeX, insieme alle coordinate del riquadro di delimitazione.

Ecco un esempio di rappresentazione LaTeX:

  • Immagine rilevata

    enterprise-document-ocr-2

  • Conversione in LaTeX

    enterprise-document-ocr-3

Input

Attiva impostando ProcessOptions.ocrConfig.premiumFeatures.enableMathOcr su true nella richiesta di elaborazione.

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

Output

L'output dell'OCR matematico viene visualizzato in Document.pages[].visualElements[] con "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"
  }
]

Puoi controllare l'output JSON completo di Document in questo link .

Estrazione del segno di selezione

Se abilitato, il modello tenta di estrarre tutte le caselle di controllo e i pulsanti di opzione nel documento, insieme alle coordinate del riquadro di delimitazione.

Input

Attiva impostando ProcessOptions.ocrConfig.premiumFeatures.enableSelectionMarkDetection su true nella richiesta di elaborazione.

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

Output

L'output della casella di controllo viene visualizzato in Document.pages[].visualElements[] con "type": "unfilled_checkbox" o "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"
  }
],

Puoi controllare l'output JSON completo di Document in questo link .

Rilevamento dello stile dei caratteri

Con il rilevamento dello stile dei caratteri abilitato, Enterprise Document OCR estrae gli attributi dei caratteri, che possono essere utilizzati per una post-elaborazione migliore.

A livello di token (parola), vengono rilevati i seguenti attributi:

  • Rilevamento della scrittura a mano libera
  • Stile carattere
  • Dimensione carattere
  • Tipo di carattere
  • Colore carattere
  • Spessore del carattere
  • Spaziatura tra le lettere
  • Grassetto
  • Corsivo
  • Sottolineato
  • Colore del testo (RGBa)

  • Colore di sfondo (RGBa)

Input

Attiva impostando ProcessOptions.ocrConfig.premiumFeatures.computeStyleInfo su true nella richiesta di elaborazione.

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

Output

L'output dello stile del carattere viene visualizzato in Document.pages[].tokens[].styleInfo con il 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
      }
    }
  },
  ...
]

Puoi controllare l'output JSON completo di Document in questo link .

Convertire gli oggetti del documento nel formato dell'API Vision AI

La Document AI Toolbox include uno strumento che converte il formato Document dell'API Document AI nel formato AnnotateFileResponse di Vision AI, consentendo agli utenti di confrontare le risposte tra il processore OCR dei documenti e l'API Vision AI. Ecco un codice di esempio.

Discrepanze note tra la risposta dell'API Vision AI e la risposta e il convertitore dell'API Document AI:

  • La risposta dell'API Vision AI compila solo vertices per le richieste di immagini e solo normalized_vertices per le richieste di PDF. La risposta di Document AI e il convertitore compilano sia vertices che normalized_vertices.
  • La risposta dell'API Vision AI compila il carattere detected_break nell'ultimo simbolo della parola. La risposta dell'API Document AI e il convertitore inseriscono detected_break nella parola e nell'ultimo simbolo della parola.
  • La risposta dell'API Vision AI compila sempre i campi dei simboli. Per impostazione predefinita, la risposta di Document AI non compila i campi dei simboli. Per assicurarti che la risposta di Document AI e il convertitore vengano compilati con i campi dei simboli, imposta la funzionalità enable_symbol come descritto.

Esempi di codice

I seguenti esempi di codice mostrano come inviare una richiesta di elaborazione che attiva le configurazioni e i componenti aggiuntivi OCR, quindi legge e stampa i campi nel terminale:

REST

Prima di utilizzare i dati della richiesta, apporta le seguenti sostituzioni:

  • LOCATION: la posizione del tuo elaboratore, ad esempio:
    • us - Stati Uniti
    • eu - Unione Europea
  • PROJECT_ID: l'ID del tuo progetto Google Cloud .
  • PROCESSOR_ID: l'ID del tuo processore personalizzato.
  • PROCESSOR_VERSION: l'identificatore della versione del processore. Per saperne di più, consulta Selezionare una versione del processore. Ad esempio:
    • pretrained-TYPE-vX.X-YYYY-MM-DD
    • stable
    • rc
  • skipHumanReview: un valore booleano per disattivare la revisione da parte di persone fisiche (supportato solo dai processori human-in-the-loop).
    • true - salta la revisione umana
    • false: attiva la revisione da parte di persone fisiche (valore predefinito)
  • MIME_TYPE†: una delle opzioni valide per il tipo MIME.
  • IMAGE_CONTENT†: uno dei contenuti validi dei documenti in linea, rappresentato come uno stream di byte. Per le rappresentazioni JSON, la codifica base64 (stringa ASCII) dei dati immagine binari. Questa stringa dovrebbe essere simile alla seguente:
    • /9j/4QAYRXhpZgAA...9tAVx/zDQDlGxn//2Q==
    Per ulteriori informazioni, consulta l'argomento Codifica Base64.
  • FIELD_MASK: specifica i campi da includere nell'output Document. Si tratta di un elenco separato da virgole di nomi completi dei campi in formato FieldMask.
    • Esempio: text,entities,pages.pageNumber
  • Configurazioni OCR
    • ENABLE_NATIVE_PDF_PARSING: (booleano) Estrae il testo incorporato dai PDF, se disponibile.
    • ENABLE_IMAGE_QUALITY_SCORES: (booleano) consente di ottenere punteggi di qualità intelligenti.
    • ENABLE_SYMBOL: (booleano) include le informazioni OCR dei simboli (lettere).
    • DISABLE_CHARACTER_BOXES_DETECTION: (booleano) disattiva il rilevatore delle caselle dei caratteri nel motore OCR.
    • LANGUAGE_HINTS: elenco dei codici lingua BCP-47 da utilizzare per l'OCR.
    • ADVANCED_OCR_OPTIONS: un elenco di opzioni OCR avanzate per perfezionare ulteriormente il comportamento dell'OCR. I valori validi attuali sono:
      • legacy_layout: un algoritmo di rilevamento del layout basato su regole, che funge da alternativa all'attuale algoritmo di rilevamento del layout basato su ML.
  • Componenti aggiuntivi OCR Premium
    • ENABLE_SELECTION_MARK_DETECTION: (booleano) attiva il rilevatore del segno di selezione nel motore OCR.
    • COMPUTE_STYLE_INFO (booleano) Attiva il modello di identificazione dei caratteri e restituisce le informazioni sullo stile dei caratteri.
    • ENABLE_MATH_OCR: (booleano) attiva il modello in grado di estrarre le formule matematiche LaTeX.
  • INDIVIDUAL_PAGES: un elenco di singole pagine da elaborare.
    • In alternativa, specifica il campo fromStart o fromEnd per elaborare una quantità specifica di pagine dall'inizio o dalla fine del documento.

† Questi contenuti possono essere specificati anche utilizzando contenuti codificati in base64 nell'oggetto inlineDocument.

Metodo HTTP e URL: 

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

Corpo JSON della richiesta: 

{
  "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]
    }
  }
}

Per inviare la richiesta, scegli una delle seguenti opzioni:

curl

Salva il corpo della richiesta in un file denominato request.json, quindi esegui il comando seguente: 

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

Salva il corpo della richiesta in un file denominato request.json, quindi esegui il comando seguente: 

$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 la richiesta riesce, il server restituisce un codice di stato HTTP 200 OK e la risposta in formato JSON. Il corpo della risposta contiene un'istanza di Document.

Python

Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Document AI Python.

Per autenticarti a Document AI, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 


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
    )

Passaggi successivi