

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Rilevamento di testo in un'immagine
<a name="text-detecting-text-procedure"></a>

Puoi fornire un'immagine di input come matrice di byte dell'immagine (byte dell'immagine codificata in formato Base64) o come oggetto di Amazon S3. In questa procedura, puoi caricare un'immagine in formato JPEG o PNG nel bucket S3 e specificare il nome file. 

**Per rilevare il testo in un'immagine (API)**

1. Qualora non fossero già stati soddisfatti, completa i seguenti prerequisiti:

   1. Crea o aggiorna un utente con le autorizzazioni `AmazonRekognitionFullAccess` e `AmazonS3ReadOnlyAccess`. Per ulteriori informazioni, consulta [Fase 1: impostazione di un account AWS e creazione di un utente](setting-up.md#setting-up-iam).

   1. Installa e configura il e il. AWS Command Line Interface AWS SDKs Per ulteriori informazioni, consulta [Passaggio 2: configura AWS CLI e AWS SDKs](setup-awscli-sdk.md).

1. Carica l’immagine contenente testo nel bucket S3. 

   Per le istruzioni, consulta [Caricamento di oggetti in Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UploadingObjectsintoAmazonS3.html) nella *Guida per l'utente di Amazon Simple Storage Service*.

1. Utilizzare i seguenti esempi per richiamare l'operazione `DetectText`.

------
#### [ Java ]

   Il codice di esempio seguente mostra le righe e le parole rilevate in un'immagine. 

   Sostituisci i valori `amzn-s3-demo-bucket` e `photo` con i nomi del bucket S3 e dell'immagine utilizzati nella fase 2. 

   ```
   //Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
   //PDX-License-Identifier: MIT-0 (For details, see https://github.com/awsdocs/amazon-rekognition-developer-guide/blob/master/LICENSE-SAMPLECODE.)
   
   package aws.example.rekognition.image;
   import com.amazonaws.services.rekognition.AmazonRekognition;
   import com.amazonaws.services.rekognition.AmazonRekognitionClientBuilder;
   import com.amazonaws.services.rekognition.model.AmazonRekognitionException;
   import com.amazonaws.services.rekognition.model.Image;
   import com.amazonaws.services.rekognition.model.S3Object;
   import com.amazonaws.services.rekognition.model.DetectTextRequest;
   import com.amazonaws.services.rekognition.model.DetectTextResult;
   import com.amazonaws.services.rekognition.model.TextDetection;
   import java.util.List;
   
   
   
   public class DetectText {
   
      public static void main(String[] args) throws Exception {
         
     
         String photo = "inputtext.jpg";
         String bucket = "bucket";
   
         AmazonRekognition rekognitionClient = AmazonRekognitionClientBuilder.defaultClient();
   
        
         
         DetectTextRequest request = new DetectTextRequest()
                 .withImage(new Image()
                 .withS3Object(new S3Object()
                 .withName(photo)
                 .withBucket(bucket)));
       
   
         try {
            DetectTextResult result = rekognitionClient.detectText(request);
            List<TextDetection> textDetections = result.getTextDetections();
   
            System.out.println("Detected lines and words for " + photo);
            for (TextDetection text: textDetections) {
         
                    System.out.println("Detected: " + text.getDetectedText());
                    System.out.println("Confidence: " + text.getConfidence().toString());
                    System.out.println("Id : " + text.getId());
                    System.out.println("Parent Id: " + text.getParentId());
                    System.out.println("Type: " + text.getType());
                    System.out.println();
            }
         } catch(AmazonRekognitionException e) {
            e.printStackTrace();
         }
      }
   }
   ```

------
#### [ Java V2 ]

   Questo codice è tratto dal GitHub repository degli esempi di AWS Documentation SDK. Guarda l'esempio completo [qui](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javav2/example_code/rekognition/src/main/java/com/example/rekognition/DetectText.java).

   ```
   /**
   *  To run this code example, ensure that you perform the Prerequisites as stated in the Amazon Rekognition Guide:
   *  https://docs.aws.amazon.com/rekognition/latest/dg/video-analyzing-with-sqs.html
   *
   * Also, ensure that set up your development environment, including your credentials.
   *
   * For information, see this documentation topic:
   *
   * https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
   */
   
   //snippet-start:[rekognition.java2.detect_text.import]
   import software.amazon.awssdk.auth.credentials.ProfileCredentialsProvider;
   import software.amazon.awssdk.core.SdkBytes;
   import software.amazon.awssdk.regions.Region;
   import software.amazon.awssdk.services.rekognition.RekognitionClient;
   import software.amazon.awssdk.services.rekognition.model.DetectTextRequest;
   import software.amazon.awssdk.services.rekognition.model.Image;
   import software.amazon.awssdk.services.rekognition.model.DetectTextResponse;
   import software.amazon.awssdk.services.rekognition.model.TextDetection;
   import software.amazon.awssdk.services.rekognition.model.RekognitionException;
   import java.io.FileInputStream;
   import java.io.FileNotFoundException;
   import java.io.InputStream;
   import java.util.List;
   //snippet-end:[rekognition.java2.detect_text.import]
   
   /**
   * Before running this Java V2 code example, set up your development environment, including your credentials.
   *
   * For more information, see the following documentation topic:
   *
   * https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
   */
   public class DetectTextImage {
   
    public static void main(String[] args) {
   
        final String usage = "\n" +
            "Usage: " +
            "   <sourceImage>\n\n" +
            "Where:\n" +
            "   sourceImage - The path to the image that contains text (for example, C:\\AWS\\pic1.png). \n\n";
   
      if (args.length != 1) {
            System.out.println(usage);
            System.exit(1);
        }
   
        String sourceImage = args[0] ;
        Region region = Region.US_WEST_2;
        RekognitionClient rekClient = RekognitionClient.builder()
            .region(region)
            .credentialsProvider(ProfileCredentialsProvider.create("default"))
            .build();
   
        detectTextLabels(rekClient, sourceImage );
        rekClient.close();
    }
   
    // snippet-start:[rekognition.java2.detect_text.main]
    public static void detectTextLabels(RekognitionClient rekClient, String sourceImage) {
   
        try {
            InputStream sourceStream = new FileInputStream(sourceImage);
            SdkBytes sourceBytes = SdkBytes.fromInputStream(sourceStream);
            Image souImage = Image.builder()
                .bytes(sourceBytes)
                .build();
   
            DetectTextRequest textRequest = DetectTextRequest.builder()
                .image(souImage)
                .build();
   
            DetectTextResponse textResponse = rekClient.detectText(textRequest);
            List<TextDetection> textCollection = textResponse.textDetections();
            System.out.println("Detected lines and words");
            for (TextDetection text: textCollection) {
                System.out.println("Detected: " + text.detectedText());
                System.out.println("Confidence: " + text.confidence().toString());
                System.out.println("Id : " + text.id());
                System.out.println("Parent Id: " + text.parentId());
                System.out.println("Type: " + text.type());
                System.out.println();
            }
   
        } catch (RekognitionException | FileNotFoundException e) {
            System.out.println(e.getMessage());
            System.exit(1);
        }
    }
    // snippet-end:[rekognition.java2.detect_text.main]
   ```

------
#### [ AWS CLI ]

   Questo AWS CLI comando visualizza l'output JSON per l'operazione `detect-text` CLI. 

   Sostituisci i valori `amzn-s3-demo-bucket` e `Name` con i nomi del bucket S3 e dell'immagine utilizzati nella fase 2. 

   Sostituisci il valore di `profile_name` con il nome del tuo profilo di sviluppatore.

   ```
   aws rekognition detect-text  --image "{"S3Object":{"Bucket":"amzn-s3-demo-bucket","Name":"image-name"}}" --profile default
   ```

   Se accedi alla CLI da un dispositivo Windows, usa le virgolette doppie anziché le virgolette singole ed evita le virgolette doppie interne tramite barra rovesciata (ovvero, \$1) per risolvere eventuali errori del parser che potresti riscontrare. Per un esempio, consulta quanto segue: 

   ```
   aws rekognition detect-text  --image "{\"S3Object\":{\"Bucket\":\"amzn-s3-demo-bucket\",\"Name\":\"image-name\"}}" --profile default
   ```

------
#### [ Python ]

   Il codice di esempio seguente mostra le righe e le parole rilevate in un'immagine. 

   Sostituisci i valori `amzn-s3-demo-bucket` e `photo` con i nomi del bucket S3 e dell'immagine utilizzati nella fase 2. Sostituisci il valore di `profile_name` nella riga che crea la sessione di Rekognition con il nome del tuo profilo di sviluppatore.

   ```
   # Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
   # PDX-License-Identifier: MIT-0 (For details, see https://github.com/awsdocs/amazon-rekognition-developer-guide/blob/master/LICENSE-SAMPLECODE.)
   
   import boto3
   
   def detect_text(photo, bucket):
   
       session = boto3.Session(profile_name='default')
       client = session.client('rekognition')
   
       response = client.detect_text(Image={'S3Object': {'Bucket': bucket, 'Name': photo}})
   
       textDetections = response['TextDetections']
       print('Detected text\n----------')
       for text in textDetections:
           print('Detected text:' + text['DetectedText'])
           print('Confidence: ' + "{:.2f}".format(text['Confidence']) + "%")
           print('Id: {}'.format(text['Id']))
           if 'ParentId' in text:
               print('Parent Id: {}'.format(text['ParentId']))
           print('Type:' + text['Type'])
           print()
       return len(textDetections)
   
   def main():
       bucket = 'amzn-s3-demo-bucket'
       photo = 'photo-name'
       text_count = detect_text(photo, bucket)
       print("Text detected: " + str(text_count))
   
   if __name__ == "__main__":
       main()
   ```

------
#### [ .NET ]

   Il codice di esempio seguente mostra le righe e le parole rilevate in un'immagine. 

   Sostituisci i valori `amzn-s3-demo-bucket` e `photo` con i nomi del bucket S3 e dell'immagine utilizzati nella fase 2. 

   ```
   //Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
   //PDX-License-Identifier: MIT-0 (For details, see https://github.com/awsdocs/amazon-rekognition-developer-guide/blob/master/LICENSE-SAMPLECODE.)
   
   using System;
   using Amazon.Rekognition;
   using Amazon.Rekognition.Model;
   
   public class DetectText
   {
       public static void Example()
       {
           String photo = "input.jpg";
           String bucket = "amzn-s3-demo-bucket";
   
           AmazonRekognitionClient rekognitionClient = new AmazonRekognitionClient();
   
           DetectTextRequest detectTextRequest = new DetectTextRequest()
           {
               Image = new Image()
               {
                   S3Object = new S3Object()
                   {
                       Name = photo,
                       Bucket = bucket
                   }
               }
           };
   
           try
           {
               DetectTextResponse detectTextResponse = rekognitionClient.DetectText(detectTextRequest);
               Console.WriteLine("Detected lines and words for " + photo);
               foreach (TextDetection text in detectTextResponse.TextDetections)
               {
                   Console.WriteLine("Detected: " + text.DetectedText);
                   Console.WriteLine("Confidence: " + text.Confidence);
                   Console.WriteLine("Id : " + text.Id);
                   Console.WriteLine("Parent Id: " + text.ParentId);
                   Console.WriteLine("Type: " + text.Type);
               }
           }
           catch (Exception e)
           {
               Console.WriteLine(e.Message);
           }
       }
   }
   ```

------
#### [ Node.JS ]

   Il codice di esempio seguente mostra le righe e le parole rilevate in un'immagine. 

   Sostituisci i valori `amzn-s3-demo-bucket` e `photo` con i nomi del bucket S3 e dell'immagine utilizzati nella fase 2. Sostituisci il valore di `region` con la regione trovata nelle tue credenziali .aws. Sostituisci il valore di `profile_name` nella riga che crea la sessione di Rekognition con il nome del tuo profilo di sviluppatore. 

   ```
   var AWS = require('aws-sdk');
   
   const bucket = 'bucket' // the bucketname without s3://
   const photo  = 'photo' // the name of file
   
   const config = new AWS.Config({
     accessKeyId: process.env.AWS_ACCESS_KEY_ID,
     secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
   }) 
   AWS.config.update({region:'region'});
   const client = new AWS.Rekognition();
   const params = {
     Image: {
       S3Object: {
         Bucket: bucket,
         Name: photo
       },
     },
   }
   client.detectText(params, function(err, response) {
     if (err) {
       console.log(err, err.stack); // handle error if an error occurred
     } else {
       console.log(`Detected Text for: ${photo}`)
       console.log(response)
       response.TextDetections.forEach(label => {
         console.log(`Detected Text: ${label.DetectedText}`),
         console.log(`Type: ${label.Type}`),
         console.log(`ID: ${label.Id}`),
         console.log(`Parent ID: ${label.ParentId}`),
         console.log(`Confidence: ${label.Confidence}`),
         console.log(`Polygon: `)
         console.log(label.Geometry.Polygon)
       } 
       )
     } 
   });
   ```

------

## DetectText richiesta di operazione
<a name="detecttext-request"></a>

Nell'operazione `DetectText` puoi specificare un'immagine di input come matrice di byte con codifica base64 o come immagine archiviata in un bucket Amazon S3. La seguente richiesta JSON di esempio mostra l'immagine caricata da un bucket Amazon S3.

```
{
    "Image": {
        "S3Object": {
            "Bucket": "amzn-s3-demo-bucket",
            "Name": "inputtext.jpg"
        }
    }
}
```

### Filtri
<a name="text-filters"></a>

La possibilità di filtrare per regione del testo, dimensione e punteggio di affidabilità offre la flessibilità necessaria a controllare l'output del rilevamento di testo. Utilizzando le regioni di interesse, è possibile limitare facilmente il rilevamento del testo alle regioni pertinenti, ad esempio in alto a destra della foto del profilo o di una posizione fissa in relazione a un punto di riferimento quando si leggono i numeri delle parti da un'immagine di una macchina. Il filtro relativo alla dimensione del riquadro di delimitazione del testo può essere utilizzato per evitare testo troppo piccolo sullo sfondo che può risultare un disturbo o irrilevante. Il filtro di affidabilità delle parole ti permette di rimuovere i risultati inaffidabili perché sfocati o sbavati. 

Per informazioni sui valori dei filtri, consulta `[DetectTextFilters](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectTextFilters.html)`.

Puoi utilizzare i filtri seguenti:
+ **MinConfidence**—Imposta il livello di confidenza del rilevamento delle parole. Le parole con sicurezza di rilevamento al di sotto di questo livello sono escluse dal risultato. I valori dovrebbero essere compresi tra 0 e 100.
+ **MinBoundingBoxWidth**— Imposta la larghezza minima del riquadro di delimitazione delle parole. Le parole con caselle di delimitazione inferiori a questo valore sono escluse dal risultato. Il valore è relativo alla larghezza del fotogramma dell'immagine.
+ **MinBoundingBoxHeight**— Imposta l'altezza minima del riquadro di delimitazione delle parole. Le parole con altezze dei box di delimitazione inferiori a questo valore sono escluse dal risultato. Il valore è relativo all'altezza del fotogramma dell'immagine.
+ **RegionsOfInterest**— Limita il rilevamento a una regione specifica della cornice dell'immagine. I valori sono relativi alle dimensioni del fotogramma. Per il testo solo parzialmente all'interno di un'area, la risposta non è definita.

## DetectText risposta operativa
<a name="text-response"></a>

L'`DetectText`operazione analizza l'immagine e restituisce un array TextDetections, in cui ogni elemento (`[TextDetection](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_TextDetection.html)`) rappresenta una riga o una parola rilevata nell'immagine. Per ogni elemento, `DetectText` restituisce le informazioni riportate di seguito. 
+ Il testo rilevato (`DetectedText`)
+ Le relazioni tra parole e righe (`Id` e `ParentId`)
+ La posizione del testo nell'immagine (`Geometry`)
+ L'affidabilità di Amazon Rekognition riguardo alla precisione del testo rilevato e del riquadro di delimitazione (`Confidence`)
+ Il tipo di testo rilevato (`Type`)

### Testo rilevato
<a name="text-detected-text"></a>

Ogni elemento `TextDetection` contiene testo riconosciuto (parole o righe) nel campo `DetectedText`. Una parola corrisponde a uno o più caratteri non separati da spazi. `DetectText` è in grado di rilevare fino a 100 parole in un'immagine. Il testo restituito potrebbe includere caratteri che rendono irriconoscibile una parola. Ad esempio, *C@t* in luogo di *Cat*. Per determinare se un elemento `TextDetection` rappresenta una riga di testo o una parola, usa il campo `Type`.

 

Ogni elemento `TextDetection` include un valore percentuale che rappresenta il grado di affidabilità di Amazon Rekognition riguardo alla precisione del testo rilevato e del riquadro di delimitazione attorno al testo. 

### Relazioni tra parole e righe
<a name="text-ids"></a>

Ogni elemento `TextDetection` ha un campo di identificazione, `Id`. L'`Id` mostra la posizione della parola in una riga. Se l'elemento è una parola, il campo di identificazione padre `ParentId` identifica la riga in cui è stata rilevata la parola. Il `ParentId` per una riga è nullo. Ad esempio, la riga "but keep" nell'immagine di esempio contiene i seguenti valori `Id` e `ParentId` 


|  Testo  |  ID  |  ID padre  | 
| --- | --- | --- | 
|  but keep  |  3  |     | 
|  but  |  8  |  3  | 
|  keep  |  9  |  3  | 

### Posizione del testo in un'immagine
<a name="text-location"></a>

Per determinare dove si trova il testo riconosciuto in un'immagine, utilizzare le informazioni sul riquadro di delimitazione ([Geometria](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_Geometry.html)) restituite da `DetectText`. L'oggetto `Geometry` contiene due tipi di informazioni sul riquadro di delimitazione per le righe e le parole rilevate:
+ Un contorno rettangolare grossolano allineato all'asse in un oggetto [BoundingBox](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_BoundingBox.html)
+ Un poligono più dettagliato costituito da più coordinate X e Y in una matrice [Point](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_Point.html) 

Il riquadro di delimitazione e le coordinate del poligono mostrano dove è posizionato il testo nell'immagine di origine. I valori delle coordinate sono espressi in percentuale rispetto alla dimensione generale dell'immagine. Per ulteriori informazioni, consulta [BoundingBox](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_BoundingBox.html). 

La seguente risposta JSON dell'operazione `DetectText` mostra le parole e le righe rilevate nell'immagine seguente.

![\[Tazza da caffè sorridente accanto al testo con la scritta «È lunedì ma continua a sorridere» su uno sfondo a mattoncini, con riquadri di testo.\]](http://docs.aws.amazon.com/it_it/rekognition/latest/dg/images/text.png)


```
{
 'TextDetections': [{'Confidence': 99.35693359375,
                     'DetectedText': "IT'S",
                     'Geometry': {'BoundingBox': {'Height': 0.09988046437501907,
                                                  'Left': 0.6684935688972473,
                                                  'Top': 0.18226495385169983,
                                                  'Width': 0.1461552083492279},
                                  'Polygon': [{'X': 0.6684935688972473,
                                               'Y': 0.1838926374912262},
                                              {'X': 0.8141663074493408,
                                               'Y': 0.18226495385169983},
                                              {'X': 0.8146487474441528,
                                               'Y': 0.28051772713661194},
                                              {'X': 0.6689760088920593,
                                               'Y': 0.2821454107761383}]},
                     'Id': 0,
                     'Type': 'LINE'},
                    {'Confidence': 99.6207275390625,
                     'DetectedText': 'MONDAY',
                     'Geometry': {'BoundingBox': {'Height': 0.11442459374666214,
                                                  'Left': 0.5566731691360474,
                                                  'Top': 0.3525116443634033,
                                                  'Width': 0.39574965834617615},
                                  'Polygon': [{'X': 0.5566731691360474,
                                               'Y': 0.353712260723114},
                                              {'X': 0.9522717595100403,
                                               'Y': 0.3525116443634033},
                                              {'X': 0.9524227976799011,
                                               'Y': 0.4657355844974518},
                                              {'X': 0.5568241477012634,
                                               'Y': 0.46693623065948486}]},
                     'Id': 1,
                     'Type': 'LINE'},
                    {'Confidence': 99.6160888671875,
                     'DetectedText': 'but keep',
                     'Geometry': {'BoundingBox': {'Height': 0.08314694464206696,
                                                  'Left': 0.6398131847381592,
                                                  'Top': 0.5267938375473022,
                                                  'Width': 0.2021435648202896},
                                  'Polygon': [{'X': 0.640289306640625,
                                               'Y': 0.5267938375473022},
                                              {'X': 0.8419567942619324,
                                               'Y': 0.5295097827911377},
                                              {'X': 0.8414806723594666,
                                               'Y': 0.609940767288208},
                                              {'X': 0.6398131847381592,
                                               'Y': 0.6072247624397278}]},
                     'Id': 2,
                     'Type': 'LINE'},
                    {'Confidence': 88.95134735107422,
                     'DetectedText': 'Smiling',
                     'Geometry': {'BoundingBox': {'Height': 0.4326171875,
                                                  'Left': 0.46289217472076416,
                                                  'Top': 0.5634765625,
                                                  'Width': 0.5371078252792358},
                                  'Polygon': [{'X': 0.46289217472076416,
                                               'Y': 0.5634765625},
                                              {'X': 1.0, 'Y': 0.5634765625},
                                              {'X': 1.0, 'Y': 0.99609375},
                                              {'X': 0.46289217472076416,
                                               'Y': 0.99609375}]},
                     'Id': 3,
                     'Type': 'LINE'},
                    {'Confidence': 99.35693359375,
                     'DetectedText': "IT'S",
                     'Geometry': {'BoundingBox': {'Height': 0.09988046437501907,
                                                  'Left': 0.6684935688972473,
                                                  'Top': 0.18226495385169983,
                                                  'Width': 0.1461552083492279},
                                  'Polygon': [{'X': 0.6684935688972473,
                                               'Y': 0.1838926374912262},
                                              {'X': 0.8141663074493408,
                                               'Y': 0.18226495385169983},
                                              {'X': 0.8146487474441528,
                                               'Y': 0.28051772713661194},
                                              {'X': 0.6689760088920593,
                                               'Y': 0.2821454107761383}]},
                     'Id': 4,
                     'ParentId': 0,
                     'Type': 'WORD'},
                    {'Confidence': 99.6207275390625,
                     'DetectedText': 'MONDAY',
                     'Geometry': {'BoundingBox': {'Height': 0.11442466825246811,
                                                  'Left': 0.5566731691360474,
                                                  'Top': 0.35251158475875854,
                                                  'Width': 0.39574965834617615},
                                  'Polygon': [{'X': 0.5566731691360474,
                                               'Y': 0.3537122905254364},
                                              {'X': 0.9522718787193298,
                                               'Y': 0.35251158475875854},
                                              {'X': 0.9524227976799011,
                                               'Y': 0.4657355546951294},
                                              {'X': 0.5568241477012634,
                                               'Y': 0.46693626046180725}]},
                     'Id': 5,
                     'ParentId': 1,
                     'Type': 'WORD'},
                    {'Confidence': 99.96778869628906,
                     'DetectedText': 'but',
                     'Geometry': {'BoundingBox': {'Height': 0.0625,
                                                  'Left': 0.6402802467346191,
                                                  'Top': 0.5283203125,
                                                  'Width': 0.08027780801057816},
                                  'Polygon': [{'X': 0.6402802467346191,
                                               'Y': 0.5283203125},
                                              {'X': 0.7205580472946167,
                                               'Y': 0.5283203125},
                                              {'X': 0.7205580472946167,
                                               'Y': 0.5908203125},
                                              {'X': 0.6402802467346191,
                                               'Y': 0.5908203125}]},
                     'Id': 6,
                     'ParentId': 2,
                     'Type': 'WORD'},
                    {'Confidence': 99.26438903808594,
                     'DetectedText': 'keep',
                     'Geometry': {'BoundingBox': {'Height': 0.0818721204996109,
                                                  'Left': 0.7344760298728943,
                                                  'Top': 0.5280686020851135,
                                                  'Width': 0.10748066753149033},
                                  'Polygon': [{'X': 0.7349520921707153,
                                               'Y': 0.5280686020851135},
                                              {'X': 0.8419566750526428,
                                               'Y': 0.5295097827911377},
                                              {'X': 0.8414806127548218,
                                               'Y': 0.6099407076835632},
                                              {'X': 0.7344760298728943,
                                               'Y': 0.6084995269775391}]},
                     'Id': 7,
                     'ParentId': 2,
                     'Type': 'WORD'},
                    {'Confidence': 88.95134735107422,
                     'DetectedText': 'Smiling',
                     'Geometry': {'BoundingBox': {'Height': 0.4326171875,
                                                  'Left': 0.46289217472076416,
                                                  'Top': 0.5634765625,
                                                  'Width': 0.5371078252792358},
                                  'Polygon': [{'X': 0.46289217472076416,
                                               'Y': 0.5634765625},
                                              {'X': 1.0, 'Y': 0.5634765625},
                                              {'X': 1.0, 'Y': 0.99609375},
                                              {'X': 0.46289217472076416,
                                               'Y': 0.99609375}]},
                     'Id': 8,
                     'ParentId': 3,
                     'Type': 'WORD'}],
 'TextModelVersion': '3.0'}
```