As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Detecção de equipamento de proteção individual
<a name="ppe-detection"></a>

O Amazon Rekognition pode detectar o Equipamento de Proteção Individual (EPI) usado por pessoas em uma imagem. Você pode usar essas informações para melhorar as práticas de segurança no local de trabalho. Por exemplo, você pode usar a detecção de EPI para ajudar a determinar se os trabalhadores em um canteiro de obras estão usando coberturas para a cabeça ou se os profissionais da área médica estão usando coberturas faciais e protetores para as mãos. A imagem a seguir mostra alguns dos tipos de EPI que podem ser detectados.

![\[Trabalhador usando EPI, incluindo capacete, óculos de segurança, máscara protetora e luvas, operando uma ferramenta elétrica. Caixas delimitadoras ao redor dos itens.\]](http://docs.aws.amazon.com/pt_br/rekognition/latest/dg/images/worker-with-bb.png)


Para detectar PPE em uma imagem, você chama a [DetectProtectiveEquipment](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectProtectiveEquipment.html)API e passa uma imagem de entrada. A resposta é uma estrutura JSON que inclui o seguinte.
+ As pessoas detectadas na imagem.
+ As partes do corpo em que o EPI é usado (rosto, cabeça, mão esquerda e mão direita).
+ Os tipos de EPI detectados em partes do corpo (cobertura facial, cobertura para as mãos e cobertura para a cabeça). 
+ Para itens de EPI detectados, um indicador de se o EPI cobre ou não a parte corporal correspondente.

As caixas delimitadoras são devolvidas para a localização das pessoas e itens de EPI detectados na imagem. 

Opcionalmente, você pode solicitar um resumo dos itens de EPI e das pessoas detectadas em uma imagem. Para obter mais informações, consulte [Resumindo o EPI detectado em uma imagem](#ppe-summarization). 

**nota**  
A detecção de PPE do Amazon Rekognition não realiza reconhecimento facial ou comparação facial e não consegue identificar as pessoas detectadas. 

## Tipos de EPI
<a name="ppe-types"></a>

[DetectProtectiveEquipment](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectProtectiveEquipment.html)detecta os seguintes tipos de EPI. Se você quiser detectar outros tipos de EPI em imagens, considere usar Amazon Rekognition Custom Labels para treinar um modelo personalizado. Para obter mais informações, consulte [Amazon Rekognition Custom Labels](https://docs.aws.amazon.com/rekognition/latest/customlabels-dg/what-is.html).

### Proteção facial
<a name="ppe-face-cover"></a>

`DetectProtectiveEquipment` pode detectar proteções faciais comuns, como máscaras cirúrgicas, N95 e feitas de tecido. 

### Proteções de mão
<a name="ppe-hand-cover"></a>

`DetectProtectiveEquipment` pode detectar proteções de mão, como luvas cirúrgicas e luvas de segurança. 

### Proteções de cabeça
<a name="ppe-head-cover"></a>

`DetectProtectiveEquipment` pode detectar capacetes e chapéus. 

A API indica que uma cobertura de cabeça, mão ou rosto foi detectada em uma imagem. A API não retorna informações sobre o tipo de uma capa específica. Por exemplo, "luva cirúrgica" para o tipo de capa de mão. 

## Confiança na detecção de EP
<a name="ppe-confidence"></a>

O Amazon Rekognition faz uma previsão sobre a presença de EPI, pessoas e partes do corpo em uma imagem. A API fornece uma pontuação (50 a 100) que indica a confiança do Amazon Rekognition na precisão de uma previsão. 

**nota**  
Se você planeja usar a operação `DetectProtectiveEquipment` para tomar uma decisão que afete os direitos, a privacidade ou o acesso a serviços de um indivíduo, recomendamos que você passe o resultado a um humano para análise e validação antes de agir. 

## Resumindo o EPI detectado em uma imagem
<a name="ppe-summarization"></a>

Opcionalmente, você pode solicitar um resumo dos itens do PPE e das pessoas detectadas em uma imagem. Você pode especificar uma lista de equipamentos de proteção necessários (proteção facial, proteção para as mãos ou proteção para a cabeça) e um limite mínimo de confiança (por exemplo, 80%). A resposta inclui um resumo consolidado do identificador por imagem (ID) de pessoas com o EPI exigido, pessoas sem o EPI exigido e pessoas em que uma determinação não pôde ser feita. 

O resumo permite que você responda rapidamente a perguntas como *Quantas pessoas não estão usando proteções faciais?* ou *Todo mundo está usando EPI?* Cada pessoa detectada no resumo tem um ID exclusivo. Você pode usar o documento de identidade para descobrir informações como a localização da caixa delimitadora de uma pessoa que não usa EPI. 

**nota**  
O ID é gerado aleatoriamente com base na análise por imagem e não é consistente em todas as imagens ou em várias análises da mesma imagem.

Você pode resumir capas faciais, capas de cabeça, capas para mãos ou uma combinação de sua escolha. Para especificar os tipos de EPI necessários, consulte [Especificando os requisitos do resumo](ppe-request-response.md#ppe-summarization-input-parameters). Você também pode especificar um nível mínimo de confiança (50-100) que deve ser atingido para que as detecções sejam incluídas no resumo. 

 Para obter mais informações sobre a resposta resumida de `DetectProtectiveEquipment`, consulte [Entendendo a DetectProtectiveEquipment resposta](ppe-request-response.md#detect-protective-equipment-response).

## Tutorial: Criando uma AWS Lambda função que detecta imagens com PPE
<a name="ppe-tutorial-lambda"></a>

Você pode criar uma AWS Lambda função que detecte equipamentos de proteção individual (EPI) em imagens localizadas em um bucket do Amazon S3. Consulte o [ GitHub repositório de exemplos do SDK de AWS documentação](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/javav2/usecases/creating_lambda_ppe) para ver este tutorial do Java V2.

# Entendendo a API de detecção de equipamentos de proteção individual
<a name="ppe-request-response"></a>

As informações a seguir descrevem a [DetectProtectiveEquipment](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectProtectiveEquipment.html)API. Para obter um código de exemplo, consulte [Detectando equipamento de proteção individual em uma imagem](ppe-procedure-image.md).

## Fornecer uma imagem
<a name="detect-protective-equipment-request"></a>

Você pode fornecer a imagem de entrada (formato JPG ou PNG) como bytes de imagem ou fazer referência a uma imagem armazenada em um bucket do Amazon S3. 

Recomendamos usar imagens em que a face da pessoa esteja voltado para a câmera.

Se sua imagem de entrada não estiver girada para a orientação de 0 grau, recomendamos girá-la para a orientação de 0 grau antes de enviá-la para `DetectProtectiveEquipment`. As imagens no formato JPG podem conter informações de orientação nos metadados do formato de arquivo de imagem intercambiável (Exif). Você pode usar essas informações para escrever um código que gira sua imagem. Para obter mais informações, consulte [Exif versão 2.32](http://cipa.jp/std/documents/download_e.html?DC-008-Translation-2019-E). As imagens no formato PNG não contêm informações de orientação da imagem. 

 Para passar uma imagem de um bucket do Amazon S3, use um usuário com pelo menos privilégios do `` ReadOnlyAccess AmazonS3. Use um usuário com privilégios `AmazonRekognitionFullAccess` para fazer chamadas `DetectProtectiveEquipment.` 

No exemplo de JSON de entrada a seguir, a imagem é passada em um bucket do Amazon S3. Para obter mais informações, consulte [Como trabalhar com imagens](images.md). O exemplo solicita um resumo de todos os tipos de EPI (cobertura de cabeça, capa de mão e cobertura facial) com uma confiança de detecção mínima (`MinConfidence`) de 80%. Você deve especificar um valor de `MinConfidence` entre 50 e 100%, pois `DetectProtectiveEquipment` retorna previsões somente quando a confiança da detecção está entre 50% e 100%. Se você especificar um valor menor que 50%, os resultados serão os mesmos especificando um valor de 50%. Para obter mais informações, consulte [Especificando os requisitos do resumo](#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 você tiver uma grande coleção de imagens a serem processadas para reconhecimento, considere usar o [AWS Batch](https://docs.aws.amazon.com/batch/latest/userguide/) para processar as chamadas de `DetectProtectiveEquipment` em lotes em segundo plano. 

### Especificando os requisitos do resumo
<a name="ppe-summarization-input-parameters"></a>

Opcionalmente, você pode usar o parâmetro de entrada `SummarizationAttributes` ([ProtectiveEquipmentSummarizationAttributes](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ProtectiveEquipmentSummarizationAttributes.html)) para solicitar informações resumidas sobre os tipos de PPE detectados em uma imagem.

Para especificar os tipos de PPE a serem resumidos, use o campo de matriz `RequiredEquipmentTypes`. Na matriz, inclua um ou mais de `FACE_COVER`, `HAND_COVER` ou `HEAD_COVER`. 

Use o campo `MinConfidence` para especificar uma confiança mínima de detecção (50-100). O resumo não inclui pessoas, partes do corpo, cobertura de partes do corpo e itens de EPI, detectados com uma confiança inferiora `MinConfidence`.

Para obter informações sobre a resposta resumida de `DetectProtectiveEquipment`, consulte [Entendendo a DetectProtectiveEquipment resposta](#detect-protective-equipment-response). 



## Entendendo a DetectProtectiveEquipment resposta
<a name="detect-protective-equipment-response"></a>

`DetectProtectiveEquipment` retorna uma matriz de pessoas detectadas na imagem de entrada. Para cada pessoa, as informações sobre partes do corpo detectadas e itens de EPI detectados são devolvidas. O JSON da imagem a seguir de um trabalhador usando uma cobertura para a cabeça, para as mãos e para a face é o seguinte.

![\[Trabalhador da construção civil vestindo camisa quadriculada, capacete e máscara facial, segurando uma ferramenta elétrica. As caixas verdes destacam o rosto, o capacete, a mão enluvada e a ferramenta.\]](http://docs.aws.amazon.com/pt_br/rekognition/latest/dg/images/worker-with-bb.png)


No JSON, observe o seguinte.
+ **Pessoas detectadas** — `Persons` é uma variedade de pessoas detectadas na imagem (incluindo pessoas que não usam EPI). `DetectProtectiveEquipment` pode detectar EPI em até 15 pessoas detectadas em uma imagem. Cada [ProtectiveEquipmentPerson](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ProtectiveEquipmentPerson.html)objeto na matriz contém uma identificação pessoal, uma caixa delimitadora para a pessoa, partes do corpo detectadas e itens detectados de EPI. O valor de `Confidence` in `ProtectiveEquipmentPerson` indica a porcentagem de confiança que o Amazon Rekognition tem de que a caixa delimitadora contém uma pessoa.
+ **Partes do corpo** — `BodyParts` é uma série de partes do corpo ([ProtectiveEquipmentBodyPart](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ProtectiveEquipmentBodyPart.html)) detectadas em uma pessoa (incluindo partes do corpo não cobertas pelo EPI). Cada `ProtectiveEquipmentBodyPart` inclui o nome (`Name`) da parte do corpo detectada. `DetectProtectEquipment` pode detectar partes da face, cabeça, mão esquerda e direita do corpo. O campo `Confidence` em `ProtectiveEquipmentBodyPart` indica a porcentagem de confiança que o Amazon Rekognition tem na precisão de detecção da parte do corpo. 
+ **Itens PPE**: a matriz `EquipmentDetections` em um objeto `ProtectiveEquipmentBodyPart` contém uma matriz de itens EPI detectados. Cada [EquipmentDetection](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_EquipmentDetection.html)objeto contém os seguintes campos. 
  +  `Type`: o tipo do EPI detectado.
  + `BoundingBox`: uma caixa delimitadora ao redor do EPI detectado.
  + `Confidence`: a confiança que o Amazon Rekognition tem de que a caixa delimitadora contém o EPI detectado.
  + `CoversBodyPart`: indica se o EPI detectado está na parte do corpo correspondente.

  O [CoversBodyPart](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CoversBodyPart.html)campo `Value` é um valor booleano que indica se o PPE detectado está na parte correspondente do corpo. O campo `Confidence` indica a confiança na previsão. Você pode usar `CoversBodyPart` para filtrar os casos em que o EPI detectado está na imagem, mas não na verdade na pessoa. 
**nota**  
`CoversBodyPart` não indica, nem implica, que a pessoa está adequadamente protegida pelo equipamento de proteção ou que o equipamento de proteção em si está usado adequadamente. 
+ **Informações resumidas** — `Summary` contém as informações resumidas especificadas no parâmetro de entrada `SummarizationAttributes`. Para obter mais informações, consulte [Especificando os requisitos do resumo](#ppe-summarization-input-parameters).

  `Summary`é um objeto do tipo [ProtectiveEquipmentSummary](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ProtectiveEquipmentSummary.html)que contém as seguintes informações.
  + `PersonsWithRequiredEquipment`— Uma série IDs de pessoas em que cada pessoa atende aos seguintes critérios.
    + A pessoa está usando todos os EPI especificados no parâmetro de entrada `SummarizationAttributes`. 
    + O `Confidence` para a pessoa (`ProtectiveEquipmentPerson`), parte do corpo (`ProtectiveEquipmentBodyPart`), equipamento de proteção (`EquipmentDetection`) é igual ou maior que o limite mínimo de confiança especificado (`MinConfidence`).
    + O valor de `CoversBodyPart` para todos os itens do EPI é verdadeiro. 
  + `PersonsWithoutRequiredEquipment`— Uma série IDs de pessoas que atendem a um dos seguintes critérios. 
    + O valor `Confidence` da pessoa (`ProtectiveEquipmentPerson`), parte do corpo (`ProtectiveEquipmentBodyPart`) e cobertura da parte do corpo (`CoversBodyPart`) é maior do que o limite mínimo de confiança especificado (`MinConfidence`), mas falta um ou mais EPI especificados (`SummarizationAttributes`) à pessoa.
    + O valor de `CoversBodyPart` é falso para qualquer EPI (`SummarizationAttributes`) especificado que tenha um valor `Confidence` maior que o limite mínimo de confiança especificado (`MinConfidence`). A pessoa também tem todos os EPI especificados (`SummarizationAttributes`) e os `Confidence` valores para pessoa (`ProtectiveEquipmentPerson`), parte do corpo (`ProtectiveEquipmentBodyPart`) e equipamento de proteção (`EquipmentDetection`) são maiores ou iguais ao limite mínimo de confiança (`MinConfidence`.
  + `PersonsIndeterminate`— Uma matriz IDs de pessoas detectadas em que o `Confidence` valor da pessoa (`ProtectiveEquipmentPerson`), parte do corpo (`ProtectiveEquipmentBodyPart`), equipamento de proteção (`EquipmentDetection`) ou `CoversBodyPart` booleano é inferior ao limite mínimo de confiança especificado (`MinConfidence`). 

  Use o tamanho da matriz para obter uma contagem de um resumo específico. Por exemplo, o tamanho de `PersonsWithRequiredEquipment` indica o número de pessoas detectadas usando o tipo especificado de EPI.

  Você pode usar o ID pessoal para descobrir mais informações sobre uma pessoa, como a localização da caixa delimitadora da pessoa. O ID da pessoa é mapeado para o campo ID de um objeto `ProtectiveEquipmentPerson`) retornado em `Persons` (matriz de `ProtectiveEquipmentPerson`). Você pode então obter a caixa delimitadora e outras informações do objeto correspondente `ProtectiveEquipmentPerson`. 

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

# Detectando equipamento de proteção individual em uma imagem
<a name="ppe-procedure-image"></a>

Para detectar equipamentos de proteção individual (EPI) em pessoas em uma imagem, use a operação [DetectProtectiveEquipment](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectProtectiveEquipment.html)de API sem armazenamento. 

Você pode fornecer a imagem de entrada como uma matriz de bytes de imagem (bytes de imagem codificados em base64) ou como um objeto do Amazon S3, usando o AWS SDK ou o AWS Command Line Interface (AWS CLI). Esses exemplos usam uma imagem armazenada em um bucket do Amazon S3. Para obter mais informações, consulte [Como trabalhar com imagens](images.md). 

**Para detectar EPI em pessoas em uma imagem**

1. Se ainda não tiver feito isso:

   1. Crie ou atualize um usuário com permissões `AmazonRekognitionFullAccess` e `AmazonS3ReadOnlyAccess`. Para obter mais informações, consulte [Etapa 1: Configure uma conta da AWS e crie um usuário](setting-up.md#setting-up-iam).

   1. Instale e configure o AWS CLI e AWS SDKs o. Para obter mais informações, consulte [Etapa 2: configurar o AWS CLI e AWS SDKs](setup-awscli-sdk.md).

1. Faça upload de uma imagem (que contenha uma ou mais pessoas usando EPI) no seu bucket do S3. 

   Para obter instruções, consulte [Como fazer upload de objetos no Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UploadingObjectsintoAmazonS3.html) no *Guia do usuário do Amazon Simple Storage Service*.

1. Use os exemplos a seguir para chamar a operação `DetectProtectiveEquipment`. Para obter informações sobre como exibir caixas delimitadoras em uma imagem, consulte [Exibir caixas delimitadoras](images-displaying-bounding-boxes.md).

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

   Este exemplo exibe informações sobre os itens de EPI detectados em pessoas detectadas em uma imagem. 

   Altere o valor de `amzn-s3-demo-bucket` para o nome do bucket do Amazon S3 que contém sua imagem. Altere o valor de `photo` para o nome do seu arquivo de imagem.

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

   Esse código foi retirado do GitHub repositório de exemplos do SDK de AWS documentação. Veja o exemplo completo [aqui](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 ]

   Esse AWS CLI comando solicita um resumo do PPE e exibe a saída JSON para a operação da `detect-protective-equipment` CLI. 

   Mude `amzn-s3-demo-bucket` para o nome de um bucket do Amazon S3 que contém uma imagem. Mude `input.jpg` para o nome da imagem que você deseja usar.

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

   Esse AWS CLI comando exibe a saída JSON para a operação da `detect-protective-equipment` CLI. 

   Mude `amzn-s3-demo-bucket` para o nome de um bucket do Amazon S3 que contém uma imagem. Mude `input.jpg` para o nome da imagem que você deseja usar.

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

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

   Este exemplo exibe informações sobre os itens de EPI detectados em pessoas detectadas em uma imagem. 

   Altere o valor de `amzn-s3-demo-bucket` para o nome do bucket do Amazon S3 que contém sua imagem. Altere o valor de `photo` para o nome do seu arquivo de imagem. Substitua o valor de `profile_name` na linha que cria a sessão do Rekognition pelo nome do seu perfil de desenvolvedor. 

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

------

# Exemplo: Desenhando caixas delimitadoras em torno de capas faciais
<a name="ppe-example-image-bounding-box"></a>

Os exemplos a seguir mostram como desenhar caixas delimitadoras em torno de coberturas faciais detectadas em pessoas. Para ver um exemplo que usa AWS Lambda o Amazon DynamoDB, consulte o repositório de exemplos de SDK [AWS de documentação](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/javav2/usecases/creating_lambda_ppe). GitHub 

Para detectar capas faciais, você usa a operação [DetectProtectiveEquipment](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectProtectiveEquipment.html)de API sem armazenamento. A imagem é carregada do sistema de arquivos local. Você fornece a imagem de entrada `DetectProtectiveEquipment` como uma matriz de bytes de imagem (bytes de imagem codificados em base64). Para obter mais informações, consulte [Como trabalhar com imagens](images.md).

O exemplo exibe uma caixa delimitadora ao redor das capas faciais detectadas. A caixa delimitadora é verde se a cobertura facial cobrir totalmente a parte do corpo. Caso contrário, uma caixa delimitadora vermelha será exibida. Como aviso, uma caixa delimitadora amarela é exibida dentro da caixa delimitadora da tampa frontal, se a confiança de detecção for menor que o valor de confiança especificado. Se uma cobertura facial não for detectada, uma caixa delimitadora vermelha é desenhada ao redor da pessoa. 

A saída da imagem é semelhante à seguinte. 

![\[Quatro trabalhadores em um armazém usando coletes, capacetes, óculos de segurança e máscaras de alta visibilidade. As máscaras estão dentro de caixas delimitadoras.\]](http://docs.aws.amazon.com/pt_br/rekognition/latest/dg/images/workers-with-bb.png)


**Para exibir caixas delimitadoras nas capas faciais detectadas**

1. Se ainda não tiver feito isso:

   1. Crie ou atualize um usuário com permissões `AmazonRekognitionFullAccess`. Para obter mais informações, consulte [Etapa 1: Configure uma conta da AWS e crie um usuário](setting-up.md#setting-up-iam).

   1. Instale e configure o AWS CLI e AWS SDKs o. Para obter mais informações, consulte [Etapa 2: configurar o AWS CLI e AWS SDKs](setup-awscli-sdk.md).

1. Use os exemplos a seguir para chamar a operação `DetectProtectiveEquipment`. Para obter informações sobre como exibir caixas delimitadoras em uma imagem, consulte [Exibir caixas delimitadoras](images-displaying-bounding-boxes.md).

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

   Na função `main`, altere o seguinte: 
   + O valor de `photo` para o caminho e o nome de arquivo de um arquivo de imagem local (PNG ou JPEG).
   + O valor de `confidence` até o nível de confiança desejado (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 ]

   Esse código foi retirado do GitHub repositório de exemplos do SDK de AWS documentação. Veja o exemplo completo [aqui](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 ]

   Na função `main`, altere o seguinte: 
   + O valor de `photo` para o caminho e o nome de arquivo de um arquivo de imagem local (PNG ou JPEG).
   + O valor de `confidence` até o nível de confiança desejado (50-100).
   +  Substitua o valor de `profile_name` na linha que cria a sessão do Rekognition pelo nome do seu perfil de desenvolvedor. 

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

   No exemplo de CLI a seguir, altere o valor dos argumentos listados abaixo: 
   + O valor de `photo` para o caminho e o nome de arquivo de um arquivo de imagem local (PNG ou JPEG).
   + O valor de `confidence` até o nível de confiança desejado (50-100).
   +  Substitua o valor de `profile_name` na linha que cria a sessão do Rekognition pelo nome do seu perfil de desenvolvedor. 

   ```
                                   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 você estiver acessando a CLI em um dispositivo Windows, use aspas duplas em vez de aspas simples e escape das aspas duplas internas com barra invertida (ou seja, \$1) para resolver quaisquer erros de analisador que você possa encontrar. Para obter um exemplo, veja o seguinte: 

   ```
                                   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\"]}"
   ```

------