Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Detección de equipos de protección individual
<a name="ppe-detection"></a>

Amazon Rekognition puede detectar el equipo de protección individual (EPI) que llevan las personas en una imagen. Puede utilizar esta información para mejorar las prácticas de seguridad en el lugar de trabajo. Por ejemplo, puede usar la detección de EPI para ayudar a determinar si los trabajadores de una obra de construcción llevan cubierta la cabeza o si los trabajadores médicos usan cubiertas para la cara y las manos. La siguiente imagen muestra algunos de los tipos de EPI que se pueden detectar.

![\[Trabajador con equipo de protección individual que incluye casco, gafas de seguridad, máscara protectora y guantes, con una herramienta eléctrica. Cuadros delimitadores alrededor de los artículos\]](http://docs.aws.amazon.com/es_es/rekognition/latest/dg/images/worker-with-bb.png)


Para detectar el PPE en una imagen, debe llamar a la [DetectProtectiveEquipment](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectProtectiveEquipment.html)API y pasar una imagen de entrada. La respuesta es una estructura JSON que incluye lo siguiente.
+ Las personas detectadas en la imagen.
+ Las partes del cuerpo en las que se lleva puesto el EPI (cara, cabeza, mano izquierda y mano derecha).
+ Los tipos de EPI que se detectan en las partes del cuerpo (cubierta facial, cubierta para manos y cubierta para la cabeza). 
+ En el caso de los elementos de EPI detectados, un indicador de si el EPI cubre o no la parte del cuerpo correspondiente.

Los recuadros delimitadores indican la ubicación de las personas y los objetos de EPI detectados en la imagen. 

Si lo desea, puede solicitar un resumen de los objetos de EPI y las personas detectados en una imagen. Para obtener más información, consulte [Descripción de EPI detectado en una imagen](#ppe-summarization). 

**nota**  
La detección de EPI de Amazon Rekognition no realiza reconocimiento facial ni comparación facial y no puede identificar a las personas detectadas. 

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

[DetectProtectiveEquipment](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectProtectiveEquipment.html)detecta los siguientes tipos de EPP. Si desea detectar otros tipos de EPI en las imágenes, considere la posibilidad de utilizar las Etiquetas personalizadas de Amazon Rekognition para entrenar un modelo personalizado. Para obtener más información, consulte [Etiquetas personalizadas de Amazon Rekognition](https://docs.aws.amazon.com/rekognition/latest/customlabels-dg/what-is.html).

### Cubierta facial
<a name="ppe-face-cover"></a>

`DetectProtectiveEquipment` puede detectar mascarillas comunes, como las quirúrgicas, las N95 y las mascarillas de tela. 

### Cubierta para la mano
<a name="ppe-hand-cover"></a>

`DetectProtectiveEquipment` puede detectar cubiertas para la mano, como guantes quirúrgicos y guantes de seguridad. 

### Cubierta para la cabeza
<a name="ppe-head-cover"></a>

`DetectProtectiveEquipment` puede detectar gorros y cascos. 

La API indica que se ha detectado una cubierta para la cabeza, la mano o la cara en una imagen. La API no devuelve información sobre el tipo de cubierta específica. Por ejemplo, “guante quirúrgico” para el tipo de cubierta de mano. 

## Confianza de detección de EPI
<a name="ppe-confidence"></a>

Amazon Rekognition realiza una predicción sobre la presencia de EPI, personas y partes del cuerpo en una imagen. La API proporciona una puntuación (50 a 100) que indica la confianza de Amazon Rekognition en la precisión de una predicción. 

**nota**  
Si piensa utilizar la operación `DetectProtectiveEquipment` para tomar una decisión que afecte a los derechos, la privacidad o el acceso de una persona a los servicios, le recomendamos que transmita el resultado a una persona para que lo revise y lo valide antes de tomar medidas. 

## Descripción de EPI detectado en una imagen
<a name="ppe-summarization"></a>

Si lo desea, puede solicitar un resumen de los objetos de EPI y las personas detectados en una imagen. Puede especificar una lista de EPI necesario (cubierta facial, cubierta para las manos o cubierta para la cabeza) y un umbral de confianza mínimo (por ejemplo, el 80 %). La respuesta incluye un resumen consolidado del identificador (ID) por imagen de las personas que llevan el EPI requerido, las personas que no tienen el EPI requerido y las personas sobre las que no se pudo tomar una decisión. 

El resumen le permite responder rápidamente a preguntas como: *¿Cuántas personas no se cubren la cara?* o *¿Todas las personas usan EPI?* Cada persona detectada en el resumen tiene un ID único. Puede utilizar el ID para obtener información como la ubicación del recuadro delimitador de una persona que no lleve puesto el EPI. 

**nota**  
El ID se genera aleatoriamente a partir de un análisis por imagen y no es coherente en todas las imágenes o en varios análisis de la misma imagen.

Puede resumir las cubiertas faciales, las cubiertas para la cabeza, las cubiertas para las manos o una combinación de lo que prefiera. Para especificar los tipos de EPI necesarios, consulte [Especificar los requisitos de resumen](ppe-request-response.md#ppe-summarization-input-parameters). También puede especificar un nivel de confianza mínimo (50-100) que debe cumplirse para que las detecciones se incluyan en el resumen. 

 Para obtener más información sobre la respuesta de resumen de `DetectProtectiveEquipment`, consulte [Entender la DetectProtectiveEquipment respuesta](ppe-request-response.md#detect-protective-equipment-response).

## Tutorial: Creación de una AWS Lambda función que detecte imágenes con PPE
<a name="ppe-tutorial-lambda"></a>

Puede crear una AWS Lambda función que detecte el equipo de protección personal (EPP) en las imágenes ubicadas en un bucket de Amazon S3. Consulte el [ GitHub repositorio de ejemplos del SDK de AWS documentación](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/javav2/usecases/creating_lambda_ppe) para ver este tutorial sobre Java V2.

# Comprensión de la API de detección de equipos de protección individual
<a name="ppe-request-response"></a>

La siguiente información describe la [DetectProtectiveEquipment](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectProtectiveEquipment.html)API. Para ver el código de ejemplo, consulte [Detección de equipos de protección individual en una imagen](ppe-procedure-image.md).

## Suministrar una imagen
<a name="detect-protective-equipment-request"></a>

Puede proporcionar una imagen de entrada (formato JPG o PNG) como bytes de imagen o referencia a una imagen almacenada en un bucket de Amazon S3. 

Recomendamos utilizar imágenes en las que el rostro de la persona mire hacia la cámara.

Si la imagen de entrada no está girada en una orientación de 0 grados, le recomendamos girarla a una orientación de 0 grados antes de enviarla a `DetectProtectiveEquipment`. Las imágenes en formato JPG pueden contener información de orientación en los metadatos del formato de archivo de imagen intercambiable (Exif). Puede utilizar esta información para escribir código que haga una rotación. Para obtener más información, consulte [Exif Version 2.32](http://cipa.jp/std/documents/download_e.html?DC-008-Translation-2019-E). Las imágenes en formato PNG no contienen información sobre la orientación de la imagen. 

 Para transferir una imagen desde un bucket de Amazon S3, utilice un usuario con al menos los ReadOnlyAccess privilegios de `` Amazon S3. Utilice un usuario con privilegios de `AmazonRekognitionFullAccess` para llamar a `DetectProtectiveEquipment.` 

En el siguiente ejemplo, si introduce JSON, la imagen se pasa a un bucket de Amazon S3. Para obtener más información, consulte [Trabajar con imágenes](images.md). En el ejemplo se solicita un resumen de todos los tipos de EPI (cubierta para la cabeza, cubierta para las manos y cubierta para la cara) con una confianza de detección mínima (`MinConfidence`) del 80 %. Debe especificar un valor de `MinConfidence` que esté entre el 50 y el 100 %, ya que `DetectProtectiveEquipment` solo devuelve predicciones cuando la confianza de detección está entre el 50 y el 100 %. Si especifica un valor inferior al 50 %, los resultados son los mismos, especificando un valor del 50 %. Para obtener más información, consulte [Especificar los requisitos de resumen](#ppe-summarization-input-parameters). 

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

Si tiene una amplia gama de imágenes para procesar, considere la posibilidad de utilizar [AWS Batch](https://docs.aws.amazon.com/batch/latest/userguide/) para procesar las llamadas a `DetectProtectiveEquipment` en lotes en segundo plano. 

### Especificar los requisitos de resumen
<a name="ppe-summarization-input-parameters"></a>

Si lo desea, puede utilizar el parámetro de entrada `SummarizationAttributes` ([ProtectiveEquipmentSummarizationAttributes](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ProtectiveEquipmentSummarizationAttributes.html)) para solicitar información resumida sobre los tipos de PPE detectados en una imagen.

Para especificar los tipos de EPI que se van a resumir, utilice el campo de matriz de `RequiredEquipmentTypes`. En la matriz, incluya uno o más `FACE_COVER`, `HAND_COVER` o `HEAD_COVER`. 

Utilice el campo `MinConfidence` para especificar una confianza de detección mínima (50-100). El resumen no incluye las personas, las partes del cuerpo, la cobertura de partes del cuerpo ni los elementos de EPI detectados con una confianza inferior a `MinConfidence`.

Para obtener información sobre la respuesta de resumen de `DetectProtectiveEquipment`, consulte [Entender la DetectProtectiveEquipment respuesta](#detect-protective-equipment-response). 



## Entender la DetectProtectiveEquipment respuesta
<a name="detect-protective-equipment-response"></a>

`DetectProtectiveEquipment` devuelve una matriz de personas detectadas en la imagen de entrada. Para cada persona, se devuelve información sobre las partes del cuerpo detectadas y los elementos de EPI. El código JSON de la siguiente imagen de un trabajador con la cabeza, las manos y la cara cubiertas es el siguiente.

![\[Trabajador de la construcción con una camisa a cuadros, casco y máscara facial que sujeta una herramienta eléctrica. El rostro, el casco, los guantes y la herramienta se resaltan con cuadros verdes.\]](http://docs.aws.amazon.com/es_es/rekognition/latest/dg/images/worker-with-bb.png)


En el JSON, tenga en cuenta lo siguiente.
+ **Personas detectadas**: `Persons` es un conjunto de personas detectadas en la imagen (incluidas las personas que no llevan EPI). `DetectProtectiveEquipment` puede detectar el EPI en hasta 15 personas detectadas en una imagen. Cada [ProtectiveEquipmentPerson](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ProtectiveEquipmentPerson.html)objeto de la matriz contiene un carné de identidad, un recuadro delimitador para la persona, las partes del cuerpo detectadas y los elementos de protección personal detectados. El valor `Confidence` en `ProtectiveEquipmentPerson` indica el porcentaje de confianza que Amazon Rekognition tiene en que el recuadro delimitador contiene una persona.
+ **Partes del cuerpo**: `BodyParts` es un conjunto de partes del cuerpo ([ProtectiveEquipmentBodyPart](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ProtectiveEquipmentBodyPart.html)) detectadas en una persona (incluidas las partes del cuerpo que no están cubiertas por el EPP). Cada `ProtectiveEquipmentBodyPart` incluye el nombre (`Name`) de la parte del cuerpo detectada. `DetectProtectEquipment` puede detectar partes del cuerpo de la cara, la cabeza y las manos. El campo `Confidence` en `ProtectiveEquipmentBodyPart` indica el porcentaje de confianza que Amazon Rekognition tiene en la precisión de detección de la parte del cuerpo. 
+ **Elementos de EPI**: la matriz de `EquipmentDetections` en un objeto `ProtectiveEquipmentBodyPart` contiene una serie de elementos de EPI detectados. Cada [EquipmentDetection](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_EquipmentDetection.html)objeto contiene los siguientes campos. 
  +  `Type`: el tipo de EPI detectado.
  + `BoundingBox`: un recuadro delimitador alrededor del EPI detectado.
  + `Confidence`: la confianza que Amazon Rekognition tiene de que el recuadro delimitador contiene el EPI detectado.
  + `CoversBodyPart`: indica si el EPI detectado se encuentra en la parte del cuerpo correspondiente.

  El [CoversBodyPart](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CoversBodyPart.html)campo `Value` es un valor booleano que indica si el EPP detectado se encuentra en la parte del cuerpo correspondiente. El campo `Confidence` indica la confianza en la predicción. Se puede utilizar `CoversBodyPart` para filtrar los casos en los que el EPI detectado aparezca en la imagen, pero no en la persona. 
**nota**  
`CoversBodyPart` no indica ni implica que la persona esté adecuadamente protegida por el EPI o que el equipo de protección en sí esté debidamente colocado. 
+ **Información resumida**: `Summary` contiene la información resumida especificada en el parámetro de entrada `SummarizationAttributes`. Para obtener más información, consulte [Especificar los requisitos de resumen](#ppe-summarization-input-parameters).

  `Summary`es un objeto de tipo [ProtectiveEquipmentSummary](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ProtectiveEquipmentSummary.html)que contiene la siguiente información.
  + `PersonsWithRequiredEquipment`— Un conjunto IDs de personas en el que cada persona cumple los siguientes criterios.
    + La persona lleva puesto todo el EPI especificado en el parámetro de entrada `SummarizationAttributes`. 
    + El `Confidence` para la persona (`ProtectiveEquipmentPerson`), la parte del cuerpo (`ProtectiveEquipmentBodyPart`) y el equipo de protección (`EquipmentDetection`) es igual o superior al umbral de confianza mínimo especificado (`MinConfidence`).
    + El valor de `CoversBodyPart` para todos los elementos del EPI es true. 
  + `PersonsWithoutRequiredEquipment`— Un conjunto IDs de personas que cumplen uno de los siguientes criterios. 
    + El valor `Confidence` de la persona (`ProtectiveEquipmentPerson`), la parte del cuerpo (`ProtectiveEquipmentBodyPart`) y la cobertura de la parte del cuerpo (`CoversBodyPart`) superan el umbral de confianza mínimo especificado (`MinConfidence`), pero a la persona le faltan uno o más EPI específicos (`SummarizationAttributes`).
    + El valor de `CoversBodyPart` es falso para cualquier EPI (`SummarizationAttributes`) especificado que tenga un valor de `Confidence` superior al umbral de confianza mínimo especificado (`MinConfidence`). La persona también tiene todo el EPI especificado (`SummarizationAttributes`) y los valores `Confidence` de persona (`ProtectiveEquipmentPerson`), parte del cuerpo (`ProtectiveEquipmentBodyPart`) y equipo de protección (`EquipmentDetection`) son superiores o iguales al umbral mínimo de confianza (`MinConfidence`).
  + `PersonsIndeterminate`— Un conjunto IDs de personas detectadas en el que el `Confidence` valor correspondiente a la persona (`ProtectiveEquipmentPerson`), la parte del cuerpo (`ProtectiveEquipmentBodyPart`), el equipo de protección (`EquipmentDetection`) o el valor `CoversBodyPart` booleano es inferior al umbral mínimo de confianza especificado (`MinConfidence`). 

  Utilice el tamaño de la matriz para obtener el recuento de un resumen concreto. Por ejemplo, el valor de `PersonsWithRequiredEquipment` indica el número de personas detectadas que llevan el tipo de EPI especificado.

  Puede usar el ID de la persona para obtener más información sobre una persona, como la ubicación del recuadro delimitador de la persona. El ID de la persona se asigna al campo de ID de un objeto `ProtectiveEquipmentPerson` devuelto en `Persons` (matriz de `ProtectiveEquipmentPerson`). A continuación, puede obtener el cuadro delimitador y otra información del objeto `ProtectiveEquipmentPerson` correspondiente. 

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

# Detección de equipos de protección individual en una imagen
<a name="ppe-procedure-image"></a>

Para detectar el equipo de protección personal (EPP) en las personas de una imagen, utilice la operación API [DetectProtectiveEquipment](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectProtectiveEquipment.html)sin almacenamiento. 

Puede proporcionar la imagen de entrada como matriz de bytes de imagen (bytes de imagen con codificación base64) o como un objeto de Amazon S3, utilizando el AWS SDK o la AWS Command Line Interface (AWS CLI). En estos ejemplos, se utiliza una imagen almacenada en un bucket de Amazon S3. Para obtener más información, consulte [Trabajar con imágenes](images.md). 

**Para detectar el EPI en las personas de una imagen**

1. Si aún no lo ha hecho:

   1. Cree o actualice un usuario con los permisos `AmazonRekognitionFullAccess` y `AmazonS3ReadOnlyAccess`. Para obtener más información, consulte [Paso 1: Configurar una cuenta de AWS y crear un usuario](setting-up.md#setting-up-iam).

   1. Instale y configure el AWS CLI y el AWS SDKs. Para obtener más información, consulte [Paso 2: Configure y AWS CLI AWS SDKs](setup-awscli-sdk.md).

1. Suba una imagen que contenga una o varias personas llevando EPI en su bucket de S3. 

   Para ver las instrucciones, consulte [Carga de objetos en Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UploadingObjectsintoAmazonS3.html) en la *Guía del usuario de Amazon Simple Storage Service*.

1. Consulte los siguientes ejemplos para llamar a la operación `DetectProtectiveEquipment`. Para obtener información sobre cómo mostrar los cuadros delimitadores en una imagen, consulte [Visualización de cuadros delimitadores](images-displaying-bounding-boxes.md).

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

   En este ejemplo, se muestra información sobre los elementos de EPI detectados en las personas detectadas en una imagen. 

   Cambie el valor de `amzn-s3-demo-bucket` por el nombre del bucket de Amazon S3 que contiene su imagen. Cambie el valor de `photo` por el nombre de su archivo de imagen.

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

   Este código se ha tomado del GitHub repositorio de ejemplos del SDK de AWS documentación. Consulte el ejemplo completo [aquí](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 ]

   Este AWS CLI comando solicita un resumen del PPE y muestra el resultado JSON de la operación `detect-protective-equipment` CLI. 

   Cambie `amzn-s3-demo-bucket` por el nombre del bucket de Amazon S3 que contiene una imagen. Cambie el valor de `input.jpg` por el nombre de la imagen que desee 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']"
   ```

   Este AWS CLI comando muestra el resultado JSON de la operación `detect-protective-equipment` CLI. 

   Cambie `amzn-s3-demo-bucket` por el nombre del bucket de Amazon S3 que contiene una imagen. Cambie el valor de `input.jpg` por el nombre de la imagen que desee usar.

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

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

   En este ejemplo, se muestra información sobre los elementos de EPI detectados en las personas detectadas en una imagen. 

   Cambie el valor de `amzn-s3-demo-bucket` por el nombre del bucket de Amazon S3 que contiene su imagen. Cambie el valor de `photo` por el nombre de su archivo de imagen. Sustituya el valor de `profile_name` en la línea que crea la sesión de Rekognition por el nombre de su perfil de desarrollador. 

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

------

# Ejemplo: dibujar recuadros delimitadores alrededor de las mascarillas
<a name="ppe-example-image-bounding-box"></a>

En los siguientes ejemplos, se muestra cómo dibujar recuadros delimitadores alrededor de las mascarillas detectadas en personas. Para ver un ejemplo que utilice AWS Lambda Amazon DynamoDB, consulte el repositorio de ejemplos [AWS del SDK de documentación](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/javav2/usecases/creating_lambda_ppe). GitHub 

Para detectar mascarillas, utilice la operación API que [DetectProtectiveEquipment](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectProtectiveEquipment.html)no es de almacenamiento. La imagen se carga desde el sistema de archivos local. Puede proporcionar la imagen de entrada a `DetectProtectiveEquipment` como una matriz de bytes de imagen (bytes con codificación en base64). Para obtener más información, consulte [Trabajar con imágenes](images.md).

El ejemplo muestra un recuadro delimitador alrededor de las mascarillas detectadas. El recuadro delimitador es verde si la mascarilla cubre completamente la parte del cuerpo. De lo contrario, aparecerá un cuadro delimitador rojo. Como advertencia, si la confianza de la detección es inferior al valor de confianza especificado, aparecerá un recuadro delimitador amarillo dentro del recuadro delimitador de la mascarilla. Si no se detecta ninguna mascarilla, se dibuja un cuadro delimitador rojo alrededor de la persona. 

El resultado de la imagen es similar al siguiente. 

![\[Cuatro trabajadores de un almacén, con chalecos reflectantes, cascos, gafas de seguridad y máscaras. Las máscaras están rodeadas por cuadros delimitadores.\]](http://docs.aws.amazon.com/es_es/rekognition/latest/dg/images/workers-with-bb.png)


**Para mostrar los recuadros delimitadores en las mascarillas detectadas**

1. Si aún no lo ha hecho:

   1. Cree o actualice un usuario de `AmazonRekognitionFullAccess` con permisos. Para obtener más información, consulte [Paso 1: Configurar una cuenta de AWS y crear un usuario](setting-up.md#setting-up-iam).

   1. Instale y configure el AWS CLI y el AWS SDKs. Para obtener más información, consulte [Paso 2: Configure y AWS CLI AWS SDKs](setup-awscli-sdk.md).

1. Consulte los siguientes ejemplos para llamar a la operación `DetectProtectiveEquipment`. Para obtener información sobre cómo mostrar los cuadros delimitadores en una imagen, consulte [Visualización de cuadros delimitadores](images-displaying-bounding-boxes.md).

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

   En la función `main`, cambie lo siguiente: 
   + El valor de `photo` a la ruta y el nombre de archivo de un archivo de imagen local (PNG o JPEG).
   + El valor de `confidence` al nivel de confianza deseado (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 ]

   Este código se ha tomado del GitHub repositorio de ejemplos del SDK de AWS documentación. Consulte el ejemplo completo [aquí](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 ]

   En la función `main`, cambie lo siguiente: 
   + El valor de `photo` a la ruta y el nombre de archivo de un archivo de imagen local (PNG o JPEG).
   + El valor de `confidence` al nivel de confianza deseado (50-100).
   +  Sustituya el valor de `profile_name` en la línea que crea la sesión de Rekognition por el nombre de su perfil de desarrollador. 

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

   En el siguiente ejemplo de la CLI, cambie el valor de los argumentos que se enumeran a continuación: 
   + El valor de `photo` a la ruta y el nombre de archivo de un archivo de imagen local (PNG o JPEG).
   + El valor de `confidence` al nivel de confianza deseado (50-100).
   +  Sustituya el valor de `profile_name` en la línea que crea la sesión de Rekognition por el nombre de su perfil de desarrollador. 

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

    Si accede a la CLI en un dispositivo Windows, utilice comillas dobles en lugar de comillas simples y evite las comillas dobles internas con una barra invertida (es decir, \$1) para corregir cualquier error del analizador que pueda encontrar. Por ver un ejemplo, consulte lo siguiente: 

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

------