Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Erkennung von persönlicher Schutzausrüstung
<a name="ppe-detection"></a>

Amazon Rekognition kann persönliche Schutzausrüstung (PSA) erkennen, die von Personen auf einem Bild getragen wird. Sie können diese Informationen verwenden, um die Sicherheitsmaßnahmen am Arbeitsplatz zu verbessern. Mithilfe der PSA-Erkennung können Sie beispielsweise feststellen, ob Arbeiter auf einer Baustelle Kopfbedeckungen tragen oder ob medizinisches Personal Gesichtsbedeckungen und Handbedeckungen trägt. Die folgende Abbildung zeigt einige Arten von persönlicher Schutzausrüstung, die erkannt werden können.

![\[Arbeiter, der persönliche Schutzausrüstung einschließlich Helm, Schutzbrille, Schutzmaske und Handschuhe trägt und ein Elektrowerkzeug bedient. Begrenzungsboxen rund um die Gegenstände.\]](http://docs.aws.amazon.com/de_de/rekognition/latest/dg/images/worker-with-bb.png)


Um PPE in einem Bild zu erkennen, rufen Sie die [DetectProtectiveEquipment](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectProtectiveEquipment.html)API auf und übergeben ein Eingabebild. Die Antwort ist eine JSON-Struktur, die Folgendes umfasst.
+ Die auf dem Bild erkannten Personen.
+ Die Körperteile, an denen persönliche Schutzausrüstung getragen wird (Gesicht, Kopf, linke Hand und rechte Hand).
+ Die Arten von PSA, die an Körperteilen festgestellt wurden (Gesichtsbedeckung, Handbedeckung und Kopfbedeckung). 
+ Bei erkannten PSA-Artikeln ein Indikator dafür, ob die PSA den entsprechenden Körperteil bedeckt oder nicht.

Sie erhalten Begrenzungsrahmen für die Positionen von Personen und PSA-Artikel, die auf dem Bild erkannt wurden. 

Optional können Sie eine Zusammenfassung der auf einem Bild erkannten PSA-Artikel und Personen anfordern. Weitere Informationen finden Sie unter [Zusammenfassung der PSA, die in einem Bild erkannt wurde](#ppe-summarization). 

**Anmerkung**  
Die Amazon-Rekognition-PSA-Erkennung führt weder Gesichtserkennung noch Gesichtsvergleiche durch und kann die erkannten Personen nicht identifizieren. 

## Arten von PSA
<a name="ppe-types"></a>

[DetectProtectiveEquipment](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectProtectiveEquipment.html)erkennt die folgenden Arten von persönlicher Schutzausrüstung. Wenn Sie andere Arten von PSA in Bildern erkennen möchten, sollten Sie erwägen, Amazon Rekognition Custom Labels zu verwenden, um ein benutzerdefiniertes Modell zu trainieren. Weitere Informationen finden Sie unter [Amazon Rekognition Custom Labels](https://docs.aws.amazon.com/rekognition/latest/customlabels-dg/what-is.html).

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

`DetectProtectiveEquipment` kann gängige Gesichtsbedeckungen wie chirurgische Gesichtsbedeckungen, N95-Masken und Masken aus Stoff erkennen. 

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

`DetectProtectiveEquipment` kann Handbedeckungen wie Operationshandschuhe und Schutzhandschuhe erkennen. 

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

`DetectProtectiveEquipment` kann Schutzhelme erkennen. 

Die API gibt an, dass in einem Bild ein Kopf, eine Hand oder eine Gesichtsbedeckung erkannt wurde. Die API gibt keine Informationen zum Typ einer bestimmten Abdeckung zurück. Zum Beispiel „Operationshandschuh“ für die Art einer Handbedeckung. 

## Zuverlässigkeit der PSA-Erkennung
<a name="ppe-confidence"></a>

Amazon Rekognition macht eine Vorhersage über das Vorhandensein von PSA, Personen und Körperteilen in einem Bild. Die API liefert eine Punktzahl (50–100), die angibt, wie sicher Amazon Rekognition von der Genauigkeit einer Vorhersage ist. 

**Anmerkung**  
Wenn Sie die `DetectProtectiveEquipment`-Operation nutzen möchten, um eine Entscheidung zu treffen, die sich auf die Rechte, den Datenschutz oder den Zugang zu Diensten einer Person auswirkt, empfehlen wir Ihnen, das Ergebnis zur Überprüfung und Bestätigung an einen Mitarbeiter weiterzuleiten, bevor Sie Maßnahmen ergreifen. 

## Zusammenfassung der PSA, die in einem Bild erkannt wurde
<a name="ppe-summarization"></a>

Optional können Sie eine Zusammenfassung der auf einem Bild erkannten PSA-Artikel und Personen anfordern. Sie können eine Liste der erforderlichen Schutzausrüstung (Gesichtsbedeckung, Handbedeckung oder Kopfbedeckung) und eine Mindestvertrauensschwelle (z. B. 80 %) angeben. Die Antwort umfasst eine konsolidierte Zusammenfassung pro Bild anhand der Identifikationsnummer (ID) der Personen mit der erforderlichen persönlichen Schutzausrüstung, der Personen ohne die erforderliche persönliche Schutzausrüstung und der Personen, bei denen keine Entscheidung getroffen werden konnte. 

Anhand der Zusammenfassung können Sie schnell Fragen wie „*Wie viele Personen tragen keine Gesichtsbedeckungen?*“ oder *Tragen alle persönliche Schutzausrüstung?* beantworten. Jede erkannte Person in der Zusammenfassung hat eine eindeutige ID. Mithilfe der ID können Sie Informationen wie die Position des Begrenzungsrahmens einer Person ermitteln, die keine persönliche Schutzausrüstung trägt. 

**Anmerkung**  
Die ID wird für jede Bildanalyse nach dem Zufallsprinzip generiert und ist bei Bildern oder mehreren Analysen desselben Bilds nicht einheitlich.

Sie können Gesichtsbedeckungen, Kopfbedeckungen, Handbedeckungen oder eine Kombination Ihrer Wahl zusammenfassen. Informationen zur Angabe der erforderlichen PSA-Typen finden Sie unter [Spezifizierung der Anforderungen für die Zusammenfassung](ppe-request-response.md#ppe-summarization-input-parameters). Sie können auch ein Mindestzuverlässigkeitsniveau (50–100) angeben, das erfüllt sein muss, damit Erkennungen in die Zusammenfassung aufgenommen werden. 

 Weitere Informationen zur Antwort auf die Zusammenfassung von `DetectProtectiveEquipment` finden Sie unter [Die DetectProtectiveEquipment Antwort verstehen](ppe-request-response.md#detect-protective-equipment-response).

## Tutorial: Eine AWS Lambda Funktion erstellen, die Bilder mit PPE erkennt
<a name="ppe-tutorial-lambda"></a>

Sie können eine AWS Lambda Funktion erstellen, die persönliche Schutzausrüstung (PSA) in Bildern erkennt, die sich in einem Amazon S3 S3-Bucket befinden. Dieses Java V2-Tutorial finden Sie im [AWS GitHub Dokumentations-SDK-Beispiel-Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/javav2/usecases/creating_lambda_ppe).

# Grundlegendes zur API zur Erkennung persönlicher Schutzausrüstung
<a name="ppe-request-response"></a>

Die folgenden Informationen beschreiben die [DetectProtectiveEquipment](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectProtectiveEquipment.html)API. Einen Beispielcode finden Sie unter [Erkennung von persönlicher Schutzausrüstung in einem Bild](ppe-procedure-image.md).

## Bereitstellung eines Bilds
<a name="detect-protective-equipment-request"></a>

Sie können das Eingabebild (JPG- oder PNG-Format) entweder als Bild-Bytes bereitstellen oder auf ein in einem Amazon-S3-Bucket gespeichertes Bild verweisen. 

Wir empfehlen, Bilder zu verwenden, bei denen das Gesicht der Person zur Kamera zeigt.

Wenn Ihr Eingabebild nicht auf 0 Grad gedreht ist, empfehlen wir, es vor dem Senden an `DetectProtectiveEquipment` auf 0 Grad zu drehen. Bilder im JPG-Format können Ausrichtungsinformationen in den Metadaten des Exchangeable Image File Format (Exif) enthalten. Sie können diese Informationen verwenden, um einen Code zu schreiben, der Ihr Bild dreht. Weitere Informationen finden Sie unter [Exif Version 2.32](http://cipa.jp/std/documents/download_e.html?DC-008-Translation-2019-E). Bilder im PNG-Format enthalten keine Informationen zur Bildausrichtung. 

 Um ein Bild aus einem Amazon S3 S3-Bucket zu übergeben, verwenden Sie einen Benutzer mit mindestens `` AmazonS3-RechtenReadOnlyAccess . Verwenden Sie einen Benutzer mit `AmazonRekognitionFullAccess`-Berechtigungen zum Aufruf von `DetectProtectiveEquipment.` 

Im folgenden Eingabe-JSON-Beispiel wird das Bild in einem Amazon-S3-Bucket übergeben. Weitere Informationen finden Sie unter [Arbeiten mit Bildern](images.md). Im Beispiel wird eine Zusammenfassung aller PSA-Typen (Kopfbedeckung, Handbedeckung und Gesichtsbedeckung) mit einer Erkennungssicherheit (`MinConfidence`) von mindestens 80 % angefordert. Sie sollten einen `MinConfidence`-Wert zwischen 50 und 100 % angeben, da Vorhersagen nur dann von `DetectProtectiveEquipment` zurückgegeben werden, wenn die Erkennungssicherheit zwischen 50 und 100 % liegt. Wenn Sie einen Wert unter 50 % angeben, sind die Ergebnisse identisch, wenn Sie einen Wert von 50 % angeben. Weitere Informationen finden Sie unter [Spezifizierung der Anforderungen für die Zusammenfassung](#ppe-summarization-input-parameters). 

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

Wenn Sie eine große Sammlung von Bildern verarbeiten, empfiehlt sich der Einsatz von [AWS Batch](https://docs.aws.amazon.com/batch/latest/userguide/) zum Verarbeiten von Aufrufen an `DetectProtectiveEquipment` in Stapeln im Hintergrund. 

### Spezifizierung der Anforderungen für die Zusammenfassung
<a name="ppe-summarization-input-parameters"></a>

Sie können optional den Eingabeparameter `SummarizationAttributes` ([ProtectiveEquipmentSummarizationAttributes](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ProtectiveEquipmentSummarizationAttributes.html)) verwenden, um zusammenfassende Informationen zu den in einem Bild erkannten PSA-Typen anzufordern.

Verwenden Sie das `RequiredEquipmentTypes`-Array-Feld, um die PSA-Typen anzugeben, die zusammengefasst werden sollen. Fügen Sie in das Array einen oder mehrere `FACE_COVER` `HAND_COVER` oder `HEAD_COVER` ein. 

Verwenden Sie das `MinConfidence`-Feld, um ein Mindestmaß an Erkennungssicherheit (50–100) anzugeben. Die Zusammenfassung enthält keine Personen, Körperteile, Körperteilabdeckung und PSA-Elemente, die mit einer Wahrscheinlichkeit von weniger als `MinConfidence` erkennt werden.

Weitere Informationen zur Antwort auf die Zusammenfassung von `DetectProtectiveEquipment` finden Sie unter [Die DetectProtectiveEquipment Antwort verstehen](#detect-protective-equipment-response). 



## Die DetectProtectiveEquipment Antwort verstehen
<a name="detect-protective-equipment-response"></a>

`DetectProtectiveEquipment` gibt ein Array von Personen zurück, die im Eingabebild erkannt wurden. Für jede Person werden Informationen über die erkannten Körperteile und die erkannten persönlichen Schutzausrüstungen zurückgegeben. Der JSON-Code für das folgende Bild eines Arbeiters, der eine Kopf-, Hand- und Gesichtsbedeckung trägt, lautet wie folgt.

![\[Bauarbeiter mit kariertem Hemd, Schutzhelm und Gesichtsmaske, hält ein Elektrowerkzeug in der Hand. In grünen Kästchen sind Gesicht, Schutzhelm, behandschuhte Hand und Werkzeug hervorgehoben.\]](http://docs.aws.amazon.com/de_de/rekognition/latest/dg/images/worker-with-bb.png)


Beachten Sie in den JSON-Daten Folgendes:
+ **Erkannte Personen**: `Persons` ist eine Reihe von Personen, die auf dem Bild erkannt wurden (einschließlich Personen, die keine persönliche Schutzausrüstung tragen). `DetectProtectiveEquipment` kann persönliche Schutzausrüstung bei bis zu 15 Personen erkennen, die auf einem Bild erkannt wurden. Jedes [ProtectiveEquipmentPerson](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ProtectiveEquipmentPerson.html)Objekt in der Reihe enthält eine Personen-ID, einen Begrenzungsrahmen für die Person, erkannte Körperteile und erkannte persönliche Schutzausrüstung. Der Wert von `Confidence` in `ProtectiveEquipmentPerson` gibt die prozentuale Sicherheit von Amazon Rekognition an, dass das Begrenzungsfeld eine Person enthält.
+ **Körperteile** — `BodyParts` ist eine Reihe von Körperteilen ([ProtectiveEquipmentBodyPart](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ProtectiveEquipmentBodyPart.html)), die an einer Person erkannt wurden (einschließlich Körperteile, die nicht durch persönliche Schutzausrüstung abgedeckt sind). Jeder `ProtectiveEquipmentBodyPart` enthält den Namen (`Name`) des erkannten Körperteils. `DetectProtectEquipment` kann Gesicht, Kopf, linke und rechte Körperteile erkennen. Das `Confidence`-Feld in `ProtectiveEquipmentBodyPart` gibt das prozentuale Vertrauen an, das Amazon Rekognition in Bezug auf die Erkennungsgenauigkeit des Körperteils hat. 
+ **PSA-Artikel**: Das Array `EquipmentDetections` in einem `ProtectiveEquipmentBodyPart`-Objekt enthält eine Reihe von erkannten PSA-Artikeln. Jedes [EquipmentDetection](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_EquipmentDetection.html)Objekt enthält die folgenden Felder. 
  +  `Type` – der Typ der gefundenen PSA.
  + `BoundingBox` – ein Begrenzungsrahmen um die erkannte PSA.
  + `Confidence` – Das Vertrauen von Amazon Rekognition, dass der Begrenzungsrahmen die erkannte persönliche Schutzausrüstung enthält.
  + `CoversBodyPart` – Zeigt an, ob sich die erkannte persönliche Schutzausrüstung an der entsprechenden Körperstelle befindet.

  Das [CoversBodyPart](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CoversBodyPart.html)Feld `Value` ist ein boolescher Wert, der angibt, ob sich die erkannte PSA am entsprechenden Körperteil befindet. Das Feld `Confidence` gibt das Vertrauen in die Vorhersage an. Sie können `CoversBodyPart` verwenden, um Fälle herauszufiltern, in denen sich die erkannte persönliche Schutzausrüstung zwar auf dem Bild, aber nicht auf der Person befindet. 
**Anmerkung**  
`CoversBodyPart` bedeutet bzw. impliziert nicht, dass die Person durch die Schutzausrüstung angemessen geschützt ist oder dass die Schutzausrüstung selbst ordnungsgemäß getragen wurde. 
+ **Übersichtsinformationen**: `Summary` enthält die im `SummarizationAttributes`-Eingabeparameter angegebenen zusammenfassenden Informationen. Weitere Informationen finden Sie unter [Spezifizierung der Anforderungen für die Zusammenfassung](#ppe-summarization-input-parameters).

  `Summary`ist ein Objekt des Typs [ProtectiveEquipmentSummary](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ProtectiveEquipmentSummary.html), das die folgenden Informationen enthält.
  + `PersonsWithRequiredEquipment`— Eine Gruppe IDs von Personen, wobei jede Person die folgenden Kriterien erfüllt.
    + Die Person trägt die gesamte im `SummarizationAttributes`-Eingabeparameter angegebene persönliche Schutzausrüstung. 
    + Die `Confidence` für Person (`ProtectiveEquipmentPerson`), Körperteil (`ProtectiveEquipmentBodyPart`) und PSA (`EquipmentDetection`) ist gleich oder größer als die angegebene minimale Vertrauensschwelle (`MinConfidence`).
    + Der Wert von `CoversBodyPart` für alle PSA-Artikel ist wahr. 
  + `PersonsWithoutRequiredEquipment`— Eine Reihe IDs von Personen, die eines der folgenden Kriterien erfüllen. 
    + Der `Confidence`-Wert für Person (`ProtectiveEquipmentPerson`), Körperteil (`ProtectiveEquipmentBodyPart`) und Körperteilbedeckung (`CoversBodyPart`) liegt über dem angegebenen Mindestzuverlässigkeitsschwellenwert (`MinConfidence`), aber der Person fehlt ein oder mehrere angegebene PSA-Artikel (`SummarizationAttributes`).
    + Der Wert von `CoversBodyPart` ist falsch für jede angegebene persönliche Schutzausrüstung (`SummarizationAttributes`), deren `Confidence`-Wert über dem angegebenen Mindestzuverlässigkeitsschwellenwert (`MinConfidence`) liegt. Die Person verfügt außerdem über sämtliche angegebene PSA (`SummarizationAttributes`) und die `Confidence`-Werte für Person (`ProtectiveEquipmentPerson`), Körperteil (`ProtectiveEquipmentBodyPart`) und Schutzausrüstung (`EquipmentDetection`) sind größer oder gleich der minimalen Vertrauensschwelle (`MinConfidence`).
  + `PersonsIndeterminate`— Eine Reihe von erkannten Personen, bei denen IDs der `Confidence` Wert für die Person (`ProtectiveEquipmentPerson`), den Körperteil (), die Schutzausrüstung (`ProtectiveEquipmentBodyPart``EquipmentDetection`) oder den `CoversBodyPart` booleschen Wert unter dem angegebenen Mindestkonfidenzschwellenwert (`MinConfidence`) liegt. 

  Verwenden Sie die Array-Größe, um die Anzahl für eine bestimmte Zusammenfassung zu ermitteln. Die Größe von `PersonsWithRequiredEquipment` gibt beispielsweise Auskunft über die Anzahl der Personen, bei denen festgestellt wurde, dass sie den angegebenen PSA-Typ tragen.

  Sie können die Personen-ID verwenden, um weitere Informationen über eine Person herauszufinden, z. B. den Standort der Person im Begrenzungsrahmen. Die Personen-ID ist dem ID-Feld eines Objekts (`ProtectiveEquipmentPerson`) zugeordnet, das in `Persons` (Array von `ProtectiveEquipmentPerson`) zurückgegeben wurde. Sie können dann den Begrenzungsrahmen und andere Informationen aus dem entsprechenden `ProtectiveEquipmentPerson`-Objekt abrufen. 

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

# Erkennung von persönlicher Schutzausrüstung in einem Bild
<a name="ppe-procedure-image"></a>

Um persönliche Schutzausrüstung (PSA) von Personen auf einem Bild zu erkennen, verwenden Sie den API-Vorgang [DetectProtectiveEquipment](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectProtectiveEquipment.html)ohne Speicherung. 

Sie können das Eingabebild als Bild-Byte-Array (base64-codierte Bild-Bytes) oder als Amazon-S3-Objekt bereitstellen, indem Sie entweder AWS-SDK oder AWS Command Line Interface (AWS CLI) verwenden. In diesen Beispielen wird ein Bild, das in einem Amazon-S3-Bucket gespeichert ist, verwendet. Weitere Informationen finden Sie unter [Arbeiten mit Bildern](images.md). 

**So erkennen Sie PSA an Personen in einem Bild**

1. Wenn Sie dies noch nicht getan haben:

   1. Erstellen oder aktualisieren Sie einen Benutzer mit `AmazonRekognitionFullAccess`- und `AmazonS3ReadOnlyAccess`-Berechtigungen. Weitere Informationen finden Sie unter [Schritt 1: Einrichten eines AWS-Kontos und Erstellen eines Benutzers](setting-up.md#setting-up-iam).

   1. Installieren und konfigurieren Sie das AWS CLI und das AWS SDKs. Weitere Informationen finden Sie unter [Schritt 2: Richten Sie das AWS CLI und ein AWS SDKs](setup-awscli-sdk.md).

1. Laden Sie ein Bild (das eine oder mehrere Personen mit PSA enthält) in Ihren S3-Bucket hoch. 

   Weitere Anleitungen finden Sie unter [Upload eines Objekts in Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UploadingObjectsintoAmazonS3.html) im *Benutzerhandbuch für Amazon Simple Storage Service*.

1. Verwenden Sie die folgenden Beispiele zum Aufrufen der `DetectProtectiveEquipment`-Operation. Informationen zur Anzeige von Begrenzungsrahmen in einem Bild finden Sie unter [Anzeigen von Begrenzungsrahmen](images-displaying-bounding-boxes.md).

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

   In diesem Beispiel werden Informationen zu den PSA-Gegenständen angezeigt, die bei Personen erkannt wurden, die auf einem Bild erkannt wurden. 

   Ändern Sie den Wert von `amzn-s3-demo-bucket` in den Namen des Amazon S3-Buckets, das Ihr Bild enthält. Ändern Sie den Wert von `photo` in Ihren Bilddateinamen.

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

   Dieser Code stammt aus dem AWS Documentation SDK Examples GitHub Repository. Das vollständige Beispiel finden Sie [hier](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 ]

   Dieser AWS CLI Befehl fordert eine PPE-Zusammenfassung an und zeigt die JSON-Ausgabe für den `detect-protective-equipment` CLI-Vorgang an. 

   Ändern Sie `amzn-s3-demo-bucket` in den Namen eines Amazon-S3-Buckets, der ein Bild enthält. Ändern Sie `input.jpg` in den Namen des Bilds, den Sie verwenden möchten.

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

   Dieser AWS CLI Befehl zeigt die JSON-Ausgabe für den `detect-protective-equipment` CLI-Vorgang an. 

   Ändern Sie `amzn-s3-demo-bucket` in den Namen eines Amazon-S3-Buckets, der ein Bild enthält. Ändern Sie `input.jpg` in den Namen des Bilds, den Sie verwenden möchten.

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

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

   In diesem Beispiel werden Informationen zu den PSA-Gegenständen angezeigt, die bei Personen erkannt wurden, die auf einem Bild erkannt wurden. 

   Ändern Sie den Wert von `amzn-s3-demo-bucket` in den Namen des Amazon S3-Buckets, das Ihr Bild enthält. Ändern Sie den Wert von `photo` in Ihren Bilddateinamen. Ersetzen Sie den Wert von `profile_name` in der Zeile, die die Rekognition-Sitzung erstellt, durch den Namen Ihres Entwicklerprofils. 

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

------

# Beispiel: Zeichnen von Begrenzungsrahmen um Gesichtsbedeckungen
<a name="ppe-example-image-bounding-box"></a>

Die folgenden Beispiele zeigen Ihnen, wie Sie Begrenzungsrahmen um Gesichtsbedeckungen zeichnen, die bei Personen entdeckt wurden. Ein Beispiel, das Amazon DynamoDB verwendet AWS Lambda , finden Sie im [AWS Documentation SDK Examples GitHub ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/javav2/usecases/creating_lambda_ppe) Repository. 

Um Gesichtsbedeckungen zu erkennen, verwenden Sie den API-Vorgang [DetectProtectiveEquipment](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectProtectiveEquipment.html)ohne Speicherung. Das Bild wird aus dem lokalen Dateisystem geladen. Sie stellen das Eingabebild an `DetectProtectiveEquipment` als Bild-Byte-Array (base64-kodierte Bild-Bytes) zur Verfügung. Weitere Informationen finden Sie unter [Arbeiten mit Bildern](images.md).

Im Beispiel wird ein Begrenzungsrahmen um die erkannten Gesichtsbedeckungen herum angezeigt. Der Begrenzungsrahmen ist grün, wenn die Gesichtsbedeckung den Körperteil vollständig bedeckt. Andernfalls wird ein roter Begrenzungsrahmen angezeigt. Als Warnung wird innerhalb des Begrenzungsrahmens der Gesichtsbedeckung ein gelber Begrenzungsrahmen angezeigt, wenn die Erkennungssicherheit unter dem angegebenen Zuverlässigkeitswert liegt. Wenn keine Gesichtsbedeckung erkannt wird, wird ein roter Begrenzungsrahmen um die Person herum gezeichnet. 

Die Bildausgabe sieht folgendermaßen oder ähnlich aus. 

![\[Vier Arbeiter in einem Lagerhaus tragen Warnwesten, Helme, Schutzbrillen und Masken. Die Masken sind von Begrenzungsboxen umgeben.\]](http://docs.aws.amazon.com/de_de/rekognition/latest/dg/images/workers-with-bb.png)


**So zeigen Sie Begrenzungsrahmen auf erkannten Gesichtsbedeckungen an**

1. Wenn Sie dies noch nicht getan haben:

   1. Erstellen oder aktualisieren Sie einen Benutzer mit `AmazonRekognitionFullAccess`-Berechtigungen. Weitere Informationen finden Sie unter [Schritt 1: Einrichten eines AWS-Kontos und Erstellen eines Benutzers](setting-up.md#setting-up-iam).

   1. Installieren und konfigurieren Sie das AWS CLI und das AWS SDKs. Weitere Informationen finden Sie unter [Schritt 2: Richten Sie das AWS CLI und ein AWS SDKs](setup-awscli-sdk.md).

1. Verwenden Sie die folgenden Beispiele zum Aufrufen der `DetectProtectiveEquipment`-Operation. Informationen zur Anzeige von Begrenzungsrahmen in einem Bild finden Sie unter [Anzeigen von Begrenzungsrahmen](images-displaying-bounding-boxes.md).

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

   In der Funktion `main` ändern Sie Folgendes: 
   + Der Wert von `photo` zum Pfad- und Dateinamen einer lokalen Bilddatei (PNG oder JPEG).
   + Der Wert von `confidence` bis zum gewünschten Zuverlässigkeitsniveau (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 ]

   Dieser Code stammt aus dem AWS Documentation SDK Examples GitHub Repository. Das vollständige Beispiel finden Sie [hier](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 ]

   In der Funktion `main` ändern Sie Folgendes: 
   + Der Wert von `photo` zum Pfad- und Dateinamen einer lokalen Bilddatei (PNG oder JPEG).
   + Der Wert von `confidence` bis zum gewünschten Zuverlässigkeitsniveau (50–100).
   +  Ersetzen Sie den Wert von `profile_name` in der Zeile, die die Rekognition-Sitzung erstellt, durch den Namen Ihres Entwicklerprofils. 

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

   Ändern Sie im folgenden CLI-Beispiel den Wert der unten aufgeführten Argumente: 
   + Der Wert von `photo` zum Pfad- und Dateinamen einer lokalen Bilddatei (PNG oder JPEG).
   + Der Wert von `confidence` bis zum gewünschten Zuverlässigkeitsniveau (50–100).
   +  Ersetzen Sie den Wert von `profile_name` in der Zeile, die die Rekognition-Sitzung erstellt, durch den Namen Ihres Entwicklerprofils. 

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

    Wenn Sie auf einem Windows-Gerät auf die CLI zugreifen, verwenden Sie doppelte Anführungszeichen anstelle von einfachen Anführungszeichen und maskieren Sie die inneren doppelten Anführungszeichen durch einen Backslash (d. h. \$1), um eventuell auftretende Parserfehler zu beheben. Sehen Sie sich zum Beispiel Folgendes an: 

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

------