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

# Rilevamento dei dispositivi di protezione individuale
<a name="ppe-detection"></a>

Amazon Rekognition è in grado di rilevare i dispositivi di protezione individuale (DPI) indossati dalle persone in un'immagine. Puoi utilizzare queste informazioni per migliorare le pratiche di sicurezza sul lavoro. Ad esempio, è possibile utilizzare il rilevamento dei DPI per determinare se i lavoratori in un cantiere edile indossano copricapi o se gli operatori sanitari indossano protezioni per il volto e per le mani. L'immagine seguente mostra alcuni dei tipi di DPI che è possibile rilevare.

![\[Lavoratore che indossa DPI tra cui elmetto protettivo, occhiali di sicurezza, maschera protettiva e guanti, e utilizza un utensile elettrico. Delimitare i riquadri attorno agli oggetti.\]](http://docs.aws.amazon.com/it_it/rekognition/latest/dg/images/worker-with-bb.png)


Per rilevare i PPE in un'immagine si chiama l'[DetectProtectiveEquipment](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectProtectiveEquipment.html)API e si passa un'immagine di input. La risposta è una struttura JSON che include quanto segue.
+ Le persone rilevate nell'immagine.
+ Le parti del corpo in cui vengono indossati i DPI (viso, testa, mano sinistra e mano destra).
+ I tipi di DPI rilevati sulle parti del corpo (protezione per il volto, protezione per le mani e copricapo). 
+ Per i DPI rilevati, un indicatore che indica se il DPI copre o meno la parte del corpo corrispondente.

Vengono restituiti i riquadri di delimitazione per indicare l'ubicazione delle persone e degli oggetti dei DPI rilevati nell'immagine. 

Facoltativamente, è possibile richiedere un riepilogo degli articoli e delle persone DPI rilevati in un'immagine. Per ulteriori informazioni, consulta [Riepilogo dei DPI rilevati in un'immagine](#ppe-summarization). 

**Nota**  
Il rilevamento DPI di Amazon Rekognition non esegue il riconoscimento o il confronto facciale e non è in grado di identificare le persone rilevate. 

## Tipi di DPI
<a name="ppe-types"></a>

[DetectProtectiveEquipment](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectProtectiveEquipment.html)rileva i seguenti tipi di DPI. Se desideri rilevare altri tipi di DPI nelle immagini, prendi in considerazione l'utilizzo di Etichette personalizzate Amazon Rekognition per addestrare un modello personalizzato. Per maggiori informazioni, consulta [Etichette personalizzate Amazon Rekognition](https://docs.aws.amazon.com/rekognition/latest/customlabels-dg/what-is.html).

### Protezione per il volto
<a name="ppe-face-cover"></a>

`DetectProtectiveEquipment` è in grado di rilevare le protezioni per il volto comuni come quelle chirurgiche, N95 e maschere in tessuto. 

### Guanti
<a name="ppe-hand-cover"></a>

`DetectProtectiveEquipment` è in grado di rilevare protezioni per le mani come guanti chirurgici e guanti di sicurezza. 

### Copricapo
<a name="ppe-head-cover"></a>

`DetectProtectiveEquipment` è in grado di rilevare elmetti e caschi. 

L'API indica che in un'immagine è stata rilevata una protezione per la testa, la mano o il viso. L'API non restituisce informazioni sul tipo di protezione specifica. Ad esempio, «guanto chirurgico» per il tipo di protezione per le mani. 

## Affidabilità nel rilevamento dei DPI
<a name="ppe-confidence"></a>

Amazon Rekognition effettua una previsione sulla presenza di DPI, persone e parti del corpo in un'immagine. L'API fornisce un punteggio (50-100) che indica la fiducia di Amazon Rekognition nell'accuratezza di una previsione. 

**Nota**  
Se prevedi di usare l’operazione `DetectProtectiveEquipment` per prendere una decisione che influisca sui diritti, sulla privacy o sull'accesso ai servizi di una persona, ti consigliamo di trasmettere il risultato a un essere umano per la revisione e la convalida prima di agire. 

## Riepilogo dei DPI rilevati in un'immagine
<a name="ppe-summarization"></a>

Facoltativamente è possibile richiedere un riepilogo degli articoli e delle persone DPI rilevati in un'immagine. È possibile specificare un elenco dei dispositivi di protezione richiesti (protezione per il volto, protezione per le mani o copricapo) e una soglia minima di confidenza (ad esempio, 80%). La risposta include un riepilogo consolidato per immagine identificativo (ID) delle persone con il DPI richiesto, delle persone senza il DPI richiesto e delle persone per le quali non è stato possibile effettuare una determinazione. 

Il riepilogo consente di rispondere rapidamente a domande come *Quante persone non indossano protezioni per il volto?* o *Tutti indossano DPI?* Ogni persona rilevata nel riepilogo ha un ID univoco. Puoi utilizzare l'ID per scoprire informazioni come la posizione del riquadro di delimitazione di una persona che non indossa dispositivi di protezione individuale. 

**Nota**  
L'ID viene generato casualmente sulla base di un'analisi per immagine e non è coerente tra le immagini o le analisi multiple della stessa immagine.

Puoi riassumere le protezioni per il viso, i copricapi, le protezioni per le mani o una combinazione a tua scelta. Per specificare i tipi di DPI richiesti, consulta [Specificazione dei requisiti di riepilogo](ppe-request-response.md#ppe-summarization-input-parameters). È inoltre possibile specificare un livello di confidenza minimo (50-100) che deve essere soddisfatto affinché i rilevamenti vengano inclusi nel riepilogo. 

 Per ulteriori informazioni sulla risposta di riepilogo da `DetectProtectiveEquipment`, consulta [Comprendere la risposta DetectProtectiveEquipment](ppe-request-response.md#detect-protective-equipment-response).

## Tutorial: creazione di una AWS Lambda funzione che rileva le immagini con PPE
<a name="ppe-tutorial-lambda"></a>

Puoi creare una AWS Lambda funzione che rileva i dispositivi di protezione individuale (DPI) nelle immagini che si trovano in un bucket Amazon S3. Consulta l'[ GitHub archivio degli esempi di AWS Documentation SDK](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/javav2/usecases/creating_lambda_ppe) per questo tutorial su Java V2.

# Comprensione dell'API di rilevamento dei dispositivi di protezione individuale
<a name="ppe-request-response"></a>

Le seguenti informazioni descrivono l'API. [DetectProtectiveEquipment](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectProtectiveEquipment.html) Per il codice di esempio, consulta [Rilevamento dei dispositivi di protezione individuale in un immagine](ppe-procedure-image.md).

## Fornire un'immagine
<a name="detect-protective-equipment-request"></a>

Puoi fornire un'immagine di input (formato JPG o PNG) sia come byte di immagine sia facendo riferimento a un'immagine archiviata in un bucket S3. 

Si consiglia di utilizzare immagini in cui il viso della persona è rivolto verso la fotocamera.

Se l'immagine in ingresso non è ruotata di 0 gradi, consigliamo di ruotarla di 0 gradi prima di inviarla a `DetectProtectiveEquipment`. Le immagini in formato JPG potrebbero contenere informazioni di orientamento nei metadati Exif (Exchangeable Image File Format). È possibile utilizzare queste informazioni per scrivere un codice che ruoti l'immagine. Per ulteriori informazioni, consulta [Exif versione 2.32](http://cipa.jp/std/documents/download_e.html?DC-008-Translation-2019-E). Le immagini in formato PNG non contengono informazioni sull'orientamento dell'immagine. 

 Per trasferire un'immagine da un bucket Amazon S3, usa un utente con almeno `` i privilegi AmazonS3. ReadOnlyAccess Usa un utente con privilegi `AmazonRekognitionFullAccess` per chiamare `DetectProtectiveEquipment.` 

Nell'esempio seguente input JSON, l'immagine viene passata in un bucket Amazon S3. Per ulteriori informazioni, consulta [Lavorare con le immagini](images.md). L'esempio richiede un riepilogo di tutti i tipi di DPI (copricapo, protezione per i guanti e protezione per il volto) con una confidenza di rilevamento minima (`MinConfidence`) dell'80%. È necessario specificare un valore `MinConfidence` compreso tra il 50 e il 100%, in quanto `DetectProtectiveEquipment` restituisce previsioni solo quando la confidenza del rilevamento è compresa tra il 50% e il 100%. Se si specifica un valore inferiore al 50%, i risultati sono gli stessi specificando un valore del 50%. Per ulteriori informazioni, consulta [Specificazione dei requisiti di riepilogo](#ppe-summarization-input-parameters). 

```
{
    "Image": {
        "S3Object": {
            "Bucket": "amzn-s3-demo-bucket",
            "Name": "worker.jpg"
        }
    },
    "SummarizationAttributes": {
        "MinConfidence": 80,
        "RequiredEquipmentTypes": [
            "FACE_COVER",
            "HAND_COVER",
            "HEAD_COVER"
        ]
    }
}
```

Se disponi di un'ampia raccolta di immagini da elaborare, considera la possibilità di utilizzare [Batch AWS](https://docs.aws.amazon.com/batch/latest/userguide/) per elaborare le chiamate a `DetectProtectiveEquipment` in batch in background. 

### Specificazione dei requisiti di riepilogo
<a name="ppe-summarization-input-parameters"></a>

Facoltativamente, puoi utilizzare il parametro di input `SummarizationAttributes` ([ProtectiveEquipmentSummarizationAttributes](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ProtectiveEquipmentSummarizationAttributes.html)) per richiedere informazioni di riepilogo sui tipi di DPI rilevati in un'immagine.

Per specificare i tipi di DPI da riepilogare, utilizzate il campo array `RequiredEquipmentTypes`. Nell'array, includete uno o più di `FACE_COVER`, `HAND_COVER` o `HEAD_COVER`. 

Utilizzate il campo `MinConfidence` per specificare una confidenza minima di rilevamento (50-100). Il riepilogo non include persone, parti del corpo, parti del corpo coperte e articoli di DPI rilevati con un grado di confidenza inferiore a `MinConfidence`.

Per informazioni sulla risposta di riepilogo da `DetectProtectiveEquipment`, consulta [Comprendere la risposta DetectProtectiveEquipment](#detect-protective-equipment-response). 



## Comprendere la risposta DetectProtectiveEquipment
<a name="detect-protective-equipment-response"></a>

`DetectProtectiveEquipment` restituisce un array di persone rilevate nell'immagine di input. Per ogni persona, vengono restituite informazioni sulle parti del corpo rilevate e sugli articoli di DPI rilevati. Il codice JSON per l'immagine seguente di un lavoratore che indossa un copricapo, una protezione per le mani e una protezione per il volto è il seguente.

![\[Operaio edile che indossa camicia a quadretti, elmetto e mascherina con in mano un utensile elettrico. Le caselle verdi evidenziano viso, elmetto, mano guantata e strumento.\]](http://docs.aws.amazon.com/it_it/rekognition/latest/dg/images/worker-with-bb.png)


Nel JSON, tenere presente quanto segue.
+ **Persone rilevate**: `Persons` è un array di persone rilevate nell'immagine (comprese le persone che non indossano DPI). `DetectProtectiveEquipment` è in grado di rilevare i DPI su un massimo di 15 persone rilevate in un'immagine. Ogni [ProtectiveEquipmentPerson](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ProtectiveEquipmentPerson.html)oggetto dell'array contiene un ID personale, un riquadro di delimitazione per la persona, le parti del corpo rilevate e gli elementi di DPI rilevati. Il valore di `Confidence` in `ProtectiveEquipmentPerson` indica la percentuale di fiducia di Amazon Rekognition che il riquadro di delimitazione contenga una persona.
+ **Parti del corpo**: `BodyParts` è una serie di parti del corpo ([ProtectiveEquipmentBodyPart](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ProtectiveEquipmentBodyPart.html)) rilevate su una persona (comprese le parti del corpo non coperte dai DPI). Ciascuna `ProtectiveEquipmentBodyPart` include il nome (`Name`) della parte del corpo rilevata. `DetectProtectEquipment` è in grado di rilevare parti del corpo del volto, della testa, della mano sinistra e della mano destra. Il campo `Confidence` in `ProtectiveEquipmentBodyPart` indica la percentuale di confidenza di Amazon Rekognition nella precisione di rilevamento della parte del corpo. 
+ **Elementi DPI**: l'array `EquipmentDetections` di un oggetto `ProtectiveEquipmentBodyPart` contiene una serie di elementi DPI rilevati. Ogni [EquipmentDetection](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_EquipmentDetection.html)oggetto contiene i seguenti campi. 
  +  `Type`— Il tipo di DPI rilevato.
  + `BoundingBox`— un riquadro di delimitazione attorno al DPI rilevato.
  + `Confidence`— La fiducia di Amazon Rekognition che il riquadro di delimitazione contenga i DPI rilevati.
  + `CoversBodyPart`— Indica se il DPI rilevato si trova sulla parte del corpo corrispondente.

  Il [CoversBodyPart](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CoversBodyPart.html)campo `Value` è un valore booleano che indica se il DPI rilevato si trova sulla parte del corpo corrispondente. Il campo `Confidence` indica la fiducia nella previsione. È possibile usare `CoversBodyPart` per filtrare i casi in cui il DPI rilevato è presente nell'immagine, ma non effettivamente sulla persona. 
**Nota**  
`CoversBodyPart` non indica o implica che la persona sia adeguatamente protetta dall'equipaggiamento protettivo o che l'equipaggiamento protettivo stesso sia indossato correttamente. 
+ **Informazioni di riepilogo** – `Summary` contiene le informazioni di riepilogo specificate nel parametro `SummarizationAttributes` di input. Per ulteriori informazioni, consulta [Specificazione dei requisiti di riepilogo](#ppe-summarization-input-parameters).

  `Summary`è un oggetto di tipo [ProtectiveEquipmentSummary](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ProtectiveEquipmentSummary.html)che contiene le seguenti informazioni.
  + `PersonsWithRequiredEquipment`— Una serie IDs di persone in cui ogni persona soddisfa i seguenti criteri.
    + La persona indossa tutti i DPI specificati nel parametro `SummarizationAttributes` di input. 
    + La `Confidence` per la persona (`ProtectiveEquipmentPerson`), parte del corpo (`ProtectiveEquipmentBodyPart`), equipaggiamento protettivo (`EquipmentDetection`) è uguale o superiore alla soglia minima di confidenza specificata (`MinConfidence`).
    + Il valore di `CoversBodyPart` per tutti gli articoli di DPI è vero. 
  + `PersonsWithoutRequiredEquipment`— Una serie IDs di persone che soddisfano uno dei seguenti criteri. 
    + Il valore `Confidence` per la persona (`ProtectiveEquipmentPerson`), parte del corpo (`ProtectiveEquipmentBodyPart`) e copertura delle parti del corpo (`CoversBodyPart`) sono superiori alla soglia minima di confidenza specificata (`MinConfidence`), ma alla persona mancano uno o più DPI specificati (`SummarizationAttributes`).
    + Il valore di `CoversBodyPart` è false per ogni DPI specificato (`SummarizationAttributes`) con un valore `Confidence` superiore alla soglia di confidenza minima specificata (`MinConfidence`). La persona dispone inoltre di tutti i DPI specificati (`SummarizationAttributes`), e i valori `Confidence` per persona (`ProtectiveEquipmentPerson`), parte del corpo (`ProtectiveEquipmentBodyPart`) e equipaggiamento protettivo (`EquipmentDetection`) sono superiori o uguali alla soglia minima di confidenza (`MinConfidence`).
  + `PersonsIndeterminate`— Una serie IDs di persone rilevate in cui il `Confidence` valore della persona (`ProtectiveEquipmentPerson`), della parte del corpo (), dell'equipaggiamento protettivo (`EquipmentDetection`) o del valore `CoversBodyPart` booleano è inferiore alla soglia di confidenza minima specificata (`MinConfidence`). `ProtectiveEquipmentBodyPart` 

  Utilizzate la dimensione dell'array per ottenere un conteggio per un particolare riepilogo. Ad esempio, la taglia di `PersonsWithRequiredEquipment` indica il numero di persone rilevate che indossano il tipo di DPI specificato.

  Puoi utilizzare l'ID della persona per scoprire ulteriori informazioni su una persona, come la posizione del riquadro di delimitazione della persona. L'ID della persona viene mappato al campo ID di un oggetto restituito (`ProtectiveEquipmentPerson`) in `Persons` (array di`ProtectiveEquipmentPerson`). È quindi possibile ottenere il riquadro di delimitazione e altre informazioni dall'oggetto `ProtectiveEquipmentPerson` corrispondente. 

```
 {
    "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": []
    }
}
```

# Rilevamento dei dispositivi di protezione individuale in un immagine
<a name="ppe-procedure-image"></a>

Per rilevare i dispositivi di protezione individuale (DPI) sulle persone in un'immagine, utilizzate l'operazione API [DetectProtectiveEquipment](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectProtectiveEquipment.html)senza archiviazione. 

Puoi fornire l'immagine di input come matrice di byte dell'immagine (byte dell'immagine codificata in formato Base64) o come un oggetto Amazon S3 utilizzando AWS SDK o AWS Command Line Interface (AWS CLI). Questi esempi utilizzano un'immagine memorizzata in un bucket Amazon S3. Per ulteriori informazioni, consulta [Lavorare con le immagini](images.md). 

**Per rilevare i DPI sulle persone in un'immagine**

1. Se non lo hai già fatto:

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

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

1. Carica un'immagine (contenente una o più persone che indossano un DPI) nel bucket S3. 

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

1. Utilizzare i seguenti esempi per richiamare l'operazione `DetectProtectiveEquipment`. Per informazioni sulla visualizzazione dei riquadri di delimitazione in un'immagine, consultare [Visualizzazione di riquadri di delimitazione](images-displaying-bounding-boxes.md).

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

   Questo esempio visualizza informazioni sui DPI rilevati sulle persone rilevate in un'immagine. 

   Modificare il valore di `amzn-s3-demo-bucket` con il nome del bucket Amazon S3 che contiene l’immagine. Modifica il valore di `photo` nel nome del file immagine.

   ```
   //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 <ProtectiveEquipmentPerson> persons = result.getPersons();
   
   
               for (ProtectiveEquipmentPerson person: persons) {
                   System.out.println("ID: " + person.getId());
                   List<ProtectiveEquipmentBodyPart> 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<EquipmentDetection> 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<Integer> 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<Integer> 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 ]

   Questo codice è tratto dal GitHub repository degli esempi di AWS Documentation SDK. Guarda l'esempio completo [qui](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javav2/example_code/rekognition/src/main/java/com/example/rekognition/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: " +
            "   <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_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<ProtectiveEquipmentPerson> persons = result.persons();
            for (ProtectiveEquipmentPerson person: persons) {
                System.out.println("ID: " + person.id());
                List<ProtectiveEquipmentBodyPart> 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<EquipmentDetection> 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<GetObjectResponse> 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<Integer> 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 ]

   Questo AWS CLI comando richiede un riepilogo PPE e visualizza l'output JSON per l'operazione CLI`detect-protective-equipment`. 

   Sostituisci `amzn-s3-demo-bucket` con il nome di un bucket Amazon S3 contenente un'immagine. Sostituisci `input.jpg` con il nome dell'immagine che si desidera utilizzare.

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

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

   Sostituisci `amzn-s3-demo-bucket` con il nome di un bucket Amazon S3 contenente un'immagine. Sostituisci `input.jpg` con il nome dell'immagine che si desidera utilizzare.

   ```
   aws rekognition detect-protective-equipment \
     --image "S3Object={Bucket=amzn-s3-demo-bucket,Name=input.jpg}"
   ```

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

   Questo esempio visualizza informazioni sui DPI rilevati sulle persone rilevate in un'immagine. 

   Modificare il valore di `amzn-s3-demo-bucket` con il nome del bucket Amazon S3 che contiene l’immagine. Modifica il valore di `photo` nel nome del file immagine. Sostituisci il valore di `profile_name` nella riga che crea la sessione di Rekognition con il nome del tuo profilo di sviluppatore. 

   ```
   # 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()
   ```

------

# Esempio: disegnare riquadri di delimitazione attorno alle protezioni del viso
<a name="ppe-example-image-bounding-box"></a>

Gli esempi seguenti mostrano come disegnare dei riquadri di delimitazione attorno alle protezioni del viso rilevate sulle persone. Per un esempio che utilizza AWS Lambda Amazon DynamoDB, consulta l'archivio degli esempi di [Documentation AWS SDK](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/javav2/usecases/creating_lambda_ppe). GitHub 

Per rilevare le coperture facciali, si utilizza l'operazione API non di storage [DetectProtectiveEquipment](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectProtectiveEquipment.html). L'immagine viene caricata dal file system locale. Fornisci un'immagine di input a `DetectProtectiveEquipment` come matrice di byte dell'immagine (byte dell'immagine codificata in formato base64). Per ulteriori informazioni, consulta [Lavorare con le immagini](images.md).

L'esempio visualizza un riquadro di delimitazione attorno alle protezioni del viso rilevate. Il riquadro di delimitazione è verde se la protezione del viso copre completamente la parte del corpo. Altrimenti viene visualizzato un riquadro di delimitazione rosso. Come avvertimento, se la confidenza di rilevamento è inferiore al valore di confidenza specificato, viene visualizzato un riquadro di delimitazione giallo all'interno del riquadro di delimitazione facciale. Se non viene rilevata una copertura facciale, attorno alla persona viene disegnato un riquadro di delimitazione rosso. 

L’immagine output è simile a quello riportato di seguito. 

![\[Quattro operai in un magazzino, che indossano giubbotti ad alta visibilità, caschi, occhiali di sicurezza e mascherine. Le maschere sono circondate da scatole delimitative.\]](http://docs.aws.amazon.com/it_it/rekognition/latest/dg/images/workers-with-bb.png)


**Per visualizzare i riquadri di delimitazione sulle protezioni del viso rilevate**

1. Se non lo hai già fatto:

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

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

1. Utilizzare i seguenti esempi per richiamare l'operazione `DetectProtectiveEquipment`. Per informazioni sulla visualizzazione dei riquadri di delimitazione in un'immagine, consultare [Visualizzazione di riquadri di delimitazione](images-displaying-bounding-boxes.md).

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

   Nella funzione `main`, modificate quanto segue: 
   + Il valore di `photo` del percorso e il nome di un file di immagine locale (PNG o JPEG).
   + Il valore del livello `confidence` di confidenza desiderato (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<ProtectiveEquipmentPerson> persons = result.getPersons();
   
           for (ProtectiveEquipmentPerson person: persons) {
               BoundingBox boxPerson = person.getBoundingBox();
               left = width * boxPerson.getLeft();
               top = height * boxPerson.getTop();
               Boolean foundMask=false;
   
               List<ProtectiveEquipmentBodyPart> bodyParts=person.getBodyParts();
               
               if (bodyParts.isEmpty()==false)
                {
                       //body parts detected
   
                       for (ProtectiveEquipmentBodyPart bodyPart: bodyParts) {
   
                           List<EquipmentDetection> 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 ]

   Questo codice è tratto dal GitHub repository degli esempi di AWS Documentation SDK. Guarda l'esempio completo [qui](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javav2/example_code/rekognition/src/main/java/com/example/rekognition/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: " +
            "   <sourceImage> <bucketName>\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<GetObjectResponse> 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<ProtectiveEquipmentPerson> persons = result.persons();
        for (ProtectiveEquipmentPerson person: persons) {
   
            List<ProtectiveEquipmentBodyPart> bodyParts=person.bodyParts();
            if (!bodyParts.isEmpty()){
                for (ProtectiveEquipmentBodyPart bodyPart: bodyParts) {
                    List<EquipmentDetection> 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 ]

   Nella funzione `main`, modificate quanto segue: 
   + Il valore di `photo` del percorso e il nome di un file di immagine locale (PNG o JPEG).
   + Il valore del livello `confidence` di confidenza desiderato (50-100).
   +  Sostituisci il valore di `profile_name` nella riga che crea la sessione di Rekognition con il nome del tuo profilo di sviluppatore. 

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

   Nel seguente esempio di CLI, modifica il valore degli argomenti elencati di seguito: 
   + Il valore di `photo` del percorso e il nome di un file di immagine locale (PNG o JPEG).
   + Il valore del livello `confidence` di confidenza desiderato (50-100).
   +  Sostituisci il valore di `profile_name` nella riga che crea la sessione di Rekognition con il nome del tuo profilo di sviluppatore. 

   ```
                                   aws rekognition detect-protective-equipment  --image "{"S3Object":{"Bucket":"amzn-s3-demo-bucket","Name":"image-name"}}" --profile profile-name \ 
                                   --summarization-attributes "{"MinConfidence":MinConfidenceNumber,"RequiredEquipmentTypes":["FACE_COVER"]}"
   ```

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

   ```
                                   aws rekognition detect-protective-equipment  --image "{\"S3Object\":{\"Bucket\":\"amzn-s3-demo-bucket\",\"Name\":\"image-name\"}}" \ 
                                   --profile profile-name --summarization-attributes "{\"MinConfidence\":MinConfidenceNumber,\"RequiredEquipmentTypes\":[\"FACE_COVER\"]}"
   ```

------