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.

# Arbeiten mit Bildern
<a name="images"></a>

In diesem Abschnitt werden die Arten von Analysen beschrieben, die Amazon Rekognition Image für Bilder durchführen kann. 
+ [Objekt- und Szenenerkennung](labels.md)
+ [Gesichtserkennung und -vergleich](faces.md)
+ [Gesichtssuche in einer Sammlung](collections.md)
+ [Prominentenerkennung](celebrities.md)
+ [Überwachen von Bildern](moderation.md)
+ [Texterkennung in Bildern](text-detection.md)

Diese werden durch nicht-speicherbare API-Vorgänge ausgeführt, bei denen Amazon Rekognition Image die durch die Operation ermittelten Informationen nicht speichert. Es werden keine Eingabebild-Bytes durch die nicht speicherbasierten API-Operationen persistent gespeichert. Weitere Informationen finden Sie unter [Grundlegendes zu Nicht-Speicher- und Speicher-API-Vorgängen](how-it-works-storage-non-storage.md).

Amazon Rekognition Image kann auch Metadaten zu Gesichtern in Sammlungen für den späteren Abruf speichern. Weitere Informationen finden Sie unter [Gesichtssuche in einer Sammlung](collections.md).

In diesem Abschnitt verwenden Sie die Operationen der Amazon Rekognition Image API, um Bilder zu analysieren, die in einem Amazon-S3-Bucket gespeichert sind, sowie Bildbytes, die aus dem lokalen Dateisystem geladen wurden. Dieser Abschnitt behandelt auch das Abrufen von Bildausrichtungsinformationen aus einem JPG-Bild. 

 Rekognition verwendet nur RGB-Kanäle, um Inferenzen durchzuführen. AWS empfiehlt Benutzern, den Alphakanal zu entfernen, bevor sie ein Display verwenden, um den Vergleich visuell (manuell durch einen Menschen) zu überprüfen. 

**Topics**
+ [Bildspezifikationen](images-information.md)
+ [Analysieren von Bildern, die in einem Amazon-S3-Bucket gespeichert sind](images-s3.md)
+ [Analysieren eines aus einem lokalen Dateisystem geladenen Bildes](images-bytes.md)
+ [Anzeigen von Begrenzungsrahmen](images-displaying-bounding-boxes.md)
+ [Erhalten der Bildausrichtung und der Koordinaten von Begrenzungsrahmen](images-orientation.md)

# Bildspezifikationen
<a name="images-information"></a>

Amazon-Rekognition-Image-Operationen können Bilder im .jpg- oder .png-Format analysieren.

Sie übergeben Bild-Bytes an eine Amazon-Rekognition-Image-Operation als Teil des Aufrufs oder Sie verweisen auf ein vorhandenes Amazon-S3-Objekt. Ein Beispiel für die Analyse eines Bildes, das in einem Amazon-S3-Bucket gespeichert ist, finden Sie unter [Analysieren von Bildern, die in einem Amazon-S3-Bucket gespeichert sind](images-s3.md). Ein Beispiel für die Übergabe von Bild-Bytes an eine Amazon-Rekognition-Image-API-Operation finden Sie unter [Analysieren eines aus einem lokalen Dateisystem geladenen Bildes](images-bytes.md).

Wenn Sie HTTP verwenden und die Bild-Bytes als Teil einer Amazon-Rekognition-Image-Operation übertragen, müssen die Bild-Bytes als base64-kodierte Zeichenfolge vorliegen. Wenn Sie das AWS-SDK verwenden und Bild-Bytes als Teil des API-Operation-Aufrufs übertragen, hängt es von Ihrer verwendeten Sprache ab, ob Sie die Bild-Bytes base64 kodieren müssen. 

In den folgenden Fällen AWS SDKs werden Bilder automatisch mit Base64 codiert, und Sie müssen keine Bildbytes codieren, bevor Sie eine Amazon Rekognition Image API-Operation aufrufen.
+ Java
+ JavaScript
+ Python
+ PHP

Wenn Sie ein anderes AWS-SDK verwenden und beim Aufruf einer Rekognition-API-Operation einen Bildformatfehler erhalten, versuchen Sie die Codierung in base64 Bild-Bytes, bevor Sie sie an eine Rekognition-API-Operation übergeben.

Wenn Sie Amazon Rekognition Image-Operationen aufrufen, wird die Übergabe von Bildbytes als Teil des Aufrufs nicht unterstützt. AWS CLI Sie müssen das Bild zuerst auf einen Amazon S3-Bucket hochladen und anschließend die Operation mit Verweis auf das hochgeladene Bild aufrufen.

**Anmerkung**  
Das Bild muss nicht base64-codiert werden, wenn Sie ein Bild übergeben, das in einem `S3Object` anstatt in Bild-Bytes gespeichert ist.

Informationen zur Sicherstellung der geringstmöglichen Latenz für Amazon-Rekognition-Image-Operationen finden Sie unter [Latenz der Amazon-Rekognition-Image-Operation](operation-latency.md). 

## Korrigieren der Bildausrichtung
<a name="images-image-orientation-correction"></a>

In mehreren Amazon-Rekognition-API-Operationen wird die Ausrichtung eines analysierten Bildes zurückgegeben. Es ist wichtig, die Bildausrichtung zu kennen, da dies Ihnen ermöglicht, Bilder für die Anzeige neu auszurichten. Rekognition-API-Operationen, die Gesichter analysieren, geben auch Begrenzungsrahmen für die Position von Gesichtern innerhalb eines Bilds zurück. Sie können die Begrenzungsrahmen verwenden, um einen Rahmen um ein Gesicht herum auf einem Bild anzuzeigen. Die zurückgegebenen Koordinaten der Begrenzungsrahmen werden von der Bildausrichtung beeinflusst, und Sie müssen die Koordinaten der Begrenzungsrahmen eventuell übertragen, damit der Rahmen um ein Gesicht korrekt angezeigt wird. Weitere Informationen finden Sie unter [Erhalten der Bildausrichtung und der Koordinaten von Begrenzungsrahmen](images-orientation.md). 

## Größe eines Bilds anpassen
<a name="images-image-sizing"></a>

Während der Analyse passt Amazon Rekognition die Größe von Bildern intern anhand einer Reihe vordefinierter Bereiche an, die am besten zu einem bestimmten Modell oder Algorithmus passen. Aus diesem Grund kann Amazon Rekognition je nach Auflösung des Eingabebilds eine unterschiedliche Anzahl von Objekten erkennen oder unterschiedliche Ergebnisse liefern. Nehmen wir an, Sie haben zwei Bilder. Das erste Bild hat eine Auflösung von 1024x768 Pixeln. Das zweite Bild, eine verkleinerte Version des ersten Bildes, hat eine Auflösung von 640x480 Pixeln. Wenn Sie die Bilder an senden [DetectLabels](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectLabels.html), `DetectLabels` können sich die Antworten der beiden Aufrufe an geringfügig unterscheiden.

# Analysieren von Bildern, die in einem Amazon-S3-Bucket gespeichert sind
<a name="images-s3"></a>

Amazon Rekognition Image kann Bilder analysieren, die in einem Amazon-S3-Bucket gespeichert sind, oder Bilder, die als Bild-Bytes bereitgestellt werden.

In diesem Thema verwenden Sie den [DetectLabels](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectLabels.html)API-Vorgang, um Objekte, Konzepte und Szenen in einem Bild (JPEG oder PNG) zu erkennen, das in einem Amazon S3 S3-Bucket gespeichert ist. Sie übergeben ein Bild an eine Amazon-Rekognition-Image-API-Operation, indem Sie den Eingabeparameter [Bild](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_Image.html) verwenden. Innerhalb von `Image`spezifizieren Sie die [S3Object](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_3Object.html)-Objekteigenschaft, um auf ein in einem S3-Bucket gespeichertes Bild zu verweisen. Bild-Bytes für Bilder, die in Amazon-S3-Buckets gespeichert sind, müssen nicht base64-codiert werden. Weitere Informationen finden Sie unter [Bildspezifikationen](images-information.md). 

## Beispielanforderung
<a name="images-s3-request"></a>

In diesem Beispiel einer JSON-Anforderung für `DetectLabels` wird das Quell-Bild (`input.jpg`) aus einem Amazon-S3-Bucket mit dem Namen `amzn-s3-demo-bucket` geladen. Beachten Sie, dass die Region für den S3-Bucket, der das S3-Objekt enthält, mit der Region übereinstimmen muss, die Sie für Amazon-Rekognition-Image-Operationen verwenden.

```
{
    "Image": {
        "S3Object": {
            "Bucket": "amzn-s3-demo-bucket",
            "Name": "input.jpg"
        }
    },
    "MaxLabels": 10,
    "MinConfidence": 75
}
```

In den folgenden Beispielen werden die AWS SDKs Aufrufe various und AWS CLI to verwendet`DetectLabels`. Informationen über die Antwort auf die Operation `DetectLabels` finden Sie unter [DetectLabels Antwort](labels-detect-labels-image.md#detectlabels-response).

**So erkennen Sie Labels 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). Stellen Sie sicher, dass Sie dem Benutzer, der die API-Operationen aufruft, die richtigen Berechtigungen für den programmatischen Zugriff erteilt haben. Eine Anleitung dazu finden Sie unter [Erteilen programmgesteuerten Zugriffs](sdk-programmatic-access.md).

1. Laden Sie ein Bild mit einem oder mehreren Objekten wie Bäumen, Häusern und einem Boot auf Ihren S3-Bucket hoch. Das Bild muss entweder im *JPG*- oder *PNG*-Format vorliegen.

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

1. Verwenden Sie die folgenden Beispiele zum Aufrufen der `DetectLabels`-Operation.

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

   Dieses Beispiel zeigt eine Liste von Labels an, die auf dem Eingabebild erkannt wurden. Ersetzen Sie die Werte von `bucket` und `photo` durch die Namen des Amazon-S3-Buckets und des Bilds, das Sie in Schritt 2 verwendet haben. 

   ```
   //Copyright 2018 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.services.rekognition.AmazonRekognition;
   import com.amazonaws.services.rekognition.AmazonRekognitionClientBuilder;
   import com.amazonaws.services.rekognition.model.AmazonRekognitionException;
   import com.amazonaws.services.rekognition.model.DetectLabelsRequest;
   import com.amazonaws.services.rekognition.model.DetectLabelsResult;
   import com.amazonaws.services.rekognition.model.Image;
   import com.amazonaws.services.rekognition.model.Label;
   import com.amazonaws.services.rekognition.model.S3Object;
   import java.util.List;
   
   public class DetectLabels {
   
      public static void main(String[] args) throws Exception {
   
         String photo = "input.jpg";
         String bucket = "bucket";
   
   
         AmazonRekognition rekognitionClient = AmazonRekognitionClientBuilder.defaultClient();
   
         DetectLabelsRequest request = new DetectLabelsRequest()
              .withImage(new Image()
              .withS3Object(new S3Object()
              .withName(photo).withBucket(bucket)))
              .withMaxLabels(10)
              .withMinConfidence(75F);
   
         try {
            DetectLabelsResult result = rekognitionClient.detectLabels(request);
            List <Label> labels = result.getLabels();
   
            System.out.println("Detected labels for " + photo);
            for (Label label: labels) {
               System.out.println(label.getName() + ": " + label.getConfidence().toString());
            }
         } catch(AmazonRekognitionException e) {
            e.printStackTrace();
         }
      }
   }
   ```

------
#### [ AWS CLI ]

   Dieses Beispiel zeigt die JSON-Ausgabe von der `detect-labels`-CLI-Operation an. Ersetzen Sie die Werte von `bucket` und `photo` durch die Namen des Amazon-S3-Buckets und des Bilds, das Sie in Schritt 2 verwendet haben. Ersetzen Sie den Wert von `profile_name` in der Zeile, die die Rekognition-Sitzung erstellt, durch den Namen Ihres Entwicklerprofils. 

   ```
   aws rekognition detect-labels --image '{ "S3Object": { "Bucket": "bucket-name", "Name": "file-name" } }' \
   --features GENERAL_LABELS IMAGE_PROPERTIES \
   --settings '{"ImageProperties": {"MaxDominantColors":1}, {"GeneralLabels":{"LabelInclusionFilters":["Cat"]}}}' \
   --profile profile-name \
   --region us-east-1
   ```

   Wenn Sie Windows verwenden, müssen Sie möglicherweise die Escaped Anführungszeichen verwenden, wie im Beispiel unten gezeigt.

   ```
   aws rekognition detect-labels --image "{\"S3Object\":{\"Bucket\":\"bucket-name\",\"Name\":\"file-name\"}}" --features GENERAL_LABELS IMAGE_PROPERTIES --settings "{\"GeneralLabels\":{\"LabelInclusionFilters\":[\"Car\"]}}" --profile profile-name --region us-east-1
   ```

------
#### [ 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/DetectLabelsS3.java).

   ```
   //snippet-start:[rekognition.java2.detect_labels.import]
   import software.amazon.awssdk.auth.credentials.ProfileCredentialsProvider;
   import software.amazon.awssdk.regions.Region;
   import software.amazon.awssdk.services.rekognition.RekognitionClient;
   import software.amazon.awssdk.services.rekognition.model.Image;
   import software.amazon.awssdk.services.rekognition.model.DetectLabelsRequest;
   import software.amazon.awssdk.services.rekognition.model.DetectLabelsResponse;
   import software.amazon.awssdk.services.rekognition.model.Label;
   import software.amazon.awssdk.services.rekognition.model.RekognitionException;
   import software.amazon.awssdk.services.rekognition.model.S3Object;
   import java.util.List;
   
   /**
   * 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 DetectLabels {
   
       public static void main(String[] args) {
   
           final String usage = "\n" +
               "Usage: " +
               "   <bucket> <image>\n\n" +
               "Where:\n" +
               "   bucket - The name of the Amazon S3 bucket that contains the image (for example, ,ImageBucket)." +
               "   image - The name of the image located in the Amazon S3 bucket (for example, Lake.png). \n\n";
   
           if (args.length != 2) {
               System.out.println(usage);
               System.exit(1);
           }
   
           String bucket = args[0];
           String image = args[1];
           Region region = Region.US_WEST_2;
           RekognitionClient rekClient = RekognitionClient.builder()
               .region(region)
               .credentialsProvider(ProfileCredentialsProvider.create("profile-name"))
               .build();
   
           getLabelsfromImage(rekClient, bucket, image);
           rekClient.close();
       }
   
       // snippet-start:[rekognition.java2.detect_labels_s3.main]
       public static void getLabelsfromImage(RekognitionClient rekClient, String bucket, String image) {
   
           try {
               S3Object s3Object = S3Object.builder()
                   .bucket(bucket)
                   .name(image)
                   .build() ;
   
               Image myImage = Image.builder()
                   .s3Object(s3Object)
                   .build();
   
               DetectLabelsRequest detectLabelsRequest = DetectLabelsRequest.builder()
                   .image(myImage)
                   .maxLabels(10)
                   .build();
   
               DetectLabelsResponse labelsResponse = rekClient.detectLabels(detectLabelsRequest);
               List<Label> labels = labelsResponse.labels();
               System.out.println("Detected labels for the given photo");
               for (Label label: labels) {
                   System.out.println(label.name() + ": " + label.confidence().toString());
               }
   
           } catch (RekognitionException e) {
               System.out.println(e.getMessage());
               System.exit(1);
           }
       }
    // snippet-end:[rekognition.java2.detect_labels.main]
   }
   ```

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

   Dieses Beispiel zeigt die Labels an, die auf dem Eingabebild erkannt wurden. Ersetzen Sie die Werte von `bucket` und `photo` durch die Namen des Amazon-S3-Buckets und des Bilds, das Sie in Schritt 2 verwendet haben. Ersetzen Sie den Wert von `profile_name` in der Zeile, die die Rekognition-Sitzung erstellt, durch den Namen Ihres Entwicklerprofils.

   ```
   #Copyright 2018 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_labels(photo, bucket):
   
        session = boto3.Session(profile_name='profile-name')
        client = session.client('rekognition')
   
        response = client.detect_labels(Image={'S3Object':{'Bucket':bucket,'Name':photo}},
        MaxLabels=10,
        # Uncomment to use image properties and filtration settings
        #Features=["GENERAL_LABELS", "IMAGE_PROPERTIES"],
        #Settings={"GeneralLabels": {"LabelInclusionFilters":["Cat"]},
        # "ImageProperties": {"MaxDominantColors":10}}
        )
   
        print('Detected labels for ' + photo)
        print()
        for label in response['Labels']:
            print("Label: " + label['Name'])
            print("Confidence: " + str(label['Confidence']))
            print("Instances:")
   
            for instance in label['Instances']:
                print(" Bounding box")
                print(" Top: " + str(instance['BoundingBox']['Top']))
                print(" Left: " + str(instance['BoundingBox']['Left']))
                print(" Width: " + str(instance['BoundingBox']['Width']))
                print(" Height: " + str(instance['BoundingBox']['Height']))
                print(" Confidence: " + str(instance['Confidence']))
                print()
   
            print("Parents:")
            for parent in label['Parents']:
               print(" " + parent['Name'])
   
            print("Aliases:")
            for alias in label['Aliases']:
                print(" " + alias['Name'])
   
                print("Categories:")
            for category in label['Categories']:
                print(" " + category['Name'])
                print("----------")
                print()
   
        if "ImageProperties" in str(response):
            print("Background:")
            print(response["ImageProperties"]["Background"])
            print()
            print("Foreground:")
            print(response["ImageProperties"]["Foreground"])
            print()
            print("Quality:")
            print(response["ImageProperties"]["Quality"])
            print()
   
        return len(response['Labels'])
   
   def main():
       photo = 'photo-name'
       bucket = 'amzn-s3-demo-bucket'
       label_count = detect_labels(photo, bucket)
       print("Labels detected: " + str(label_count))
   
   if __name__ == "__main__":
       main()
   ```

------
#### [ Node.Js ]

   In diesem Beispiel werden Informationen über in einem Bild erkannte Labels angezeigt. 

   Ändern Sie den Wert von `photo` in den Pfad und Dateinamen einer Bilddatei mit einem oder mehreren prominenten Gesichtern. Ändern Sie den Wert von `bucket` in den Namen des S3-Buckets, der die angegebene Bilddatei enthält. Ändern Sie den Wert von `REGION` in den Namen der Region, die Ihrem Konto zugeordnet ist. Ersetzen Sie den Wert von `profile_name` in der Zeile, die die Rekognition-Sitzung erstellt, durch den Namen Ihres Entwicklerprofils. 

   ```
   // Import required AWS SDK clients and commands for Node.js
   import { DetectLabelsCommand } from  "@aws-sdk/client-rekognition";
   import  { RekognitionClient } from "@aws-sdk/client-rekognition";
   
   import {fromIni} from '@aws-sdk/credential-providers';
   
   // Set the AWS Region.
   const REGION = "region-name"; //e.g. "us-east-1"
   
   // Create SNS service object.
   const rekogClient = new RekognitionClient({
     region: REGION,
     credentials: fromIni({
          profile: 'profile-name',
     }),
   });
   
   const bucket = 'bucket-name'
   const photo = 'photo-name'
   
   // Set params
   const params = {For example, to grant
       Image: {
         S3Object: {
           Bucket: bucket,
           Name: photo
         },
       },
     }
   
   const detect_labels = async () => {
       try {
           const response = await rekogClient.send(new DetectLabelsCommand(params));
           console.log(response.Labels)
           response.Labels.forEach(label =>{
               console.log(`Confidence: ${label.Confidence}`)
               console.log(`Name: ${label.Name}`)
               console.log('Instances:')
               label.Instances.forEach(instance => {
                   console.log(instance)
               })
               console.log('Parents:')
               label.Parents.forEach(name => {
                   console.log(name)
               })
               console.log("-------")
           })
           return response; // For unit tests.
         } catch (err) {
           console.log("Error", err);
         }
   };
   
   detect_labels();
   ```

------
#### [ .NET ]

   Dieses Beispiel zeigt eine Liste von Labels an, die auf dem Eingabebild erkannt wurden. Ersetzen Sie die Werte von `bucket` und `photo` durch die Namen des Amazon-S3-Buckets und des Bilds, das Sie in Schritt 2 verwendet haben. 

   ```
   //Copyright 2018 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.)
   
   using System;
   using Amazon.Rekognition;
   using Amazon.Rekognition.Model;
   
   public class DetectLabels
   {
       public static void Example()
       {
           String photo = "input.jpg";
           String bucket = "amzn-s3-demo-bucket";
   
           AmazonRekognitionClient rekognitionClient = new AmazonRekognitionClient();
   
           DetectLabelsRequest detectlabelsRequest = new DetectLabelsRequest()
           {
               Image = new Image()
               {
                   S3Object = new S3Object()
                   {
                       Name = photo,
                       Bucket = bucket
                   },
               },
               MaxLabels = 10,
               MinConfidence = 75F
           };
   
           try
           {
               DetectLabelsResponse detectLabelsResponse = rekognitionClient.DetectLabels(detectlabelsRequest);
               Console.WriteLine("Detected labels for " + photo);
               foreach (Label label in detectLabelsResponse.Labels)
                   Console.WriteLine("{0}: {1}", label.Name, label.Confidence);
           }
           catch (Exception e)
           {
               Console.WriteLine(e.Message);
           }
       }
   }
   ```

------
#### [ Ruby ]

   Dieses Beispiel zeigt eine Liste von Labels an, die auf dem Eingabebild erkannt wurden. Ersetzen Sie die Werte von `bucket` und `photo` durch die Namen des Amazon-S3-Buckets und des Bilds, das Sie in Schritt 2 verwendet haben. 

   ```
      # Add to your Gemfile
      # gem 'aws-sdk-rekognition'
      require 'aws-sdk-rekognition'
      credentials = Aws::Credentials.new(
         ENV['AWS_ACCESS_KEY_ID'],
         ENV['AWS_SECRET_ACCESS_KEY']
      )
      bucket = 'bucket' # the bucket name without s3://
      photo  = 'photo' # the name of file
      client   = Aws::Rekognition::Client.new credentials: credentials
      attrs = {
        image: {
          s3_object: {
            bucket: bucket,
            name: photo
          },
        },
        max_labels: 10
      }
     response = client.detect_labels attrs
     puts "Detected labels for: #{photo}"
     response.labels.each do |label|
       puts "Label:      #{label.name}"
       puts "Confidence: #{label.confidence}"
       puts "Instances:"
       label['instances'].each do |instance|
         box = instance['bounding_box']
         puts "  Bounding box:"
         puts "    Top:        #{box.top}"
         puts "    Left:       #{box.left}"
         puts "    Width:      #{box.width}"
         puts "    Height:     #{box.height}"
         puts "  Confidence: #{instance.confidence}"
       end
       puts "Parents:"
       label.parents.each do |parent|
         puts "  #{parent.name}"
       end
       puts "------------"
       puts ""
     end
   ```

------



## Beispielantwort
<a name="images-s3-response"></a>

Die Antwort von `DetectLabels` ist ein Array der erkannten Labels in dem Bild und der Zuverlässigkeitswert, mit dem sie erkannt wurden. 

Wenn Sie die `DetectLabels`-Operation mit einem Bild ausführen, gibt Amazon Rekognition eine Ausgabe zurück, die der folgenden Beispielantwort ähnelt.

Die Antwort zeigt, dass die Operation mehrere Labels erkannt hat, einschließlich Person, Fahrzeug und Auto. Jedem Label ist ein Zuverlässigkeitswert zugeordnet. Beispielsweise ist der Erkennungsalgorithmus zu 98,991432 % sicher, dass auf dem Bild eine Person abgebildet ist.

Die Antwort umfasst auch die übergeordneten Vorgängerlabels für ein Label im `Parents`-Array. Beispielsweise hat das Label „Automobil“ die zwei übergeordneten Labels „Fahrzeug“ und „Transport“. 

Die Antwort für gängige Objektlabels enthält Informationen zum Begrenzungsrahmen für die Position des Labels auf dem Eingabebild. Beispiel: Das Label „Person“ ist ein Instances-Array mit zwei Begrenzungsrahmen. Dies sind die Positionen von zwei Personen, die im Bild erkannt wurden.

Das Feld `LabelModelVersion` enthält die Versionsnummer des von `DetectLabels` verwendeten Erkennungsmodells. 

Weitere Informationen zur Verwendung der `DetectLabels`-Operation finden Sie unter [Erkennung von Objekten und Konzepten](labels.md).

```
{
            
    {
    "Labels": [
        {
            "Name": "Vehicle",
            "Confidence": 99.15271759033203,
            "Instances": [],
            "Parents": [
                {
                    "Name": "Transportation"
                }
            ]
        },
        {
            "Name": "Transportation",
            "Confidence": 99.15271759033203,
            "Instances": [],
            "Parents": []
        },
        {
            "Name": "Automobile",
            "Confidence": 99.15271759033203,
            "Instances": [],
            "Parents": [
                {
                    "Name": "Vehicle"
                },
                {
                    "Name": "Transportation"
                }
            ]
        },
        {
            "Name": "Car",
            "Confidence": 99.15271759033203,
            "Instances": [
                {
                    "BoundingBox": {
                        "Width": 0.10616336017847061,
                        "Height": 0.18528179824352264,
                        "Left": 0.0037978808395564556,
                        "Top": 0.5039216876029968
                    },
                    "Confidence": 99.15271759033203
                },
                {
                    "BoundingBox": {
                        "Width": 0.2429988533258438,
                        "Height": 0.21577216684818268,
                        "Left": 0.7309805154800415,
                        "Top": 0.5251884460449219
                    },
                    "Confidence": 99.1286392211914
                },
                {
                    "BoundingBox": {
                        "Width": 0.14233611524105072,
                        "Height": 0.15528248250484467,
                        "Left": 0.6494812965393066,
                        "Top": 0.5333095788955688
                    },
                    "Confidence": 98.48368072509766
                },
                {
                    "BoundingBox": {
                        "Width": 0.11086395382881165,
                        "Height": 0.10271988064050674,
                        "Left": 0.10355594009160995,
                        "Top": 0.5354844927787781
                    },
                    "Confidence": 96.45606231689453
                },
                {
                    "BoundingBox": {
                        "Width": 0.06254628300666809,
                        "Height": 0.053911514580249786,
                        "Left": 0.46083059906959534,
                        "Top": 0.5573825240135193
                    },
                    "Confidence": 93.65448760986328
                },
                {
                    "BoundingBox": {
                        "Width": 0.10105438530445099,
                        "Height": 0.12226245552301407,
                        "Left": 0.5743985772132874,
                        "Top": 0.534368634223938
                    },
                    "Confidence": 93.06217193603516
                },
                {
                    "BoundingBox": {
                        "Width": 0.056389667093753815,
                        "Height": 0.17163699865341187,
                        "Left": 0.9427769780158997,
                        "Top": 0.5235804319381714
                    },
                    "Confidence": 92.6864013671875
                },
                {
                    "BoundingBox": {
                        "Width": 0.06003860384225845,
                        "Height": 0.06737709045410156,
                        "Left": 0.22409997880458832,
                        "Top": 0.5441341400146484
                    },
                    "Confidence": 90.4227066040039
                },
                {
                    "BoundingBox": {
                        "Width": 0.02848697081208229,
                        "Height": 0.19150497019290924,
                        "Left": 0.0,
                        "Top": 0.5107086896896362
                    },
                    "Confidence": 86.65286254882812
                },
                {
                    "BoundingBox": {
                        "Width": 0.04067881405353546,
                        "Height": 0.03428703173995018,
                        "Left": 0.316415935754776,
                        "Top": 0.5566273927688599
                    },
                    "Confidence": 85.36471557617188
                },
                {
                    "BoundingBox": {
                        "Width": 0.043411049991846085,
                        "Height": 0.0893595889210701,
                        "Left": 0.18293385207653046,
                        "Top": 0.5394920110702515
                    },
                    "Confidence": 82.21705627441406
                },
                {
                    "BoundingBox": {
                        "Width": 0.031183116137981415,
                        "Height": 0.03989990055561066,
                        "Left": 0.2853088080883026,
                        "Top": 0.5579366683959961
                    },
                    "Confidence": 81.0157470703125
                },
                {
                    "BoundingBox": {
                        "Width": 0.031113790348172188,
                        "Height": 0.056484755128622055,
                        "Left": 0.2580395042896271,
                        "Top": 0.5504819750785828
                    },
                    "Confidence": 56.13441467285156
                },
                {
                    "BoundingBox": {
                        "Width": 0.08586374670267105,
                        "Height": 0.08550430089235306,
                        "Left": 0.5128012895584106,
                        "Top": 0.5438792705535889
                    },
                    "Confidence": 52.37760925292969
                }
            ],
            "Parents": [
                {
                    "Name": "Vehicle"
                },
                {
                    "Name": "Transportation"
                }
            ]
        },
        {
            "Name": "Human",
            "Confidence": 98.9914321899414,
            "Instances": [],
            "Parents": []
        },
        {
            "Name": "Person",
            "Confidence": 98.9914321899414,
            "Instances": [
                {
                    "BoundingBox": {
                        "Width": 0.19360728561878204,
                        "Height": 0.2742200493812561,
                        "Left": 0.43734854459762573,
                        "Top": 0.35072067379951477
                    },
                    "Confidence": 98.9914321899414
                },
                {
                    "BoundingBox": {
                        "Width": 0.03801717236638069,
                        "Height": 0.06597328186035156,
                        "Left": 0.9155802130699158,
                        "Top": 0.5010883808135986
                    },
                    "Confidence": 85.02790832519531
                }
            ],
            "Parents": []
        }
    ],
    "LabelModelVersion": "2.0"
}

    
}
```

# Analysieren eines aus einem lokalen Dateisystem geladenen Bildes
<a name="images-bytes"></a>

Amazon-Rekognition-Image-Operationen können Bilder analysieren, die als Bild-Bytes oder in einem Amazon-S3-Bucket gespeichert sind.

In diesen Themen finden Sie Beispiele, wie Sie Bild-Bytes an Amazon-Rekognition-Image-API-Operationen übertragen können, indem Sie eine Datei verwenden, die aus einem lokalen Dateisystem geladen wird. Sie übergeben Bild-Bytes an eine Amazon-Rekognition-API-Operation, indem Sie den Eingabeparameter [Bild](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_Image.html) verwenden. Innerhalb von `Image` geben Sie die Eigenschaft `Bytes` zum Übergeben von base64-codierten Bild-Bytes an.

Bild-Bytes, die an eine Amazon-Rekognition-API-Operation mit dem Eingabeparameter `Bytes` übergeben werden, müssen base64-codiert sein. Die AWS SDKs , dass diese Beispiele Bilder automatisch mit Base64 kodieren. Sie müssen vor dem Aufruf einer Amazon-Rekognition-API-Operation keine Bild-Bytes codieren. Weitere Informationen finden Sie unter [Bildspezifikationen](images-information.md). 

In diesem Beispiel einer JSON-Anforderung für `DetectLabels` werden die Quellbild-Bytes im `Bytes`-Eingabeparameter übergeben. 

```
{
    "Image": {
        "Bytes": "/9j/4AAQSk....."
    },
    "MaxLabels": 10,
    "MinConfidence": 77
}
```

In den folgenden Beispielen werden various AWS SDKs und to call verwendet. AWS CLI `DetectLabels` Informationen über die Antwort auf die Operation `DetectLabels` finden Sie unter [DetectLabels Antwort](labels-detect-labels-image.md#detectlabels-response).

Ein clientseitiges JavaScript Beispiel finden Sie unter. [Verwenden JavaScript](image-bytes-javascript.md)

**So erkennen Sie Labels in einem lokalen 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. Verwenden Sie die folgenden Beispiele zum Aufrufen der `DetectLabels`-Operation.

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

   Das folgende Java-Beispiel zeigt, wie Sie ein Bild aus dem lokalen Dateisystem laden und Labels mithilfe der AWS-SDK-Operation [detectLabels](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/rekognition/model/DetectLabelsRequest.html) erkennen. Ändern Sie den Wert von `photo` in den Pfad und Dateinamen einer Bilddatei (JPG- oder PNG-Format).

   ```
   //Copyright 2018 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 aws.example.rekognition.image;
   import java.io.File;
   import java.io.FileInputStream;
   import java.io.InputStream;
   import java.nio.ByteBuffer;
   import java.util.List;
   import com.amazonaws.services.rekognition.AmazonRekognition;
   import com.amazonaws.services.rekognition.AmazonRekognitionClientBuilder;
   import com.amazonaws.AmazonClientException;
   import com.amazonaws.services.rekognition.model.AmazonRekognitionException;
   import com.amazonaws.services.rekognition.model.DetectLabelsRequest;
   import com.amazonaws.services.rekognition.model.DetectLabelsResult;
   import com.amazonaws.services.rekognition.model.Image;
   import com.amazonaws.services.rekognition.model.Label;
   import com.amazonaws.util.IOUtils;
   
   public class DetectLabelsLocalFile {
       public static void main(String[] args) throws Exception {
       	String photo="input.jpg";
   
   
           ByteBuffer imageBytes;
           try (InputStream inputStream = new FileInputStream(new File(photo))) {
               imageBytes = ByteBuffer.wrap(IOUtils.toByteArray(inputStream));
           }
   
   
           AmazonRekognition rekognitionClient = AmazonRekognitionClientBuilder.defaultClient();
   
           DetectLabelsRequest request = new DetectLabelsRequest()
                   .withImage(new Image()
                           .withBytes(imageBytes))
                   .withMaxLabels(10)
                   .withMinConfidence(77F);
   
           try {
   
               DetectLabelsResult result = rekognitionClient.detectLabels(request);
               List <Label> labels = result.getLabels();
   
               System.out.println("Detected labels for " + photo);
               for (Label label: labels) {
                  System.out.println(label.getName() + ": " + label.getConfidence().toString());
               }
   
           } catch (AmazonRekognitionException e) {
               e.printStackTrace();
           }
   
       }
   }
   ```

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

   Das folgende [AWS-SDK für Python](https://aws.amazon.com/sdk-for-python/)-Beispiel zeigt, wie Sie ein Bild aus dem lokalen Dateisystem laden und die Operation [detect\$1labels](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/rekognition.html#Rekognition.Client.detect_labels) aufrufen. Ändern Sie den Wert von `photo` in den Pfad und Dateinamen einer Bilddatei (JPG- oder PNG-Format). 

   ```
   #Copyright 2018 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_labels_local_file(photo):
   
   
       client=boto3.client('rekognition')
      
       with open(photo, 'rb') as image:
           response = client.detect_labels(Image={'Bytes': image.read()})
           
       print('Detected labels in ' + photo)    
       for label in response['Labels']:
           print (label['Name'] + ' : ' + str(label['Confidence']))
   
       return len(response['Labels'])
   
   def main():
       photo='photo'
   
       label_count=detect_labels_local_file(photo)
       print("Labels detected: " + str(label_count))
   
   
   if __name__ == "__main__":
       main()
   ```

------
#### [ .NET ]

   Das folgende Beispiel veranschaulicht, wie Sie ein Bild aus dem lokalen Dateisystem laden und Labels mithilfe der Operation `DetectLabels` erkennen. Ändern Sie den Wert von `photo` in den Pfad und Dateinamen einer Bilddatei (JPG- oder PNG-Format).

   ```
   //Copyright 2018 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.)
   
   using System;
   using System.IO;
   using Amazon.Rekognition;
   using Amazon.Rekognition.Model;
   
   public class DetectLabelsLocalfile
   {
       public static void Example()
       {
           String photo = "input.jpg";
   
           Amazon.Rekognition.Model.Image image = new Amazon.Rekognition.Model.Image();
           try
           {
               using (FileStream fs = new FileStream(photo, FileMode.Open, FileAccess.Read))
               {
                   byte[] data = null;
                   data = new byte[fs.Length];
                   fs.Read(data, 0, (int)fs.Length);
                   image.Bytes = new MemoryStream(data);
               }
           }
           catch (Exception)
           {
               Console.WriteLine("Failed to load file " + photo);
               return;
           }
   
           AmazonRekognitionClient rekognitionClient = new AmazonRekognitionClient();
   
           DetectLabelsRequest detectlabelsRequest = new DetectLabelsRequest()
           {
               Image = image,
               MaxLabels = 10,
               MinConfidence = 77F
           };
   
           try
           {
               DetectLabelsResponse detectLabelsResponse = rekognitionClient.DetectLabels(detectlabelsRequest);
               Console.WriteLine("Detected labels for " + photo);
               foreach (Label label in detectLabelsResponse.Labels)
                   Console.WriteLine("{0}: {1}", label.Name, label.Confidence);
           }
           catch (Exception e)
           {
               Console.WriteLine(e.Message);
           }
       }
   }
   ```

------
#### [ PHP ]

   Das folgende Beispiel [für ein AWS SDK for PHP](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/welcome.html#getting-started) zeigt, wie ein Bild aus dem lokalen Dateisystem geladen und die [DetectFaces](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-rekognition-2016-06-27.html#detectfaces)API-Operation aufgerufen wird. Ändern Sie den Wert von `photo` in den Pfad und Dateinamen einer Bilddatei (JPG- oder PNG-Format). 

   ```
   
   <?php
   //Copyright 2018 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.)
   
       require 'vendor/autoload.php';
   
       use Aws\Rekognition\RekognitionClient;
   
       $options = [
          'region'            => 'us-west-2',
           'version'           => 'latest'
       ];
   
       $rekognition = new RekognitionClient($options);
   	
       // Get local image
       $photo = 'input.jpg';
       $fp_image = fopen($photo, 'r');
       $image = fread($fp_image, filesize($photo));
       fclose($fp_image);
   
   
       // Call DetectFaces
       $result = $rekognition->DetectFaces(array(
          'Image' => array(
             'Bytes' => $image,
          ),
          'Attributes' => array('ALL')
          )
       );
   
       // Display info for each detected person
       print 'People: Image position and estimated age' . PHP_EOL;
       for ($n=0;$n<sizeof($result['FaceDetails']); $n++){
   
         print 'Position: ' . $result['FaceDetails'][$n]['BoundingBox']['Left'] . " "
         . $result['FaceDetails'][$n]['BoundingBox']['Top']
         . PHP_EOL
         . 'Age (low): '.$result['FaceDetails'][$n]['AgeRange']['Low']
         .  PHP_EOL
         . 'Age (high): ' . $result['FaceDetails'][$n]['AgeRange']['High']
         .  PHP_EOL . PHP_EOL;
       }
   ?>
   ```

------
#### [ Ruby ]

   Dieses Beispiel zeigt eine Liste von Labels an, die auf dem Eingabebild erkannt wurden. Ändern Sie den Wert von `photo` in den Pfad und Dateinamen einer Bilddatei (JPG- oder PNG-Format).

   ```
   #Copyright 2018 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.)
   
       # gem 'aws-sdk-rekognition'
       require 'aws-sdk-rekognition'
       credentials = Aws::Credentials.new(
          ENV['AWS_ACCESS_KEY_ID'],
          ENV['AWS_SECRET_ACCESS_KEY']
       )
       client   = Aws::Rekognition::Client.new credentials: credentials
       photo = 'photo.jpg'
       path = File.expand_path(photo) # expand path relative to the current directory
       file = File.read(path)
       attrs = {
         image: {
           bytes: file
         },
         max_labels: 10
       }
       response = client.detect_labels attrs
       puts "Detected labels for: #{photo}"
       response.labels.each do |label|
         puts "Label:      #{label.name}"
         puts "Confidence: #{label.confidence}"
         puts "Instances:"
         label['instances'].each do |instance|
           box = instance['bounding_box']
           puts "  Bounding box:"
           puts "    Top:        #{box.top}"
           puts "    Left:       #{box.left}"
           puts "    Width:      #{box.width}"
           puts "    Height:     #{box.height}"
           puts "  Confidence: #{instance.confidence}"
         end
         puts "Parents:"
         label.parents.each do |parent|
           puts "  #{parent.name}"
         end
         puts "------------"
         puts ""
       end
   ```

------
#### [ 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/DetectLabels.java).

   ```
   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.*;
   
   import java.io.FileInputStream;
   import java.io.FileNotFoundException;
   import java.io.InputStream;
   import java.util.List;
   
   /**
    * 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 DetectLabels {
       public static void main(String[] args) {
           final String usage = """
               Usage: <bucketName> <sourceImage>
   
               Where:
                   bucketName - The name of the Amazon S3 bucket where the image is stored
                   sourceImage - The name of the image file (for example, pic1.png).\s
               """;
   
           if (args.length != 2) {
               System.out.println(usage);
               System.exit(1);
           }
   
           String bucketName = args[0] ;
           String sourceImage = args[1] ;
           Region region = Region.US_WEST_2;
           RekognitionClient rekClient = RekognitionClient.builder()
                   .region(region)
                   .build();
   
           detectImageLabels(rekClient, bucketName, sourceImage);
           rekClient.close();
       }
   
       /**
        * Detects the labels in an image stored in an Amazon S3 bucket using the Amazon Rekognition service.
        *
        * @param rekClient     the Amazon Rekognition client used to make the detection request
        * @param bucketName    the name of the Amazon S3 bucket where the image is stored
        * @param sourceImage   the name of the image file to be analyzed
        */
       public static void detectImageLabels(RekognitionClient rekClient, String bucketName, String sourceImage) {
           try {
               S3Object s3ObjectTarget = S3Object.builder()
                       .bucket(bucketName)
                       .name(sourceImage)
                       .build();
   
               Image souImage = Image.builder()
                       .s3Object(s3ObjectTarget)
                       .build();
   
               DetectLabelsRequest detectLabelsRequest = DetectLabelsRequest.builder()
                       .image(souImage)
                       .maxLabels(10)
                       .build();
   
               DetectLabelsResponse labelsResponse = rekClient.detectLabels(detectLabelsRequest);
               List<Label> labels = labelsResponse.labels();
               System.out.println("Detected labels for the given photo");
               for (Label label : labels) {
                   System.out.println(label.name() + ": " + label.confidence().toString());
               }
   
           } catch (RekognitionException e) {
               System.out.println(e.getMessage());
               System.exit(1);
           }
       }
   }
   ```

------

# Verwenden JavaScript
<a name="image-bytes-javascript"></a>

Das folgende JavaScript Webseitenbeispiel ermöglicht es einem Benutzer, ein Bild auszuwählen und sich das geschätzte Alter der Gesichter anzusehen, die auf dem Bild erkannt wurden. Die geschätzten Altersgruppen werden über einen Aufruf von [DetectFaces](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectFaces.html) zurückgegeben. 

Das gewählte Bild wird mithilfe der JavaScript `FileReader.readAsDataURL` Funktion geladen, die das Bild base64-kodiert. Dies ist nützlich, um das Bild auf einer HTML-Zeichenfläche anzuzeigen. Es bedeutet jedoch, dass die Bild-Bytes in ein nicht codiertes Format umgewandelt werden müssen, bevor sie einer Amazon-Rekognition-Image-Operation übergeben werden. In diesem Beispiel wird gezeigt, wie Sie die geladenen Bildbytes entcodieren. Wenn die entcodierten Bild-Bytes nicht nützlich für Sie sind, verwenden Sie stattdessen `FileReader.readAsArrayBuffer`, da das geladenen Bild nicht kodiert ist. Das bedeutet, dass Amazon-Rekognition-Image-Operationen aufgerufen werden können, ohne dass die Bild-Bytes zuvor in ein nicht codiertes Format umgewandelt werden müssen. Ein Beispiel finden Sie unter [readAsArrayBuffer verwenden](#image-bytes-javascript-unencoded).

**Um das Beispiel auszuführen JavaScript**

1. Laden Sie den Beispielquellcode in einen Editor.

1. Rufen Sie die Amazon-Cognito-Identitätspool-ID ab. Weitere Informationen finden Sie unter [Abrufen der Amazon-Cognito-Identitätspool-ID](#image-bytes-javascript-auth).

1. Ändern Sie in der `AnonLog`-Funktion des Beispielcodes `IdentityPoolIdToUse` und `RegionToUse` in die Werte, die Sie in Schritt 9 von [Abrufen der Amazon-Cognito-Identitätspool-ID](#image-bytes-javascript-auth) notiert haben. 

1. Ändern Sie in der Funktion `DetectFaces` `RegionToUse` in den im vorigen Schritt verwendeten Wert.

1. Speichern Sie den Beispielquellcode als `.html`-Datei.

1. Laden Sie die Datei in Ihren Browser.

1. Wählen Sie die Schaltfläche **Durchsuchen...** und wählen Sie ein Bild aus, das ein oder mehrere Gesichter enthält. Eine Tabelle wird mit den geschätzten Altersgruppen für jedes im Bild erkannt Gesicht wird angezeigt. 

**Anmerkung**  
Im folgenden Codebeispiel werden zwei Skripts verwendet, die nicht mehr Teil von Amazon Cognito sind. Um diese Dateien abzurufen, folgen Sie den Links für [ aws-cognito-sdk.min.js](https://raw.githubusercontent.com/aws/amazon-cognito-identity-js/master/dist/aws-cognito-sdk.js) und [ amazon-cognito-identity.min.js](https://raw.githubusercontent.com/aws/amazon-cognito-identity-js/master/dist/amazon-cognito-identity.min.js) und speichern Sie dann den Text aus jeder Datei als separate `.js` Dateien. 

## JavaScript Beispielcode
<a name="image-bytes-javascript-code"></a>

Das folgende Codebeispiel verwendet JavaScript V2. Ein Beispiel für JavaScript V3 finden Sie in [dem Beispiel im AWS Documentation SDK Examples GitHub Repository.](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/javascriptv3/example_code/rekognition/estimate-age-example/src)

```
<!--
Copyright 2018 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.)
-->
<!DOCTYPE html>
<html>
<head>
  <script src="aws-cognito-sdk.min.js"></script>
  <script src="amazon-cognito-identity.min.js"></script>
  <script src="https://sdk.amazonaws.com/js/aws-sdk-2.16.0.min.js"></script>
  <meta charset="UTF-8">
  <title>Rekognition</title>
</head>

<body>
  <H1>Age Estimator</H1>
  <input type="file" name="fileToUpload" id="fileToUpload" accept="image/*">
  <p id="opResult"></p>
</body>
<script>

  document.getElementById("fileToUpload").addEventListener("change", function (event) {
    ProcessImage();
  }, false);
  
  //Calls DetectFaces API and shows estimated ages of detected faces
  function DetectFaces(imageData) {
    AWS.region = "RegionToUse";
    var rekognition = new AWS.Rekognition();
    var params = {
      Image: {
        Bytes: imageData
      },
      Attributes: [
        'ALL',
      ]
    };
    rekognition.detectFaces(params, function (err, data) {
      if (err) console.log(err, err.stack); // an error occurred
      else {
       var table = "<table><tr><th>Low</th><th>High</th></tr>";
        // show each face and build out estimated age table
        for (var i = 0; i < data.FaceDetails.length; i++) {
          table += '<tr><td>' + data.FaceDetails[i].AgeRange.Low +
            '</td><td>' + data.FaceDetails[i].AgeRange.High + '</td></tr>';
        }
        table += "</table>";
        document.getElementById("opResult").innerHTML = table;
      }
    });
  }
  //Loads selected image and unencodes image bytes for Rekognition DetectFaces API
  function ProcessImage() {
    AnonLog();
    var control = document.getElementById("fileToUpload");
    var file = control.files[0];

    // Load base64 encoded image 
    var reader = new FileReader();
    reader.onload = (function (theFile) {
      return function (e) {
        var img = document.createElement('img');
        var image = null;
        img.src = e.target.result;
        var jpg = true;
        try {
          image = atob(e.target.result.split("data:image/jpeg;base64,")[1]);

        } catch (e) {
          jpg = false;
        }
        if (jpg == false) {
          try {
            image = atob(e.target.result.split("data:image/png;base64,")[1]);
          } catch (e) {
            alert("Not an image file Rekognition can process");
            return;
          }
        }
        //unencode image bytes for Rekognition DetectFaces API 
        var length = image.length;
        imageBytes = new ArrayBuffer(length);
        var ua = new Uint8Array(imageBytes);
        for (var i = 0; i < length; i++) {
          ua[i] = image.charCodeAt(i);
        }
        //Call Rekognition  
        DetectFaces(ua);
      };
    })(file);
    reader.readAsDataURL(file);
  }
  //Provides anonymous log on to AWS services
  function AnonLog() {
    
    // Configure the credentials provider to use your identity pool
    AWS.config.region = 'RegionToUse'; // Region
    AWS.config.credentials = new AWS.CognitoIdentityCredentials({
      IdentityPoolId: 'IdentityPoolIdToUse',
    });
    // Make the call to obtain credentials
    AWS.config.credentials.get(function () {
      // Credentials will be available when this function is called.
      var accessKeyId = AWS.config.credentials.accessKeyId;
      var secretAccessKey = AWS.config.credentials.secretAccessKey;
      var sessionToken = AWS.config.credentials.sessionToken;
    });
  }
</script>
</html>
```

### readAsArrayBuffer verwenden
<a name="image-bytes-javascript-unencoded"></a>

Der folgende Codeausschnitt ist eine alternative Implementierung der `ProcessImage` Funktion im Beispielcode unter Verwendung JavaScript von V2. Es verwendet `readAsArrayBuffer`, um ein Bild zu laden und `DetectFaces` aufzurufen. Da `readAsArrayBuffer` die Datei nicht mit base64 codiert, ist es nicht notwendig, die Bild-Bytes zu entcodieren, bevor eine Amazon-Rekognition-Image-Operation aufgerufen wird.

```
//Copyright 2018 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.)

function ProcessImage() {
    AnonLog();
    var control = document.getElementById("fileToUpload");
    var file = control.files[0];

    // Load base64 encoded image for display 
    var reader = new FileReader();
    reader.onload = (function (theFile) {
      return function (e) {
        //Call Rekognition  
        AWS.region = "RegionToUse";  
        var rekognition = new AWS.Rekognition();
        var params = {
          Image: {
          Bytes: e.target.result
        },
        Attributes: [
        'ALL',
      ]
    };
    rekognition.detectFaces(params, function (err, data) {
      if (err) console.log(err, err.stack); // an error occurred
      else {
       var table = "<table><tr><th>Low</th><th>High</th></tr>";
        // show each face and build out estimated age table
        for (var i = 0; i < data.FaceDetails.length; i++) {
          table += '<tr><td>' + data.FaceDetails[i].AgeRange.Low +
            '</td><td>' + data.FaceDetails[i].AgeRange.High + '</td></tr>';
        }
        table += "</table>";
        document.getElementById("opResult").innerHTML = table;
      }
    });

      };
    })(file);
    reader.readAsArrayBuffer(file);
  }
```

## Abrufen der Amazon-Cognito-Identitätspool-ID
<a name="image-bytes-javascript-auth"></a>

Der Einfachheit halber wird in diesem Beispiel ein anonymer Amazon-Cognito-Identitätspool verwendet, um einen nicht authentifizierten Zugriff auf die Amazon-Rekognition-Image-API zu ermöglichen. Dies könnte für Ihre Anforderungen nützlich sein. Sie können den nicht authentifizierten Zugriff beispielsweise verwenden, um kostenlosen Zugriff auf Ihre Website oder einen Testzugang zu bieten, bevor sich Benutzer anmelden. Um authentifizierten Zugriff bereitzustellen, verwenden Sie einen Amazon-Cognito-Benutzerpool. Weitere Informationen finden Sie unter [Amazon-Cognito-Benutzerpool](https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools.html). 

Das folgende Verfahren zeigt, wie Sie einen Identitätspool erstellen, der den Zugriff auf nicht authentifizierte Identitäten ermöglicht, und wie Sie die Identitätspool-ID abrufen, die im Beispielcode benötigt wird.

**Abrufen der Identitätspool-ID**

1. Öffnen Sie die [Amazon-Cognito-Konsole](https://console.aws.amazon.com/cognito/federated).

1. Wählen Sie **Neuen Identitätspool erstellen**.

1. Geben Sie für **Identitätspoolname\$1** einen Namen für Ihren Identitätspool ein.

1. Wählen Sie in **Nicht authentifizierte Identitäten** die Option **Zugriff auf nicht authentifizierte Identitäten aktivieren**.

1. Wählen Sie **Pool erstellen**.

1. Wählen Sie **Details anzeigen** und notieren Sie den Rollennamen für nicht authentifizierte Identitäten.

1. Wählen Sie **Zulassen**.

1. Wählen Sie unter **Plattform die** Option. **JavaScript**

1. Notieren Sie in **AWS-Anmeldeinformationen abrufen** die Werte von `AWS.config.region` und `IdentityPooldId`, die im Codeabschnitt angezeigt werden.

1. Öffnen Sie unter [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) die IAM-Konsole.

1. Wählen Sie im Navigationsbereich **Rollen** aus.

1. Wählen Sie den Rollennamen, den Sie in Schritt 6 notiert haben.

1. Wählen Sie in der Registerkarte **Berechtigungen** die Option **Richtlinien anfügen** aus.

1. Wählen Sie **AmazonRekognitionReadOnlyAccess**.

1. Wählen Sie **Richtlinie anfügen** aus.

# Anzeigen von Begrenzungsrahmen
<a name="images-displaying-bounding-boxes"></a>

Amazon-Rekognition-Image-Operationen können Koordinaten der Begrenzungsrahmen für Elemente zurückgeben, die in Bildern erkannt werden. Beispiel: Die [DetectFaces](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectFaces.html)-Operation gibt für jedes Gesicht, das in einem Bild erkannt wird, einen Begrenzungsrahmen ([BoundingBox](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_BoundingBox.html)) zurück. Sie können die Koordinaten des Begrenzungsrahmens verwenden, um einen Rahmen um die erkannten Elemente anzuzeigen. Beispiel: In der folgenden Abbildung wird ein Begrenzungsrahmen angezeigt, der ein Gesicht umgibt.

![\[Lächelnde junge Frau mit Brille und Blasen um sie herum.\]](http://docs.aws.amazon.com/de_de/rekognition/latest/dg/images/face.png)


Eine `BoundingBox` besitzt die folgenden Eigenschaften:
+ Höhe: Höhe des Begrenzungsrahmens als Verhältnis der gesamten Bildhöhe.
+ Links: Linke Koordinate des Begrenzungsrahmens als Verhältnis zur Gesamtbildbreite.
+ Oben: Obere Koordinate des Begrenzungsrahmens als Verhältnis zur Gesamtbildbreite.
+ Breite: Breite des Begrenzungsrahmens als Verhältnis der gesamten Bildbreite.

Jede BoundingBox Eigenschaft hat einen Wert zwischen 0 und 1. Jeder Eigenschaftswert ist ein Verhältnis der gesamten Breite (`Left` und `Width`) oder der gesamten Höhe (`Height` und `Top`) des Bildes. Beispiel: Bei einem Eingabebild mit 700 x 200 Pixeln und einer linken oberen Koordinate des Begrenzungsrahmens von 350 x 50 Pixeln gibt die API einen `Left`-Wert von 0,5 (350/700) und einen `Top`-Wert von 0,25 (50/200) zurück. 

Das folgende Diagramm zeigt den Bereich eines Bildes, der von jeder Begrenzungsrahmen-Eigenschaft abgedeckt wird.

![\[Eine Grafik, die zeigt, wie sich ein Begrenzungsrahmen auf die Abmessungen eines Bildes bezieht.\]](http://docs.aws.amazon.com/de_de/rekognition/latest/dg/images/bounding-box.png)


Um den Begrenzungsrahmen mit der richtigen Position und Größe anzuzeigen, müssen Sie die BoundingBox Werte mit der Bildbreite oder -höhe (abhängig vom gewünschten Wert) multiplizieren, um die Pixelwerte zu erhalten. Sie verwenden die Pixelwerte, um den Begrenzungsrahmen anzuzeigen. Beispiel: Die Pixelmaße des vorherigen Bildes waren Breite 608 x Höhe 588. Die Werte des Begrenzungsrahmens für das Gesicht sind: 

```
BoundingBox.Left: 0.3922065
BoundingBox.Top: 0.15567766
BoundingBox.Width: 0.284666
BoundingBox.Height: 0.2930403
```

Der Speicherort des Gesichts-Begrenzungsrahmens in Pixeln wird wie folgt berechnet: 

`Left coordinate = BoundingBox.Left (0.3922065) * image width (608) = 238`

`Top coordinate = BoundingBox.Top (0.15567766) * image height (588) = 91`

`Face width = BoundingBox.Width (0.284666) * image width (608) = 173`

`Face height = BoundingBox.Height (0.2930403) * image height (588) = 172`

Sie können mit diesen Werten einen Begrenzungsrahmen um das Gesicht herum anzeigen.

**Anmerkung**  
Ein Bild kann auf verschiedene Weise ausgerichtet werden. Ihre Anwendung muss das Bild möglicherweise rotieren, um es in der richtigen Ausrichtung anzuzeigen. Die Koordinaten des Begrenzungsrahmens sind von der Ausrichtung des Bildes betroffen. Sie müssen die Koordinaten möglicherweise übersetzen, bevor Sie einen Begrenzungsrahmen an der richtigen Stelle anzeigen können. Weitere Informationen finden Sie unter [Erhalten der Bildausrichtung und der Koordinaten von Begrenzungsrahmen](images-orientation.md).

Die folgenden Beispiele zeigen, wie Sie einen Begrenzungsrahmen um Gesichter herum anzeigen, die durch Aufrufen von [DetectFaces](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectFaces.html) erkannt werden. Die Beispiele gehen davon aus, dass die Bilder auf 0 Grad ausgerichtet sind. Die Beispiele zeigen auch, wie das Bild aus einem Amazon-S3-Bucket heruntergeladen wird. 

**So zeigen Sie einen Begrenzungsrahmen an**

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. Verwenden Sie die folgenden Beispiele zum Aufrufen der `DetectFaces`-Operation.

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

   Ändern Sie den Wert von `bucket` in den Amazon-S3-Bucket mit der Bilddatei. Ändern Sie den Wert von `photo` in den Dateinamen einer Bilddatei (JPG- oder PNG-Format).

   ```
    
   //Loads images, detects faces and draws bounding boxes.Determines exif orientation, if necessary.
   package com.amazonaws.samples;
   
   //Import the basic graphics classes.
   import java.awt.*;
   import java.awt.image.BufferedImage;
   import java.util.List;
   import javax.imageio.ImageIO;
   import javax.swing.*;
   
   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.DetectFacesRequest;
   import com.amazonaws.services.rekognition.model.DetectFacesResult;
   import com.amazonaws.services.rekognition.model.FaceDetail;
   import com.amazonaws.services.rekognition.model.Image;
   import com.amazonaws.services.rekognition.model.S3Object;
   import com.amazonaws.services.s3.AmazonS3;
   import com.amazonaws.services.s3.AmazonS3ClientBuilder;
   import com.amazonaws.services.s3.model.S3ObjectInputStream;
   
   // Calls DetectFaces and displays a bounding box around each detected image.
   public class DisplayFaces extends JPanel {
   
       private static final long serialVersionUID = 1L;
   
       BufferedImage image;
       static int scale;
       DetectFacesResult result;
   
       public DisplayFaces(DetectFacesResult facesResult, BufferedImage bufImage) throws Exception {
           super();
           scale = 1; // increase to shrink image size.
   
           result = facesResult;
           image = bufImage;
   
           
       }
       // 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);
   
           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 faces and display bounding boxes.
           List<FaceDetail> faceDetails = result.getFaceDetails();
           for (FaceDetail face : faceDetails) {
               
               BoundingBox box = face.getBoundingBox();
               left = width * box.getLeft();
               top = height * box.getTop();
               g2d.drawRect(Math.round(left / scale), Math.round(top / scale),
                       Math.round((width * box.getWidth()) / scale), Math.round((height * box.getHeight())) / scale);
               
           }
       }
   
   
       public static void main(String arg[]) throws Exception {
   
           String photo = "photo.png";
           String bucket = "bucket";
           int height = 0;
           int width = 0;
   
           // Get the image from an S3 Bucket
           AmazonS3 s3client = AmazonS3ClientBuilder.defaultClient();
   
           com.amazonaws.services.s3.model.S3Object s3object = s3client.getObject(bucket, photo);
           S3ObjectInputStream inputStream = s3object.getObjectContent();
           BufferedImage image = ImageIO.read(inputStream);
           DetectFacesRequest request = new DetectFacesRequest()
                   .withImage(new Image().withS3Object(new S3Object().withName(photo).withBucket(bucket)));
   
           width = image.getWidth();
           height = image.getHeight();
   
           // Call DetectFaces    
           AmazonRekognition amazonRekognition = AmazonRekognitionClientBuilder.defaultClient();
           DetectFacesResult result = amazonRekognition.detectFaces(request);
           
           //Show the bounding box info for each face.
           List<FaceDetail> faceDetails = result.getFaceDetails();
           for (FaceDetail face : faceDetails) {
   
               BoundingBox box = face.getBoundingBox();
               float left = width * box.getLeft();
               float top = height * box.getTop();
               System.out.println("Face:");
   
               System.out.println("Left: " + String.valueOf((int) left));
               System.out.println("Top: " + String.valueOf((int) top));
               System.out.println("Face Width: " + String.valueOf((int) (width * box.getWidth())));
               System.out.println("Face Height: " + String.valueOf((int) (height * box.getHeight())));
               System.out.println();
   
           }
   
           // Create frame and panel.
           JFrame frame = new JFrame("RotateImage");
           frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
           DisplayFaces panel = new DisplayFaces(result, image);
           panel.setPreferredSize(new Dimension(image.getWidth() / scale, image.getHeight() / scale));
           frame.setContentPane(panel);
           frame.pack();
           frame.setVisible(true);
   
       }
   }
   ```

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

   Ändern Sie den Wert von `bucket` in den Amazon-S3-Bucket mit der Bilddatei. Ändern Sie den Wert von `photo` in den Dateinamen einer Bilddatei (JPG- oder PNG-Format). Ersetzen Sie den Wert von `profile_name` in der Zeile, die die Rekognition-Sitzung erstellt, durch den Namen Ihres Entwicklerprofils.

   ```
   import boto3
   import io
   from PIL import Image, ImageDraw
   
   def show_faces(photo, bucket):
   
       session = boto3.Session(profile_name='profile-name')
       client = session.client('rekognition')
   
       # Load image from S3 bucket
       s3_connection = boto3.resource('s3')
       s3_object = s3_connection.Object(bucket, photo)
       s3_response = s3_object.get()
   
       stream = io.BytesIO(s3_response['Body'].read())
       image = Image.open(stream)
   
       # Call DetectFaces
       response = client.detect_faces(Image={'S3Object': {'Bucket': bucket, 'Name': photo}},
                                      Attributes=['ALL'])
   
       imgWidth, imgHeight = image.size
       draw = ImageDraw.Draw(image)
   
       # calculate and display bounding boxes for each detected face
       print('Detected faces for ' + photo)
       for faceDetail in response['FaceDetails']:
           print('The detected face is between ' + str(faceDetail['AgeRange']['Low'])
                 + ' and ' + str(faceDetail['AgeRange']['High']) + ' years old')
   
           box = faceDetail['BoundingBox']
           left = imgWidth * box['Left']
           top = imgHeight * box['Top']
           width = imgWidth * box['Width']
           height = imgHeight * box['Height']
   
           print('Left: ' + '{0:.0f}'.format(left))
           print('Top: ' + '{0:.0f}'.format(top))
           print('Face Width: ' + "{0:.0f}".format(width))
           print('Face Height: ' + "{0:.0f}".format(height))
   
           points = (
               (left, top),
               (left + width, top),
               (left + width, top + height),
               (left, top + height),
               (left, top)
   
           )
           draw.line(points, fill='#00d400', width=2)
   
           # Alternatively can draw rectangle. However you can't set line width.
           # draw.rectangle([left,top, left + width, top + height], outline='#00d400')
   
       image.show()
   
       return len(response['FaceDetails'])
   
   def main():
       bucket = "bucket-name"
       photo = "photo-name"
       faces_count = show_faces(photo, bucket)
       print("faces detected: " + str(faces_count))
   
   if __name__ == "__main__":
       main()
   ```

------
#### [ 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/DisplayFacesFrame.java).

   Beachten Sie, dass `s3` sich auf den AWS-SDK-Amazon-S3-Client bezieht und `rekClient` sich auf den AWS-SDK-Amazon-Rekognition-Client bezieht. 

   ```
   //snippet-start:[rekognition.java2.detect_labels.import]
   import java.awt.*;
   import java.awt.image.BufferedImage;
   import java.io.ByteArrayInputStream;
   import java.io.FileNotFoundException;
   import java.io.IOException;
   import java.io.InputStream;
   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.Attribute;
   import software.amazon.awssdk.services.rekognition.model.BoundingBox;
   import software.amazon.awssdk.services.rekognition.model.DetectFacesRequest;
   import software.amazon.awssdk.services.rekognition.model.DetectFacesResponse;
   import software.amazon.awssdk.services.rekognition.model.FaceDetail;
   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;
   //snippet-end:[rekognition.java2.detect_labels.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 DisplayFaces extends JPanel {
   
       static DetectFacesResponse result;
       static BufferedImage image;
       static int scale;
   
       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 (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_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();
   
           displayAllFaces(s3, rekClient, sourceImage, bucketName);
           s3.close();
           rekClient.close();
       }
   
       // snippet-start:[rekognition.java2.display_faces.main]
       public static void displayAllFaces(S3Client s3,
                                          RekognitionClient rekClient,
                                          String sourceImage,
                                          String bucketName) {
           int height;
           int width;
           byte[] data = getObjectBytes (s3, bucketName, sourceImage);
           InputStream is = new ByteArrayInputStream(data);
   
           try {
               SdkBytes sourceBytes = SdkBytes.fromInputStream(is);
               image = ImageIO.read(sourceBytes.asInputStream());
               width = image.getWidth();
               height = image.getHeight();
   
               // Create an Image object for the source image
               software.amazon.awssdk.services.rekognition.model.Image souImage = Image.builder()
                   .bytes(sourceBytes)
                   .build();
   
               DetectFacesRequest facesRequest = DetectFacesRequest.builder()
                   .attributes(Attribute.ALL)
                   .image(souImage)
                   .build();
   
               result = rekClient.detectFaces(facesRequest);
   
               // Show the bounding box info for each face.
               List<FaceDetail> faceDetails = result.faceDetails();
               for (FaceDetail face : faceDetails) {
                   BoundingBox box = face.boundingBox();
                   float left = width * box.left();
                   float top = height * box.top();
                   System.out.println("Face:");
   
                   System.out.println("Left: " + (int) left);
                   System.out.println("Top: " + (int) top);
                   System.out.println("Face Width: " + (int) (width * box.width()));
                   System.out.println("Face Height: " + (int) (height * box.height()));
                   System.out.println();
               }
   
               // Create the frame and panel.
               JFrame frame = new JFrame("RotateImage");
               frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
               DisplayFaces panel = new DisplayFaces(image);
               panel.setPreferredSize(new Dimension(image.getWidth() / scale, image.getHeight() / scale));
               frame.setContentPane(panel);
               frame.pack();
               frame.setVisible(true);
   
           } catch (RekognitionException | FileNotFoundException e) {
               System.out.println(e.getMessage());
               System.exit(1);
           } catch (IOException 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 DisplayFaces(BufferedImage bufImage) {
           super();
           scale = 1; // increase to shrink image size.
           image = bufImage;
       }
   
       // Draws the bounding box around the detected faces.
       public void paintComponent(Graphics g) {
           float left;
           float top;
           int height = image.getHeight(this);
           int width = image.getWidth(this);
           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 the faces and display bounding boxes.
           List<FaceDetail> faceDetails = result.faceDetails();
           for (FaceDetail face : faceDetails) {
               BoundingBox box = face.boundingBox();
               left = width * box.left();
               top = height * box.top();
               g2d.drawRect(Math.round(left / scale), Math.round(top / scale),
                       Math.round((width * box.width()) / scale), Math.round((height * box.height())) / scale);
           }
       }
       // snippet-end:[rekognition.java2.display_faces.main]
   }
   ```

------

# Erhalten der Bildausrichtung und der Koordinaten von Begrenzungsrahmen
<a name="images-orientation"></a>

Anwendungen, die Amazon Rekognition Image verwenden, müssen in der Regel die von Amazon Rekognition Image erkannten Bilder und die Rahmen um die erkannten Gesichter anzeigen. Um ein Bild in Ihrer Anwendung korrekt anzuzeigen, müssen Sie die Ausrichtung des Bildes kennen. Möglicherweise müssen Sie diese Ausrichtung anpassen. Bei einigen JPG-Dateien ist die Orientierung des Bildes in den Metadaten des Exchangeable Image File Format (Exif) des Bildes enthalten. 

Um einen Rahmen um ein Gesicht herum anzuzeigen, benötigen Sie die Koordinaten für den Begrenzungsrahmen des Gesichts. Wenn das Feld nicht richtig ausgerichtet ist, müssen Sie diese Koordinaten möglicherweise anpassen. Die Gesichtserkennungsoperationen von Amazon Rekognition Image geben die Bounding-Box-Koordinaten für jedes erkannte Gesicht zurück, aber die Koordinaten für JPG-Dateien ohne Exif-Metadaten werden nicht geschätzt.

Die folgenden Beispiele zeigen, wie Sie die Bounding-Box-Koordinaten für die in einem Bild erkannten Gesichter erhalten.

Verwenden Sie die Informationen in diesem Beispiel, um sicherzustellen, dass Ihre Bilder richtig ausgerichtet sind, und dass die Begrenzungsrahmen an der richtigen Stelle in Ihrer Anwendung angezeigt werden. 

Da der Code, der zum Drehen und Anzeigen von Bildern und Begrenzungsrahmen verwendet wird, von der Sprache und Umgebung abhängt, die Sie verwenden, erklären wir nicht, wie Sie Bilder und Begrenzungsrahmen in Ihrem Code darstellen oder wie Sie Orientierungsinformationen aus den Exif-Metadaten erhalten.



## Ermitteln der Ausrichtung eines Bildes
<a name="images-discovering-image-orientation"></a>

Um ein Bild in Ihrer Anwendung korrekt darzustellen, müssen Sie es möglicherweise drehen. Das folgende Bild ist auf 0 Grad ausgerichtet und wird korrekt dargestellt.

![\[Generisches Profilsymbol, das ein Benutzerkonto oder ein Profilbild darstellt.\]](http://docs.aws.amazon.com/de_de/rekognition/latest/dg/images/00face.png)


Das folgende Bild ist jedoch um 90 Grad gegen den Uhrzeigersinn gedreht. Um es korrekt darzustellen, müssen Sie die Ausrichtung des Bildes ermitteln und diese Information in Ihrem Code verwenden, um das Bild auf 0 Grad zu drehen. 

![\[Generisches Profilsymbol, das ein Benutzerkonto oder ein Profilbild darstellt und um 90 Grad gegen den Uhrzeigersinn gedreht ist.\]](http://docs.aws.amazon.com/de_de/rekognition/latest/dg/images/90face.png)


Einige Bilder im JPG-Format enthalten Orientierungsinformationen in den Exif-Metadaten. Falls verfügbar, enthalten die Exif-Metadaten für das Bild die Ausrichtung. In den Exif-Metadaten finden Sie die Ausrichtung des Bildes im Feld `orientation`. Obwohl Amazon Rekognition Image das Vorhandensein von Bildausrichtungsinformationen in Exif-Metadaten identifiziert, bietet es keinen Zugriff darauf. Um auf die Exif-Metadaten in einem Bild zuzugreifen, verwenden Sie eine Bibliothek eines Drittanbieters oder schreiben Sie Ihren eigenen Code. Weitere Informationen finden Sie unter [Exif Version 2.32](http://cipa.jp/std/documents/download_e.html?DC-008-Translation-2019-E).

 



Wenn Sie die Ausrichtung eines Bildes kennen, können Sie Code schreiben, um es zu drehen und korrekt darzustellen.

## Anzeigen von Begrenzungsrahmen
<a name="images-bounding-boxes"></a>

Die Amazon-Rekognition-Image-Operationen, die Gesichter in einem Bild analysieren, geben auch die Koordinaten der Begrenzungsrahmen zurück, die die Gesichter umgeben. Weitere Informationen finden Sie unter [BoundingBox](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_BoundingBox.html). 

Um in Ihrer Anwendung einen Begrenzungsrahmen um ein Gesicht herum anzuzeigen, das dem im folgenden Bild ähnlich ist, verwenden Sie die Begrenzungsrahmenkoordinaten in Ihrem Code. Die Koordinaten des Begrenzungsrahmens, die von einer Operation zurückgegeben werden, spiegeln die Ausrichtung des Bildes wider. Wenn Sie das Bild drehen müssen, um es korrekt darzustellen, müssen Sie die Koordinaten des Begrenzungsrahmens entsprechend übertragen.



![\[Profilsymbol mit hervorgehobenem Gesicht in einem roten Quadrat.\]](http://docs.aws.amazon.com/de_de/rekognition/latest/dg/images/00facebounding.png)




### Anzeigen von Begrenzungsrahmen, wenn die Orientierungsinformationen in Exif-Metadaten vorhanden sind
<a name="images-exif-metadata"></a>

Wenn die Ausrichtung eines Bildes in den Exif-Metadaten enthalten ist, machen die Amazon-Rekognition-Image-Operationen folgendes:
+ Geben Null im Feld für die Orientierungskorrektur in der Antwort der Operation zurück. Um das Bild zu drehen, verwenden Sie die Orientierung, die in den Exif-Metadaten in Ihrem Code angegeben ist.
+ Geben Koordinaten für Begrenzungsrahmen bereits auf 0 Grad orientiert zurück. Um den Begrenzungsrahmen an der richtigen Position anzuzeigen, verwenden Sie die zurückgegebenen Koordinaten. Sie müssen sie nicht übertragen.

## Beispiel: Erhalten der Bildausrichtung und der Koordinaten von Begrenzungsrahmen für ein Bild
<a name="images-correcting-image-orientation-java"></a>

Die folgenden Beispiele zeigen, wie Sie das AWS-SDK verwenden, um die Exif-Bildausrichtungsdaten und die Bounding-Box-Koordinaten für die von der `RecognizeCelebrities`-Operation erkannten Berühmtheiten zu erhalten.

**Anmerkung**  
Die Unterstützung für die Schätzung der Bildausrichtung anhand des `OrientationCorrection`-Feldes wurde im August 2021 eingestellt. Alle zurückgegebenen Werte für dieses Feld, die in einer API-Antwort enthalten sind, sind immer NULL.

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

Dieses Beispiel lädt ein Bild aus dem lokalen Dateisystem, ruft die `RecognizeCelebrities`-Operation auf, bestimmt die Höhe und Breite des Bildes und berechnet die Koordinaten des Begrenzungsrahmens des Gesichts für das gedrehte Bild. Das Beispiel zeigt nicht, wie Orientierungsinformationen, die in Exif-Metadaten gespeichert sind, verarbeitet werden können.

Ersetzen Sie in der `main`-Funktion den Wert von `photo` durch den Namen und Pfad eines Bildes, das lokal im PNG- oder JPG-Format gespeichert ist.

```
//Copyright 2018 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 java.awt.image.BufferedImage;
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 java.util.List;
import javax.imageio.ImageIO;
import com.amazonaws.services.rekognition.AmazonRekognition;
import com.amazonaws.services.rekognition.AmazonRekognitionClientBuilder;
import com.amazonaws.services.rekognition.model.Image;
import com.amazonaws.services.rekognition.model.RecognizeCelebritiesRequest;
import com.amazonaws.services.rekognition.model.RecognizeCelebritiesResult;
import com.amazonaws.util.IOUtils;
import com.amazonaws.services.rekognition.model.AmazonRekognitionException;
import com.amazonaws.services.rekognition.model.BoundingBox;
import com.amazonaws.services.rekognition.model.Celebrity;
import com.amazonaws.services.rekognition.model.ComparedFace;

public class RotateImage {

public static void main(String[] args) throws Exception {

  String photo = "photo.png";

  //Get Rekognition client
 AmazonRekognition amazonRekognition = AmazonRekognitionClientBuilder.defaultClient();


  // Load image
  ByteBuffer imageBytes=null;
  BufferedImage image = null;

  try (InputStream inputStream = new FileInputStream(new File(photo))) {
     imageBytes = ByteBuffer.wrap(IOUtils.toByteArray(inputStream));

  }
  catch(Exception e)
  {
      System.out.println("Failed to load file " + photo);
      System.exit(1);
  }

  //Get image width and height
  InputStream imageBytesStream;
  imageBytesStream = new ByteArrayInputStream(imageBytes.array());

  ByteArrayOutputStream baos = new ByteArrayOutputStream();
  image=ImageIO.read(imageBytesStream);
  ImageIO.write(image, "jpg", baos);

  int height = image.getHeight();
  int width = image.getWidth();

  System.out.println("Image Information:");
  System.out.println(photo);
  System.out.println("Image Height: " + Integer.toString(height));
  System.out.println("Image Width: " + Integer.toString(width));

  //Call GetCelebrities

  try{
    RecognizeCelebritiesRequest request = new RecognizeCelebritiesRequest()
           .withImage(new Image()
              .withBytes((imageBytes)));


      RecognizeCelebritiesResult result = amazonRekognition.recognizeCelebrities(request);
      // The returned value of OrientationCorrection will always be null
      System.out.println("Orientation: " + result.getOrientationCorrection() + "\n");
      List <Celebrity> celebs = result.getCelebrityFaces();

      for (Celebrity celebrity: celebs) {
          System.out.println("Celebrity recognized: " + celebrity.getName());
          System.out.println("Celebrity ID: " + celebrity.getId());
          ComparedFace  face = celebrity.getFace()
;             ShowBoundingBoxPositions(height,
                  width,
                  face.getBoundingBox(),
                  result.getOrientationCorrection());
                 
            System.out.println();
       }

   } catch (AmazonRekognitionException e) {
      e.printStackTrace();
   }

}


public static void ShowBoundingBoxPositions(int imageHeight, int imageWidth, BoundingBox box, String rotation) {

  float left = 0;
  float top = 0;
   
  if(rotation==null){
      System.out.println("No estimated estimated orientation. Check Exif data.");
      return;
  }
  //Calculate face position based on image orientation.
  switch (rotation) {
     case "ROTATE_0":
        left = imageWidth * box.getLeft();
        top = imageHeight * box.getTop();
        break;
     case "ROTATE_90":
        left = imageHeight * (1 - (box.getTop() + box.getHeight()));
        top = imageWidth * box.getLeft();
        break;
     case "ROTATE_180":
        left = imageWidth - (imageWidth * (box.getLeft() + box.getWidth()));
        top = imageHeight * (1 - (box.getTop() + box.getHeight()));
        break;
     case "ROTATE_270":
        left = imageHeight * box.getTop();
        top = imageWidth * (1 - box.getLeft() - box.getWidth());
        break;
     default:
        System.out.println("No estimated orientation information. Check Exif data.");
        return;
  }

  //Display face location information.
  System.out.println("Left: " + String.valueOf((int) left));
  System.out.println("Top: " + String.valueOf((int) top));
  System.out.println("Face Width: " + String.valueOf((int)(imageWidth * box.getWidth())));
  System.out.println("Face Height: " + String.valueOf((int)(imageHeight * box.getHeight())));

  }
}
```

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

In diesem Beispiel wird die PIL/Pillow Bildbibliothek verwendet, um die Breite und Höhe des Bildes zu ermitteln. Weitere Informationen finden Sie unter [Pillow](https://pillow.readthedocs.io/en/stable/). Dieses Beispiel bewahrt die Exif-Metadaten auf, die Sie möglicherweise an anderer Stelle in Ihrer Anwendung benötigen.

Ersetzen Sie in der `main`-Funktion den Wert von `photo` durch den Namen und Pfad eines Bildes, das lokal im PNG- oder JPG-Format gespeichert ist.

```
#Copyright 2018 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


# Calculate positions from from estimated rotation
def show_bounding_box_positions(imageHeight, imageWidth, box):
    left = 0
    top = 0

    print('Left: ' + '{0:.0f}'.format(left))
    print('Top: ' + '{0:.0f}'.format(top))
    print('Face Width: ' + "{0:.0f}".format(imageWidth * box['Width']))
    print('Face Height: ' + "{0:.0f}".format(imageHeight * box['Height']))


def celebrity_image_information(photo):
    client = boto3.client('rekognition')

    # Get image width and height
    image = Image.open(open(photo, 'rb'))
    width, height = image.size

    print('Image information: ')
    print(photo)
    print('Image Height: ' + str(height))
    print('Image Width: ' + str(width))

    # call detect faces and show face age and placement
    # if found, preserve exif info
    stream = io.BytesIO()
    if 'exif' in image.info:
        exif = image.info['exif']
        image.save(stream, format=image.format, exif=exif)
    else:
        image.save(stream, format=image.format)
    image_binary = stream.getvalue()

    response = client.recognize_celebrities(Image={'Bytes': image_binary})

    print()
    print('Detected celebrities for ' + photo)

    for celebrity in response['CelebrityFaces']:
        print('Name: ' + celebrity['Name'])
        print('Id: ' + celebrity['Id'])

        # Value of "orientation correction" will always be null
        if 'OrientationCorrection' in response:
            show_bounding_box_positions(height, width, celebrity['Face']['BoundingBox'])

        print()
    return len(response['CelebrityFaces'])


def main():
    photo = 'photo'

    celebrity_count = celebrity_image_information(photo)
    print("celebrities detected: " + str(celebrity_count))


if __name__ == "__main__":
    main()
```

------
#### [ 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/RotateImage.java).

```
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.RecognizeCelebritiesRequest;
import software.amazon.awssdk.services.rekognition.model.Image;
import software.amazon.awssdk.services.rekognition.model.RecognizeCelebritiesResponse;
import software.amazon.awssdk.services.rekognition.model.Celebrity;
import software.amazon.awssdk.services.rekognition.model.ComparedFace;
import software.amazon.awssdk.services.rekognition.model.RekognitionException;
import software.amazon.awssdk.services.rekognition.model.BoundingBox;
import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.*;
import java.util.List;

/**
 * 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 RotateImage {
    public static void main(String[] args) {
        final String usage = """

                Usage:    <sourceImage>

                Where:
                   sourceImage - The path to the image (for example, C:\\AWS\\pic1.png).\s
                """;

        if (args.length != 1) {
            System.out.println(usage);
            System.exit(1);
        }

        String sourceImage = args[0];
        Region region = Region.US_WEST_2;
        RekognitionClient rekClient = RekognitionClient.builder()
                .region(region)
                .build();

        System.out.println("Locating celebrities in " + sourceImage);
        recognizeAllCelebrities(rekClient, sourceImage);
        rekClient.close();
    }

    public static void recognizeAllCelebrities(RekognitionClient rekClient, String sourceImage) {
        try {
            BufferedImage image;
            InputStream sourceStream = new FileInputStream(sourceImage);
            SdkBytes sourceBytes = SdkBytes.fromInputStream(sourceStream);

            image = ImageIO.read(sourceBytes.asInputStream());
            int height = image.getHeight();
            int width = image.getWidth();

            Image souImage = Image.builder()
                    .bytes(sourceBytes)
                    .build();

            RecognizeCelebritiesRequest request = RecognizeCelebritiesRequest.builder()
                    .image(souImage)
                    .build();

            RecognizeCelebritiesResponse result = rekClient.recognizeCelebrities(request);
            List<Celebrity> celebs = result.celebrityFaces();
            System.out.println(celebs.size() + " celebrity(s) were recognized.\n");
            for (Celebrity celebrity : celebs) {
                System.out.println("Celebrity recognized: " + celebrity.name());
                System.out.println("Celebrity ID: " + celebrity.id());
                ComparedFace face = celebrity.face();
                ShowBoundingBoxPositions(height,
                        width,
                        face.boundingBox(),
                        result.orientationCorrectionAsString());
            }

        } catch (RekognitionException | FileNotFoundException e) {
            System.out.println(e.getMessage());
            System.exit(1);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void ShowBoundingBoxPositions(int imageHeight, int imageWidth, BoundingBox box, String rotation) {
        float left;
        float top;
        if (rotation == null) {
            System.out.println("No estimated estimated orientation.");
            return;
        }

        // Calculate face position based on the image orientation.
        switch (rotation) {
            case "ROTATE_0" -> {
                left = imageWidth * box.left();
                top = imageHeight * box.top();
            }
            case "ROTATE_90" -> {
                left = imageHeight * (1 - (box.top() + box.height()));
                top = imageWidth * box.left();
            }
            case "ROTATE_180" -> {
                left = imageWidth - (imageWidth * (box.left() + box.width()));
                top = imageHeight * (1 - (box.top() + box.height()));
            }
            case "ROTATE_270" -> {
                left = imageHeight * box.top();
                top = imageWidth * (1 - box.left() - box.width());
            }
            default -> {
                System.out.println("No estimated orientation information. Check Exif data.");
                return;
            }
        }

        System.out.println("Left: " + (int) left);
        System.out.println("Top: " + (int) top);
        System.out.println("Face Width: " + (int) (imageWidth * box.width()));
        System.out.println("Face Height: " + (int) (imageHeight * box.height()));
    }
}
```

------