Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Travail avec les images
<a name="images"></a>

Cette section couvre les types d’analyse qu’Image Amazon Rekognition peut effectuer sur les images. 
+ [Détection des objets et des scènes](labels.md)
+ [Détection et comparaison de visages](faces.md)
+ [Recherche de visages dans une collection](collections.md)
+ [Reconnaissance de célébrités](celebrities.md)
+ [Modération des images](moderation.md)
+ [Détection de texte dans les images](text-detection.md)

Ces analyses sont effectuées par des opérations d’API hors stockage où Image Amazon Rekognition ne conserve pas les informations découvertes par l’opération. Les octets d’image en entrée ne sont pas conservés par les opérations d’API hors stockage. Pour de plus amples informations, veuillez consulter [Comprendre les opérations non liées au stockage et aux API de stockage](how-it-works-storage-non-storage.md).

Image Amazon Rekognition peut également stocker les métadonnées faciales dans des collections afin de les récupérer ultérieurement. Pour de plus amples informations, veuillez consulter [Recherche de visages dans une collection](collections.md).

Dans cette section, vous utilisez les opérations d’API Image Amazon Rekognition pour analyser les images stockées dans un compartiment S3, ainsi que les octets d’image chargés à partir du système de fichiers local. Cette section traite également l’obtention d’informations d’orientation d’image à partir d’une image .jpg. 

 Rekognition utilise uniquement les canaux RGB pour effectuer des inférences. AWS recommande aux utilisateurs de supprimer le canal Alpha avant d'utiliser un écran pour inspecter visuellement (manuellement par un humain) la comparaison. 

**Topics**
+ [Spécifications d’images](images-information.md)
+ [Analyse d’images stockées dans un compartiment Amazon S3](images-s3.md)
+ [Analyse d’une image chargée à partir d’un système de fichiers local](images-bytes.md)
+ [Affichage de cadres de délimitation](images-displaying-bounding-boxes.md)
+ [Obtention de l’orientation d’une image et des coordonnées du cadre de délimitation](images-orientation.md)

# Spécifications d’images
<a name="images-information"></a>

Les opérations Image Amazon Rekognition peuvent analyser les images au format .jpg ou .png.

Vous transmettez les octets des images à une opération Image Amazon Rekognition dans le cadre de l’appel ou vous référencez un objet Amazon S3 existant. Pour obtenir un exemple d’analyse d’une image stockée dans un compartiment Amazon S3, consultez [Analyse d’images stockées dans un compartiment Amazon S3](images-s3.md). Pour obtenir un exemple de transmission d’octets d’image à une opération d’API Image Amazon Rekognition consultez [Analyse d’une image chargée à partir d’un système de fichiers local](images-bytes.md).

Si vous utilisez HTTP et transmettez les octets d’image dans le cadre d’une opération Image Amazon Rekognition, ils doivent former une chaîne encodée en base64. Si vous utilisez le kit de développement logiciel AWS SDK et transmettez les octets d’image dans le cadre de l’appel d’opération d’API, la nécessité de les encoder en base64 dépend du langage que vous utilisez. 

Les images courantes suivantes AWS SDKs encodent automatiquement les images en base64, et vous n'avez pas besoin de coder des octets d'image avant d'appeler une opération d'API Amazon Rekognition Image.
+ Java
+ JavaScript
+ Python
+ PHP

Si vous utilisez un autre kit AWS SDK et obtenez une erreur de format d’image en appelant une opération Rekognition API, essayez d’encoder les octets d’image en base64 avant de les transmettre à une opération Rekognition API.

Si vous utilisez le AWS CLI pour appeler les opérations Amazon Rekognition Image, le transfert d'octets d'image dans le cadre de l'appel n'est pas pris en charge. Vous devez d’abord charger l’image dans un compartiment Amazon S3, puis appeler l’opération faisant référence à l’image chargée.

**Note**  
Il n’est pas nécessaire d’encoder l’image en base64 si vous transmettez une image stockée dans une propriété `S3Object` plutôt que des octets d’image.

Pour savoir comment limiter autant que possible la latence pour les opérations Image Amazon Rekognition, consultez [Latence de fonctionnement d’Image Amazon Rekognition](operation-latency.md). 

## Correction de l’orientation d’une image
<a name="images-image-orientation-correction"></a>

Dans plusieurs opérations Rekognition API l’orientation d’une image analysée est renvoyée. Il est important de connaître l’orientation d’une image, car elle vous permet de réorienter les images à afficher. Les opérations Rekognition API chargées d’analyser les visages renvoient également des cadres de délimitation correspondant à l’emplacement des visages dans une image. Vous pouvez utiliser des cadres de délimitation pour afficher un cadre autour d’un visage sur une image. Les coordonnées de cadre de délimitation renvoyées variant en fonction de l’orientation de l’image, vous pouvez être amené à traduire ces coordonnées pour afficher correctement un cadre autour d’un visage. Pour de plus amples informations, veuillez consulter [Obtention de l’orientation d’une image et des coordonnées du cadre de délimitation](images-orientation.md). 

## Redimensionnement d’images
<a name="images-image-sizing"></a>

Au cours de l’analyse, Amazon Rekognition redimensionne les images en interne à l’aide d’un ensemble de plages prédéfinies qui conviennent le mieux à un modèle ou à un algorithme en particulier. De ce fait, Amazon Rekognition peut détecter un nombre différent d’objets ou fournir des résultats différents en fonction de la résolution de l’image d’entrée. Par exemple, supposons que vous avez deux images. La première image a une résolution de 1024 x 768 pixels. La deuxième image, une version redimensionnée de la première image, a une résolution de 640 x 480 pixels. Si vous soumettez les images à [DetectLabels](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectLabels.html), les réponses aux deux appels `DetectLabels` peuvent légèrement différer.

# Analyse d’images stockées dans un compartiment Amazon S3
<a name="images-s3"></a>

Image Amazon Rekognition peut analyser des images stockées dans un compartiment Amazon S3, ou des images fournies sous forme d’octets d’image.

Dans cette rubrique, vous utilisez l'opération [DetectLabels](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectLabels.html)API pour détecter des objets, des concepts et des scènes dans une image (JPEG ou PNG) stockée dans un compartiment Amazon S3. Pour transmettre une image à une opération d’API Image Amazon Rekognition, utilisez le paramètre d’entrée [Image](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_Image.html). Dans `Image`, vous spécifiez la propriété d’objet [S3Object](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_3Object.html) pour référencer une image stockée dans un compartiment S3. Il n’est pas nécessaire d’encoder en base64 les octets d’image pour les images stockées dans des compartiments Amazon S3. Pour de plus amples informations, veuillez consulter [Spécifications d’images](images-information.md). 

## Exemple de demande
<a name="images-s3-request"></a>

Dans cet exemple de demande JSON `DetectLabels`, l’image source (`input.jpg`) est chargée à partir d’un compartiment Amazon S3 nommé `amzn-s3-demo-bucket`. La région du compartiment S3 contenant l’objet S3 doit correspondre à la région que vous utilisez pour les opérations Image Amazon Rekognition.

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

Les exemples suivants utilisent various AWS SDKs et AWS CLI to call`DetectLabels`. Pour en savoir plus sur la réponse d’opération `DetectLabels`, consultez [DetectLabels réponse](labels-detect-labels-image.md#detectlabels-response).

**Pour détecter des étiquettes dans une image**

1. Si vous ne l’avez pas déjà fait :

   1. Créez ou mettez à jour un utilisateur avec `AmazonRekognitionFullAccess` et autorisations `AmazonS3ReadOnlyAccess`. Pour de plus amples informations, veuillez consulter [Étape 1 : configurer un compte AWS et créer un utilisateur](setting-up.md#setting-up-iam).

   1. Installez et configurez le AWS CLI et le AWS SDKs. Pour de plus amples informations, veuillez consulter [Étape 2 : configurer le AWS CLI et AWS SDKs](setup-awscli-sdk.md). Assurez-vous que vous avez accordé à l’utilisateur qui appelle les opérations d’API les autorisations appropriées pour l’accès par programmation. Consultez [Octroi d’un accès par programmation](sdk-programmatic-access.md) les instructions sur la procédure à suivre.

1. Chargez une image qui contient un ou plusieurs objets - par exemple des arbres, des maisons et un bateau - dans votre compartiment S3. L’image doit être au format *.jpg* ou *.png*.

   Pour en savoir plus, consultez [Chargement d’objets dans Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html) dans le *Guide de l’utilisateur Amazon Simple Storage Service*.

1. Utilisez les exemples suivants pour appeler l’opération `DetectLabels`.

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

   Cet exemple affiche la liste des étiquettes qui ont été détectées dans l’image d’entrée. Remplacez les valeurs de `bucket` et `photo` par le nom du compartiment Amazon S3 et le nom de l’image utilisés à l’étape 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 ]

   Cet exemple affiche la sortie JSON de l’opération `detect-labels` de l’interface de ligne de commande (CLI). Remplacez les valeurs de `bucket` et de `photo` par le nom du compartiment Amazon S3 et le nom de l’image utilisés à l’étape 2. Remplacez la valeur de `profile_name` dans la ligne qui crée la session de Rekognition par le nom de votre profil de développeur. 

   ```
   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
   ```

   Si vous utilisez Windows, vous devrez peut-être éviter les guillemets, comme indiqué dans l’exemple ci-dessous.

   ```
   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 ]

   Ce code est extrait du GitHub référentiel d'exemples du SDK de AWS documentation. Voir l’exemple complet [ici](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 ]

   Cet exemple affiche les étiquettes qui ont été détectées dans l’image d’entrée. Remplacez les valeurs de `bucket` et de `photo` par le nom du compartiment Amazon S3 et le nom de l’image utilisés à l’étape 2. Remplacez la valeur de `profile_name` dans la ligne qui crée la session de Rekognition par le nom de votre profil de développeur.

   ```
   #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 ]

   Cet exemple affiche des informations sur les étiquettes qui sont détectées dans une image. 

   Remplacez la valeur de `photo` par le chemin et le nom d’un fichier image qui contient un ou plusieurs visages de célébrités. Remplacez la valeur de `bucket` par le nom du compartiment S3 qui contient le fichier image. Remplacez la valeur de `REGION` par le nom de la région associée à votre utilisateur. Remplacez la valeur de `profile_name` dans la ligne qui crée la session de Rekognition par le nom de votre profil de développeur. 

   ```
   // 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 ]

   Cet exemple affiche la liste des étiquettes qui ont été détectées dans l’image d’entrée. Remplacez les valeurs de `bucket` et `photo` par le nom du compartiment Amazon S3 et le nom de l’image utilisés à l’étape 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 ]

   Cet exemple affiche la liste des étiquettes qui ont été détectées dans l’image d’entrée. Remplacez les valeurs de `bucket` et de `photo` par le nom du compartiment Amazon S3 et le nom de l’image utilisés à l’étape 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
   ```

------



## Exemple de réponse
<a name="images-s3-response"></a>

La réponse de `DetectLabels` est un tableau qui recense les étiquettes détectées dans l’image et qui indique le niveau de fiabilité de la détection. 

Lorsque vous effectuez l’opération `DetectLabels` sur une image, Amazon Rekognition renvoie un résultat similaire à l’exemple de réponse suivant.

La réponse montre que l’opération a détecté plusieurs étiquettes, notamment Person (Personne), Vehicle (Véhicule) et Car (Voiture). A chaque étiquette est associé un niveau de fiabilité. Par exemple, l’algorithme de détection est certain à 98,991432 % que l’image contient une personne.

La réponse comprend également les étiquettes d’ancêtre d’une étiquette dans le tableau `Parents`. Par exemple, l’étiquette Automobile possède deux étiquettes parents nommées Vehicle et Transportation. 

La réponse pour les étiquettes d’objets courants comprend des informations de cadre de délimitation pour l’emplacement de l’étiquette sur l’image d’entrée. Par exemple, l’étiquette Personne comporte un tableau d’instances contenant deux cadres de délimitation. Il s’agit des emplacements de deux personnes détectées dans l’image.

Le champ `LabelModelVersion` contient le numéro de version du modèle de détection utilisé par `DetectLabels`. 

Pour plus d’informations sur l’utilisation de l’opération `DetectLabels`, consultez [Détection d’objets et de concepts](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"
}

    
}
```

# Analyse d’une image chargée à partir d’un système de fichiers local
<a name="images-bytes"></a>

Les opérations Image Amazon Rekognition peuvent analyser les images fournies sous forme d’octets d’image ou les images stockées dans un compartiment Amazon S3.

Ces rubriques proposent des exemples où des octets d’image sont fournis aux opérations d’API Image Amazon Rekognition en utilisant un fichier chargé à partir d’un système de fichiers local. Pour transmettre des octets d’image à une opération d’API Amazon Rekognition, vous utilisez le paramètre d’entrée [Image](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_Image.html). Dans `Image`, vous spécifiez la propriété `Bytes` pour transmettre des octets d’image encodés en base64.

Les octets d’image transmis à une opération d’API Amazon Rekognition à l’aide du paramètre d’entrée `Bytes` doivent être encodés en base64. L'AWS SDKs que ces exemples utilisent automatiquement pour encoder les images en base64. Vous n’avez pas besoin de coder les octets d’image avant d’appeler une opération d’API Amazon Rekognition. Pour de plus amples informations, veuillez consulter [Spécifications d’images](images-information.md). 

Dans cet exemple de demande JSON `DetectLabels`, les octets d’image source sont transmis dans le paramètre d’entrée `Bytes`. 

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

Les exemples suivants utilisent various AWS SDKs et AWS CLI to call`DetectLabels`. Pour en savoir plus sur la réponse d’opération `DetectLabels`, consultez [DetectLabels réponse](labels-detect-labels-image.md#detectlabels-response).

Pour un JavaScript exemple côté client, voir. [En utilisant JavaScript](image-bytes-javascript.md)

**Pour détecter des étiquettes dans une image locale**

1. Si vous ne l’avez pas déjà fait :

   1. Créez ou mettez à jour un utilisateur avec `AmazonRekognitionFullAccess` et autorisations `AmazonS3ReadOnlyAccess`. Pour de plus amples informations, veuillez consulter [Étape 1 : configurer un compte AWS et créer un utilisateur](setting-up.md#setting-up-iam).

   1. Installez et configurez le AWS CLI et le AWS SDKs. Pour de plus amples informations, veuillez consulter [Étape 2 : configurer le AWS CLI et AWS SDKs](setup-awscli-sdk.md).

1. Utilisez les exemples suivants pour appeler l’opération `DetectLabels`.

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

   L’exemple Java suivant montre comment charger une image à partir du système de fichiers local et comment détecter les étiquettes à l’aide de l’opération [detectLabels](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/rekognition/model/DetectLabelsRequest.html) de l'AWS SDK. Remplacez la valeur de `photo` par le chemin et le nom d’un fichier image (au format .jpg ou .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 ]

   L’exemple [AWS SDK pour Python](https://aws.amazon.com/sdk-for-python/) suivant montre comment charger une image à partir du système de fichiers local et comment appeler l’opération [detect\$1labels](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/rekognition.html#Rekognition.Client.detect_labels). Remplacez la valeur de `photo` par le chemin et le nom d’un fichier image (au format .jpg ou .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 ]

   L’exemple suivant montre comment charger une image à partir du système de fichiers local et détecter les étiquettes à l’aide de l’opération `DetectLabels`. Remplacez la valeur de `photo` par le chemin et le nom d’un fichier image (au format .jpg ou .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 ]

   L'exemple de [SDK AWS pour](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/welcome.html#getting-started) PHP suivant montre comment charger une image depuis le système de fichiers local et appeler [DetectFaces](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-rekognition-2016-06-27.html#detectfaces)l'opération d'API. Remplacez la valeur de `photo` par le chemin et le nom d’un fichier image (au format .jpg ou .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 ]

   Cet exemple affiche la liste des étiquettes qui ont été détectées dans l’image d’entrée. Remplacez la valeur de `photo` par le chemin et le nom d’un fichier image (au format .jpg ou .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 ]

   Ce code est extrait du GitHub référentiel d'exemples du SDK de AWS documentation. Voir l’exemple complet [ici](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);
           }
       }
   }
   ```

------

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

L'exemple de JavaScript page Web suivant permet à un utilisateur de choisir une image et de visualiser l'âge estimé des visages détectés sur l'image. Les âges estimés sont renvoyés par un appel à [DetectFaces](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectFaces.html). 

L'image choisie est chargée à l'aide de la JavaScript `FileReader.readAsDataURL` fonction qui code l'image en base64. Cela permet d’afficher l’image sur un canevas HTML. Mais cela signifie que les octets d’image doivent être décodés avant d’être transmis à une opération Image Amazon Rekognition. Cet exemple montre comment décoder les octets d’image chargés. Si les octets d’image codés ne sont pas utiles pour vous, utilisez plutôt `FileReader.readAsArrayBuffer`, car l’image chargée n’est pas codée. Cela signifie que les opérations Image Amazon Rekognition peuvent être appelées sans que les octets d’image soient décodés au préalable. Pour obtenir un exemple, consultez [Utilisation de readAsArray Buffer](#image-bytes-javascript-unencoded).

**Pour exécuter l' JavaScript exemple**

1. Chargez l’exemple de code source dans un éditeur.

1. Obtenez l’ID de la réserve d'identités Amazon Cognito. Pour de plus amples informations, veuillez consulter [Obtenir l’ID de la réserve d'identités Amazon Cognito](#image-bytes-javascript-auth).

1. Dans la fonction `AnonLog` de l’exemple de code, remplacez `IdentityPoolIdToUse` et `RegionToUse` par les valeurs que vous avez notées à l’étape 9 de [Obtenir l’ID de la réserve d'identités Amazon Cognito](#image-bytes-javascript-auth). 

1. Dans la fonction `DetectFaces`, remplacez `RegionToUse` par la valeur que vous avez utilisée à l’étape précédente.

1. Enregistrez l’exemple de code source en tant que fichier `.html`.

1. Chargez le fichier dans votre navigateur.

1. Choisissez le bouton **Parcourir...**, puis choisissez une image qui contient un ou plusieurs visages. La table qui s’affiche contient les âges estimés pour chaque visage détecté dans l’image. 

**Note**  
L’exemple de code suivant utilise deux scripts qui ne font plus partie d’ Amazon Cognito. Pour obtenir ces fichiers, suivez les liens pour [ aws-cognito-sdk.min.js et [ 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), puis enregistrez le texte de chacun sous forme de fichiers séparés. `.js` 

## JavaScript exemple de code
<a name="image-bytes-javascript-code"></a>

L'exemple de code suivant utilise la JavaScript version V2. Pour un exemple dans la JavaScript version 3, consultez [l'exemple dans le référentiel d'exemples GitHub du SDK de AWS documentation](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/javascriptv3/example_code/rekognition/estimate-age-example/src).

```
<!--
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>
```

### Utilisation de readAsArray Buffer
<a name="image-bytes-javascript-unencoded"></a>

L'extrait de code suivant est une implémentation alternative de la `ProcessImage` fonction dans l'exemple de code, à l'aide JavaScript de la version V2. Il utilise `readAsArrayBuffer` pour charger une image et appeler `DetectFaces`. Comme `readAsArrayBuffer` n’encode pas le fichier chargé en base64, il n’est pas nécessaire de décoder les octets d’image avant d’appeler une opération Image 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);
  }
```

## Obtenir l’ID de la réserve d'identités Amazon Cognito
<a name="image-bytes-javascript-auth"></a>

Pour plus de simplicité, l’exemple utilise une réserve d'identités anonyme Amazon Cognito pour fournir un accès non authentifié à l’API Image Amazon Rekognition. Cela peut répondre à vos besoins. Par exemple, vous pouvez utiliser un accès non authentifié pour offrir un accès gratuit ou un accès test à votre site web avant que les utilisateurs ne s’inscrivent. Pour fournir un accès authentifié, utilisez un groupe d’utilisateurs Amazon Cognito. Pour plus d’informations, consultez [Groupe d’utilisateurs dans Amazon Cognito](https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools.html). 

La procédure suivante montre comment créer une réserve d'identités qui permet d’accéder à des identités non authentifiées, et comment obtenir l’identifiant de la réserve d'identités requis dans l’exemple de code.

**Pour obtenir l’identifiant de la réserve d'identités**

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

1. Sélectionnez **Create new identity pool**.

1. Pour **Identity pool name\$1** (Nom de la réserve d'identités\$1), tapez un nom pour votre réserve d'identités.

1. Dans **Identités non authentifiées**, choisissez **Activer l’accès aux identités non authentifiées**.

1. Sélectionnez **Créer une réserve**.

1. Choisissez **View Details** (Afficher les détails) et notez le nom du rôle pour les identités non authentifiées.

1. Sélectionnez **Allow (Autoriser)**.

1. Dans **Plateforme**, sélectionnez **JavaScript**.

1. Dans **Obtenir les informations d’identification AWS**, notez les valeurs de `AWS.config.region` et `IdentityPooldId` qui sont affichées dans l’extrait de code.

1. Ouvrez la console IAM à l’adresse [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. Dans le panneau de navigation, choisissez **Rôles**.

1. Choisissez le nom du rôle que vous avez noté à l’étape 6.

1. Dans l’onglet **Autorisations**, choisissez **Attacher des stratégies**.

1. Sélectionnez **AmazonRekognitionReadOnlyAccess**.

1. Choisissez **Attach Policy** (Attacher une politique).

# Affichage de cadres de délimitation
<a name="images-displaying-bounding-boxes"></a>

Les opérations Image Amazon Rekognition peuvent renvoyer les coordonnées des cadres de délimitation pour les éléments détectés dans les images. Par exemple, l'opération [DetectFaces](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectFaces.html) renvoie un cadre de délimitation ([BoundingBox](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_BoundingBox.html)) pour chaque visage détecté dans une image. Vous pouvez utiliser les coordonnées du cadre de délimitation pour afficher un cadre autour des éléments détectés. Par exemple, l’image suivante illustre un cadre de délimitation autour d’un visage.

![\[Jeune femme souriante portant des lunettes, entourée de bulles.\]](http://docs.aws.amazon.com/fr_fr/rekognition/latest/dg/images/face.png)


La propriété `BoundingBox` dispose des valeurs suivantes :
+ Height : hauteur du cadre de délimitation sous forme de ratio de la hauteur d’image globale.
+ Left : coordonnée gauche du cadre de délimitation sous forme de ratio de la largeur d’image globale.
+ Top : coordonnée supérieure du cadre de délimitation sous forme de ratio de la hauteur d’image globale.
+ Width : largeur du cadre de délimitation sous forme de ratio de la largeur d’image globale.

Chaque BoundingBox propriété possède une valeur comprise entre 0 et 1. Chaque valeur de propriété est un ratio de la largeur d’image globale (`Left` et `Width`) ou de la hauteur d’image globale (`Height` et `Top`). Par exemple, si l’image d’entrée a une résolution de 700 x 200 pixels, et que la coordonnée supérieure gauche du cadre de délimitation est de 350 x 50 pixels, l’API renvoie une valeur `Left` de 0,5 (350/700) et une valeur `Top` de 0,25 (50/200). 

Le schéma suivant illustre la plage d’une image couverte par chaque propriété du cadre de délimitation.

![\[Graphique illustrant le lien entre un cadre de sélection et les dimensions d'une image.\]](http://docs.aws.amazon.com/fr_fr/rekognition/latest/dg/images/bounding-box.png)


Pour afficher le cadre de sélection à l'emplacement et à la taille corrects, vous devez multiplier les BoundingBox valeurs par la largeur ou la hauteur de l'image (selon la valeur souhaitée) pour obtenir les valeurs en pixels. Vous utilisez les valeurs en pixels pour afficher le cadre de délimitation. Par exemple, les dimensions en pixels de l’image précédente sont de 608 (largeur) x 588 (hauteur). Les valeurs du cadre de délimitation pour le visage sont les suivantes : 

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

L’emplacement du cadre de délimitation du visage en pixels est calculé comme suit : 

`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`

Vous utilisez ces valeurs pour afficher un cadre de délimitation autour du visage.

**Note**  
Une image peut être orientée de diverses manières. Pour qu’une image s’affiche avec l’orientation corrigée, il se peut que l’application ait besoin de la faire pivoter. Les coordonnées du cadre de délimitation sont affectées par l’orientation de l’image. Vous aurez peut-être besoin de convertir les coordonnées pour pouvoir afficher un cadre de délimitation à l’emplacement approprié. Pour de plus amples informations, veuillez consulter [Obtention de l’orientation d’une image et des coordonnées du cadre de délimitation](images-orientation.md).

Les exemples suivants indiquent comment afficher un cadre de délimitation autour de visages détectés en appelant [DetectFaces](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectFaces.html). Les exemples supposent que l’orientation des images est de 0 degré. Ils montrent aussi comment télécharger l’image à partir d’un compartiment Amazon S3. 

**Pour afficher un cadre de délimitation**

1. Si vous ne l’avez pas déjà fait :

   1. Créez ou mettez à jour un utilisateur avec `AmazonRekognitionFullAccess` et autorisations `AmazonS3ReadOnlyAccess`. Pour de plus amples informations, veuillez consulter [Étape 1 : configurer un compte AWS et créer un utilisateur](setting-up.md#setting-up-iam).

   1. Installez et configurez le AWS CLI et le AWS SDKs. Pour de plus amples informations, veuillez consulter [Étape 2 : configurer le AWS CLI et AWS SDKs](setup-awscli-sdk.md).

1. Utilisez les exemples suivants pour appeler l’opération `DetectFaces`.

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

   Remplacez la valeur de `bucket` par le compartiment Amazon S3 qui contient le fichier image. Remplacez la valeur de `photo` par le nom d’un fichier image (au format .jpg ou .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 ]

   Remplacez la valeur de `bucket` par le compartiment Amazon S3 qui contient le fichier image. Remplacez la valeur de `photo` par le nom d’un fichier image (au format .jpg ou .png). Remplacez la valeur de `profile_name` dans la ligne qui crée la session de Rekognition par le nom de votre profil de développeur.

   ```
   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 ]

   Ce code est extrait du GitHub référentiel d'exemples du SDK de AWS documentation. Voir l’exemple complet [ici](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javav2/example_code/rekognition/src/main/java/com/example/rekognition/DisplayFacesFrame.java).

   Notez que `s3` fait référence au client Amazon S3 de l'AWS SDK et `rekClient` au client Amazon Rekognition de l'AWS SDK. 

   ```
   //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]
   }
   ```

------

# Obtention de l’orientation d’une image et des coordonnées du cadre de délimitation
<a name="images-orientation"></a>

Il est courant que les applications qui utilisent Image Amazon Rekognition soient appelées à afficher les images détectées par les opérations Image Amazon Rekognition et les cadres entourant les visages détectés. Pour afficher correctement une image dans votre application, vous devez connaître son orientation. Vous devez peut-être corriger cette orientation. Pour certains fichiers .jpg, l’orientation de l’image est contenue dans ses métadonnées Exif (Exchangeable Image File Format). 

Pour afficher un cadre autour d’un visage, vous avez besoin des coordonnées du cadre de délimitation du visage. Si la boîte n’est pas orientée correctement, vous devez peut-être ajuster ces coordonnées. Les opérations de détection de visages Image Amazon Rekognition renvoient les coordonnées du cadre de délimitation pour chaque visage détecté, mais elles n’estiment pas les coordonnées des fichiers .jpg sans métadonnées Exif.

Les exemples suivants montrent comment obtenir les coordonnées des cadres de délimitation des visages détectés dans une image.

Servez-vous de cet exemple pour déterminer si vos images sont correctement orientées et si les cadres de délimitation sont affichés à l’emplacement approprié dans votre application. 

Comme le code permettant de faire pivoter et d’afficher les images et les cadres de délimitation dépend du langage et de l’environnement utilisés, nous n’expliquons pas comment afficher les images et les cadres de délimitation dans votre code ni comment obtenir les informations d’orientation à partir des métadonnées Exif.



## Détermination de l’orientation d’une image
<a name="images-discovering-image-orientation"></a>

Pour qu’une image s’affiche correctement dans votre application, il peut être nécessaire de la faire pivoter. L’image suivante présente une orientation de 0 degré et est correctement affichée.

![\[Icône de profil générique représentant un compte utilisateur ou une image de profil.\]](http://docs.aws.amazon.com/fr_fr/rekognition/latest/dg/images/00face.png)


Cependant, l’image suivante a faire l’objet d’une rotation de 90 degrés dans le sens inverse des aiguilles d’une montre. Pour l’afficher correctement, vous devez déterminer l’orientation de l’image et utiliser ces informations dans votre code pour la faire pivoter à 0 degré. 

![\[Icône de profil générique représentant un compte utilisateur ou une image de profil, pivotée de 90 degrés dans le sens antihoraire.\]](http://docs.aws.amazon.com/fr_fr/rekognition/latest/dg/images/90face.png)


Pour certaines images au format .jpg, les informations d’orientation sont contenues dans leurs métadonnées Exif. Si elles sont disponibles, les métadonnées Exif de l’image contiennent l’orientation. Dans les métadonnées Exif, l’orientation de l’image est indiquée dans le champ `orientation`. Même si Image Amazon Rekognition identifie la présence d’informations sur l’orientation de l’image dans les métadonnées Exif, il n’y donne pas accès. Pour accéder aux métadonnées Exif d’une image, vous devez utiliser une bibliothèque tierce ou écrire votre propre code. Pour en savoir plus, consultez [Exif Version 2.32](http://cipa.jp/std/documents/download_e.html?DC-008-Translation-2019-E).

 



Du moment où vous connaissez l’orientation d’une image, vous pouvez écrire du code pour la faire pivoter et l’afficher correctement.

## Affichage de cadres de délimitation
<a name="images-bounding-boxes"></a>

Les opérations Image Amazon Rekognition qui analysent les visages dans une image renvoient également les coordonnées des cadres de délimitation qui entourent les visages. Pour de plus amples informations, veuillez consulter [BoundingBox](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_BoundingBox.html). 

Pour afficher un cadre de délimitation autour d’un visage, à l’instar de celui figurant dans l’image suivante, dans votre application, utilisez les coordonnées de ce cadre dans votre code. Les coordonnées du cadre de délimitation renvoyées par une opération reflètent l’orientation de l’image. Si vous devez faire pivoter l’image pour l’afficher correctement, vous pouvez être amené à traduire les coordonnées du cadre de délimitation.



![\[Icône de profil avec le visage surligné dans un carré rouge.\]](http://docs.aws.amazon.com/fr_fr/rekognition/latest/dg/images/00facebounding.png)




### Affichage des cadres de délimitation en présence d’informations d’orientation dans les métadonnées Exif
<a name="images-exif-metadata"></a>

Si l’orientation d’une image est incluse dans les métadonnées Exif, les opérations Image Amazon Rekognition produisent les résultats suivants :
+ Retour de la valeur null dans le champ de correction de l’orientation dans la réponse de l’opération. Pour faire pivoter l’image, utilisez l’orientation fournie dans les métadonnées Exif dans votre code.
+ Retour des coordonnées du cadre de délimitation qui présente déjà une orientation de 0 degré. Pour afficher le cadre de délimitation à l’emplacement approprié, utilisez les coordonnées renvoyées. Vous n’avez pas besoin de les traduire.

## Exemple : obtention de l’orientation d’une image et des coordonnées du cadre de délimitation associé
<a name="images-correcting-image-orientation-java"></a>

L’exemple suivant montre comment utiliser l’AWS SDK pour obtenir l’orientation d’une image Exif et les coordonnées des cadres de délimitation des célébrités détectées par l’opération `RecognizeCelebrities`.

**Note**  
L’assistance pour estimer l’orientation de l’image à l’aide du champ `OrientationCorrection` a cessé en août 2021. Toutes les valeurs renvoyées pour ce champ inclus dans une réponse d’API seront toujours NULL.

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

Cet exemple charge une image à partir du système de fichiers local, appelle l’opération `RecognizeCelebrities`, détermine la hauteur et la largeur de l’image et calcule enfin les coordonnées du cadre de délimitation du visage pour l’image ayant fait l’objet d’une rotation. L’exemple ne montre pas comment traiter les informations d’orientation stockées dans les métadonnées Exif.

Dans la fonction `main`, remplacez la valeur de `photo` par le nom et le chemin d’une image stockée localement au format .png ou .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 ]

Cet exemple utilise la bibliothèque PIL/Pillow d'images pour obtenir la largeur et la hauteur de l'image. Pour en savoir plus, consultez [Pillow](https://pillow.readthedocs.io/en/stable/). Cet exemple conserve les métadonnées Exif, dont vous pourriez avoir besoin ailleurs dans votre application.

Dans la fonction `main`, remplacez la valeur de `photo` par le nom et le chemin d’une image stockée localement au format .png ou .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 ]

Ce code est extrait du GitHub référentiel d'exemples du SDK de AWS documentation. Voir l’exemple complet [ici](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()));
    }
}
```

------