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.

# Tracé du parcours de personnes
<a name="persons"></a>

**Note**  
*Avis de fin de support :* le 31 octobre 2025, AWS cessera de prendre en charge Amazon Rekognition People Pathing. Après le 31 octobre 2025, vous ne pourrez plus utiliser la fonctionnalité Rekognition People Pathing. Pour plus d'informations, consultez ce billet de [blog](https://aws.amazon.com/blogs/machine-learning/transitioning-from-amazon-rekognition-people-pathing-exploring-other-alternatives/).

Vidéo Amazon Rekognition peut créer un suivi des chemins empruntés par les personnes dans les vidéos et fournir des informations telles que : 
+ Emplacement de la personne dans le cadre vidéo au moment où son chemin fait l’objet d’un suivi.
+ Des repères faciaux tels que la position de l’œil gauche, lorsqu’ils sont détectés. 

Le tracé du parcours des personnes par Vidéo Amazon Rekognition dans les vidéos stockées est une opération asynchrone. Pour commencer à suivre le chemin des personnes dans les vidéos, appelez [StartPersonTracking](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_StartPersonTracking.html). Vidéo Amazon Rekognition publie l’état d’achèvement de l’opération d’analyse vidéo dans une rubrique Amazon Simple Notification Service. Si l'analyse vidéo est réussie, appelez [GetPersonTracking](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_GetPersonTracking.html)pour obtenir les résultats de l'analyse vidéo. Pour en savoir plus sur les appels d’opérations d’API Vidéo Amazon Rekognition consultez [Appeler les opérations de Vidéo Amazon Rekognition](api-video.md). 

La procédure suivante montre comment suivre le chemin des personnes via une vidéo stockée dans un compartiment Amazon S3. L’exemple s’appuie sur le code figurant dans [Analyse d’une vidéo stockée dans un compartiment Amazon S3 avec Java or Python (SDK)](video-analyzing-with-sqs.md), qui utilise une file d’attente Amazon Simple Queue Service pour obtenir le statut d’achèvement d’une demande d’analyse vidéo. 

**Pour détecter des personnes dans une vidéo stockée dans un compartiment Amazon S3 (SDK)**

1. Effectuez une [Analyse d’une vidéo stockée dans un compartiment Amazon S3 avec Java or Python (SDK)](video-analyzing-with-sqs.md).

1. Ajoutez le code suivant à la classe `VideoDetect` que vous avez créée à l’étape 1.

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

   ```
          //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.)
   
           //Persons========================================================================
           private static void StartPersonDetection(String bucket, String video) throws Exception{
               
               
               NotificationChannel channel= new NotificationChannel()
                       .withSNSTopicArn(snsTopicArn)
                       .withRoleArn(roleArn);
               
            StartPersonTrackingRequest req = new StartPersonTrackingRequest()
                    .withVideo(new Video()
                            .withS3Object(new S3Object()
                                .withBucket(bucket)
                                .withName(video)))
                    .withNotificationChannel(channel);
                                   
                
               
            StartPersonTrackingResult startPersonDetectionResult = rek.startPersonTracking(req);
            startJobId=startPersonDetectionResult.getJobId();
               
           } 
           
           private static void GetPersonDetectionResults() throws Exception{
               int maxResults=10;
               String paginationToken=null;
               GetPersonTrackingResult personTrackingResult=null;
               
               do{
                   if (personTrackingResult !=null){
                       paginationToken = personTrackingResult.getNextToken();
                   }
                   
                   personTrackingResult = rek.getPersonTracking(new GetPersonTrackingRequest()
                        .withJobId(startJobId)
                        .withNextToken(paginationToken)
                        .withSortBy(PersonTrackingSortBy.TIMESTAMP)
                        .withMaxResults(maxResults));
             
                   VideoMetadata videoMetaData=personTrackingResult.getVideoMetadata();
                       
                   System.out.println("Format: " + videoMetaData.getFormat());
                   System.out.println("Codec: " + videoMetaData.getCodec());
                   System.out.println("Duration: " + videoMetaData.getDurationMillis());
                   System.out.println("FrameRate: " + videoMetaData.getFrameRate());
                       
                       
                   //Show persons, confidence and detection times
                   List<PersonDetection> detectedPersons= personTrackingResult.getPersons();
                
                   for (PersonDetection detectedPerson: detectedPersons) { 
                       
                      long seconds=detectedPerson.getTimestamp()/1000;
                      System.out.print("Sec: " + Long.toString(seconds) + " ");
                      System.out.println("Person Identifier: "  + detectedPerson.getPerson().getIndex());
                         System.out.println();             
                   }
               }  while (personTrackingResult !=null && personTrackingResult.getNextToken() != null);
               
           }
   ```

   Dans la fonction `main`, remplacez les lignes : 

   ```
           StartLabelDetection(amzn-s3-demo-bucket, video);
   
           if (GetSQSMessageSuccess()==true)
           	GetLabelDetectionResults();
   ```

   avec :

   ```
           StartPersonDetection(amzn-s3-demo-bucket, video);
   
           if (GetSQSMessageSuccess()==true)
           	GetPersonDetectionResults();
   ```

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

   ```
   import software.amazon.awssdk.regions.Region;
   import software.amazon.awssdk.services.rekognition.RekognitionClient;
   import software.amazon.awssdk.services.rekognition.model.S3Object;
   import software.amazon.awssdk.services.rekognition.model.NotificationChannel;
   import software.amazon.awssdk.services.rekognition.model.StartPersonTrackingRequest;
   import software.amazon.awssdk.services.rekognition.model.Video;
   import software.amazon.awssdk.services.rekognition.model.StartPersonTrackingResponse;
   import software.amazon.awssdk.services.rekognition.model.RekognitionException;
   import software.amazon.awssdk.services.rekognition.model.GetPersonTrackingResponse;
   import software.amazon.awssdk.services.rekognition.model.GetPersonTrackingRequest;
   import software.amazon.awssdk.services.rekognition.model.VideoMetadata;
   import software.amazon.awssdk.services.rekognition.model.PersonDetection;
   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 VideoPersonDetection {
       private static String startJobId = "";
   
       public static void main(String[] args) {
   
           final String usage = """
   
                   Usage:    <bucket> <video> <topicArn> <roleArn>
   
                   Where:
                      bucket - The name of the bucket in which the video is located (for example, (for example, myBucket).\s
                      video - The name of video (for example, people.mp4).\s
                      topicArn - The ARN of the Amazon Simple Notification Service (Amazon SNS) topic.\s
                      roleArn - The ARN of the AWS Identity and Access Management (IAM) role to use.\s
                   """;
   
           if (args.length != 4) {
               System.out.println(usage);
               System.exit(1);
           }
   
           String bucket = args[0];
           String video = args[1];
           String topicArn = args[2];
           String roleArn = args[3];
           Region region = Region.US_EAST_1;
           RekognitionClient rekClient = RekognitionClient.builder()
                   .region(region)
                   .build();
   
           NotificationChannel channel = NotificationChannel.builder()
                   .snsTopicArn(topicArn)
                   .roleArn(roleArn)
                   .build();
   
           startPersonLabels(rekClient, channel, bucket, video);
           getPersonDetectionResults(rekClient);
           System.out.println("This example is done!");
           rekClient.close();
       }
   
       public static void startPersonLabels(RekognitionClient rekClient,
               NotificationChannel channel,
               String bucket,
               String video) {
           try {
               S3Object s3Obj = S3Object.builder()
                       .bucket(bucket)
                       .name(video)
                       .build();
   
               Video vidOb = Video.builder()
                       .s3Object(s3Obj)
                       .build();
   
               StartPersonTrackingRequest personTrackingRequest = StartPersonTrackingRequest.builder()
                       .jobTag("DetectingLabels")
                       .video(vidOb)
                       .notificationChannel(channel)
                       .build();
   
               StartPersonTrackingResponse labelDetectionResponse = rekClient.startPersonTracking(personTrackingRequest);
               startJobId = labelDetectionResponse.jobId();
   
           } catch (RekognitionException e) {
               System.out.println(e.getMessage());
               System.exit(1);
           }
       }
   
       public static void getPersonDetectionResults(RekognitionClient rekClient) {
           try {
               String paginationToken = null;
               GetPersonTrackingResponse personTrackingResult = null;
               boolean finished = false;
               String status;
               int yy = 0;
   
               do {
                   if (personTrackingResult != null)
                       paginationToken = personTrackingResult.nextToken();
   
                   GetPersonTrackingRequest recognitionRequest = GetPersonTrackingRequest.builder()
                           .jobId(startJobId)
                           .nextToken(paginationToken)
                           .maxResults(10)
                           .build();
   
                   // Wait until the job succeeds
                   while (!finished) {
   
                       personTrackingResult = rekClient.getPersonTracking(recognitionRequest);
                       status = personTrackingResult.jobStatusAsString();
   
                       if (status.compareTo("SUCCEEDED") == 0)
                           finished = true;
                       else {
                           System.out.println(yy + " status is: " + status);
                           Thread.sleep(1000);
                       }
                       yy++;
                   }
   
                   finished = false;
   
                   // Proceed when the job is done - otherwise VideoMetadata is null.
                   VideoMetadata videoMetaData = personTrackingResult.videoMetadata();
   
                   System.out.println("Format: " + videoMetaData.format());
                   System.out.println("Codec: " + videoMetaData.codec());
                   System.out.println("Duration: " + videoMetaData.durationMillis());
                   System.out.println("FrameRate: " + videoMetaData.frameRate());
                   System.out.println("Job");
   
                   List<PersonDetection> detectedPersons = personTrackingResult.persons();
                   for (PersonDetection detectedPerson : detectedPersons) {
                       long seconds = detectedPerson.timestamp() / 1000;
                       System.out.print("Sec: " + seconds + " ");
                       System.out.println("Person Identifier: " + detectedPerson.person().index());
                       System.out.println();
                   }
   
               } while (personTrackingResult != null && personTrackingResult.nextToken() != null);
   
           } catch (RekognitionException | InterruptedException e) {
               System.out.println(e.getMessage());
               System.exit(1);
           }
       }
   }
   ```

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

   ```
   #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.)
   
       # ============== People pathing ===============  
       def StartPersonPathing(self):
           response=self.rek.start_person_tracking(Video={'S3Object': {'Bucket': self.bucket, 'Name': self.video}},
               NotificationChannel={'RoleArn': self.roleArn, 'SNSTopicArn': self.snsTopicArn})
   
           self.startJobId=response['JobId']
           print('Start Job Id: ' + self.startJobId)
       
       def GetPersonPathingResults(self):
           maxResults = 10
           paginationToken = ''
           finished = False
   
           while finished == False:
               response = self.rek.get_person_tracking(JobId=self.startJobId,
                                               MaxResults=maxResults,
                                               NextToken=paginationToken)
   
               print('Codec: ' + response['VideoMetadata']['Codec'])
               print('Duration: ' + str(response['VideoMetadata']['DurationMillis']))
               print('Format: ' + response['VideoMetadata']['Format'])
               print('Frame rate: ' + str(response['VideoMetadata']['FrameRate']))
               print()
   
               for personDetection in response['Persons']:
                   print('Index: ' + str(personDetection['Person']['Index']))
                   print('Timestamp: ' + str(personDetection['Timestamp']))
                   print()
   
               if 'NextToken' in response:
                   paginationToken = response['NextToken']
               else:
                   finished = True
   ```

   Dans la fonction `main`, remplacez les lignes :

   ```
       analyzer.StartLabelDetection()
       if analyzer.GetSQSMessageSuccess()==True:
           analyzer.GetLabelDetectionResults()
   ```

   avec :

   ```
       analyzer.StartPersonPathing()
       if analyzer.GetSQSMessageSuccess()==True:
           analyzer.GetPersonPathingResults()
   ```

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

   Exécutez la AWS CLI commande suivante pour démarrer le suivi des utilisateurs dans une vidéo.

   ```
   aws rekognition start-person-tracking --video "{"S3Object":{"Bucket":"amzn-s3-demo-bucket","Name":"video-name"}}" \ 
   --notification-channel "{"SNSTopicArn":"topic-ARN","RoleArn":"role-ARN"}" \
   --region region-name --profile profile-name
   ```

   Mettez à jour les valeurs suivantes :
   + Remplacez `amzn-s3-demo-bucket` et `video-name` par le nom du compartiment Amazon S3 et le nom du fichier que vous avez spécifiés à l’étape 2.
   + Remplacez `region-name` par la région AWS que vous utilisez.
   + 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.
   + Remplacez `topic-ARN` par l’ARN de la rubrique Amazon SNS que vous avez créée à l’étape 3 de [Configuration de Vidéo Amazon Rekognition](api-video-roles.md).
   + Remplacez `role-ARN` par l’ARN de la fonction de service IAM que vous avez créé à l’étape 7 de [Configuration de Vidéo Amazon Rekognition](api-video-roles.md).

   Si vous accédez à la CLI sur un périphérique Windows, utilisez des guillemets doubles au lieu de guillemets simples et évitez les guillemets doubles internes par une barre oblique inverse (c’est-à-dire \$1) pour corriger les erreurs d’analyse que vous pourriez rencontrer. Pour un exemple, voir ci-dessous : 

   ```
   aws rekognition start-person-tracking --video "{\"S3Object\":{\"Bucket\":\"amzn-s3-demo-bucket\",\"Name\":\"video-name\"}}" 
   --notification-channel "{\"SNSTopicArn\":\"topic-ARN\",\"RoleArn\":\"role-ARN\"}" \
   --region region-name --profile profile-name
   ```

   Après avoir exécuté l’exemple de code suivant, copiez l’`jobID` renvoyé et saisissez-le dans la commande suivante `GetPersonTracking` pour obtenir vos résultats, en remplaçant `job-id-number` par `jobID` que vous avez reçu précédemment : 

   ```
   aws rekognition get-person-tracking --job-id job-id-number                                
   ```

------
**Note**  
Si vous avez déjà exécuté un exemple vidéo autre que [Analyse d’une vidéo stockée dans un compartiment Amazon S3 avec Java or Python (SDK)](video-analyzing-with-sqs.md), le code à remplacer peut être différent.

1. Exécutez le code. Les identifiants uniques des personnes suivies s’affichent avec le moment, en secondes, où les chemins des personnes ont été suivis.

## GetPersonTracking réponse à l'opération
<a name="getresultspersons-operation-response"></a>

`GetPersonTracking` renvoie un tableau `Persons` constitué d'objets [PersonDetection](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_PersonDetection.html) qui contiennent des informations sur les personnes détectées dans la vidéo et sur les moments où leurs chemins sont suivis. 

Vous pouvez trier `Persons` à l’aide du paramètre d’entrée `SortBy`. Spécifiez `TIMESTAMP` pour trier les éléments en fonction du moment où les chemins des personnes sont suivis dans la vidéo. Spécifiez `INDEX` pour effectuer un tri en fonction des personnes suivies dans la vidéo. Dans chaque ensemble de résultats relatifs à une personne, les éléments sont triés par ordre décroissant de fiabilité de la précision du suivi de chemin. Par défaut, `Persons` est renvoyé trié par `TIMESTAMP`. L’exemple suivant constitue la réponse JSON de `GetPersonDetection`. Les résultats sont triés en fonction du moment, en millisecondes depuis le début de la vidéo, où les chemins des personnes sont suivis dans la vidéo. Dans la réponse, notez les points suivants :
+ **Informations sur la personne** : l’élément de tableau `PersonDetection` contient des informations sur la personne détectée. Par exemple, le moment où la personne a été détectée (`Timestamp`), la position de la personne dans le cadre vidéo au moment où elle a été détectée (`BoundingBox`), ainsi que le niveau de fiabilité de Vidéo Amazon Rekognition quant à la précision de la détection de la personne (`Confidence`).

  Les caractéristiques faciales ne sont pas retournées à chaque moment horodaté où le chemin de la personne est suivi. En outre, dans certaines circonstances, le corps d’une personne suivie peut ne pas être visible. Dans ce cas, seul l’emplacement du visage est renvoyé.
+ **Informations sur la pagination** : l’exemple montre une page d’informations sur la détection de personne. Vous pouvez spécifier le nombre d’éléments de personne à renvoyer dans le paramètre d’entrée `MaxResults` pour `GetPersonTracking`. Si le nombre de résultats est supérieur à `MaxResults`, `GetPersonTracking` renvoie un jeton (`NextToken`) utilisé pour obtenir la page de résultats suivante. Pour de plus amples informations, veuillez consulter [Obtenir les résultats de l’analyse de Vidéo Amazon Rekognition](api-video.md#api-video-get).
+ **Index** : identifiant unique pour l’identification de la personne tout au long de la vidéo. 
+ **Informations sur la vidéo** : la réponse comprend des informations sur le format de la vidéo (`VideoMetadata`) dans chaque page d’informations renvoyée par `GetPersonDetection`.

```
{
    "JobStatus": "SUCCEEDED",
    "NextToken": "AcDymG0fSSoaI6+BBYpka5wVlqttysSPP8VvWcujMDluj1QpFo/vf+mrMoqBGk8eUEiFlllR6g==",
    "Persons": [
        {
            "Person": {
                "BoundingBox": {
                    "Height": 0.8787037134170532,
                    "Left": 0.00572916679084301,
                    "Top": 0.12129629403352737,
                    "Width": 0.21666666865348816
                },
                "Face": {
                    "BoundingBox": {
                        "Height": 0.20000000298023224,
                        "Left": 0.029999999329447746,
                        "Top": 0.2199999988079071,
                        "Width": 0.11249999701976776
                    },
                    "Confidence": 99.85971069335938,
                    "Landmarks": [
                        {
                            "Type": "eyeLeft",
                            "X": 0.06842322647571564,
                            "Y": 0.3010137975215912
                        },
                        {
                            "Type": "eyeRight",
                            "X": 0.10543643683195114,
                            "Y": 0.29697132110595703
                        },
                        {
                            "Type": "nose",
                            "X": 0.09569807350635529,
                            "Y": 0.33701086044311523
                        },
                        {
                            "Type": "mouthLeft",
                            "X": 0.0732642263174057,
                            "Y": 0.3757539987564087
                        },
                        {
                            "Type": "mouthRight",
                            "X": 0.10589495301246643,
                            "Y": 0.3722417950630188
                        }
                    ],
                    "Pose": {
                        "Pitch": -0.5589138865470886,
                        "Roll": -5.1093974113464355,
                        "Yaw": 18.69594955444336
                    },
                    "Quality": {
                        "Brightness": 43.052337646484375,
                        "Sharpness": 99.68138885498047
                    }
                },
                "Index": 0
            },
            "Timestamp": 0
        },
        {
            "Person": {
                "BoundingBox": {
                    "Height": 0.9074074029922485,
                    "Left": 0.24791666865348816,
                    "Top": 0.09259258955717087,
                    "Width": 0.375
                },
                "Face": {
                    "BoundingBox": {
                        "Height": 0.23000000417232513,
                        "Left": 0.42500001192092896,
                        "Top": 0.16333332657814026,
                        "Width": 0.12937499582767487
                    },
                    "Confidence": 99.97504425048828,
                    "Landmarks": [
                        {
                            "Type": "eyeLeft",
                            "X": 0.46415066719055176,
                            "Y": 0.2572723925113678
                        },
                        {
                            "Type": "eyeRight",
                            "X": 0.5068183541297913,
                            "Y": 0.23705792427062988
                        },
                        {
                            "Type": "nose",
                            "X": 0.49765899777412415,
                            "Y": 0.28383663296699524
                        },
                        {
                            "Type": "mouthLeft",
                            "X": 0.487221896648407,
                            "Y": 0.3452930748462677
                        },
                        {
                            "Type": "mouthRight",
                            "X": 0.5142884850502014,
                            "Y": 0.33167609572410583
                        }
                    ],
                    "Pose": {
                        "Pitch": 15.966927528381348,
                        "Roll": -15.547388076782227,
                        "Yaw": 11.34195613861084
                    },
                    "Quality": {
                        "Brightness": 44.80223083496094,
                        "Sharpness": 99.95819854736328
                    }
                },
                "Index": 1
            },
            "Timestamp": 0
        }.....

    ],
    "VideoMetadata": {
        "Codec": "h264",
        "DurationMillis": 67301,
        "FileExtension": "mp4",
        "Format": "QuickTime / MOV",
        "FrameHeight": 1080,
        "FrameRate": 29.970029830932617,
        "FrameWidth": 1920
    }
}
```