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à.

# Lavorare con le immagini
<a name="images"></a>

In questa sezione vengono illustrati i tipi di analisi che Immagini Amazon Rekognition può eseguire sulle immagini. 
+ [Rilevamento di oggetti e scene](labels.md)
+ [Rilevamento e confronto facciale](faces.md)
+ [Ricerca di volti in una raccolta](collections.md)
+ [Riconoscimento di volti celebri](celebrities.md)
+ [Moderazione di immagini](moderation.md)
+ [Rilevamento di testo nelle immagini](text-detection.md)

Queste azioni vengono eseguite da operazioni API non basate su storage, in cui Immagini Amazon Rekognition non mantiene le informazioni rilevate dall'operazione. Nessun byte di immagine di input viene mantenuto da parte di operazioni API non basate su storage. Per ulteriori informazioni, consulta [Comprensione delle operazioni delle API diverse dallo storage e dallo storage](how-it-works-storage-non-storage.md).

Immagini Amazon Rekognition può anche memorizzare metadati facciali in raccolte per il successivo recupero. Per ulteriori informazioni, consulta [Ricerca di volti in una raccolta](collections.md).

In questa sezione si utilizzano le operazioni API di Immagini Amazon Rekognition per analizzare le immagini memorizzate in un bucket Amazon S3 e i byte di immagine caricati dal file system locale. Questa sezione riguarda anche l'ottenimento di informazioni sull'orientamento dell'immagine da un'immagine .jpg. 

 Rekognition utilizza solo canali RGB per eseguire l'inferenza. AWS consiglia agli utenti di rimuovere il canale alfa prima di utilizzare un display per ispezionare visivamente (manualmente da un umano) il confronto. 

**Topics**
+ [Specifiche dell'immagine](images-information.md)
+ [Analisi di immagini archiviate in un bucket Amazon S3](images-s3.md)
+ [Analisi di un'immagine caricata da un file system locale](images-bytes.md)
+ [Visualizzazione di riquadri di delimitazione](images-displaying-bounding-boxes.md)
+ [Ottenere l'orientamento dell'immagine e le coordinate del riquadro di delimitazione](images-orientation.md)

# Specifiche dell'immagine
<a name="images-information"></a>

Le operazioni di Immagini Amazon Rekognition analizzano un'immagine di input in formato .jpg o .png.

È possibile passare i byte di immagine a un'operazione di Immagini Amazon Rekognition come parte della chiamata o fare riferimento a un oggetto esistente Amazon S3. Per un esempio di analisi di un'immagine memorizzata in un bucket Amazon S3, consulta [Analisi di immagini archiviate in un bucket Amazon S3](images-s3.md). Per un esempio di trasferimento dei byte di immagine in un'operazione API Immagini Amazon Rekognition, consulta [Analisi di un'immagine caricata da un file system locale](images-bytes.md).

Se si utilizza HTTP e si trasferiscono i byte di immagine nell'ambito di un'operazione di Immagini Amazon Rekognition, i byte di immagine devono essere una stringa codificata in formato Base64. Se si utilizza l'SDK AWS e si trasmettono i byte di immagine nell'ambito della chiamata all'operazione API, la necessità di codificare i byte di immagine in formato Base64 dipende dalla lingua utilizzata. 

Le seguenti immagini comuni codificano AWS SDKs automaticamente in base 64 e non è necessario codificare i byte dell'immagine prima di chiamare un'operazione API di Amazon Rekognition Image.
+ Java
+ JavaScript
+ Python
+ PHP

Se si utilizza un altro AWS SDK e compare un errore di formato immagine quando si richiama un'operazione API di Rekognition provare a codificare i byte di immagine in formato Base64 prima di trasmetterli a un'operazione API di Rekognition.

Se utilizzi Amazon Rekognition Image operations AWS CLI per chiamare Amazon Rekognition Image, il trasferimento di byte di immagine come parte della chiamata non è supportato. È necessario prima caricare l'immagine in un bucket Amazon S3, quindi richiamare l'operazione referenziando l'immagine caricata.

**Nota**  
Non è necessario che l'immagine sia codificata in formato Base64 se si trasmette un'immagine memorizzata in un `S3Object` invece dei byte di immagine.

Per informazioni su come garantire la latenza più bassa possibile per le operazioni di Immagini Amazon Rekognition, consulta [Latenza delle operazioni di Immagini Amazon Rekognition](operation-latency.md). 

## Correzione dell'orientamento di un'immagine
<a name="images-image-orientation-correction"></a>

In diverse operazioni API di Rekognition viene restituito l'orientamento di un'immagine analizzata. Conoscere l'orientamento dell'immagine è importante in quanto consente di riorientare le immagini per la visualizzazione. Le operazioni API di Rekognition che analizzano i volti restituiscono anche i riquadri di delimitazione relativi alla posizione dei volti all'interno di un'immagine. È possibile utilizzare i riquadri di delimitazione per visualizzare una cornice intorno a un volto su un'immagine. Le coordinate del riquadro restituite sono influenzate dall'orientamento dell'immagine e potrebbe essere necessario convertirle per visualizzare correttamente una cornice intorno a un volto. Per ulteriori informazioni, consulta [Ottenere l'orientamento dell'immagine e le coordinate del riquadro di delimitazione](images-orientation.md). 

## Ridimensionamento dell'immagine
<a name="images-image-sizing"></a>

Durante l'analisi, Amazon Rekognition ridimensiona internamente le immagini utilizzando una serie di intervalli predefiniti che meglio si adattano a un particolare modello o algoritmo. Per questo motivo, Amazon Rekognition potrebbe rilevare un numero diverso di oggetti o fornire risultati diversi, a seconda della risoluzione dell'immagine di input. Supponiamo, ad esempio, che ti vengano mostrate due immagini. La prima immagine ha una risoluzione di 1024x768 pixel. La seconda immagine, una versione ridimensionata della prima, ha una risoluzione di 640x480 pixel. Se invii le immagini a [DetectLabels](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectLabels.html), le risposte delle due chiamate a potrebbero differire `DetectLabels` leggermente.

# Analisi di immagini archiviate in un bucket Amazon S3
<a name="images-s3"></a>

Immagini Amazon Rekognition è in grado di analizzare le immagini archiviate in un bucket Amazon S3 o le immagini fornite come byte di immagine.

In questo argomento, utilizzi l'operazione [DetectLabels](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectLabels.html)API per rilevare oggetti, concetti e scene in un'immagine (JPEG o PNG) archiviata in un bucket Amazon S3. È possibile trasmettere un'immagine a un'operazione API di Immagini Amazon Rekognition utilizzando il parametro di input [Image](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_Image.html). In `Image`, è necessario specificare la proprietà dell'oggetto [S3Object](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_3Object.html) per fare riferimento a un'immagine archiviata in un bucket S3. I byte di immagine per le immagini archiviate in bucket Amazon S3 non devono essere codificati con Base64. Per ulteriori informazioni, consulta [Specifiche dell'immagine](images-information.md). 

## Richiesta di esempio
<a name="images-s3-request"></a>

In questa richiesta JSON di esempio per `DetectLabels`, l'immagine di origine (`input.jpg`) viene caricata da un bucket Amazon S3 denominato `amzn-s3-demo-bucket`. Nota che la regione del bucket S3 contenente l'oggetto S3 deve corrispondere alla regione utilizzata per le operazioni Immagini Amazon Rekognition.

```
{
    "Image": {
        "S3Object": {
            "Bucket": "amzn-s3-demo-bucket",
            "Name": "input.jpg"
        }
    },
    "MaxLabels": 10,
    "MinConfidence": 75
}
```

Gli esempi seguenti utilizzano various AWS SDKs and the AWS CLI to call. `DetectLabels` Per informazioni sulla risposta dell'operazione `DetectLabels`, consulta [DetectLabels - risposta](labels-detect-labels-image.md#detectlabels-response).

**Per rilevare le etichette in un'immagine**

1. Se non lo hai già fatto:

   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 AWS CLI e il AWS SDKs. Per ulteriori informazioni, consulta [Passaggio 2: configura AWS CLI e AWS SDKs](setup-awscli-sdk.md). Assicurati di aver fornito all'utente che chiama le operazioni API le autorizzazioni appropriate per l'accesso programmatico, consulta [Concessione dell'accesso programmatico](sdk-programmatic-access.md) per le istruzioni su come eseguire questa operazione.

1. Carica nel bucket S3 un'immagine contenente uno o più oggetti, ad esempio alberi, abitazioni e barche. L'immagine deve essere in formato *.jpg* o *.png*.

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

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

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

   Questo esempio mostra un elenco di etichette rilevate nell'immagine di input. Sostituisci i valori `bucket` e `photo` con i nomi del bucket Amazon 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 com.amazonaws.samples;
   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.DetectLabelsRequest;
   import com.amazonaws.services.rekognition.model.DetectLabelsResult;
   import com.amazonaws.services.rekognition.model.Image;
   import com.amazonaws.services.rekognition.model.Label;
   import com.amazonaws.services.rekognition.model.S3Object;
   import java.util.List;
   
   public class DetectLabels {
   
      public static void main(String[] args) throws Exception {
   
         String photo = "input.jpg";
         String bucket = "bucket";
   
   
         AmazonRekognition rekognitionClient = AmazonRekognitionClientBuilder.defaultClient();
   
         DetectLabelsRequest request = new DetectLabelsRequest()
              .withImage(new Image()
              .withS3Object(new S3Object()
              .withName(photo).withBucket(bucket)))
              .withMaxLabels(10)
              .withMinConfidence(75F);
   
         try {
            DetectLabelsResult result = rekognitionClient.detectLabels(request);
            List <Label> labels = result.getLabels();
   
            System.out.println("Detected labels for " + photo);
            for (Label label: labels) {
               System.out.println(label.getName() + ": " + label.getConfidence().toString());
            }
         } catch(AmazonRekognitionException e) {
            e.printStackTrace();
         }
      }
   }
   ```

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

   Questo esempio mostra l'output JSON dell'operazione CLI `detect-labels`. Sostituisci i valori `bucket` e `photo` con i nomi del bucket Amazon 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. 

   ```
   aws rekognition detect-labels --image '{ "S3Object": { "Bucket": "bucket-name", "Name": "file-name" } }' \
   --features GENERAL_LABELS IMAGE_PROPERTIES \
   --settings '{"ImageProperties": {"MaxDominantColors":1}, {"GeneralLabels":{"LabelInclusionFilters":["Cat"]}}}' \
   --profile profile-name \
   --region us-east-1
   ```

   Se usi Windows, potresti dover evitare le virgolette, come mostrato nell'esempio seguente.

   ```
   aws rekognition detect-labels --image "{\"S3Object\":{\"Bucket\":\"bucket-name\",\"Name\":\"file-name\"}}" --features GENERAL_LABELS IMAGE_PROPERTIES --settings "{\"GeneralLabels\":{\"LabelInclusionFilters\":[\"Car\"]}}" --profile profile-name --region us-east-1
   ```

------
#### [ 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/DetectLabelsS3.java).

   ```
   //snippet-start:[rekognition.java2.detect_labels.import]
   import software.amazon.awssdk.auth.credentials.ProfileCredentialsProvider;
   import software.amazon.awssdk.regions.Region;
   import software.amazon.awssdk.services.rekognition.RekognitionClient;
   import software.amazon.awssdk.services.rekognition.model.Image;
   import software.amazon.awssdk.services.rekognition.model.DetectLabelsRequest;
   import software.amazon.awssdk.services.rekognition.model.DetectLabelsResponse;
   import software.amazon.awssdk.services.rekognition.model.Label;
   import software.amazon.awssdk.services.rekognition.model.RekognitionException;
   import software.amazon.awssdk.services.rekognition.model.S3Object;
   import java.util.List;
   
   /**
   * 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 DetectLabels {
   
       public static void main(String[] args) {
   
           final String usage = "\n" +
               "Usage: " +
               "   <bucket> <image>\n\n" +
               "Where:\n" +
               "   bucket - The name of the Amazon S3 bucket that contains the image (for example, ,ImageBucket)." +
               "   image - The name of the image located in the Amazon S3 bucket (for example, Lake.png). \n\n";
   
           if (args.length != 2) {
               System.out.println(usage);
               System.exit(1);
           }
   
           String bucket = args[0];
           String image = args[1];
           Region region = Region.US_WEST_2;
           RekognitionClient rekClient = RekognitionClient.builder()
               .region(region)
               .credentialsProvider(ProfileCredentialsProvider.create("profile-name"))
               .build();
   
           getLabelsfromImage(rekClient, bucket, image);
           rekClient.close();
       }
   
       // snippet-start:[rekognition.java2.detect_labels_s3.main]
       public static void getLabelsfromImage(RekognitionClient rekClient, String bucket, String image) {
   
           try {
               S3Object s3Object = S3Object.builder()
                   .bucket(bucket)
                   .name(image)
                   .build() ;
   
               Image myImage = Image.builder()
                   .s3Object(s3Object)
                   .build();
   
               DetectLabelsRequest detectLabelsRequest = DetectLabelsRequest.builder()
                   .image(myImage)
                   .maxLabels(10)
                   .build();
   
               DetectLabelsResponse labelsResponse = rekClient.detectLabels(detectLabelsRequest);
               List<Label> labels = labelsResponse.labels();
               System.out.println("Detected labels for the given photo");
               for (Label label: labels) {
                   System.out.println(label.name() + ": " + label.confidence().toString());
               }
   
           } catch (RekognitionException e) {
               System.out.println(e.getMessage());
               System.exit(1);
           }
       }
    // snippet-end:[rekognition.java2.detect_labels.main]
   }
   ```

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

   Questo esempio mostra le etichette rilevate nell'immagine di input. Sostituisci i valori `bucket` e `photo` con i nomi del bucket Amazon 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_labels(photo, bucket):
   
        session = boto3.Session(profile_name='profile-name')
        client = session.client('rekognition')
   
        response = client.detect_labels(Image={'S3Object':{'Bucket':bucket,'Name':photo}},
        MaxLabels=10,
        # Uncomment to use image properties and filtration settings
        #Features=["GENERAL_LABELS", "IMAGE_PROPERTIES"],
        #Settings={"GeneralLabels": {"LabelInclusionFilters":["Cat"]},
        # "ImageProperties": {"MaxDominantColors":10}}
        )
   
        print('Detected labels for ' + photo)
        print()
        for label in response['Labels']:
            print("Label: " + label['Name'])
            print("Confidence: " + str(label['Confidence']))
            print("Instances:")
   
            for instance in label['Instances']:
                print(" Bounding box")
                print(" Top: " + str(instance['BoundingBox']['Top']))
                print(" Left: " + str(instance['BoundingBox']['Left']))
                print(" Width: " + str(instance['BoundingBox']['Width']))
                print(" Height: " + str(instance['BoundingBox']['Height']))
                print(" Confidence: " + str(instance['Confidence']))
                print()
   
            print("Parents:")
            for parent in label['Parents']:
               print(" " + parent['Name'])
   
            print("Aliases:")
            for alias in label['Aliases']:
                print(" " + alias['Name'])
   
                print("Categories:")
            for category in label['Categories']:
                print(" " + category['Name'])
                print("----------")
                print()
   
        if "ImageProperties" in str(response):
            print("Background:")
            print(response["ImageProperties"]["Background"])
            print()
            print("Foreground:")
            print(response["ImageProperties"]["Foreground"])
            print()
            print("Quality:")
            print(response["ImageProperties"]["Quality"])
            print()
   
        return len(response['Labels'])
   
   def main():
       photo = 'photo-name'
       bucket = 'amzn-s3-demo-bucket'
       label_count = detect_labels(photo, bucket)
       print("Labels detected: " + str(label_count))
   
   if __name__ == "__main__":
       main()
   ```

------
#### [ Node.Js ]

   Questo esempio mostra le informazioni sulle etichette che vengono rilevate in un'immagine. 

   Modifica il valore di `photo` con il percorso e il nome di un file immagine archiviato in locale contenente uno o più volti celebri. Modifica il valore di `bucket` con quello del nome del bucket S3 che contiene il file immagine fornito. Modifica il valore di `REGION` con quello del nome della regione associata al tuo account. Sostituisci il valore di `profile_name` nella riga che crea la sessione di Rekognition con il nome del tuo profilo di sviluppatore. 

   ```
   // Import required AWS SDK clients and commands for Node.js
   import { DetectLabelsCommand } from  "@aws-sdk/client-rekognition";
   import  { RekognitionClient } from "@aws-sdk/client-rekognition";
   
   import {fromIni} from '@aws-sdk/credential-providers';
   
   // Set the AWS Region.
   const REGION = "region-name"; //e.g. "us-east-1"
   
   // Create SNS service object.
   const rekogClient = new RekognitionClient({
     region: REGION,
     credentials: fromIni({
          profile: 'profile-name',
     }),
   });
   
   const bucket = 'bucket-name'
   const photo = 'photo-name'
   
   // Set params
   const params = {For example, to grant
       Image: {
         S3Object: {
           Bucket: bucket,
           Name: photo
         },
       },
     }
   
   const detect_labels = async () => {
       try {
           const response = await rekogClient.send(new DetectLabelsCommand(params));
           console.log(response.Labels)
           response.Labels.forEach(label =>{
               console.log(`Confidence: ${label.Confidence}`)
               console.log(`Name: ${label.Name}`)
               console.log('Instances:')
               label.Instances.forEach(instance => {
                   console.log(instance)
               })
               console.log('Parents:')
               label.Parents.forEach(name => {
                   console.log(name)
               })
               console.log("-------")
           })
           return response; // For unit tests.
         } catch (err) {
           console.log("Error", err);
         }
   };
   
   detect_labels();
   ```

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

   Questo esempio mostra un elenco di etichette rilevate nell'immagine di input. Sostituisci i valori `bucket` e `photo` con i nomi del bucket Amazon 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 DetectLabels
   {
       public static void Example()
       {
           String photo = "input.jpg";
           String bucket = "amzn-s3-demo-bucket";
   
           AmazonRekognitionClient rekognitionClient = new AmazonRekognitionClient();
   
           DetectLabelsRequest detectlabelsRequest = new DetectLabelsRequest()
           {
               Image = new Image()
               {
                   S3Object = new S3Object()
                   {
                       Name = photo,
                       Bucket = bucket
                   },
               },
               MaxLabels = 10,
               MinConfidence = 75F
           };
   
           try
           {
               DetectLabelsResponse detectLabelsResponse = rekognitionClient.DetectLabels(detectlabelsRequest);
               Console.WriteLine("Detected labels for " + photo);
               foreach (Label label in detectLabelsResponse.Labels)
                   Console.WriteLine("{0}: {1}", label.Name, label.Confidence);
           }
           catch (Exception e)
           {
               Console.WriteLine(e.Message);
           }
       }
   }
   ```

------
#### [ Ruby ]

   Questo esempio mostra un elenco di etichette rilevate nell'immagine di input. Sostituisci i valori `bucket` e `photo` con i nomi del bucket Amazon S3 e dell'immagine utilizzati nella fase 2. 

   ```
      # Add to your Gemfile
      # gem 'aws-sdk-rekognition'
      require 'aws-sdk-rekognition'
      credentials = Aws::Credentials.new(
         ENV['AWS_ACCESS_KEY_ID'],
         ENV['AWS_SECRET_ACCESS_KEY']
      )
      bucket = 'bucket' # the bucket name without s3://
      photo  = 'photo' # the name of file
      client   = Aws::Rekognition::Client.new credentials: credentials
      attrs = {
        image: {
          s3_object: {
            bucket: bucket,
            name: photo
          },
        },
        max_labels: 10
      }
     response = client.detect_labels attrs
     puts "Detected labels for: #{photo}"
     response.labels.each do |label|
       puts "Label:      #{label.name}"
       puts "Confidence: #{label.confidence}"
       puts "Instances:"
       label['instances'].each do |instance|
         box = instance['bounding_box']
         puts "  Bounding box:"
         puts "    Top:        #{box.top}"
         puts "    Left:       #{box.left}"
         puts "    Width:      #{box.width}"
         puts "    Height:     #{box.height}"
         puts "  Confidence: #{instance.confidence}"
       end
       puts "Parents:"
       label.parents.each do |parent|
         puts "  #{parent.name}"
       end
       puts "------------"
       puts ""
     end
   ```

------



## Esempio di risposta
<a name="images-s3-response"></a>

La risposta di `DetectLabels` è una matrice di etichette rilevate nell'immagine e il livello di affidabilità con cui sono state rilevate. 

Quando esegui l'operazione `DetectLabels` su un'immagine, Amazon Rekognition restituisce un output simile alla risposta di esempio seguente.

La risposta mostra che l'operazione ha rilevato più etichette, tra cui Persona, Veicolo e Auto. A ogni etichetta è associato un livello di affidabilità. Ad esempio, l'algoritmo di rilevamento è sicuro al 98,991432% che l'immagine contenga una persona.

La risposta include inoltre una serie `Parents` con i predecessori dell'etichetta. Ad esempio, l'etichetta Automobile ha due etichette padre denominate Vehicle (Veicolo) e Transportation (Trasporti). 

La risposta per le etichette relative a oggetti comuni include informazioni sul riquadro di delimitazione per la posizione dell'etichetta nell'immagine in input. Ad esempio, l'etichetta Persona dispone di una serie di istanze contenenti due riquadri di delimitazione che si riferiscono a due persone rilevate all'interno dell'immagine.

Il campo `LabelModelVersion` contiene il numero di versione del modello di rilevamento utilizzato da `DetectLabels`. 

Per ulteriori informazioni sull'utilizzo di questa operazione `DetectLabels`, consulta [Rilevamento di oggetti e concetti](labels.md).

```
{
            
    {
    "Labels": [
        {
            "Name": "Vehicle",
            "Confidence": 99.15271759033203,
            "Instances": [],
            "Parents": [
                {
                    "Name": "Transportation"
                }
            ]
        },
        {
            "Name": "Transportation",
            "Confidence": 99.15271759033203,
            "Instances": [],
            "Parents": []
        },
        {
            "Name": "Automobile",
            "Confidence": 99.15271759033203,
            "Instances": [],
            "Parents": [
                {
                    "Name": "Vehicle"
                },
                {
                    "Name": "Transportation"
                }
            ]
        },
        {
            "Name": "Car",
            "Confidence": 99.15271759033203,
            "Instances": [
                {
                    "BoundingBox": {
                        "Width": 0.10616336017847061,
                        "Height": 0.18528179824352264,
                        "Left": 0.0037978808395564556,
                        "Top": 0.5039216876029968
                    },
                    "Confidence": 99.15271759033203
                },
                {
                    "BoundingBox": {
                        "Width": 0.2429988533258438,
                        "Height": 0.21577216684818268,
                        "Left": 0.7309805154800415,
                        "Top": 0.5251884460449219
                    },
                    "Confidence": 99.1286392211914
                },
                {
                    "BoundingBox": {
                        "Width": 0.14233611524105072,
                        "Height": 0.15528248250484467,
                        "Left": 0.6494812965393066,
                        "Top": 0.5333095788955688
                    },
                    "Confidence": 98.48368072509766
                },
                {
                    "BoundingBox": {
                        "Width": 0.11086395382881165,
                        "Height": 0.10271988064050674,
                        "Left": 0.10355594009160995,
                        "Top": 0.5354844927787781
                    },
                    "Confidence": 96.45606231689453
                },
                {
                    "BoundingBox": {
                        "Width": 0.06254628300666809,
                        "Height": 0.053911514580249786,
                        "Left": 0.46083059906959534,
                        "Top": 0.5573825240135193
                    },
                    "Confidence": 93.65448760986328
                },
                {
                    "BoundingBox": {
                        "Width": 0.10105438530445099,
                        "Height": 0.12226245552301407,
                        "Left": 0.5743985772132874,
                        "Top": 0.534368634223938
                    },
                    "Confidence": 93.06217193603516
                },
                {
                    "BoundingBox": {
                        "Width": 0.056389667093753815,
                        "Height": 0.17163699865341187,
                        "Left": 0.9427769780158997,
                        "Top": 0.5235804319381714
                    },
                    "Confidence": 92.6864013671875
                },
                {
                    "BoundingBox": {
                        "Width": 0.06003860384225845,
                        "Height": 0.06737709045410156,
                        "Left": 0.22409997880458832,
                        "Top": 0.5441341400146484
                    },
                    "Confidence": 90.4227066040039
                },
                {
                    "BoundingBox": {
                        "Width": 0.02848697081208229,
                        "Height": 0.19150497019290924,
                        "Left": 0.0,
                        "Top": 0.5107086896896362
                    },
                    "Confidence": 86.65286254882812
                },
                {
                    "BoundingBox": {
                        "Width": 0.04067881405353546,
                        "Height": 0.03428703173995018,
                        "Left": 0.316415935754776,
                        "Top": 0.5566273927688599
                    },
                    "Confidence": 85.36471557617188
                },
                {
                    "BoundingBox": {
                        "Width": 0.043411049991846085,
                        "Height": 0.0893595889210701,
                        "Left": 0.18293385207653046,
                        "Top": 0.5394920110702515
                    },
                    "Confidence": 82.21705627441406
                },
                {
                    "BoundingBox": {
                        "Width": 0.031183116137981415,
                        "Height": 0.03989990055561066,
                        "Left": 0.2853088080883026,
                        "Top": 0.5579366683959961
                    },
                    "Confidence": 81.0157470703125
                },
                {
                    "BoundingBox": {
                        "Width": 0.031113790348172188,
                        "Height": 0.056484755128622055,
                        "Left": 0.2580395042896271,
                        "Top": 0.5504819750785828
                    },
                    "Confidence": 56.13441467285156
                },
                {
                    "BoundingBox": {
                        "Width": 0.08586374670267105,
                        "Height": 0.08550430089235306,
                        "Left": 0.5128012895584106,
                        "Top": 0.5438792705535889
                    },
                    "Confidence": 52.37760925292969
                }
            ],
            "Parents": [
                {
                    "Name": "Vehicle"
                },
                {
                    "Name": "Transportation"
                }
            ]
        },
        {
            "Name": "Human",
            "Confidence": 98.9914321899414,
            "Instances": [],
            "Parents": []
        },
        {
            "Name": "Person",
            "Confidence": 98.9914321899414,
            "Instances": [
                {
                    "BoundingBox": {
                        "Width": 0.19360728561878204,
                        "Height": 0.2742200493812561,
                        "Left": 0.43734854459762573,
                        "Top": 0.35072067379951477
                    },
                    "Confidence": 98.9914321899414
                },
                {
                    "BoundingBox": {
                        "Width": 0.03801717236638069,
                        "Height": 0.06597328186035156,
                        "Left": 0.9155802130699158,
                        "Top": 0.5010883808135986
                    },
                    "Confidence": 85.02790832519531
                }
            ],
            "Parents": []
        }
    ],
    "LabelModelVersion": "2.0"
}

    
}
```

# Analisi di un'immagine caricata da un file system locale
<a name="images-bytes"></a>

Immagini Amazon Rekognition è in grado di analizzare le immagini fornite come byte di immagini o immagini memorizzate in un bucket Amazon S3.

Questi argomenti forniscono esempi relativi all'invio di byte di immagine alle operazioni API di Immagini Amazon Rekognition utilizzando un file caricato da un file system locale. È possibile trasmettere byte di immagine a un'operazione API di Immagini Amazon Rekognition utilizzando il parametro di input [Image](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_Image.html). In `Image`, è necessario specificare la proprietà `Bytes` per trasmettere i byte di immagine codificati con Base64.

I byte di immagine trasmessi a un'operazione API Amazon Rekognition utilizzando il parametro di input `Bytes` devono essere codificati in formato Base64. L'AWS SDKs che questi esempi utilizzano automaticamente le immagini con codifica in base64. Non è necessario codificare i byte di immagine prima di chiamare un'operazione API Amazon Rekognition. Per ulteriori informazioni, consulta [Specifiche dell'immagine](images-information.md). 

In questa richiesta JSON di esempio per `DetectLabels`, i byte di immagine di origine vengono trasmessi nel parametro di input `Bytes`. 

```
{
    "Image": {
        "Bytes": "/9j/4AAQSk....."
    },
    "MaxLabels": 10,
    "MinConfidence": 77
}
```

I seguenti esempi utilizzano various AWS SDKs and the to call. AWS CLI `DetectLabels` Per informazioni sulla risposta dell'operazione `DetectLabels`, consulta [DetectLabels - risposta](labels-detect-labels-image.md#detectlabels-response).

Per un JavaScript esempio sul lato client, vedere. [Usando JavaScript](image-bytes-javascript.md)

**Per rilevare le etichette in un'immagine locale**

1. Se non lo hai già fatto:

   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 AWS CLI e il. AWS SDKs Per ulteriori informazioni, consulta [Passaggio 2: configura AWS CLI e AWS SDKs](setup-awscli-sdk.md).

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

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

   L'esempio Java seguente mostra come caricare un'immagine dal file system locale e rilevare le etichette utilizzando l'operazione [detectLabels](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/rekognition/model/DetectLabelsRequest.html) dell'SDK AWS. Modifica il valore di `photo` con il percorso e il nome di un file immagine in formato .jpg o .png.

   ```
   //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 java.io.File;
   import java.io.FileInputStream;
   import java.io.InputStream;
   import java.nio.ByteBuffer;
   import java.util.List;
   import com.amazonaws.services.rekognition.AmazonRekognition;
   import com.amazonaws.services.rekognition.AmazonRekognitionClientBuilder;
   import com.amazonaws.AmazonClientException;
   import com.amazonaws.services.rekognition.model.AmazonRekognitionException;
   import com.amazonaws.services.rekognition.model.DetectLabelsRequest;
   import com.amazonaws.services.rekognition.model.DetectLabelsResult;
   import com.amazonaws.services.rekognition.model.Image;
   import com.amazonaws.services.rekognition.model.Label;
   import com.amazonaws.util.IOUtils;
   
   public class DetectLabelsLocalFile {
       public static void main(String[] args) throws Exception {
       	String photo="input.jpg";
   
   
           ByteBuffer imageBytes;
           try (InputStream inputStream = new FileInputStream(new File(photo))) {
               imageBytes = ByteBuffer.wrap(IOUtils.toByteArray(inputStream));
           }
   
   
           AmazonRekognition rekognitionClient = AmazonRekognitionClientBuilder.defaultClient();
   
           DetectLabelsRequest request = new DetectLabelsRequest()
                   .withImage(new Image()
                           .withBytes(imageBytes))
                   .withMaxLabels(10)
                   .withMinConfidence(77F);
   
           try {
   
               DetectLabelsResult result = rekognitionClient.detectLabels(request);
               List <Label> labels = result.getLabels();
   
               System.out.println("Detected labels for " + photo);
               for (Label label: labels) {
                  System.out.println(label.getName() + ": " + label.getConfidence().toString());
               }
   
           } catch (AmazonRekognitionException e) {
               e.printStackTrace();
           }
   
       }
   }
   ```

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

   Il seguente esempio [SDK AWS per Python](https://aws.amazon.com/sdk-for-python/) mostra come caricare un'immagine dal file system locale e richiamare l'operazione [detect\$1labels](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/rekognition.html#Rekognition.Client.detect_labels). Modifica il valore di `photo` con il percorso e il nome di un file immagine in formato .jpg o .png. 

   ```
   #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_labels_local_file(photo):
   
   
       client=boto3.client('rekognition')
      
       with open(photo, 'rb') as image:
           response = client.detect_labels(Image={'Bytes': image.read()})
           
       print('Detected labels in ' + photo)    
       for label in response['Labels']:
           print (label['Name'] + ' : ' + str(label['Confidence']))
   
       return len(response['Labels'])
   
   def main():
       photo='photo'
   
       label_count=detect_labels_local_file(photo)
       print("Labels detected: " + str(label_count))
   
   
   if __name__ == "__main__":
       main()
   ```

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

   Il seguente esempio di Java mostra come caricare un'immagine dal file system locale e rilevare le etichette utilizzando l'operazione `DetectLabels`. Modifica il valore di `photo` con il percorso e il nome di un file immagine in formato .jpg o .png.

   ```
   //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 System.IO;
   using Amazon.Rekognition;
   using Amazon.Rekognition.Model;
   
   public class DetectLabelsLocalfile
   {
       public static void Example()
       {
           String photo = "input.jpg";
   
           Amazon.Rekognition.Model.Image image = new Amazon.Rekognition.Model.Image();
           try
           {
               using (FileStream fs = new FileStream(photo, FileMode.Open, FileAccess.Read))
               {
                   byte[] data = null;
                   data = new byte[fs.Length];
                   fs.Read(data, 0, (int)fs.Length);
                   image.Bytes = new MemoryStream(data);
               }
           }
           catch (Exception)
           {
               Console.WriteLine("Failed to load file " + photo);
               return;
           }
   
           AmazonRekognitionClient rekognitionClient = new AmazonRekognitionClient();
   
           DetectLabelsRequest detectlabelsRequest = new DetectLabelsRequest()
           {
               Image = image,
               MaxLabels = 10,
               MinConfidence = 77F
           };
   
           try
           {
               DetectLabelsResponse detectLabelsResponse = rekognitionClient.DetectLabels(detectlabelsRequest);
               Console.WriteLine("Detected labels for " + photo);
               foreach (Label label in detectLabelsResponse.Labels)
                   Console.WriteLine("{0}: {1}", label.Name, label.Confidence);
           }
           catch (Exception e)
           {
               Console.WriteLine(e.Message);
           }
       }
   }
   ```

------
#### [ PHP ]

   Il seguente esempio di [AWS SDK for](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/welcome.html#getting-started) PHP mostra come caricare un'immagine dal file system locale e [DetectFaces](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-rekognition-2016-06-27.html#detectfaces)richiamare l'operazione dell'API. Modifica il valore di `photo` con il percorso e il nome di un file immagine in formato .jpg o .png. 

   ```
   
   <?php
   //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.)
   
       require 'vendor/autoload.php';
   
       use Aws\Rekognition\RekognitionClient;
   
       $options = [
          'region'            => 'us-west-2',
           'version'           => 'latest'
       ];
   
       $rekognition = new RekognitionClient($options);
   	
       // Get local image
       $photo = 'input.jpg';
       $fp_image = fopen($photo, 'r');
       $image = fread($fp_image, filesize($photo));
       fclose($fp_image);
   
   
       // Call DetectFaces
       $result = $rekognition->DetectFaces(array(
          'Image' => array(
             'Bytes' => $image,
          ),
          'Attributes' => array('ALL')
          )
       );
   
       // Display info for each detected person
       print 'People: Image position and estimated age' . PHP_EOL;
       for ($n=0;$n<sizeof($result['FaceDetails']); $n++){
   
         print 'Position: ' . $result['FaceDetails'][$n]['BoundingBox']['Left'] . " "
         . $result['FaceDetails'][$n]['BoundingBox']['Top']
         . PHP_EOL
         . 'Age (low): '.$result['FaceDetails'][$n]['AgeRange']['Low']
         .  PHP_EOL
         . 'Age (high): ' . $result['FaceDetails'][$n]['AgeRange']['High']
         .  PHP_EOL . PHP_EOL;
       }
   ?>
   ```

------
#### [ Ruby ]

   Questo esempio mostra un elenco di etichette rilevate nell'immagine di input. Modifica il valore di `photo` con il percorso e il nome di un file immagine in formato .jpg o .png.

   ```
   #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.)
   
       # gem 'aws-sdk-rekognition'
       require 'aws-sdk-rekognition'
       credentials = Aws::Credentials.new(
          ENV['AWS_ACCESS_KEY_ID'],
          ENV['AWS_SECRET_ACCESS_KEY']
       )
       client   = Aws::Rekognition::Client.new credentials: credentials
       photo = 'photo.jpg'
       path = File.expand_path(photo) # expand path relative to the current directory
       file = File.read(path)
       attrs = {
         image: {
           bytes: file
         },
         max_labels: 10
       }
       response = client.detect_labels attrs
       puts "Detected labels for: #{photo}"
       response.labels.each do |label|
         puts "Label:      #{label.name}"
         puts "Confidence: #{label.confidence}"
         puts "Instances:"
         label['instances'].each do |instance|
           box = instance['bounding_box']
           puts "  Bounding box:"
           puts "    Top:        #{box.top}"
           puts "    Left:       #{box.left}"
           puts "    Width:      #{box.width}"
           puts "    Height:     #{box.height}"
           puts "  Confidence: #{instance.confidence}"
         end
         puts "Parents:"
         label.parents.each do |parent|
           puts "  #{parent.name}"
         end
         puts "------------"
         puts ""
       end
   ```

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

   Questo codice è tratto dal repository degli esempi di AWS Documentation SDK. GitHub 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/DetectLabels.java).

   ```
   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.*;
   
   import java.io.FileInputStream;
   import java.io.FileNotFoundException;
   import java.io.InputStream;
   import java.util.List;
   
   /**
    * 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 DetectLabels {
       public static void main(String[] args) {
           final String usage = """
               Usage: <bucketName> <sourceImage>
   
               Where:
                   bucketName - The name of the Amazon S3 bucket where the image is stored
                   sourceImage - The name of the image file (for example, pic1.png).\s
               """;
   
           if (args.length != 2) {
               System.out.println(usage);
               System.exit(1);
           }
   
           String bucketName = args[0] ;
           String sourceImage = args[1] ;
           Region region = Region.US_WEST_2;
           RekognitionClient rekClient = RekognitionClient.builder()
                   .region(region)
                   .build();
   
           detectImageLabels(rekClient, bucketName, sourceImage);
           rekClient.close();
       }
   
       /**
        * Detects the labels in an image stored in an Amazon S3 bucket using the Amazon Rekognition service.
        *
        * @param rekClient     the Amazon Rekognition client used to make the detection request
        * @param bucketName    the name of the Amazon S3 bucket where the image is stored
        * @param sourceImage   the name of the image file to be analyzed
        */
       public static void detectImageLabels(RekognitionClient rekClient, String bucketName, String sourceImage) {
           try {
               S3Object s3ObjectTarget = S3Object.builder()
                       .bucket(bucketName)
                       .name(sourceImage)
                       .build();
   
               Image souImage = Image.builder()
                       .s3Object(s3ObjectTarget)
                       .build();
   
               DetectLabelsRequest detectLabelsRequest = DetectLabelsRequest.builder()
                       .image(souImage)
                       .maxLabels(10)
                       .build();
   
               DetectLabelsResponse labelsResponse = rekClient.detectLabels(detectLabelsRequest);
               List<Label> labels = labelsResponse.labels();
               System.out.println("Detected labels for the given photo");
               for (Label label : labels) {
                   System.out.println(label.name() + ": " + label.confidence().toString());
               }
   
           } catch (RekognitionException e) {
               System.out.println(e.getMessage());
               System.exit(1);
           }
       }
   }
   ```

------

# Usando JavaScript
<a name="image-bytes-javascript"></a>

Il seguente esempio di JavaScript pagina Web consente a un utente di scegliere un'immagine e visualizzare le età stimate dei volti rilevati nell'immagine. Le età stimate vengono restituite da una chiamata a [DetectFaces](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectFaces.html). 

L'immagine scelta viene caricata utilizzando la JavaScript `FileReader.readAsDataURL` funzione, che codifica l'immagine in base64. Questo è utile per visualizzare l'immagine su un canvas HTML. Significa però che i byte dell'immagine non devono essere codificati prima di essere passati a un'operazione Immagini Amazon Rekognition. Questo esempio illustra come non codificare i byte dell'immagine caricata. Se i byte dell'immagine codificata non sono utili, utilizza `FileReader.readAsArrayBuffer` perché l'immagine caricata non è codificata. Ciò significa che le operazioni Immagini Amazon Rekognition possono essere chiamate senza prima decodificare i byte dell'immagine. Per vedere un esempio, consulta [Utilizzo di readAsArray Buffer](#image-bytes-javascript-unencoded).

**Per eseguire l'esempio JavaScript**

1. Carica il codice sorgente dell'esempio in un editor.

1. Scarica l'identificatore Amazon Cognito del pool di identità. Per ulteriori informazioni, consulta [Scarica l'identificatore Amazon Cognito del pool di identità](#image-bytes-javascript-auth).

1. Nella funzione `AnonLog` del codice di esempio, modifica `IdentityPoolIdToUse` e `RegionToUse` nei valori indicati nella fase 9 di [Scarica l'identificatore Amazon Cognito del pool di identità](#image-bytes-javascript-auth). 

1. Nella funzione `DetectFaces`, modifica `RegionToUse` con il valore utilizzato nella fase precedente.

1. Salva il codice sorgente di esempio come un file `.html`.

1. Carica il file nel tuo browser.

1. Seleziona il pulsante **Cerca…**, quindi scegli un'immagine che contenga uno o più volti. Viene visualizzata una tabella che contiene le età stimate per ogni faccia rilevata nell'immagine. 

**Nota**  
L'esempio di codice seguente utilizza due script che non fanno più parte di Amazon Cognito. Per ottenere questi file, segui i collegamenti per [ aws-cognito-sdk.min.js e [ amazon-cognito-identity.min.js](https://raw.githubusercontent.com/aws/amazon-cognito-identity-js/master/dist/amazon-cognito-identity.min.js)](https://raw.githubusercontent.com/aws/amazon-cognito-identity-js/master/dist/aws-cognito-sdk.js), quindi salva il testo di ciascuno di essi come file separati. `.js` 

## JavaScript codice di esempio
<a name="image-bytes-javascript-code"></a>

Il seguente esempio di codice utilizza JavaScript V2. Per un esempio in JavaScript V3, vedi [l'esempio nel repository degli esempi di AWS Documentation SDK](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/javascriptv3/example_code/rekognition/estimate-age-example/src). GitHub 

```
<!--
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.)
-->
<!DOCTYPE html>
<html>
<head>
  <script src="aws-cognito-sdk.min.js"></script>
  <script src="amazon-cognito-identity.min.js"></script>
  <script src="https://sdk.amazonaws.com/js/aws-sdk-2.16.0.min.js"></script>
  <meta charset="UTF-8">
  <title>Rekognition</title>
</head>

<body>
  <H1>Age Estimator</H1>
  <input type="file" name="fileToUpload" id="fileToUpload" accept="image/*">
  <p id="opResult"></p>
</body>
<script>

  document.getElementById("fileToUpload").addEventListener("change", function (event) {
    ProcessImage();
  }, false);
  
  //Calls DetectFaces API and shows estimated ages of detected faces
  function DetectFaces(imageData) {
    AWS.region = "RegionToUse";
    var rekognition = new AWS.Rekognition();
    var params = {
      Image: {
        Bytes: imageData
      },
      Attributes: [
        'ALL',
      ]
    };
    rekognition.detectFaces(params, function (err, data) {
      if (err) console.log(err, err.stack); // an error occurred
      else {
       var table = "<table><tr><th>Low</th><th>High</th></tr>";
        // show each face and build out estimated age table
        for (var i = 0; i < data.FaceDetails.length; i++) {
          table += '<tr><td>' + data.FaceDetails[i].AgeRange.Low +
            '</td><td>' + data.FaceDetails[i].AgeRange.High + '</td></tr>';
        }
        table += "</table>";
        document.getElementById("opResult").innerHTML = table;
      }
    });
  }
  //Loads selected image and unencodes image bytes for Rekognition DetectFaces API
  function ProcessImage() {
    AnonLog();
    var control = document.getElementById("fileToUpload");
    var file = control.files[0];

    // Load base64 encoded image 
    var reader = new FileReader();
    reader.onload = (function (theFile) {
      return function (e) {
        var img = document.createElement('img');
        var image = null;
        img.src = e.target.result;
        var jpg = true;
        try {
          image = atob(e.target.result.split("data:image/jpeg;base64,")[1]);

        } catch (e) {
          jpg = false;
        }
        if (jpg == false) {
          try {
            image = atob(e.target.result.split("data:image/png;base64,")[1]);
          } catch (e) {
            alert("Not an image file Rekognition can process");
            return;
          }
        }
        //unencode image bytes for Rekognition DetectFaces API 
        var length = image.length;
        imageBytes = new ArrayBuffer(length);
        var ua = new Uint8Array(imageBytes);
        for (var i = 0; i < length; i++) {
          ua[i] = image.charCodeAt(i);
        }
        //Call Rekognition  
        DetectFaces(ua);
      };
    })(file);
    reader.readAsDataURL(file);
  }
  //Provides anonymous log on to AWS services
  function AnonLog() {
    
    // Configure the credentials provider to use your identity pool
    AWS.config.region = 'RegionToUse'; // Region
    AWS.config.credentials = new AWS.CognitoIdentityCredentials({
      IdentityPoolId: 'IdentityPoolIdToUse',
    });
    // Make the call to obtain credentials
    AWS.config.credentials.get(function () {
      // Credentials will be available when this function is called.
      var accessKeyId = AWS.config.credentials.accessKeyId;
      var secretAccessKey = AWS.config.credentials.secretAccessKey;
      var sessionToken = AWS.config.credentials.sessionToken;
    });
  }
</script>
</html>
```

### Utilizzo di readAsArray Buffer
<a name="image-bytes-javascript-unencoded"></a>

Il seguente frammento di codice è un'implementazione alternativa della `ProcessImage` funzione nel codice di esempio, utilizzando V2. JavaScript Viene utilizzato `readAsArrayBuffer` per caricare un'immagine ed effettuare la chiamata a `DetectFaces`. Poiché `readAsArrayBuffer` non utilizza la codifica Base64 per il file caricato, non è necessario decodificare i byte dell'immagine prima di chiamare un'operazione Immagini Amazon Rekognition.

```
//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.)

function ProcessImage() {
    AnonLog();
    var control = document.getElementById("fileToUpload");
    var file = control.files[0];

    // Load base64 encoded image for display 
    var reader = new FileReader();
    reader.onload = (function (theFile) {
      return function (e) {
        //Call Rekognition  
        AWS.region = "RegionToUse";  
        var rekognition = new AWS.Rekognition();
        var params = {
          Image: {
          Bytes: e.target.result
        },
        Attributes: [
        'ALL',
      ]
    };
    rekognition.detectFaces(params, function (err, data) {
      if (err) console.log(err, err.stack); // an error occurred
      else {
       var table = "<table><tr><th>Low</th><th>High</th></tr>";
        // show each face and build out estimated age table
        for (var i = 0; i < data.FaceDetails.length; i++) {
          table += '<tr><td>' + data.FaceDetails[i].AgeRange.Low +
            '</td><td>' + data.FaceDetails[i].AgeRange.High + '</td></tr>';
        }
        table += "</table>";
        document.getElementById("opResult").innerHTML = table;
      }
    });

      };
    })(file);
    reader.readAsArrayBuffer(file);
  }
```

## Scarica l'identificatore Amazon Cognito del pool di identità
<a name="image-bytes-javascript-auth"></a>

Per semplicità, l'esempio utilizza un pool di identità Amazon Cognito anonimo per fornire un accesso non autenticato all'API Immagini Amazon Rekognition. Questo potrebbe essere idoneo per le tue esigenze. Ad esempio, puoi utilizzare l'accesso non autenticato per fornire il periodo di prova o l'accesso gratuito a un sito Web, prima che gli utenti effettuino la registrazione. Per fornire l'accesso autenticato, utilizza un pool di utenti Amazon Cognito. Per ulteriori informazioni, consulta [il pool di utenti Amazon Cognito](https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools.html). 

La procedura seguente mostra come creare un pool di identità che consente l'accesso a identità non autenticate e ottenere l'identificatore del pool di identità necessario per il codice di esempio.

**Per scaricare l'identificatore del pool di identità**

1. Apri la [console Amazon Cognito](https://console.aws.amazon.com/cognito/federated).

1. Scegli **Create new identity pool** (Crea un nuovo pool di identità).

1. Digita un nome per il tuo pool di identità in **Identity pool name\$1** (Nome pool di identità).

1. In **Unauthenticated identites (Identità non autenticate)**, seleziona **Enable access to unauthenticated identities (Abilita l'accesso a identità non autenticate)**.

1. Seleziona **Create Pool** (Crea pool).

1. Scegli **View Details** (Visualizza dettagli) e annota il nome del ruolo per le identità non autenticate.

1. Scegli **Permetti**.

1. In **Piattaforma, scegli**. **JavaScript**

1. In **Ottieni credenziali AWS**, prendere nota dei valori di `AWS.config.region` e `IdentityPooldId` che sono visualizzati nello snippet di codice.

1. Aprire la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. Nel riquadro di navigazione, seleziona **Ruoli**.

1. Scegli il nome del ruolo annotato nella fase 6.

1. Nella scheda **Permissions (Autorizzazioni)**, scegliere **Attach policies (Collega policy)**.

1. Scegli **AmazonRekognitionReadOnlyAccess**.

1. Scegli **Attach Policy (Collega policy)**.

# Visualizzazione di riquadri di delimitazione
<a name="images-displaying-bounding-boxes"></a>

Le operazioni di Immagini Amazon Rekognition possono restituire le coordinate dei riquadri di delimitazione per gli elementi rilevati nelle immagini. Ad esempio, l'operazione [DetectFaces](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectFaces.html) restituisce un riquadro ([BoundingBox](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_BoundingBox.html)) per ogni volto rilevato in un'immagine. Puoi utilizzare le coordinate per visualizzare un riquadro intorno agli elementi rilevati. Ad esempio, l'immagine seguente mostra un volto circondato da un riquadro.

![\[Giovane donna sorridente che indossa occhiali, con bolle intorno a sé.\]](http://docs.aws.amazon.com/it_it/rekognition/latest/dg/images/face.png)


A `BoundingBox` possiede le seguenti proprietà:
+ Altezza: L'altezza del riquadro di delimitazione come rapporto rispetto all'altezza complessiva dell'immagine.
+ Sinistra: La coordinata di sinistra del riquadro di delimitazione come rapporto rispetto alla larghezza complessiva dell'immagine.
+ Alto: La coordinata superiore del riquadro di delimitazione come rapporto rispetto all'altezza complessiva dell'immagine.
+ Larghezza: La larghezza del riquadro di delimitazione come rapporto rispetto alla larghezza complessiva dell'immagine.

Ogni BoundingBox proprietà ha un valore compreso tra 0 e 1. Il valore di ciascuna proprietà è un rapporto tra la larghezza (`Left` e `Width`) o l'altezza (`Height` e `Top`) complessiva dell'immagine. Ad esempio, se l'immagine di input è di 700 x 200 pixel e la coordinata superiore sinistra del riquadro di delimitazione è di 350 x 50 pixel, l'API restituisce un valore `Left` di 0,5 (350/700) e un valore `Top` di 0,25 (50/200). 

Il seguente diagramma mostra la porzione di immagine coperta da ciascuna proprietà del riquadro.

![\[Un grafico che illustra il rapporto tra un riquadro di delimitazione e le dimensioni di un'immagine.\]](http://docs.aws.amazon.com/it_it/rekognition/latest/dg/images/bounding-box.png)


Per visualizzare il riquadro di delimitazione con la posizione e le dimensioni corrette, è necessario moltiplicare BoundingBox i valori per la larghezza o l'altezza dell'immagine (a seconda del valore desiderato) per ottenere i valori dei pixel. I valori in pixel servono a visualizzare il riquadro di delimitazione. Ad esempio, le dimensioni in pixel dell'immagine precedente sono 608 x 588 (larghezza x altezza). I valori del riquadro di delimitazione del volto sono: 

```
BoundingBox.Left: 0.3922065
BoundingBox.Top: 0.15567766
BoundingBox.Width: 0.284666
BoundingBox.Height: 0.2930403
```

La posizione in pixel del riquadro di delimitazione del volto viene calcolata come segue: 

`Left coordinate = BoundingBox.Left (0.3922065) * image width (608) = 238`

`Top coordinate = BoundingBox.Top (0.15567766) * image height (588) = 91`

`Face width = BoundingBox.Width (0.284666) * image width (608) = 173`

`Face height = BoundingBox.Height (0.2930403) * image height (588) = 172`

Puoi utilizzare questi valori per visualizzare un riquadro attorno al volto.

**Nota**  
Un'immagine può essere orientata in diversi modi. Per visualizzare un'immagine con l'orientamento corretto, potrebbe essere necessario eseguire una rotazione. Le coordinate del riquadro di delimitazione cambiano in base all'orientamento dell'immagine. Per visualizzare un riquadro nella posizione corretta, potrebbe essere necessario traslare le coordinate. Per ulteriori informazioni, consulta [Ottenere l'orientamento dell'immagine e le coordinate del riquadro di delimitazione](images-orientation.md).

I seguenti esempi mostrano come visualizzare un riquadro di delimitazione intorno ai volti rilevati, richiamando [DetectFaces](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectFaces.html). Negli esempi si presume che le immagini siano orientate a 0 gradi. Gli esempi indicano anche come scaricare l'immagine da un bucket Amazon S3. 

**Per visualizzare un riquadro di delimitazione**

1. Se non lo hai già fatto:

   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 AWS CLI e il. AWS SDKs Per ulteriori informazioni, consulta [Passaggio 2: configura AWS CLI e AWS SDKs](setup-awscli-sdk.md).

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

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

   Modificare il valore `bucket` con quello del bucket Amazon S3 che contiene il file immagine. Modificare il valore `photo` con il nome di un file immagine (formato .jpg o .png).

   ```
    
   //Loads images, detects faces and draws bounding boxes.Determines exif orientation, if necessary.
   package com.amazonaws.samples;
   
   //Import the basic graphics classes.
   import java.awt.*;
   import java.awt.image.BufferedImage;
   import java.util.List;
   import javax.imageio.ImageIO;
   import javax.swing.*;
   
   import com.amazonaws.services.rekognition.AmazonRekognition;
   import com.amazonaws.services.rekognition.AmazonRekognitionClientBuilder;
   
   import com.amazonaws.services.rekognition.model.BoundingBox;
   import com.amazonaws.services.rekognition.model.DetectFacesRequest;
   import com.amazonaws.services.rekognition.model.DetectFacesResult;
   import com.amazonaws.services.rekognition.model.FaceDetail;
   import com.amazonaws.services.rekognition.model.Image;
   import com.amazonaws.services.rekognition.model.S3Object;
   import com.amazonaws.services.s3.AmazonS3;
   import com.amazonaws.services.s3.AmazonS3ClientBuilder;
   import com.amazonaws.services.s3.model.S3ObjectInputStream;
   
   // Calls DetectFaces and displays a bounding box around each detected image.
   public class DisplayFaces extends JPanel {
   
       private static final long serialVersionUID = 1L;
   
       BufferedImage image;
       static int scale;
       DetectFacesResult result;
   
       public DisplayFaces(DetectFacesResult facesResult, BufferedImage bufImage) throws Exception {
           super();
           scale = 1; // increase to shrink image size.
   
           result = facesResult;
           image = bufImage;
   
           
       }
       // Draws the bounding box around the detected faces.
       public void paintComponent(Graphics g) {
           float left = 0;
           float top = 0;
           int height = image.getHeight(this);
           int width = image.getWidth(this);
   
           Graphics2D g2d = (Graphics2D) g; // Create a Java2D version of g.
   
           // Draw the image.
           g2d.drawImage(image, 0, 0, width / scale, height / scale, this);
           g2d.setColor(new Color(0, 212, 0));
   
           // Iterate through faces and display bounding boxes.
           List<FaceDetail> faceDetails = result.getFaceDetails();
           for (FaceDetail face : faceDetails) {
               
               BoundingBox box = face.getBoundingBox();
               left = width * box.getLeft();
               top = height * box.getTop();
               g2d.drawRect(Math.round(left / scale), Math.round(top / scale),
                       Math.round((width * box.getWidth()) / scale), Math.round((height * box.getHeight())) / scale);
               
           }
       }
   
   
       public static void main(String arg[]) throws Exception {
   
           String photo = "photo.png";
           String bucket = "bucket";
           int height = 0;
           int width = 0;
   
           // Get the image from an S3 Bucket
           AmazonS3 s3client = AmazonS3ClientBuilder.defaultClient();
   
           com.amazonaws.services.s3.model.S3Object s3object = s3client.getObject(bucket, photo);
           S3ObjectInputStream inputStream = s3object.getObjectContent();
           BufferedImage image = ImageIO.read(inputStream);
           DetectFacesRequest request = new DetectFacesRequest()
                   .withImage(new Image().withS3Object(new S3Object().withName(photo).withBucket(bucket)));
   
           width = image.getWidth();
           height = image.getHeight();
   
           // Call DetectFaces    
           AmazonRekognition amazonRekognition = AmazonRekognitionClientBuilder.defaultClient();
           DetectFacesResult result = amazonRekognition.detectFaces(request);
           
           //Show the bounding box info for each face.
           List<FaceDetail> faceDetails = result.getFaceDetails();
           for (FaceDetail face : faceDetails) {
   
               BoundingBox box = face.getBoundingBox();
               float left = width * box.getLeft();
               float top = height * box.getTop();
               System.out.println("Face:");
   
               System.out.println("Left: " + String.valueOf((int) left));
               System.out.println("Top: " + String.valueOf((int) top));
               System.out.println("Face Width: " + String.valueOf((int) (width * box.getWidth())));
               System.out.println("Face Height: " + String.valueOf((int) (height * box.getHeight())));
               System.out.println();
   
           }
   
           // Create frame and panel.
           JFrame frame = new JFrame("RotateImage");
           frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
           DisplayFaces panel = new DisplayFaces(result, image);
           panel.setPreferredSize(new Dimension(image.getWidth() / scale, image.getHeight() / scale));
           frame.setContentPane(panel);
           frame.pack();
           frame.setVisible(true);
   
       }
   }
   ```

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

   Modificare il valore `bucket` con quello del bucket Amazon S3 che contiene il file immagine. Modificare il valore `photo` con il nome di un file immagine (formato .jpg o .png). Sostituisci il valore di `profile_name` nella riga che crea la sessione di Rekognition con il nome del tuo profilo di sviluppatore.

   ```
   import boto3
   import io
   from PIL import Image, ImageDraw
   
   def show_faces(photo, bucket):
   
       session = boto3.Session(profile_name='profile-name')
       client = session.client('rekognition')
   
       # Load image from S3 bucket
       s3_connection = boto3.resource('s3')
       s3_object = s3_connection.Object(bucket, photo)
       s3_response = s3_object.get()
   
       stream = io.BytesIO(s3_response['Body'].read())
       image = Image.open(stream)
   
       # Call DetectFaces
       response = client.detect_faces(Image={'S3Object': {'Bucket': bucket, 'Name': photo}},
                                      Attributes=['ALL'])
   
       imgWidth, imgHeight = image.size
       draw = ImageDraw.Draw(image)
   
       # calculate and display bounding boxes for each detected face
       print('Detected faces for ' + photo)
       for faceDetail in response['FaceDetails']:
           print('The detected face is between ' + str(faceDetail['AgeRange']['Low'])
                 + ' and ' + str(faceDetail['AgeRange']['High']) + ' years old')
   
           box = faceDetail['BoundingBox']
           left = imgWidth * box['Left']
           top = imgHeight * box['Top']
           width = imgWidth * box['Width']
           height = imgHeight * box['Height']
   
           print('Left: ' + '{0:.0f}'.format(left))
           print('Top: ' + '{0:.0f}'.format(top))
           print('Face Width: ' + "{0:.0f}".format(width))
           print('Face Height: ' + "{0:.0f}".format(height))
   
           points = (
               (left, top),
               (left + width, top),
               (left + width, top + height),
               (left, top + height),
               (left, top)
   
           )
           draw.line(points, fill='#00d400', width=2)
   
           # Alternatively can draw rectangle. However you can't set line width.
           # draw.rectangle([left,top, left + width, top + height], outline='#00d400')
   
       image.show()
   
       return len(response['FaceDetails'])
   
   def main():
       bucket = "bucket-name"
       photo = "photo-name"
       faces_count = show_faces(photo, bucket)
       print("faces detected: " + str(faces_count))
   
   if __name__ == "__main__":
       main()
   ```

------
#### [ 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/DisplayFacesFrame.java).

   Nota che `s3` si riferisce al client AWS SDK Amazon Amazon S3 `rekClient` e al client AWS SDK Amazon Rekognition. 

   ```
   //snippet-start:[rekognition.java2.detect_labels.import]
   import java.awt.*;
   import java.awt.image.BufferedImage;
   import java.io.ByteArrayInputStream;
   import java.io.FileNotFoundException;
   import java.io.IOException;
   import java.io.InputStream;
   import java.util.List;
   import javax.imageio.ImageIO;
   import javax.swing.*;
   import software.amazon.awssdk.auth.credentials.ProfileCredentialsProvider;
   import software.amazon.awssdk.core.ResponseBytes;
   import software.amazon.awssdk.core.SdkBytes;
   import software.amazon.awssdk.regions.Region;
   import software.amazon.awssdk.services.rekognition.model.Attribute;
   import software.amazon.awssdk.services.rekognition.model.BoundingBox;
   import software.amazon.awssdk.services.rekognition.model.DetectFacesRequest;
   import software.amazon.awssdk.services.rekognition.model.DetectFacesResponse;
   import software.amazon.awssdk.services.rekognition.model.FaceDetail;
   import software.amazon.awssdk.services.rekognition.model.Image;
   import software.amazon.awssdk.services.rekognition.model.RekognitionException;
   import software.amazon.awssdk.services.s3.S3Client;
   import software.amazon.awssdk.services.rekognition.RekognitionClient;
   import software.amazon.awssdk.services.s3.model.GetObjectRequest;
   import software.amazon.awssdk.services.s3.model.GetObjectResponse;
   import software.amazon.awssdk.services.s3.model.S3Exception;
   //snippet-end:[rekognition.java2.detect_labels.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 DisplayFaces extends JPanel {
   
       static DetectFacesResponse result;
       static BufferedImage image;
       static int scale;
   
       public static void main(String[] args) throws Exception {
   
           final String usage = "\n" +
               "Usage: " +
               "   <sourceImage> <bucketName>\n\n" +
               "Where:\n" +
               "   sourceImage - The name of the image in an Amazon S3 bucket (for example, people.png). \n\n" +
               "   bucketName - The name of the Amazon S3 bucket (for example, amzn-s3-demo-bucket). \n\n";
   
           if (args.length != 2) {
               System.out.println(usage);
               System.exit(1);
           }
   
           String sourceImage = args[0];
           String bucketName = args[1];
           Region region = Region.US_EAST_1;
           S3Client s3 = S3Client.builder()
               .region(region)
               .credentialsProvider(ProfileCredentialsProvider.create("profile-name"))
               .build();
   
           RekognitionClient rekClient = RekognitionClient.builder()
               .region(region)
               .credentialsProvider(ProfileCredentialsProvider.create("profile-name"))
               .build();
   
           displayAllFaces(s3, rekClient, sourceImage, bucketName);
           s3.close();
           rekClient.close();
       }
   
       // snippet-start:[rekognition.java2.display_faces.main]
       public static void displayAllFaces(S3Client s3,
                                          RekognitionClient rekClient,
                                          String sourceImage,
                                          String bucketName) {
           int height;
           int width;
           byte[] data = getObjectBytes (s3, bucketName, sourceImage);
           InputStream is = new ByteArrayInputStream(data);
   
           try {
               SdkBytes sourceBytes = SdkBytes.fromInputStream(is);
               image = ImageIO.read(sourceBytes.asInputStream());
               width = image.getWidth();
               height = image.getHeight();
   
               // Create an Image object for the source image
               software.amazon.awssdk.services.rekognition.model.Image souImage = Image.builder()
                   .bytes(sourceBytes)
                   .build();
   
               DetectFacesRequest facesRequest = DetectFacesRequest.builder()
                   .attributes(Attribute.ALL)
                   .image(souImage)
                   .build();
   
               result = rekClient.detectFaces(facesRequest);
   
               // Show the bounding box info for each face.
               List<FaceDetail> faceDetails = result.faceDetails();
               for (FaceDetail face : faceDetails) {
                   BoundingBox box = face.boundingBox();
                   float left = width * box.left();
                   float top = height * box.top();
                   System.out.println("Face:");
   
                   System.out.println("Left: " + (int) left);
                   System.out.println("Top: " + (int) top);
                   System.out.println("Face Width: " + (int) (width * box.width()));
                   System.out.println("Face Height: " + (int) (height * box.height()));
                   System.out.println();
               }
   
               // Create the frame and panel.
               JFrame frame = new JFrame("RotateImage");
               frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
               DisplayFaces panel = new DisplayFaces(image);
               panel.setPreferredSize(new Dimension(image.getWidth() / scale, image.getHeight() / scale));
               frame.setContentPane(panel);
               frame.pack();
               frame.setVisible(true);
   
           } catch (RekognitionException | FileNotFoundException e) {
               System.out.println(e.getMessage());
               System.exit(1);
           } catch (IOException e) {
              e.printStackTrace();
           }
       }
   
       public static byte[] getObjectBytes (S3Client s3, String bucketName, String keyName) {
   
           try {
               GetObjectRequest objectRequest = GetObjectRequest
                   .builder()
                   .key(keyName)
                   .bucket(bucketName)
                   .build();
   
               ResponseBytes<GetObjectResponse> objectBytes = s3.getObjectAsBytes(objectRequest);
               return objectBytes.asByteArray();
   
           } catch (S3Exception e) {
               System.err.println(e.awsErrorDetails().errorMessage());
               System.exit(1);
           }
           return null;
       }
   
       public DisplayFaces(BufferedImage bufImage) {
           super();
           scale = 1; // increase to shrink image size.
           image = bufImage;
       }
   
       // Draws the bounding box around the detected faces.
       public void paintComponent(Graphics g) {
           float left;
           float top;
           int height = image.getHeight(this);
           int width = image.getWidth(this);
           Graphics2D g2d = (Graphics2D) g; // Create a Java2D version of g.
   
           // Draw the image
           g2d.drawImage(image, 0, 0, width / scale, height / scale, this);
           g2d.setColor(new Color(0, 212, 0));
   
           // Iterate through the faces and display bounding boxes.
           List<FaceDetail> faceDetails = result.faceDetails();
           for (FaceDetail face : faceDetails) {
               BoundingBox box = face.boundingBox();
               left = width * box.left();
               top = height * box.top();
               g2d.drawRect(Math.round(left / scale), Math.round(top / scale),
                       Math.round((width * box.width()) / scale), Math.round((height * box.height())) / scale);
           }
       }
       // snippet-end:[rekognition.java2.display_faces.main]
   }
   ```

------

# Ottenere l'orientamento dell'immagine e le coordinate del riquadro di delimitazione
<a name="images-orientation"></a>

Le applicazioni che utilizzano Immagini Amazon Rekognition solitamente devono visualizzare le immagini che vengono rilevate dalle operazioni di Immagini Amazon Rekognition e i riquadri intorno ai volti rilevati. Per visualizzare correttamente un'immagine nella propria applicazione, è necessario conoscere l'orientamento dell'immagine. Potrebbe essere necessario correggere questo orientamento. Per alcuni file .jpg, l'orientamento dell'immagine è contenuto nei metadata Exif (Exchangeable image file format) dell'immagine. 

Per visualizzare un riquadro intorno a un volto, è necessario disporre delle coordinate del riquadro di delimitazione del volto. Se il riquadro non è orientato correttamente, potrebbe essere necessario modificare tali coordinate. Le operazioni di riconoscimento facciale di Immagini Amazon Rekognition restituiscono le coordinate del bounding box per ogni volto rilevato, ma non stimano le coordinate per i file.jpg senza metadati Exif.

Il seguente esempio mostra come ottenere le coordinate del riquadro di delimitazione per i volti rilevati in un'immagine.

Utilizzare le informazioni in questo esempio per verificare che le immagini siano orientate correttamente e che i riquadri di delimitazione siano visualizzati in posizione corretta all'interno dell'applicazione. 

Poiché il codice utilizzato per ruotare e visualizzare le immagini e i riquadri di delimitazione dipende dalla lingua e dall'ambiente utilizzati, non spiegheremo come visualizzare le immagini e i riquadri nel codice o come ottenere informazioni di orientamento dai metadati Exif.



## Determinazione dell'orientamento di un'immagine
<a name="images-discovering-image-orientation"></a>

Per visualizzare correttamente un'immagine nella propria applicazione, potrebbe essere necessario ruotarla. La seguente immagine è orientata a 0 gradi ed è visualizzata correttamente.

![\[Icona generica del profilo che rappresenta un account utente o un'immagine del profilo.\]](http://docs.aws.amazon.com/it_it/rekognition/latest/dg/images/00face.png)


Tuttavia, la seguente immagine è ruotata di 90 gradi in senso antiorario. Per visualizzarla correttamente, è necessario determinare l'orientamento dell'immagine e utilizzare tali informazioni nel codice per ruotare l'immagine a 0 gradi. 

![\[Icona generica del profilo che rappresenta un account utente o un'immagine del profilo, ruotata di 90 gradi in senso antiorario.\]](http://docs.aws.amazon.com/it_it/rekognition/latest/dg/images/90face.png)


Alcune immagini in formato .jpg contengono le informazioni di orientamento nei metadata Exif. Se disponibili, i metadati Exif dell'immagine contengono l'orientamento. Nei metadata Exif è possibile trovare l'orientamento dell'immagine nel campo `orientation`. Anche se Immagini Amazon Rekognition identifica la presenza di informazioni sull'orientamento dell'immagine nei metadati Exif, non fornisce accesso a tali informazioni. Per accedere ai metadata Exif in un'immagine, utilizzare una libreria di terze parti o scrivere il proprio codice. Per ulteriori informazioni, consulta [Exif versione 2.32](http://cipa.jp/std/documents/download_e.html?DC-008-Translation-2019-E).

 



Quando si conosce l'orientamento di un'immagine, è possibile scrivere il codice per ruotarla e visualizzarla correttamente.

## Visualizzazione di riquadri di delimitazione
<a name="images-bounding-boxes"></a>

Le operazioni di Immagini Amazon Rekognition che analizzano i volti in un'immagine restituiscono anche le coordinate dei riquadri di delimitazione che circondano i volti. Per ulteriori informazioni, consulta [BoundingBox](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_BoundingBox.html). 

Per visualizzare un riquadro intorno a un volto simile a quello mostrato nell'immagine seguente all'interno dell'applicazione, utilizzare le coordinate del riquadro nel proprio codice. Le coordinate del riquadro di delimitazione restituite da un'operazione indicano l'orientamento dell'immagine. Se è necessario ruotare l'immagine per visualizzarla correttamente, potrebbe essere necessario convertire le coordinate del riquadro di delimitazione.



![\[Icona del profilo con il volto evidenziato in un quadrato rosso.\]](http://docs.aws.amazon.com/it_it/rekognition/latest/dg/images/00facebounding.png)




### Visualizzazione dei riquadri di delimitazione quando le informazioni di orientamento sono presenti nei metadata Exif
<a name="images-exif-metadata"></a>

Se l'orientamento di un'immagine è inclusa nei metadata Exif, le operazioni di Immagini Amazon Rekognition eseguiranno quanto segue:
+ Restituiranno un valore nullo nel campo di correzione dell'orientamento nella risposta dell'operazione. Per ruotare l'immagine, utilizzare l'orientamento fornito nei metadata Exif del proprio codice.
+ Restituiranno le coordinate del riquadro di delimitazione già orientate a 0 gradi. Per visualizzare il riquadro di delimitazione nella posizione corretta, utilizzare le coordinate restituite. Non è necessario convertirle.

## Esempio: ottenimento dell'orientamento dell'immagine e delle coordinate del riquadro per un'immagine
<a name="images-correcting-image-orientation-java"></a>

L'esempio seguente mostra come utilizzare l'AWS SDK per ottenere i dati di orientamento dell'immagine Exif e le coordinate del riquadri di delimitazione per le celebrità rilevate dall'operazione `RecognizeCelebrities`.

**Nota**  
Il supporto per la stima dell'orientamento dell'immagine utilizzando il campo `OrientationCorrection` è cessato ad agosto 2021. Tutti i valori restituiti per questo campo inclusi in una risposta API saranno sempre NULL.

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

In questo esempio viene caricata un'immagine dal file system locale, richiamata l'operazione `RecognizeCelebrities`, determinata l'altezza e la larghezza dell'immagine e vengono inoltre calcolate le coordinate del riquadro di delimitazione del volto per l'immagine ruotata. L'esempio non mostra come elaborare le informazioni di orientamento memorizzate nei metadata Exif.

Nella funzione `main` sostituire il valore di `photo` con il nome e il percorso di un'immagine memorizzata localmente in formato .png o .jpg.

```
//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 com.amazonaws.samples;
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.nio.ByteBuffer;
import java.util.List;
import javax.imageio.ImageIO;
import com.amazonaws.services.rekognition.AmazonRekognition;
import com.amazonaws.services.rekognition.AmazonRekognitionClientBuilder;
import com.amazonaws.services.rekognition.model.Image;
import com.amazonaws.services.rekognition.model.RecognizeCelebritiesRequest;
import com.amazonaws.services.rekognition.model.RecognizeCelebritiesResult;
import com.amazonaws.util.IOUtils;
import com.amazonaws.services.rekognition.model.AmazonRekognitionException;
import com.amazonaws.services.rekognition.model.BoundingBox;
import com.amazonaws.services.rekognition.model.Celebrity;
import com.amazonaws.services.rekognition.model.ComparedFace;

public class RotateImage {

public static void main(String[] args) throws Exception {

  String photo = "photo.png";

  //Get Rekognition client
 AmazonRekognition amazonRekognition = AmazonRekognitionClientBuilder.defaultClient();


  // Load image
  ByteBuffer imageBytes=null;
  BufferedImage image = null;

  try (InputStream inputStream = new FileInputStream(new File(photo))) {
     imageBytes = ByteBuffer.wrap(IOUtils.toByteArray(inputStream));

  }
  catch(Exception e)
  {
      System.out.println("Failed to load file " + photo);
      System.exit(1);
  }

  //Get image width and height
  InputStream imageBytesStream;
  imageBytesStream = new ByteArrayInputStream(imageBytes.array());

  ByteArrayOutputStream baos = new ByteArrayOutputStream();
  image=ImageIO.read(imageBytesStream);
  ImageIO.write(image, "jpg", baos);

  int height = image.getHeight();
  int width = image.getWidth();

  System.out.println("Image Information:");
  System.out.println(photo);
  System.out.println("Image Height: " + Integer.toString(height));
  System.out.println("Image Width: " + Integer.toString(width));

  //Call GetCelebrities

  try{
    RecognizeCelebritiesRequest request = new RecognizeCelebritiesRequest()
           .withImage(new Image()
              .withBytes((imageBytes)));


      RecognizeCelebritiesResult result = amazonRekognition.recognizeCelebrities(request);
      // The returned value of OrientationCorrection will always be null
      System.out.println("Orientation: " + result.getOrientationCorrection() + "\n");
      List <Celebrity> celebs = result.getCelebrityFaces();

      for (Celebrity celebrity: celebs) {
          System.out.println("Celebrity recognized: " + celebrity.getName());
          System.out.println("Celebrity ID: " + celebrity.getId());
          ComparedFace  face = celebrity.getFace()
;             ShowBoundingBoxPositions(height,
                  width,
                  face.getBoundingBox(),
                  result.getOrientationCorrection());
                 
            System.out.println();
       }

   } catch (AmazonRekognitionException e) {
      e.printStackTrace();
   }

}


public static void ShowBoundingBoxPositions(int imageHeight, int imageWidth, BoundingBox box, String rotation) {

  float left = 0;
  float top = 0;
   
  if(rotation==null){
      System.out.println("No estimated estimated orientation. Check Exif data.");
      return;
  }
  //Calculate face position based on image orientation.
  switch (rotation) {
     case "ROTATE_0":
        left = imageWidth * box.getLeft();
        top = imageHeight * box.getTop();
        break;
     case "ROTATE_90":
        left = imageHeight * (1 - (box.getTop() + box.getHeight()));
        top = imageWidth * box.getLeft();
        break;
     case "ROTATE_180":
        left = imageWidth - (imageWidth * (box.getLeft() + box.getWidth()));
        top = imageHeight * (1 - (box.getTop() + box.getHeight()));
        break;
     case "ROTATE_270":
        left = imageHeight * box.getTop();
        top = imageWidth * (1 - box.getLeft() - box.getWidth());
        break;
     default:
        System.out.println("No estimated orientation information. Check Exif data.");
        return;
  }

  //Display face location information.
  System.out.println("Left: " + String.valueOf((int) left));
  System.out.println("Top: " + String.valueOf((int) top));
  System.out.println("Face Width: " + String.valueOf((int)(imageWidth * box.getWidth())));
  System.out.println("Face Height: " + String.valueOf((int)(imageHeight * box.getHeight())));

  }
}
```

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

Questo esempio utilizza la libreria di PIL/Pillow immagini per ottenere la larghezza e l'altezza dell'immagine. Per ulteriori informazioni, consulta [Pillow](https://pillow.readthedocs.io/en/stable/). In questo esempio vengono conservati i metadati exif che potrebbe essere necessari in altri punti dell'applicazione.

Nella funzione `main` sostituire il valore di `photo` con il nome e il percorso di un'immagine memorizzata localmente in formato .png o .jpg.

```
#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
import io
from PIL import Image


# Calculate positions from from estimated rotation
def show_bounding_box_positions(imageHeight, imageWidth, box):
    left = 0
    top = 0

    print('Left: ' + '{0:.0f}'.format(left))
    print('Top: ' + '{0:.0f}'.format(top))
    print('Face Width: ' + "{0:.0f}".format(imageWidth * box['Width']))
    print('Face Height: ' + "{0:.0f}".format(imageHeight * box['Height']))


def celebrity_image_information(photo):
    client = boto3.client('rekognition')

    # Get image width and height
    image = Image.open(open(photo, 'rb'))
    width, height = image.size

    print('Image information: ')
    print(photo)
    print('Image Height: ' + str(height))
    print('Image Width: ' + str(width))

    # call detect faces and show face age and placement
    # if found, preserve exif info
    stream = io.BytesIO()
    if 'exif' in image.info:
        exif = image.info['exif']
        image.save(stream, format=image.format, exif=exif)
    else:
        image.save(stream, format=image.format)
    image_binary = stream.getvalue()

    response = client.recognize_celebrities(Image={'Bytes': image_binary})

    print()
    print('Detected celebrities for ' + photo)

    for celebrity in response['CelebrityFaces']:
        print('Name: ' + celebrity['Name'])
        print('Id: ' + celebrity['Id'])

        # Value of "orientation correction" will always be null
        if 'OrientationCorrection' in response:
            show_bounding_box_positions(height, width, celebrity['Face']['BoundingBox'])

        print()
    return len(response['CelebrityFaces'])


def main():
    photo = 'photo'

    celebrity_count = celebrity_image_information(photo)
    print("celebrities detected: " + str(celebrity_count))


if __name__ == "__main__":
    main()
```

------
#### [ 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/RotateImage.java).

```
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.RecognizeCelebritiesRequest;
import software.amazon.awssdk.services.rekognition.model.Image;
import software.amazon.awssdk.services.rekognition.model.RecognizeCelebritiesResponse;
import software.amazon.awssdk.services.rekognition.model.Celebrity;
import software.amazon.awssdk.services.rekognition.model.ComparedFace;
import software.amazon.awssdk.services.rekognition.model.RekognitionException;
import software.amazon.awssdk.services.rekognition.model.BoundingBox;
import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.*;
import java.util.List;

/**
 * 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 RotateImage {
    public static void main(String[] args) {
        final String usage = """

                Usage:    <sourceImage>

                Where:
                   sourceImage - The path to the image (for example, C:\\AWS\\pic1.png).\s
                """;

        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)
                .build();

        System.out.println("Locating celebrities in " + sourceImage);
        recognizeAllCelebrities(rekClient, sourceImage);
        rekClient.close();
    }

    public static void recognizeAllCelebrities(RekognitionClient rekClient, String sourceImage) {
        try {
            BufferedImage image;
            InputStream sourceStream = new FileInputStream(sourceImage);
            SdkBytes sourceBytes = SdkBytes.fromInputStream(sourceStream);

            image = ImageIO.read(sourceBytes.asInputStream());
            int height = image.getHeight();
            int width = image.getWidth();

            Image souImage = Image.builder()
                    .bytes(sourceBytes)
                    .build();

            RecognizeCelebritiesRequest request = RecognizeCelebritiesRequest.builder()
                    .image(souImage)
                    .build();

            RecognizeCelebritiesResponse result = rekClient.recognizeCelebrities(request);
            List<Celebrity> celebs = result.celebrityFaces();
            System.out.println(celebs.size() + " celebrity(s) were recognized.\n");
            for (Celebrity celebrity : celebs) {
                System.out.println("Celebrity recognized: " + celebrity.name());
                System.out.println("Celebrity ID: " + celebrity.id());
                ComparedFace face = celebrity.face();
                ShowBoundingBoxPositions(height,
                        width,
                        face.boundingBox(),
                        result.orientationCorrectionAsString());
            }

        } catch (RekognitionException | FileNotFoundException e) {
            System.out.println(e.getMessage());
            System.exit(1);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void ShowBoundingBoxPositions(int imageHeight, int imageWidth, BoundingBox box, String rotation) {
        float left;
        float top;
        if (rotation == null) {
            System.out.println("No estimated estimated orientation.");
            return;
        }

        // Calculate face position based on the image orientation.
        switch (rotation) {
            case "ROTATE_0" -> {
                left = imageWidth * box.left();
                top = imageHeight * box.top();
            }
            case "ROTATE_90" -> {
                left = imageHeight * (1 - (box.top() + box.height()));
                top = imageWidth * box.left();
            }
            case "ROTATE_180" -> {
                left = imageWidth - (imageWidth * (box.left() + box.width()));
                top = imageHeight * (1 - (box.top() + box.height()));
            }
            case "ROTATE_270" -> {
                left = imageHeight * box.top();
                top = imageWidth * (1 - box.left() - box.width());
            }
            default -> {
                System.out.println("No estimated orientation information. Check Exif data.");
                return;
            }
        }

        System.out.println("Left: " + (int) left);
        System.out.println("Top: " + (int) top);
        System.out.println("Face Width: " + (int) (imageWidth * box.width()));
        System.out.println("Face Height: " + (int) (imageHeight * box.height()));
    }
}
```

------