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.
# Détection des équipements de protection individuelle
Amazon Rekognition peut détecter les équipements de protection individuelle (EPI) portés par des personnes sur une image. Vous pouvez utiliser ces informations pour améliorer les pratiques de sécurité au travail. Par exemple, vous pouvez utiliser la détection des EPI pour déterminer si les travailleurs d’un chantier de construction portent des couvre-chefs ou si le personnel médical porte des couvre-visages et des couvre-mains. L'image suivante montre certains types d’EPI qui peuvent être détectés.
![\[Travailleur portant un équipement de protection individuelle, notamment un casque, des lunettes de sécurité, un masque de protection et des gants, et utilisant un outil électrique. Encadrer des boîtes autour des objets.\]](http://docs.aws.amazon.com/fr_fr/rekognition/latest/dg/images/worker-with-bb.png)
Pour détecter le PPE dans une image, vous devez appeler l'[DetectProtectiveEquipment](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectProtectiveEquipment.html)API et transmettre une image d'entrée. La réponse est une structure JSON qui inclut les éléments suivants.
+ Les personnes détectées sur l’image.
+ Parties du corps où l’EPI est porté (visage, tête, main gauche et main droite).
+ Les types d’EPI détectés sur des parties du corps (couvre-visage, couvre-mains et couvre-tête).
+ Pour les articles d’EPI détectés, un indicateur montrant si l’EPI couvre ou non la partie du corps correspondante.
Des cadres de délimitation sont renvoyés pour indiquer l’emplacement des personnes et des articles d’EPI détectés sur l’image.
Vous pouvez éventuellement demander un résumé des articles de protection individuelle et des personnes détectés sur une image. Pour de plus amples informations, veuillez consulter [Présentation des EPI détectés dans une image](#ppe-summarization).
**Note**
La détection Amazon Rekognition EPI n’effectue pas de reconnaissance faciale ni de comparaison faciale, et ne permet pas d’identifier les personnes détectées.
## Types d’EPI
[DetectProtectiveEquipment](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectProtectiveEquipment.html)détecte les types d'EPI suivants. Si vous souhaitez détecter d’autres types d’EPI dans les images, pensez à utiliser Étiquettes personnalisées Amazon Rekognition pour créer un modèle personnalisé. Pour de plus amples informations, veuillez consulter [Étiquettes personnalisées Amazon Rekognition](https://docs.aws.amazon.com/rekognition/latest/customlabels-dg/what-is.html).
### Couvre-visage
`DetectProtectiveEquipment` peut détecter les masques faciaux courants tels que les masques chirurgicaux, les masques N95 et les masques en tissu.
### Couvre-main
`DetectProtectiveEquipment` peut détecter les couvre-mains tels que les gants chirurgicaux et les gants de sécurité.
### Couvre-tête
`DetectProtectiveEquipment` peut détecter les casques de sécurité et les casques.
L’API indique qu’une tête, une main ou un masque facial ont été détectés sur une image. L’API ne renvoie aucune information sur le type de protection spécifique. Par exemple, un « gant chirurgical » pour le type de couvre-main.
## Fiabilité de détection des EPI
Amazon Rekognition prédit la présence d'EPI, de personnes et de parties du corps sur une image. L’API fournit un score (50-100) qui indique le niveau de confiance d’Amazon Rekognition quant à l’exactitude d’une prédiction.
**Note**
Si vous prévoyez d’utiliser l’opération `DetectProtectiveEquipment` pour prendre une décision qui a une incidence sur les droits, la confidentialité ou l’accès aux services d’une personne, nous vous recommandons de transmettre le résultat à un humain pour examen et validation avant de passer à l’action.
## Présentation des EPI détectés dans une image
Vous pouvez éventuellement demander un résumé des articles de protection individuelle et des personnes détectés sur une image. Vous pouvez spécifier une liste des équipements de protection requis (couvre-visage, couvre-main ou couvre-chef) et un seuil de confiance minimum (par exemple, 80 %). La réponse inclut un résumé consolidé par identifiant (ID) par image des personnes possédant l’EPI requis, des personnes n’ayant pas l’EPI requis et des personnes pour lesquelles aucune détermination n’a pu être prise.
Le résumé vous permet de répondre rapidement à des questions telles que *Combien de personnes ne portent pas de couvre-visage ?* ou *Est-ce que tout le monde porte un EPI ?* Chaque personne détectée dans le résumé a un identifiant unique. Vous pouvez utiliser l’identifiant pour obtenir des informations telles que l’emplacement du cadre de délimitation d’une personne ne portant pas d’EPI.
**Note**
L’identifiant est généré de manière aléatoire sur la base d’une analyse par image et n’est pas cohérent entre les images ou les analyses multiples de la même image.
Vous pouvez résumer les couvre-visages, les couvre-chefs, les couvre-mains ou une combinaison de votre choix. Pour spécifier les types d’EPI requis, voir [Spécifier les exigences de synthèse](ppe-request-response.md#ppe-summarization-input-parameters). Vous pouvez également spécifier un niveau de confiance minimum (50-100) qui doit être atteint pour que les détections soient incluses dans le résumé.
Pour plus d’informations sur la réponse récapitulative de `DetectProtectiveEquipment`, voir [Comprendre la DetectProtectiveEquipment réponse](ppe-request-response.md#detect-protective-equipment-response).
## Tutoriel : Création d'une AWS Lambda fonction détectant les images à l'aide d'un équipement de protection individuelle
Vous pouvez créer une AWS Lambda fonction qui détecte les équipements de protection individuelle (EPI) dans les images situées dans un compartiment Amazon S3. Consultez le [ GitHub référentiel d'exemples du SDK de AWS documentation](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/javav2/usecases/creating_lambda_ppe) pour ce didacticiel Java V2.
# Comprendre l’API de détection des équipements de protection individuelle
Les informations suivantes décrivent l'[DetectProtectiveEquipment](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectProtectiveEquipment.html)API. Pour obtenir un exemple de code, consultez [Détection d’un équipement de protection individuelle dans une image](ppe-procedure-image.md).
## Fourniture d’une image
Vous fournissez une image d’entrée (format JPG ou PNG) sous forme d’octets d’image ou en référençant une image stockée dans un compartiment S3.
Nous recommandons d’utiliser des images où le visage de la personne fait face à l’appareil photo.
Si votre image d’entrée n’est pas pivotée à 0 degré, nous vous recommandons de la faire pivoter à 0 degré avant de la soumettre à `DetectProtectiveEquipment`. Les images au format JPG peuvent contenir des informations d’orientation dans des métadonnées Exif (Exchangeable Image File Format). Vous pouvez utiliser ces informations pour écrire le code permettant de faire pivoter l’image. Pour en savoir plus, consultez [Exif Version 2.32](http://cipa.jp/std/documents/download_e.html?DC-008-Translation-2019-E). Les images au format PNG ne contiennent aucune information d’orientation de l’image.
Pour transmettre une image depuis un compartiment Amazon S3, utilisez un utilisateur possédant au moins les privilèges `` Amazon S3ReadOnlyAccess . Utiliser un utilisateur ayant des privilèges `AmazonRekognitionFullAccess` pour appeler `DetectProtectiveEquipment.`
Dans l’exemple JSON d’entrée suivant, l’image est transmise dans un compartiment Amazon S3. Pour de plus amples informations, veuillez consulter [Travail avec les images](images.md). L’exemple demande un résumé de tous les types d’EPI (couvre-tête, couvre-main et couvre-visage) avec un niveau de confiance de détection minimum (`MinConfidence`) de 80 %. Vous devez spécifier une valeur `MinConfidence` comprise entre 50 et 100 % car `DetectProtectiveEquipment` ne renvoie des prédictions que lorsque le niveau de confiance de détection est compris entre 50 % et 100 %. Si vous spécifiez une valeur inférieure à 50 %, les résultats sont identiques si vous spécifiez une valeur de 50 %. Pour de plus amples informations, veuillez consulter [Spécifier les exigences de synthèse](#ppe-summarization-input-parameters).
```
{
"Image": {
"S3Object": {
"Bucket": "amzn-s3-demo-bucket",
"Name": "worker.jpg"
}
},
"SummarizationAttributes": {
"MinConfidence": 80,
"RequiredEquipmentTypes": [
"FACE_COVER",
"HAND_COVER",
"HEAD_COVER"
]
}
}
```
Si vous disposez d’une grande collection d’images à traiter pour le processus, pensez à utiliser [AWS Batch](https://docs.aws.amazon.com/batch/latest/userguide/) afin de traiter les appels de `DetectProtectiveEquipment` par lots en arrière-plan.
### Spécifier les exigences de synthèse
Vous pouvez éventuellement utiliser le paramètre d'entrée `SummarizationAttributes` ([ProtectiveEquipmentSummarizationAttributes](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ProtectiveEquipmentSummarizationAttributes.html)) pour demander des informations récapitulatives sur les types d'EPI détectés dans une image.
Pour spécifier les types de PPE à résumer, utilisez le tableau `RequiredEquipmentTypes`. Dans le tableau, incluez un ou plusieurs des éléments suivants : `FACE_COVER`, `HAND_COVER` ou `HEAD_COVER`.
Utilisez le champ `MinConfidence` pour spécifier un niveau de confiance de détection minimal (50 à 100). Le résumé n’inclut pas les personnes, les parties du corps, les parties du corps couvertes et les articles d’EPI détectés avec un niveau de confiance inférieur à `MinConfidence`.
Pour plus d’informations sur la réponse en résumé de `DetectProtectiveEquipment` consultez [Comprendre la DetectProtectiveEquipment réponse](#detect-protective-equipment-response).
## Comprendre la DetectProtectiveEquipment réponse
`DetectProtectiveEquipment` renvoie un tableau des personnes détectées dans l’image d’entrée. Pour chaque personne, des informations sur les parties du corps détectées et les articles d’EPI détectés sont renvoyées. Le JSON de l’image suivante d’un travailleur portant un couvre-chef, un couvre-main et un couvre-visage est le suivant.
![\[Travailleur du bâtiment portant une chemise à carreaux, un casque de sécurité et un masque facial tenant un outil électrique. Les cases vertes mettent en valeur le visage, le casque, la main gantée et l'outil.\]](http://docs.aws.amazon.com/fr_fr/rekognition/latest/dg/images/worker-with-bb.png)
Dans JSON, notez les éléments suivants :
+ **Personnes détectées** : `Persons` ensemble de personnes détectées sur l’image (y compris les personnes ne portant pas d’EPI). `DetectProtectiveEquipment` peut détecter l’EPI sur un maximum de 15 personnes détectées sur une image. Chaque [ProtectiveEquipmentPerson](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ProtectiveEquipmentPerson.html)objet du tableau contient un identifiant personnel, un cadre de délimitation pour la personne, des parties du corps détectées et des articles d'EPI détectés. La valeur `Confidence` dans `ProtectiveEquipmentPerson` indique le pourcentage de confiance d’Amazon Rekognition quant à la présence d’une personne dans le cadre de délimitation.
+ **Parties du corps** : `BodyParts` ensemble de parties du corps ([ProtectiveEquipmentBodyPart](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ProtectiveEquipmentBodyPart.html)) détectées sur une personne (y compris les parties du corps non couvertes par un EPI). Chaque `ProtectiveEquipmentBodyPart` inclut le nom (`Name`) de la partie du corps détectée. `DetectProtectEquipment` peut détecter le visage, la tête, les parties du corps gauches et droites. Le champ `Confidence` dans `ProtectiveEquipmentBodyPart` indique le pourcentage de confiance d’Amazon Rekognition quant à la précision de détection de la partie du corps.
+ **Articles EPI** : le tableau `EquipmentDetections` d’un objet `ProtectiveEquipmentBodyPart` contient un ensemble d’articles EPI détectés. Chaque [EquipmentDetection](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_EquipmentDetection.html)objet contient les champs suivants.
+ `Type` : le type d’EPI détecté.
+ `BoundingBox` : un cadre de délimitation autour de l’EPI détecté.
+ `Confidence` : la confiance d’Amazon Rekognition quant au fait que le boîtier de sélection contient l’EPI détecté.
+ `CoversBodyPart` : indique si l’EPI détecté se trouve sur la partie du corps correspondante.
Le [CoversBodyPart](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CoversBodyPart.html)champ `Value` est une valeur booléenne qui indique si l'EPI détecté se trouve sur la partie du corps correspondante. Le champ `Confidence` indique le niveau de confiance dans la prédiction. Vous pouvez utiliser `CoversBodyPart` pour filtrer les cas où l’EPI détecté se trouve sur l’image, mais pas réellement sur la personne.
**Note**
`CoversBodyPart` n’indique pas ou n’implique pas que la personne est correctement protégée par l’équipement de protection, ou que l’équipement de protection lui-même est correctement porté.
+ **Informations récapitulatives** : `Summary` contient les informations récapitulatives spécifiées dans le paramètre d’entrée `SummarizationAttributes`. Pour de plus amples informations, veuillez consulter [Spécifier les exigences de synthèse](#ppe-summarization-input-parameters).
`Summary`est un objet de type [ProtectiveEquipmentSummary](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ProtectiveEquipmentSummary.html)qui contient les informations suivantes.
+ `PersonsWithRequiredEquipment`— Un ensemble IDs de personnes où chaque personne répond aux critères suivants.
+ La personne porte tous les équipements de protection individuelle spécifiés dans le paramètre d’entrée `SummarizationAttributes`.
+ Le niveau de `Confidence` pour la personne (`ProtectiveEquipmentPerson`), la partie du corps (`ProtectiveEquipmentBodyPart`), l’équipement de protection (`EquipmentDetection`) est égal ou supérieur au seuil de confiance minimum spécifié (`MinConfidence`).
+ La valeur de `CoversBodyPart` pour tous les articles de protection individuelle est vraie.
+ `PersonsWithoutRequiredEquipment`— Un ensemble IDs de personnes répondant à l'un des critères suivants.
+ Les valeurs `Confidence` pour la personne (`ProtectiveEquipmentPerson`), la partie du corps (`ProtectiveEquipmentBodyPart`) et la couverture des parties du corps (`CoversBodyPart`) sont supérieures au seuil de confiance minimum spécifié (`MinConfidence`), mais il manque un ou plusieurs EPI spécifiés (`SummarizationAttributes`) à la personne.
+ La valeur de `CoversBodyPart` est fausse pour tout PPE spécifié (`SummarizationAttributes`) dont la valeur `Confidence` est supérieure au seuil de confiance minimum spécifié (`MinConfidence`). La personne possède également tous les équipements de protection individuelle spécifiés (`SummarizationAttributes`) et les valeurs `Confidence` pour la personne (`ProtectiveEquipmentPerson`), la partie du corps (`ProtectiveEquipmentBodyPart`) et l’équipement de protection (`EquipmentDetection`) sont supérieures ou égales au seuil de confiance minimum (`MinConfidence`).
+ `PersonsIndeterminate`— Un tableau IDs des personnes détectées dont la `Confidence` valeur pour la personne (`ProtectiveEquipmentPerson`), la partie du corps (`ProtectiveEquipmentBodyPart`), l'équipement de protection (`EquipmentDetection`) ou le `CoversBodyPart` booléen est inférieure au seuil de confiance minimum spécifié (`MinConfidence`).
Utilisez la taille du tableau pour obtenir le nombre d’un résumé particulier. Par exemple, la taille de `PersonsWithRequiredEquipment` indique le nombre de personnes détectées comme portant le type d’EPI spécifié.
Vous pouvez utiliser l’identifiant de la personne pour obtenir de plus amples informations sur une personne, telles que l’emplacement de la personne dans le cadre de délimitation. L’ID de personne correspond au champ ID d’un objet (`ProtectiveEquipmentPerson`) renvoyé dans `Persons` (tableau de `ProtectiveEquipmentPerson`). Vous pouvez ensuite obtenir le cadre de délimitation et d’autres informations à partir de l’objet `ProtectiveEquipmentPerson` correspondant.
```
{
"ProtectiveEquipmentModelVersion": "1.0",
"Persons": [
{
"BodyParts": [
{
"Name": "FACE",
"Confidence": 99.99861145019531,
"EquipmentDetections": [
{
"BoundingBox": {
"Width": 0.14528800547122955,
"Height": 0.14956723153591156,
"Left": 0.4363413453102112,
"Top": 0.34203192591667175
},
"Confidence": 99.90001678466797,
"Type": "FACE_COVER",
"CoversBodyPart": {
"Confidence": 98.0676498413086,
"Value": true
}
}
]
},
{
"Name": "LEFT_HAND",
"Confidence": 96.9786376953125,
"EquipmentDetections": [
{
"BoundingBox": {
"Width": 0.14495663344860077,
"Height": 0.12936046719551086,
"Left": 0.5114737153053284,
"Top": 0.5744519829750061
},
"Confidence": 83.72270965576172,
"Type": "HAND_COVER",
"CoversBodyPart": {
"Confidence": 96.9288558959961,
"Value": true
}
}
]
},
{
"Name": "RIGHT_HAND",
"Confidence": 99.82939147949219,
"EquipmentDetections": [
{
"BoundingBox": {
"Width": 0.20971858501434326,
"Height": 0.20528452098369598,
"Left": 0.2711356580257416,
"Top": 0.6750612258911133
},
"Confidence": 95.70789337158203,
"Type": "HAND_COVER",
"CoversBodyPart": {
"Confidence": 99.85433197021484,
"Value": true
}
}
]
},
{
"Name": "HEAD",
"Confidence": 99.9999008178711,
"EquipmentDetections": [
{
"BoundingBox": {
"Width": 0.24350935220718384,
"Height": 0.34623199701309204,
"Left": 0.43011072278022766,
"Top": 0.01103297434747219
},
"Confidence": 83.88762664794922,
"Type": "HEAD_COVER",
"CoversBodyPart": {
"Confidence": 99.96485900878906,
"Value": true
}
}
]
}
],
"BoundingBox": {
"Width": 0.7403100728988647,
"Height": 0.9412225484848022,
"Left": 0.02214839495718479,
"Top": 0.03134796395897865
},
"Confidence": 99.98855590820312,
"Id": 0
}
],
"Summary": {
"PersonsWithRequiredEquipment": [
0
],
"PersonsWithoutRequiredEquipment": [],
"PersonsIndeterminate": []
}
}
```
# Détection d’un équipement de protection individuelle dans une image
Pour détecter la présence d'équipements de protection individuelle (EPI) sur des personnes sur une image, utilisez l'opération API [DetectProtectiveEquipment](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectProtectiveEquipment.html)non liée au stockage.
Vous pouvez fournir l’image d’entrée sous la forme d’un tableau d’octets d’image (octets d’image encodés en base64) ou en tant qu’objet Amazon S3 en utilisant l’AWS SDK ou l’ AWS Command Line Interface (AWS CLI). Ces exemples utilisent une image stockée dans un compartiment Amazon S3. Pour de plus amples informations, veuillez consulter [Travail avec les images](images.md).
**Pour détecter la présence d’EPI sur des personnes figurant sur 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).
1. Chargez une image (contenant une ou plusieurs personnes portant l’EPI) dans votre compartiment S3.
Pour en savoir plus, consultez [Chargement d’objets dans Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UploadingObjectsintoAmazonS3.html) dans le *Guide de l’utilisateur Amazon Simple Storage Service*.
1. Utilisez les exemples suivants pour appeler l’opération `DetectProtectiveEquipment`. Pour plus d’informations sur l’affichage des cadres de délimitation dans une image, consultez [Affichage de cadres de délimitation](images-displaying-bounding-boxes.md).
------
#### [ Java ]
Cet exemple affiche des informations sur les articles de protection individuelle détectés sur les personnes détectées sur une image.
Remplacez la valeur de `amzn-s3-demo-bucket` par le nom du compartiment Amazon S3 qui contient votre image. Remplacez la valeur de `photo` par le nom de votre fichier image.
```
//Copyright 2020 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.client.builder.AwsClientBuilder;
import com.amazonaws.services.rekognition.AmazonRekognition;
import com.amazonaws.services.rekognition.AmazonRekognitionClientBuilder;
import com.amazonaws.services.rekognition.model.AmazonRekognitionException;
import com.amazonaws.services.rekognition.model.Image;
import com.amazonaws.services.rekognition.model.ProtectiveEquipmentBodyPart;
import com.amazonaws.services.rekognition.model.S3Object;
import com.amazonaws.services.rekognition.model.ProtectiveEquipmentPerson;
import com.amazonaws.services.rekognition.model.ProtectiveEquipmentSummarizationAttributes;
import java.util.List;
import com.amazonaws.services.rekognition.model.BoundingBox;
import com.amazonaws.services.rekognition.model.DetectProtectiveEquipmentRequest;
import com.amazonaws.services.rekognition.model.DetectProtectiveEquipmentResult;
import com.amazonaws.services.rekognition.model.EquipmentDetection;
public class DetectPPE {
public static void main(String[] args) throws Exception {
String photo = "photo";
String bucket = "bucket";
AmazonRekognition rekognitionClient = AmazonRekognitionClientBuilder.defaultClient();
ProtectiveEquipmentSummarizationAttributes summaryAttributes = new ProtectiveEquipmentSummarizationAttributes()
.withMinConfidence(80F)
.withRequiredEquipmentTypes("FACE_COVER", "HAND_COVER", "HEAD_COVER");
DetectProtectiveEquipmentRequest request = new DetectProtectiveEquipmentRequest()
.withImage(new Image()
.withS3Object(new S3Object()
.withName(photo).withBucket(bucket)))
.withSummarizationAttributes(summaryAttributes);
try {
System.out.println("Detected PPE for people in image " + photo);
System.out.println("Detected people\n---------------");
DetectProtectiveEquipmentResult result = rekognitionClient.detectProtectiveEquipment(request);
List persons = result.getPersons();
for (ProtectiveEquipmentPerson person: persons) {
System.out.println("ID: " + person.getId());
List bodyParts=person.getBodyParts();
if (bodyParts.isEmpty()){
System.out.println("\tNo body parts detected");
} else
for (ProtectiveEquipmentBodyPart bodyPart: bodyParts) {
System.out.println("\t" + bodyPart.getName() + ". Confidence: " + bodyPart.getConfidence().toString());
List equipmentDetections=bodyPart.getEquipmentDetections();
if (equipmentDetections.isEmpty()){
System.out.println("\t\tNo PPE Detected on " + bodyPart.getName());
}
else {
for (EquipmentDetection item: equipmentDetections) {
System.out.println("\t\tItem: " + item.getType() + ". Confidence: " + item.getConfidence().toString());
System.out.println("\t\tCovers body part: "
+ item.getCoversBodyPart().getValue().toString() + ". Confidence: " + item.getCoversBodyPart().getConfidence().toString());
System.out.println("\t\tBounding Box");
BoundingBox box =item.getBoundingBox();
System.out.println("\t\tLeft: " +box.getLeft().toString());
System.out.println("\t\tTop: " + box.getTop().toString());
System.out.println("\t\tWidth: " + box.getWidth().toString());
System.out.println("\t\tHeight: " + box.getHeight().toString());
System.out.println("\t\tConfidence: " + item.getConfidence().toString());
System.out.println();
}
}
}
}
System.out.println("Person ID Summary\n-----------------");
//List list=;
DisplaySummary("With required equipment", result.getSummary().getPersonsWithRequiredEquipment());
DisplaySummary("Without required equipment", result.getSummary().getPersonsWithoutRequiredEquipment());
DisplaySummary("Indeterminate", result.getSummary().getPersonsIndeterminate());
} catch(AmazonRekognitionException e) {
e.printStackTrace();
}
}
static void DisplaySummary(String summaryType,List idList)
{
System.out.print(summaryType + "\n\tIDs ");
if (idList.size()==0) {
System.out.println("None");
}
else {
int count=0;
for (Integer id: idList ) {
if (count++ == idList.size()-1) {
System.out.println(id.toString());
}
else {
System.out.print(id.toString() + ", ");
}
}
}
System.out.println();
}
}
```
------
#### [ 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/DetectPPE.java).
```
//snippet-start:[rekognition.java2.detect_ppe.import]
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.RekognitionClient;
import software.amazon.awssdk.services.rekognition.model.BoundingBox;
import software.amazon.awssdk.services.rekognition.model.DetectProtectiveEquipmentRequest;
import software.amazon.awssdk.services.rekognition.model.DetectProtectiveEquipmentResponse;
import software.amazon.awssdk.services.rekognition.model.EquipmentDetection;
import software.amazon.awssdk.services.rekognition.model.ProtectiveEquipmentBodyPart;
import software.amazon.awssdk.services.rekognition.model.ProtectiveEquipmentSummarizationAttributes;
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.s3.model.GetObjectRequest;
import software.amazon.awssdk.services.s3.model.GetObjectResponse;
import software.amazon.awssdk.services.s3.model.S3Exception;
import software.amazon.awssdk.services.rekognition.model.ProtectiveEquipmentPerson;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.util.List;
//snippet-end:[rekognition.java2.detect_ppe.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 DetectPPE {
public static void main(String[] args) {
final String usage = "\n" +
"Usage: " +
" \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_WEST_2;
S3Client s3 = S3Client.builder()
.region(region)
.credentialsProvider(ProfileCredentialsProvider.create("profile-name"))
.build();
RekognitionClient rekClient = RekognitionClient.builder()
.region(region)
.credentialsProvider(ProfileCredentialsProvider.create("profile-name"))
.build();
displayGear(s3, rekClient, sourceImage, bucketName) ;
s3.close();
rekClient.close();
System.out.println("This example is done!");
}
// snippet-start:[rekognition.java2.detect_ppe.main]
public static void displayGear(S3Client s3,
RekognitionClient rekClient,
String sourceImage,
String bucketName) {
byte[] data = getObjectBytes (s3, bucketName, sourceImage);
InputStream is = new ByteArrayInputStream(data);
try {
ProtectiveEquipmentSummarizationAttributes summarizationAttributes = ProtectiveEquipmentSummarizationAttributes.builder()
.minConfidence(80F)
.requiredEquipmentTypesWithStrings("FACE_COVER", "HAND_COVER", "HEAD_COVER")
.build();
SdkBytes sourceBytes = SdkBytes.fromInputStream(is);
software.amazon.awssdk.services.rekognition.model.Image souImage = Image.builder()
.bytes(sourceBytes)
.build();
DetectProtectiveEquipmentRequest request = DetectProtectiveEquipmentRequest.builder()
.image(souImage)
.summarizationAttributes(summarizationAttributes)
.build();
DetectProtectiveEquipmentResponse result = rekClient.detectProtectiveEquipment(request);
List persons = result.persons();
for (ProtectiveEquipmentPerson person: persons) {
System.out.println("ID: " + person.id());
List bodyParts=person.bodyParts();
if (bodyParts.isEmpty()){
System.out.println("\tNo body parts detected");
} else
for (ProtectiveEquipmentBodyPart bodyPart: bodyParts) {
System.out.println("\t" + bodyPart.name() + ". Confidence: " + bodyPart.confidence().toString());
List equipmentDetections=bodyPart.equipmentDetections();
if (equipmentDetections.isEmpty()){
System.out.println("\t\tNo PPE Detected on " + bodyPart.name());
} else {
for (EquipmentDetection item: equipmentDetections) {
System.out.println("\t\tItem: " + item.type() + ". Confidence: " + item.confidence().toString());
System.out.println("\t\tCovers body part: "
+ item.coversBodyPart().value().toString() + ". Confidence: " + item.coversBodyPart().confidence().toString());
System.out.println("\t\tBounding Box");
BoundingBox box =item.boundingBox();
System.out.println("\t\tLeft: " +box.left().toString());
System.out.println("\t\tTop: " + box.top().toString());
System.out.println("\t\tWidth: " + box.width().toString());
System.out.println("\t\tHeight: " + box.height().toString());
System.out.println("\t\tConfidence: " + item.confidence().toString());
System.out.println();
}
}
}
}
System.out.println("Person ID Summary\n-----------------");
displaySummary("With required equipment", result.summary().personsWithRequiredEquipment());
displaySummary("Without required equipment", result.summary().personsWithoutRequiredEquipment());
displaySummary("Indeterminate", result.summary().personsIndeterminate());
} catch (RekognitionException e) {
e.printStackTrace();
System.exit(1);
}
}
public static byte[] getObjectBytes (S3Client s3, String bucketName, String keyName) {
try {
GetObjectRequest objectRequest = GetObjectRequest
.builder()
.key(keyName)
.bucket(bucketName)
.build();
ResponseBytes objectBytes = s3.getObjectAsBytes(objectRequest);
return objectBytes.asByteArray();
} catch (S3Exception e) {
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
return null;
}
static void displaySummary(String summaryType,List idList) {
System.out.print(summaryType + "\n\tIDs ");
if (idList.size()==0) {
System.out.println("None");
} else {
int count=0;
for (Integer id: idList ) {
if (count++ == idList.size()-1) {
System.out.println(id.toString());
} else {
System.out.print(id.toString() + ", ");
}
}
}
System.out.println();
}
// snippet-end:[rekognition.java2.detect_ppe.main]
}
```
------
#### [ AWS CLI ]
Cette AWS CLI commande demande un résumé du PPE et affiche la sortie JSON pour l'opération `detect-protective-equipment` CLI.
Remplacez `amzn-s3-demo-bucket` par le nom de l’image d’un compartiment Amazon S3 qui contient une image. Remplacez `input.jpg` par le nom de l’image que vous souhaitez utiliser.
```
aws rekognition detect-protective-equipment \
--image "S3Object={Bucket=amzn-s3-demo-bucket,Name=input.jpg}" \
--summarization-attributes "MinConfidence=80,RequiredEquipmentTypes=['FACE_COVER','HAND_COVER','HEAD_COVER']"
```
Cette AWS CLI commande affiche la sortie JSON pour l'opération `detect-protective-equipment` CLI.
Remplacez `amzn-s3-demo-bucket` par le nom de l’image d’un compartiment Amazon S3 qui contient une image. Remplacez `input.jpg` par le nom de l’image que vous souhaitez utiliser.
```
aws rekognition detect-protective-equipment \
--image "S3Object={Bucket=amzn-s3-demo-bucket,Name=input.jpg}"
```
------
#### [ Python ]
Cet exemple affiche des informations sur les articles de protection individuelle détectés sur les personnes détectées sur une image.
Remplacez la valeur de `amzn-s3-demo-bucket` par le nom du compartiment Amazon S3 qui contient votre image. Remplacez la valeur de `photo` par le nom de votre fichier image. Remplacez la valeur de `profile_name` dans la ligne qui crée la session Rekognition par le nom de votre profil de développeur.
```
# Copyright 2020 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_ppe(photo, bucket):
session = boto3.Session(profile_name='profile-name')
client = session.client('rekognition')
response = client.detect_protective_equipment(Image={'S3Object': {'Bucket': bucket, 'Name': photo}},
SummarizationAttributes={'MinConfidence': 80,
'RequiredEquipmentTypes': ['FACE_COVER',
'HAND_COVER',
'HEAD_COVER']})
print('Detected PPE for people in image ' + photo)
print('\nDetected people\n---------------')
for person in response['Persons']:
print('Person ID: ' + str(person['Id']))
print('Body Parts\n----------')
body_parts = person['BodyParts']
if len(body_parts) == 0:
print('No body parts found')
else:
for body_part in body_parts:
print('\t' + body_part['Name'] + '\n\t\tConfidence: ' + str(body_part['Confidence']))
print('\n\t\tDetected PPE\n\t\t------------')
ppe_items = body_part['EquipmentDetections']
if len(ppe_items) == 0:
print('\t\tNo PPE detected on ' + body_part['Name'])
else:
for ppe_item in ppe_items:
print('\t\t' + ppe_item['Type'] + '\n\t\t\tConfidence: ' + str(ppe_item['Confidence']))
print('\t\tCovers body part: ' + str(
ppe_item['CoversBodyPart']['Value']) + '\n\t\t\tConfidence: ' + str(
ppe_item['CoversBodyPart']['Confidence']))
print('\t\tBounding Box:')
print('\t\t\tTop: ' + str(ppe_item['BoundingBox']['Top']))
print('\t\t\tLeft: ' + str(ppe_item['BoundingBox']['Left']))
print('\t\t\tWidth: ' + str(ppe_item['BoundingBox']['Width']))
print('\t\t\tHeight: ' + str(ppe_item['BoundingBox']['Height']))
print('\t\t\tConfidence: ' + str(ppe_item['Confidence']))
print()
print()
print('Person ID Summary\n----------------')
display_summary('With required equipment', response['Summary']['PersonsWithRequiredEquipment'])
display_summary('Without required equipment', response['Summary']['PersonsWithoutRequiredEquipment'])
display_summary('Indeterminate', response['Summary']['PersonsIndeterminate'])
print()
return len(response['Persons'])
# Display summary information for supplied summary.
def display_summary(summary_type, summary):
print(summary_type + '\n\tIDs: ', end='')
if (len(summary) == 0):
print('None')
else:
for num, id in enumerate(summary, start=0):
if num == len(summary) - 1:
print(id)
else:
print(str(id) + ', ', end='')
def main():
photo = 'photo-name'
bucket = 'amzn-s3-demo-bucket'
person_count = detect_ppe(photo, bucket)
print("Persons detected: " + str(person_count))
if __name__ == "__main__":
main()
```
------
# Exemple : dessiner des cadres de délimitation autour des masques
Les exemples suivants vous montrent comment dessiner des cadres de délimitation autour des masques détectés sur des personnes. Pour un exemple utilisant AWS Lambda Amazon DynamoDB, consultez le référentiel d'exemples du SDK [AWS de documentation](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/javav2/usecases/creating_lambda_ppe). GitHub
Pour détecter les masques faciaux, vous utilisez l'opération d'API [DetectProtectiveEquipment](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectProtectiveEquipment.html)non liée au stockage. L’image est chargée à partir du système de fichiers local. Vous pouvez fournir à `DetectProtectiveEquipment` l’image d’entrée sous la forme d’un tableau d’octets d’image (octets d’image encodés en base64). Pour de plus amples informations, veuillez consulter [Travail avec les images](images.md).
L’exemple affiche un cadre de délimitation autour des couvre-visages détectés. Le cadre de délimitation est vert si le couvre-visage couvre entièrement la partie du corps. Dans le cas contraire, un cadre de délimitation rouge s’affiche. À titre d’avertissement, un cadre de délimitation jaune s’affiche à l’intérieur du cadre de délimitation de masque si le niveau de confiance de détection est inférieur à la valeur de confiance spécifiée. Si aucun masque facial n’est détecté, un cadre de délimitation rouge est dessiné autour de la personne.
La sortie d’image est similaire à ce qui suit.
![\[Quatre travailleurs d'un entrepôt, portant des gilets à haute visibilité, des casques, des lunettes de sécurité et des masques. Les masques sont entourés de boîtes de délimitation.\]](http://docs.aws.amazon.com/fr_fr/rekognition/latest/dg/images/workers-with-bb.png)
**Pour afficher les cadres de délimitation sur les masques détectés**
1. Si vous ne l’avez pas déjà fait :
1. Créez ou mettez à jour un utilisateur avec les autorisations `AmazonRekognitionFullAccess`. 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 `DetectProtectiveEquipment`. Pour plus d’informations sur l’affichage des cadres de délimitation dans une image, consultez [Affichage de cadres de délimitation](images-displaying-bounding-boxes.md).
------
#### [ Java ]
Dans la fonction `main`, modifiez les éléments suivants :
+ La valeur du `photo` vers le chemin et du nom de fichier d’un fichier image local (PNG ou JPEG).
+ La valeur du `confidence` correspondant au niveau de confiance souhaité (50-100).
```
//Loads images, detects faces and draws bounding boxes.Determines exif orientation, if necessary.
package com.amazonaws.samples;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.util.List;
import javax.imageio.ImageIO;
import javax.swing.*;
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 com.amazonaws.util.IOUtils;
import com.amazonaws.client.builder.AwsClientBuilder;
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.DetectProtectiveEquipmentRequest;
import com.amazonaws.services.rekognition.model.DetectProtectiveEquipmentResult;
import com.amazonaws.services.rekognition.model.EquipmentDetection;
import com.amazonaws.services.rekognition.model.Image;
import com.amazonaws.services.rekognition.model.ProtectiveEquipmentBodyPart;
import com.amazonaws.services.rekognition.model.ProtectiveEquipmentPerson;
// Calls DetectFaces and displays a bounding box around each detected image.
public class PPEBoundingBox extends JPanel {
private static final long serialVersionUID = 1L;
BufferedImage image;
static int scale;
DetectProtectiveEquipmentResult result;
float confidence=80;
public PPEBoundingBox(DetectProtectiveEquipmentResult ppeResult, BufferedImage bufImage, float requiredConfidence) throws Exception {
super();
scale = 2; // increase to shrink image size.
result = ppeResult;
image = bufImage;
confidence=requiredConfidence;
}
// 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);
int offset=20;
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 detected persons and display bounding boxes.
List persons = result.getPersons();
for (ProtectiveEquipmentPerson person: persons) {
BoundingBox boxPerson = person.getBoundingBox();
left = width * boxPerson.getLeft();
top = height * boxPerson.getTop();
Boolean foundMask=false;
List bodyParts=person.getBodyParts();
if (bodyParts.isEmpty()==false)
{
//body parts detected
for (ProtectiveEquipmentBodyPart bodyPart: bodyParts) {
List equipmentDetections=bodyPart.getEquipmentDetections();
for (EquipmentDetection item: equipmentDetections) {
if (item.getType().contentEquals("FACE_COVER"))
{
// Draw green or red bounding box depending on mask coverage.
foundMask=true;
BoundingBox box =item.getBoundingBox();
left = width * box.getLeft();
top = height * box.getTop();
Color maskColor=new Color( 0, 212, 0);
if (item.getCoversBodyPart().getValue()==false) {
// red bounding box
maskColor=new Color( 255, 0, 0);
}
g2d.setColor(maskColor);
g2d.drawRect(Math.round(left / scale), Math.round(top / scale),
Math.round((width * box.getWidth()) / scale), Math.round((height * box.getHeight())) / scale);
// Check confidence is > supplied confidence.
if (item.getCoversBodyPart().getConfidence()< confidence)
{
// Draw a yellow bounding box inside face mask bounding box
maskColor=new Color( 255, 255, 0);
g2d.setColor(maskColor);
g2d.drawRect(Math.round((left + offset) / scale),
Math.round((top + offset) / scale),
Math.round((width * box.getWidth())- (offset * 2 ))/ scale,
Math.round((height * box.getHeight()) -( offset* 2)) / scale);
}
}
}
}
}
// Didn't find a mask, so draw person bounding box red
if (foundMask==false) {
left = width * boxPerson.getLeft();
top = height * boxPerson.getTop();
g2d.setColor(new Color(255, 0, 0));
g2d.drawRect(Math.round(left / scale), Math.round(top / scale),
Math.round(((width) * boxPerson.getWidth()) / scale), Math.round((height * boxPerson.getHeight())) / scale);
}
}
}
public static void main(String arg[]) throws Exception {
String photo = "photo";
float confidence =80;
int height = 0;
int width = 0;
BufferedImage image = null;
ByteBuffer imageBytes;
// Get image bytes for call to DetectProtectiveEquipment
try (InputStream inputStream = new FileInputStream(new File(photo))) {
imageBytes = ByteBuffer.wrap(IOUtils.toByteArray(inputStream));
}
//Get image for display
InputStream imageBytesStream;
imageBytesStream = new ByteArrayInputStream(imageBytes.array());
ByteArrayOutputStream baos = new ByteArrayOutputStream();
image=ImageIO.read(imageBytesStream);
ImageIO.write(image, "jpg", baos);
width = image.getWidth();
height = image.getHeight();
//Get Rekognition client
AmazonRekognition rekognitionClient = AmazonRekognitionClientBuilder.defaultClient();
// Call DetectProtectiveEquipment
DetectProtectiveEquipmentRequest request = new DetectProtectiveEquipmentRequest()
.withImage(new Image()
.withBytes(imageBytes));
DetectProtectiveEquipmentResult result = rekognitionClient.detectProtectiveEquipment(request);
// Create frame and panel.
JFrame frame = new JFrame("Detect PPE");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
PPEBoundingBox panel = new PPEBoundingBox(result, image, confidence);
panel.setPreferredSize(new Dimension(image.getWidth() / scale, image.getHeight() / scale));
frame.setContentPane(panel);
frame.pack();
frame.setVisible(true);
}
}
```
------
#### [ 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/PPEBoundingBoxFrame.java).
```
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.*;
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.BoundingBox;
import software.amazon.awssdk.services.rekognition.model.DetectProtectiveEquipmentRequest;
import software.amazon.awssdk.services.rekognition.model.EquipmentDetection;
import software.amazon.awssdk.services.rekognition.model.ProtectiveEquipmentBodyPart;
import software.amazon.awssdk.services.rekognition.model.ProtectiveEquipmentPerson;
import software.amazon.awssdk.services.rekognition.model.ProtectiveEquipmentSummarizationAttributes;
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;
import software.amazon.awssdk.services.rekognition.model.DetectProtectiveEquipmentResponse;
//snippet-end:[rekognition.java2.display_mask.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 PPEBoundingBoxFrame extends JPanel {
DetectProtectiveEquipmentResponse result;
static BufferedImage image;
static int scale;
float confidence;
public static void main(String[] args) throws Exception {
final String usage = "\n" +
"Usage: " +
" \n\n" +
"Where:\n" +
" sourceImage - The name of the image in an Amazon S3 bucket that shows a person wearing a mask (for example, masks.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();
displayGear(s3, rekClient, sourceImage, bucketName);
s3.close();
rekClient.close();
}
// snippet-start:[rekognition.java2.display_mask.main]
public static void displayGear(S3Client s3,
RekognitionClient rekClient,
String sourceImage,
String bucketName) {
float confidence = 80;
byte[] data = getObjectBytes(s3, bucketName, sourceImage);
InputStream is = new ByteArrayInputStream(data);
try {
ProtectiveEquipmentSummarizationAttributes summarizationAttributes = ProtectiveEquipmentSummarizationAttributes.builder()
.minConfidence(70F)
.requiredEquipmentTypesWithStrings("FACE_COVER")
.build();
SdkBytes sourceBytes = SdkBytes.fromInputStream(is);
image = ImageIO.read(sourceBytes.asInputStream());
// Create an Image object for the source image.
software.amazon.awssdk.services.rekognition.model.Image souImage = Image.builder()
.bytes(sourceBytes)
.build();
DetectProtectiveEquipmentRequest request = DetectProtectiveEquipmentRequest.builder()
.image(souImage)
.summarizationAttributes(summarizationAttributes)
.build();
DetectProtectiveEquipmentResponse result = rekClient.detectProtectiveEquipment(request);
JFrame frame = new JFrame("Detect PPE");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
PPEBoundingBoxFrame panel = new PPEBoundingBoxFrame(result, image, confidence);
panel.setPreferredSize(new Dimension(image.getWidth() / scale, image.getHeight() / scale));
frame.setContentPane(panel);
frame.pack();
frame.setVisible(true);
} catch (RekognitionException e) {
e.printStackTrace();
System.exit(1);
} catch (Exception e) {
e.printStackTrace();
}
}
public static byte[] getObjectBytes (S3Client s3, String bucketName, String keyName) {
try {
GetObjectRequest objectRequest = GetObjectRequest
.builder()
.key(keyName)
.bucket(bucketName)
.build();
ResponseBytes objectBytes = s3.getObjectAsBytes(objectRequest);
return objectBytes.asByteArray();
} catch (S3Exception e) {
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
return null;
}
public PPEBoundingBoxFrame(DetectProtectiveEquipmentResponse ppeResult, BufferedImage bufImage, float requiredConfidence) {
super();
scale = 1; // increase to shrink image size.
result = ppeResult;
image = bufImage;
confidence=requiredConfidence;
}
// Draws the bounding box around the detected masks.
public void paintComponent(Graphics g) {
float left = 0;
float top = 0;
int height = image.getHeight(this);
int width = image.getWidth(this);
int offset=20;
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 detected persons and display bounding boxes.
List persons = result.persons();
for (ProtectiveEquipmentPerson person: persons) {
List bodyParts=person.bodyParts();
if (!bodyParts.isEmpty()){
for (ProtectiveEquipmentBodyPart bodyPart: bodyParts) {
List equipmentDetections=bodyPart.equipmentDetections();
for (EquipmentDetection item: equipmentDetections) {
String myType = item.type().toString();
if (myType.compareTo("FACE_COVER") ==0) {
// Draw green bounding box depending on mask coverage.
BoundingBox box =item.boundingBox();
left = width * box.left();
top = height * box.top();
Color maskColor=new Color( 0, 212, 0);
if (item.coversBodyPart().equals(false)) {
// red bounding box.
maskColor=new Color( 255, 0, 0);
}
g2d.setColor(maskColor);
g2d.drawRect(Math.round(left / scale), Math.round(top / scale),
Math.round((width * box.width()) / scale), Math.round((height * box.height())) / scale);
// Check confidence is > supplied confidence.
if (item.coversBodyPart().confidence() < confidence) {
// Draw a yellow bounding box inside face mask bounding box.
maskColor=new Color( 255, 255, 0);
g2d.setColor(maskColor);
g2d.drawRect(Math.round((left + offset) / scale),
Math.round((top + offset) / scale),
Math.round((width * box.width())- (offset * 2 ))/ scale,
Math.round((height * box.height()) -( offset* 2)) / scale);
}
}
}
}
}
}
}
// snippet-end:[rekognition.java2.display_mask.main]
}
```
------
#### [ Python ]
Dans la fonction `main`, modifiez les éléments suivants :
+ La valeur du `photo` vers le chemin et du nom de fichier d’un fichier image local (PNG ou JPEG).
+ La valeur du `confidence` correspondant au niveau de confiance souhaité (50-100).
+ Remplacez la valeur de `profile_name` dans la ligne qui crée la session Rekognition par le nom de votre profil de développeur.
```
#Copyright 2020 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, ImageDraw, ExifTags, ImageColor
def detect_ppe(photo, confidence):
fill_green='#00d400'
fill_red='#ff0000'
fill_yellow='#ffff00'
line_width=3
#open image and get image data from stream.
image = Image.open(open(photo,'rb'))
stream = io.BytesIO()
image.save(stream, format=image.format)
image_binary = stream.getvalue()
imgWidth, imgHeight = image.size
draw = ImageDraw.Draw(image)
client=boto3.client('rekognition')
response = client.detect_protective_equipment(Image={'Bytes': image_binary})
for person in response['Persons']:
found_mask=False
for body_part in person['BodyParts']:
ppe_items = body_part['EquipmentDetections']
for ppe_item in ppe_items:
#found a mask
if ppe_item['Type'] == 'FACE_COVER':
fill_color=fill_green
found_mask=True
# check if mask covers face
if ppe_item['CoversBodyPart']['Value'] == False:
fill_color=fill='#ff0000'
# draw bounding box around mask
box = ppe_item['BoundingBox']
left = imgWidth * box['Left']
top = imgHeight * box['Top']
width = imgWidth * box['Width']
height = imgHeight * box['Height']
points = (
(left,top),
(left + width, top),
(left + width, top + height),
(left , top + height),
(left, top)
)
draw.line(points, fill=fill_color, width=line_width)
# Check if confidence is lower than supplied value
if ppe_item['CoversBodyPart']['Confidence'] < confidence:
#draw warning yellow bounding box within face mask bounding box
offset=line_width+ line_width
points = (
(left+offset,top + offset),
(left + width-offset, top+offset),
((left) + (width-offset), (top-offset) + (height)),
(left+ offset , (top) + (height -offset)),
(left + offset, top + offset)
)
draw.line(points, fill=fill_yellow, width=line_width)
if found_mask==False:
# no face mask found so draw red bounding box around body
box = person['BoundingBox']
left = imgWidth * box['Left']
top = imgHeight * box['Top']
width = imgWidth * box['Width']
height = imgHeight * box['Height']
points = (
(left,top),
(left + width, top),
(left + width, top + height),
(left , top + height),
(left, top)
)
draw.line(points, fill=fill_red, width=line_width)
image.show()
def main():
photo='photo'
confidence=80
detect_ppe(photo, confidence)
if __name__ == "__main__":
main()
```
------
#### [ CLI ]
Dans l’exemple de CLI suivant, modifiez la valeur des arguments répertoriés ci-dessous :
+ La valeur du `photo` vers le chemin et du nom de fichier d’un fichier image local (PNG ou JPEG).
+ La valeur du `confidence` correspondant au niveau de confiance souhaité (50-100).
+ Remplacez la valeur de `profile_name` dans la ligne qui crée la session Rekognition par le nom de votre profil de développeur.
```
aws rekognition detect-protective-equipment --image "{"S3Object":{"Bucket":"amzn-s3-demo-bucket","Name":"image-name"}}" --profile profile-name \
--summarization-attributes "{"MinConfidence":MinConfidenceNumber,"RequiredEquipmentTypes":["FACE_COVER"]}"
```
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. Par exemple, consultez ce qui suit :
```
aws rekognition detect-protective-equipment --image "{\"S3Object\":{\"Bucket\":\"amzn-s3-demo-bucket\",\"Name\":\"image-name\"}}" \
--profile profile-name --summarization-attributes "{\"MinConfidence\":MinConfidenceNumber,\"RequiredEquipmentTypes\":[\"FACE_COVER\"]}"
```
------