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

# Como trabalhar com imagens
<a name="images"></a>

Esta seção aborda os tipos de análise que o Amazon Rekognition Image pode realizar em imagens. 
+ [Detecção de objetos e cenas](labels.md)
+ [Detecção e comparação de faces](faces.md)
+ [Pesquisar faces em uma coleção](collections.md)
+ [Reconhecimento de celebridades](celebrities.md)
+ [Moderação de imagem](moderation.md)
+ [Texto na detecção de imagens](text-detection.md)

Elas são realizadas por operações de API sem armazenamento, nas quais o Amazon Rekognition Image não mantém nenhuma informação descoberta pela operação. Nenhum byte da imagem de entrada é mantido pelas operações da API de não armazenamento. Para obter mais informações, consulte [Entender operações de API sem armazenamento e com armazenamento](how-it-works-storage-non-storage.md).

O Amazon Rekognition Image também pode armazenar metadados faciais em coleções para recuperação posterior. Para obter mais informações, consulte [Pesquisa de faces em uma coleção](collections.md).

Nesta seção, você usa as operações da API Amazon Rekognition Image para analisar imagens armazenadas em um bucket do Amazon S3 e bytes de imagens carregadas do sistema de arquivos local. Esta seção também aborda a obtenção das informações de orientação de uma imagem .jpg. 

 O Rekognition usa apenas canais RGB para realizar inferências. AWS recomenda que os usuários removam o Alpha Channel antes de usar um monitor para inspecionar visualmente (manualmente por um humano) a comparação. 

**Topics**
+ [Especificações de imagem](images-information.md)
+ [Analisando imagens armazenadas em um bucket do Amazon S3](images-s3.md)
+ [Analisar uma imagem carregada de um sistema de arquivos local](images-bytes.md)
+ [Exibir caixas delimitadoras](images-displaying-bounding-boxes.md)
+ [Obter a orientação e as coordenadas da caixa delimitadora da imagem](images-orientation.md)

# Especificações de imagem
<a name="images-information"></a>

As operações do Amazon Rekognition Image podem analisar imagens no formato .jpg ou .png.

Você passa bytes de imagem para uma operação do Amazon Rekognition Image como parte da chamada ou faz referência a um objeto existente do Amazon S3. Para obter um exemplo de análise de uma imagem armazenada em um bucket do Amazon S3, consulte [Analisando imagens armazenadas em um bucket do Amazon S3](images-s3.md). Para obter um exemplo de transmissão de bytes de imagem para uma operação da API Amazon Rekognition Image, consulte [Analisar uma imagem carregada de um sistema de arquivos local](images-bytes.md).

Se você usar HTTP e passar os bytes de imagem como parte de uma operação do Amazon Rekognition Image, os bytes de imagem deverão ser uma cadeia de caracteres codificada em base64. Se você usar o AWS SDK e passar bytes da imagem como parte da chamada à operação da API, a necessidade de codificar os bytes da imagem em base64 dependerá do idioma usado. 

As seguintes imagens comuns codificam AWS SDKs automaticamente em base64, e você não precisa codificar bytes de imagem antes de chamar uma operação da API Amazon Rekognition Image.
+ Java
+ JavaScript
+ Python
+ PHP

Se você estiver usando outro AWS SDK e receber um erro de formato de imagem ao chamar uma operação da API Rekognition, tente codificar os bytes de imagem com base 64 antes de passá-los para uma operação da API Rekognition.

Se você usar o AWS CLI para chamar as operações do Amazon Rekognition Image, a transmissão de bytes de imagem como parte da chamada não é suportada. Você deve primeiramente carregar a imagem em um bucket do Amazon S3 e, em seguida, chamar a operação fazendo referência à imagem carregada.

**nota**  
A imagem não precisará estar codificada em base64 se você passar uma imagem armazenada em um `S3Object`, em vez dos bytes da imagem.

Para obter mais informações sobre como garantir a menor latência possível para as operações do Amazon Rekognition Image, consulte [Latência de operação do Amazon Rekognition Image](operation-latency.md). 

## Corrigir a orientação da imagem
<a name="images-image-orientation-correction"></a>

Em várias operações da API Rekognition, a orientação de uma imagem analisada é retornada. É importante saber a orientação da imagem, pois permite que você reoriente as imagens para exibição. As operações da API Rekognition que analisam faces também retornam caixas delimitadoras para a localização de faces em uma imagem. Você pode usar caixas delimitadoras para exibir uma caixa em torno de uma face em uma imagem. As coordenadas da caixa delimitadora retornadas são afetadas pela orientação da imagem e pode ser necessário converter as coordenadas da caixa delimitadora para exibir corretamente uma caixa em torno de uma face. Para obter mais informações, consulte [Obter a orientação e as coordenadas da caixa delimitadora da imagem](images-orientation.md). 

## Redimensionamento de imagem
<a name="images-image-sizing"></a>

Durante a análise, o Amazon Rekognition redimensiona internamente as imagens usando um conjunto de intervalos predefinidos que melhor se adequam a um modelo ou algoritmo específico. Por esse motivo, o Amazon Rekognition pode detectar um número diferente de objetos ou fornecer resultados diferentes, dependendo da resolução da imagem de entrada. Por exemplo, suponha que você tenha duas imagens. A primeira imagem tem uma resolução de 1024x768 pixels. A segunda imagem, uma versão redimensionada da primeira imagem, tem uma resolução de 640x480 pixels. Se você enviar as imagens para [DetectLabels](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectLabels.html), as respostas das duas chamadas para `DetectLabels` podem ser um pouco diferentes.

# Analisando imagens armazenadas em um bucket do Amazon S3
<a name="images-s3"></a>

O Amazon Rekognition Image pode analisar imagens armazenadas em um bucket do Amazon S3 ou imagens fornecidas como bytes de imagem.

Neste tópico, você usa a operação de [DetectLabels](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectLabels.html)API para detectar objetos, conceitos e cenas em uma imagem (JPEG ou PNG) armazenada em um bucket do Amazon S3. Você passa uma imagem para uma operação da API Amazon Rekognition Image usando o parâmetro de entrada [Image](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_Image.html). Em `Image`, especifique a propriedade de objeto [S3Object](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_3Object.html) para fazer referência a uma imagem armazenada em um bucket S3. Os bytes de imagem para imagens armazenadas nos buckets do Amazon S3 não precisam ser codificados em base64. Para obter mais informações, consulte [Especificações de imagem](images-information.md). 

## Exemplo de solicitação
<a name="images-s3-request"></a>

Nesta solicitação JSON de exemplo de `DetectLabels`, a imagem de origem (`input.jpg`) é carregada de um `amzn-s3-demo-bucket` nomeado pelo bucket do Amazon S3. A região do bucket do S3 que contém o objeto S3 deve corresponder à região que você usa para operações do Amazon Rekognition Image.

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

Os exemplos a seguir usam various AWS SDKs e the AWS CLI to call`DetectLabels`. Para obter informações sobre a resposta da operação `DetectLabels`, consulte [DetectLabels resposta](labels-detect-labels-image.md#detectlabels-response).

**Para detectar rótulos em uma imagem**

1. Se ainda não tiver feito isso:

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

   1. Instale e configure o AWS CLI e AWS SDKs o. Para obter mais informações, consulte [Etapa 2: configurar o AWS CLI e AWS SDKs](setup-awscli-sdk.md). Certifique-se de ter concedido ao usuário que chama as operações de API as permissões adequadas para o acesso programático; consulte [Conceder acesso programático](sdk-programmatic-access.md) para obter instruções sobre como fazer isso.

1. Faça upload de uma imagem que contenha um ou mais objetos, como árvores, casas e barcos, para seu bucket do S3. A imagem deve estar no formato *.jpg* ou *.png*.

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

1. Use os exemplos a seguir para chamar a operação `DetectLabels`.

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

   Este exemplo exibe uma lista de rótulos que foram detectados na imagem de entrada. Substitua os valores de `bucket` e `photo` pelos nomes do bucket do Amazon S3 e da imagem usados na etapa 2. 

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

   Esse exemplo exibe a saída JSON da operação da CLI `detect-labels`. Substitua os valores de `bucket` e `photo` pelos nomes do bucket do Amazon S3 e da imagem usados na etapa 2. Substitua o valor de `profile_name` na linha que cria a sessão do Rekognition pelo nome do seu perfil de desenvolvedor. 

   ```
   aws rekognition detect-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
   ```

   Se você estiver usando o Windows, talvez seja necessário escapar das aspas, conforme mostrado no exemplo abaixo.

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

   Esse código foi retirado do GitHub repositório de exemplos do SDK de AWS documentação. Veja o exemplo completo [aqui](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javav2/example_code/rekognition/src/main/java/com/example/rekognition/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 ]

   Este exemplo exibe os rótulos que foram detectados na imagem de entrada. Substitua os valores de `bucket` e `photo` pelos nomes do bucket do Amazon S3 e da imagem usados na etapa 2. Substitua o valor de `profile_name` na linha que cria a sessão do Rekognition pelo nome do seu perfil de desenvolvedor.

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

   Este exemplo exibe informações sobre os rótulos detectados em uma imagem. 

   Altere o valor de `photo` para o caminho e o nome de arquivo de um arquivo de imagem que contenha uma ou mais faces de celebridades. Altere o valor de `bucket` para o nome do bucket S3 que contém o arquivo de imagem fornecido. Altere o valor de `REGION` para o nome da região associada à sua conta. Substitua o valor de `profile_name` na linha que cria a sessão do Rekognition pelo nome do seu perfil de desenvolvedor. 

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

   Este exemplo exibe uma lista de rótulos que foram detectados na imagem de entrada. Substitua os valores de `bucket` e `photo` pelos nomes do bucket do Amazon S3 e da imagem usados na etapa 2. 

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

   Este exemplo exibe uma lista de rótulos que foram detectados na imagem de entrada. Substitua os valores de `bucket` e `photo` pelos nomes do bucket do Amazon S3 e da imagem usados na etapa 2. 

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

------



## Exemplo de resposta
<a name="images-s3-response"></a>

A resposta de `DetectLabels` é uma matriz de rótulos detectados na imagem e o nível de confiança em que foram detectadas. 

Quando você executa a `DetectLabels` operação em uma imagem, o Amazon Rekognition retorna uma saída semelhante ao exemplo de resposta a seguir.

A resposta mostra que a operação detectou vários rótulos, incluindo Pessoa, Veículo e Carro. Cada rótulo tem um nível de confiança associado. Por exemplo, o algoritmo de detecção apresenta 98,991432% de certeza de que a imagem contém uma pessoa.

A resposta também inclui os rótulos ancestrais de um rótulo na matriz `Parents`. Por exemplo, o rótulo Automóvel tem dois rótulos pai chamados Veículo e Transporte. 

A resposta para rótulos de objetos comuns inclui as informações da caixa delimitadora para a localização do rótulo na imagem de entrada. Por exemplo, o rótulo Pessoa tem uma matriz de instâncias que contém duas caixas delimitadoras. Essas são as localizações de duas pessoas detectadas na imagem.

O campo `LabelModelVersion` contém o número da versão do modelo de detecção usado por `DetectLabels`. 

Para obter mais informações sobre o uso dessa operação `DetectLabels`, consulte [Detectando objetos e conceitos](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"
}

    
}
```

# Analisar uma imagem carregada de um sistema de arquivos local
<a name="images-bytes"></a>

As operações do Amazon Rekognition Image podem analisar imagens que são fornecidas como bytes de imagem ou imagens armazenadas em um bucket do Amazon S3.

Estes tópicos fornecem exemplos de fornecimento de bytes de imagens para as operações da API Amazon Rekognition Image usando um arquivo carregado de um sistema de arquivos local. Você passa bytes de imagem para uma operação da API Amazon Rekognition usando o parâmetro de entrada [Image](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_Image.html). Dentro de `Image`, você especifica a propriedade `Bytes` para passar bytes de imagem codificados em base64.

Os bytes de imagem passados para uma operação da API do Amazon Rekognition usando o parâmetro de entrada `Bytes` devem ser codificados em base64. A AWS SDKs que esses exemplos usam imagens codificadas automaticamente em base64. Não é necessário codificar bytes de imagem antes de chamar uma operação da API Amazon Rekognition. Para obter mais informações, consulte [Especificações de imagem](images-information.md). 

Nesta solicitação JSON de exemplo de `DetectLabels`, os bytes da imagem de origem são passados no parâmetro de entrada `Bytes`. 

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

Os exemplos a seguir usam various AWS SDKs e the AWS CLI to call`DetectLabels`. Para obter informações sobre a resposta da operação `DetectLabels`, consulte [DetectLabels resposta](labels-detect-labels-image.md#detectlabels-response).

Para obter um JavaScript exemplo do lado do cliente, consulte. [Usando JavaScript](image-bytes-javascript.md)

**Para detectar rótulos em uma imagem local**

1. Se ainda não tiver feito isso:

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

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

1. Use os exemplos a seguir para chamar a operação `DetectLabels`.

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

   O exemplo de Java a seguir mostra como carregar uma imagem do sistema de arquivos local e detectar rótulos usando a operação [detectLabels](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/rekognition/model/DetectLabelsRequest.html) do SDK da AWS. Altere o valor de `photo` para o caminho e o nome de arquivo de um arquivo de imagem (formato .jpg ou .png).

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

   O exemplo de [AWS SDK para Python](https://aws.amazon.com/sdk-for-python/) a seguir mostra como carregar uma imagem do sistema de arquivos local e chamar a operação [detect\$1labels](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/rekognition.html#Rekognition.Client.detect_labels). Altere o valor de `photo` para o caminho e o nome de arquivo de um arquivo de imagem (formato .jpg ou .png). 

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

   O exemplo a seguir mostra como carregar uma imagem do sistema de arquivos local e detectar rótulos usando a operação `DetectLabels`. Altere o valor de `photo` para o caminho e o nome de arquivo de um arquivo de imagem (formato .jpg ou .png).

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

   O exemplo a seguir do [AWS SDK for](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/welcome.html#getting-started) PHP mostra como carregar uma imagem do sistema de arquivos local e chamar [DetectFaces](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-rekognition-2016-06-27.html#detectfaces)a operação da API. Altere o valor de `photo` para o caminho e o nome de arquivo de um arquivo de imagem (formato .jpg ou .png). 

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

   Este exemplo exibe uma lista de rótulos que foram detectados na imagem de entrada. Altere o valor de `photo` para o caminho e o nome de arquivo de um arquivo de imagem (formato .jpg ou .png).

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

   Esse código foi retirado do GitHub repositório de exemplos do SDK de AWS documentação. Veja o exemplo completo [aqui](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javav2/example_code/rekognition/src/main/java/com/example/rekognition/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);
           }
       }
   }
   ```

------

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

O exemplo de JavaScript página da web a seguir permite que um usuário escolha uma imagem e visualize a idade estimada dos rostos detectados na imagem. As idades estimativas são retornadas por uma chamada à [DetectFaces](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectFaces.html). 

A imagem escolhida é carregada usando a JavaScript `FileReader.readAsDataURL` função, que codifica a imagem em base64. Isso é útil para exibir a imagem em uma tela HTML. Porém, isso significa que os bytes da imagem precisam ser descodificados antes de serem passados para uma operação do Amazon Rekognition Image. Este exemplo mostra como decodificar os bytes da imagem carregada. Se os bytes da imagem codificada não forem úteis para você, use `FileReader.readAsArrayBuffer` no lugar, porque a imagem carregada não está codificada. Isso significa que as operações do Amazon Rekognition Image podem ser chamadas sem primeiro descodificar os bytes da imagem. Para ver um exemplo, consulte [Usando o readAsArray Buffer](#image-bytes-javascript-unencoded).

**Para executar o JavaScript exemplo**

1. Carregue o código-fonte de exemplo em um editor.

1. Selecione o banco de identidades de identidade do Amazon Cognito. Para obter mais informações, consulte [Selecione o banco de identidades do Amazon Cognito.](#image-bytes-javascript-auth).

1. Na função `AnonLog` do código de exemplo, altere `IdentityPoolIdToUse` e `RegionToUse` para os valores que você anotou na etapa 9 de [Selecione o banco de identidades do Amazon Cognito.](#image-bytes-javascript-auth). 

1. Na função `DetectFaces`, altere `RegionToUse` para o valor que você usou na etapa anterior.

1. Salve o código fonte de exemplo como um arquivo `.html`.

1. Carregue o arquivo em seu navegador.

1. Escolha o botão **Procurar...** e escolha uma imagem que contenha uma ou mais faces. Uma tabela é mostrada contendo as idades estimadas de cada face detectada na imagem. 

**nota**  
O exemplo de código a seguir usa dois scripts que não fazem mais parte do Amazon Cognito. [Para obter esses arquivos, siga os links para [ aws-cognito-sdk.min.js e .min.js](https://raw.githubusercontent.com/aws/amazon-cognito-identity-js/master/dist/aws-cognito-sdk.js) e amazon-cognito-identity salve o texto de cada um como arquivos separados.](https://raw.githubusercontent.com/aws/amazon-cognito-identity-js/master/dist/amazon-cognito-identity.min.js) `.js` 

## JavaScript código de exemplo
<a name="image-bytes-javascript-code"></a>

O exemplo de código a seguir usa JavaScript V2. Para ver um exemplo na JavaScript V3, consulte [o exemplo no repositório de exemplos GitHub do SDK de AWS documentação](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>
```

### Usando o readAsArray Buffer
<a name="image-bytes-javascript-unencoded"></a>

O trecho de código a seguir é uma implementação alternativa da `ProcessImage` função no código de amostra, usando JavaScript V2. Ele usa `readAsArrayBuffer` para carregar uma imagem e chamar `DetectFaces`. Como `readAsArrayBuffer` não codifica o arquivo carregado em base64, não é necessário decodificar os bytes da imagem antes de chamar uma operação do Amazon Rekognition Image.

```
//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);
  }
```

## Selecione o banco de identidades do Amazon Cognito.
<a name="image-bytes-javascript-auth"></a>

Para simplificar, o exemplo usa um banco de identidades anônimo do Amazon Cognito para fornecer acesso não autenticado à API Amazon Rekognition Image. Isso pode ser adequado para suas necessidades. Por exemplo, você pode usar o acesso não autenticado para fornecer acesso gratuito ou avaliação gratuita a seu site antes de os usuários se cadastrarem. Para fornecer acesso autenticado, use um grupo de usuários do Amazon Cognito. Para obter mais informações, consulte [grupo de usuários do Amazon Cognito](https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools.html). 

O procedimento a seguir mostra como criar um grupo de identidades que permite acesso a identidades não autenticadas e como obter o identificador do grupo de identidades que é necessário no código de exemplo.

**Para obter o identificador do grupo de identidades**

1. Abra o [console do Amazon Cognito](https://console.aws.amazon.com/cognito/federated).

1. Escolha **Criar novo banco de identidades**.

1. Em **Identity pool name\$1** (Nome do grupo de identidades), digite um nome para o grupo de identidades.

1. Em **Unauthenticated identities (Identidades não autenticadas)**, escolha **Enable access to unauthenticated identities (Permitir acesso a identidades não autenticadas)**.

1. Selecione **Criar grupo**.

1. Escolha **View Details** (Visualizar detalhes) e anote o nome da função para identidades não autenticadas.

1. Selecione **Permitir**.

1. Em **Plataforma**, escolha **JavaScript**.

1. Em **Get AWS Credentials (Obter credenciais da AWS)**, anote os valores de `AWS.config.region` e `IdentityPooldId` que são mostrados no trecho de código.

1. Abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. No painel de navegação, escolha **Perfis**.

1. Escolha o nome da função que você anotou na etapa 6.

1. Na guia **Permissions (Permissões)**, escolha **Attach policies (Anexar políticas)**.

1. Selecione **AmazonRekognitionReadOnlyAccess**.

1. Escolha **Attach Policy**.

# Exibir caixas delimitadoras
<a name="images-displaying-bounding-boxes"></a>

As operações do Amazon Rekognition Image podem retornar as coordenadas das caixas delimitadoras para os itens que são detectados em imagens. Por exemplo, a operação [DetectFaces](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectFaces.html) retornará uma caixa delimitadora ([BoundingBox](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_BoundingBox.html)) para cada face detectada em uma imagem. Você pode usar as coordenadas da caixa delimitadora para exibir uma caixa em torno de itens detectados. Por exemplo, a imagem a seguir mostra uma caixa delimitadora em torno de uma face.

![\[Mulher jovem sorridente, usando óculos, com bolhas ao seu redor.\]](http://docs.aws.amazon.com/pt_br/rekognition/latest/dg/images/face.png)


Uma `BoundingBox` tem as seguintes propriedades:
+ Altura: a altura da caixa delimitadora como uma proporção da altura total da imagem.
+ Esquerda: a coordenada esquerda da caixa delimitadora como uma proporção da largura total da imagem.
+ Superior: a coordenada superior da caixa delimitadora como uma proporção da altura total da imagem.
+ Largura: a largura da caixa delimitadora como uma proporção da largura total da imagem.

Cada BoundingBox propriedade tem um valor entre 0 e 1. Cada valor de propriedade é uma proporção da largura (`Left` e `Width`) ou da altura (`Height` e `Top`) da imagem total. Por exemplo, se a imagem de entrada tiver 700 x 200 pixels e a coordenada superior esquerda da caixa delimitadora tiver 350 x 50 pixels, a API retornará um valor `Left` de 0,5 (350/700) e um valor `Top` de 0,25 (50/200). 

O diagrama a seguir mostra a faixa de uma imagem que cada propriedade da caixa delimitadora abrange.

![\[Um gráfico que mostra como uma caixa delimitadora se relaciona com as dimensões de uma imagem.\]](http://docs.aws.amazon.com/pt_br/rekognition/latest/dg/images/bounding-box.png)


Para exibir a caixa delimitadora com a localização e o tamanho corretos, você precisa multiplicar os BoundingBox valores pela largura ou altura da imagem (dependendo do valor desejado) para obter os valores de pixels. Você pode usar os valores de pixel para exibir a caixa delimitadora. Por exemplo, as dimensões em pixels da imagem anterior são 608 de largura x 588 de altura. Os valores da caixa delimitadora para a face são: 

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

A localização da caixa delimitadora da face em pixels é calculada da seguinte forma: 

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

Você pode usar esses valores para exibir uma caixa delimitadora em torno da face.

**nota**  
Uma imagem pode ter várias formas de orientação. Seu aplicativo pode precisar girar a imagem para exibi-la com a orientação correta. As coordenadas da caixa delimitadora são afetadas pela orientação da imagem. Pode ser necessário converter as coordenadas antes que você possa exibir uma caixa delimitadora no local correto. Para obter mais informações, consulte [Obter a orientação e as coordenadas da caixa delimitadora da imagem](images-orientation.md).

Os exemplos a seguir mostram como exibir uma caixa delimitadora em torno de faces que são detectadas chamando [DetectFaces](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectFaces.html). Os exemplos pressupõem que a orientação das imagens é de 0 graus. Os exemplos também mostram como fazer download da imagem de um bucket do Amazon S3. 

**Para exibir uma caixa delimitadora**

1. Se ainda não tiver feito isso:

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

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

1. Use os exemplos a seguir para chamar a operação `DetectFaces`.

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

   Altere o valor de `bucket` para o bucket do Amazon S3 que contém o arquivo de imagem. Altere o valor de `photo` para o nome de arquivo de um arquivo de imagem (formato .jpg ou .png).

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

   Altere o valor de `bucket` para o bucket do Amazon S3 que contém o arquivo de imagem. Altere o valor de `photo` para o nome de arquivo de um arquivo de imagem (formato .jpg ou .png). Substitua o valor de `profile_name` na linha que cria a sessão do Rekognition pelo nome do seu perfil de desenvolvedor.

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

   Esse código foi retirado do GitHub repositório de exemplos do SDK de AWS documentação. Veja o exemplo completo [aqui](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javav2/example_code/rekognition/src/main/java/com/example/rekognition/DisplayFacesFrame.java).

   Observe que `s3` se refere ao cliente Amazon S3 do AWS SDK e `rekClient` ao cliente Amazon Rekognition do AWS SDK. 

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

------

# Obter a orientação e as coordenadas da caixa delimitadora da imagem
<a name="images-orientation"></a>

Os aplicativos que usam o Amazon Rekognition Image geralmente precisam exibir as imagens detectadas pelas operações do Amazon Rekognition Image e as caixas em torno das faces detectadas. Para exibir uma imagem corretamente em seu aplicativo, é necessário saber a orientação da imagem. Talvez seja necessário corrigir essa orientação. Para alguns arquivos .jpg, a orientação da imagem está contida nos metadados do formato Exif. 

Para exibir uma caixa em torno de uma face, você precisa das coordenadas da caixa delimitadora. Se a caixa não estiver orientada corretamente, talvez seja necessário ajustar essas coordenadas. As operações de detecção de faces do Amazon Rekognition Image retornam coordenadas de caixa delimitadora para cada face detectada, mas não estimam coordenadas para arquivos .jpg sem metadados Exif.

Os exemplos a seguir mostram como obter as coordenadas da caixa delimitadora para as faces detectadas em uma imagem.

Use as informações deste exemplo para garantir que suas imagens estejam orientadas corretamente e que as caixas delimitadoras estejam exibidas no local correto em seu aplicativo. 

Como o código usado para girar e exibir imagens e caixas delimitadoras depende do idioma e do ambiente que você usa, não explicamos como exibir imagens e caixas delimitadoras em seu código ou como obter informações de orientação de metadados do Exif.



## Descobrir a orientação de uma imagem
<a name="images-discovering-image-orientation"></a>

Para exibir uma imagem corretamente em seu aplicativo, poder ser necessário girá-la. A imagem a seguir está orientada para 0 grau e é exibida corretamente.

![\[Ícone de perfil genérico representando uma conta ou imagem de perfil de usuário.\]](http://docs.aws.amazon.com/pt_br/rekognition/latest/dg/images/00face.png)


No entanto, a imagem a seguir está girada 90 graus no sentido anti-horário. Para exibi-la corretamente, você precisa encontrar a orientação da imagem e usar essas informações em seu código para girar a imagem para 0 grau. 

![\[Ícone de perfil genérico representando uma conta ou imagem de perfil de usuário girada em 90 graus no sentido anti-horário.\]](http://docs.aws.amazon.com/pt_br/rekognition/latest/dg/images/90face.png)


Algumas imagens em formato .jpg contêm informações de orientação nos metadados do Exif. Se disponíveis, os metadados Exif da imagem contêm a orientação. Nos metadados do Exif, você pode encontrar a orientação da imagem no campo `orientation`. Embora o Amazon Rekognition Image identifique a presença de informações da orientação da imagem nos metadados do Exif, ele não fornece acesso a eles. Para acessar os metadados do Exif em uma imagem, use uma biblioteca de terceiros ou escreva seu próprio código. Para obter mais informações, consulte [Exif Versão 2.32](http://cipa.jp/std/documents/download_e.html?DC-008-Translation-2019-E).

 



Quando você sabe a orientação de uma imagem, você pode escrever código para girar e exibi-la corretamente.

## Exibir caixas delimitadoras
<a name="images-bounding-boxes"></a>

As operações do Amazon Rekognition Image que analisam faces em uma imagem também retornam as coordenadas das caixas delimitadoras que circundam as faces. Para obter mais informações, consulte [BoundingBox](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_BoundingBox.html). 

Para exibir uma caixa delimitadora em torno de uma face semelhante à caixa mostrada na imagem a seguir em seu aplicativo, use as coordenadas da caixa delimitadora em seu código. As coordenadas da caixa delimitadora retornadas por uma operação refletem a orientação da imagem. Se for necessário girar a imagem para exibi-la corretamente, você poderá converter as coordenadas da caixa delimitadora.



![\[Ícone de perfil com o rosto destacado no quadrado vermelho.\]](http://docs.aws.amazon.com/pt_br/rekognition/latest/dg/images/00facebounding.png)




### Exibir caixas delimitadoras quando as informações de orientação estão presentes nos metadados do Exif
<a name="images-exif-metadata"></a>

Se a orientação de uma imagem estiver incluída nos metadados do Exif, as operações do Amazon Rekognition Image farão o seguinte:
+ Retornarão nulo no campo de correção da orientação na resposta da operação. Para girar a imagem, use a orientação fornecida nos metadados do Exif em seu código.
+ Retornarão as coordenadas da caixa delimitadora já orientadas para 0 grau. Para mostrar a caixa delimitadora na posição correta, use as coordenadas que foram retornadas. Você não precisa convertê-las.

## Exemplo: obter a orientação e as coordenadas da caixa delimitadora de uma imagem
<a name="images-correcting-image-orientation-java"></a>

Os exemplos a seguir mostram como usar o AWS SDK para obter os dados Exif de orientação da imagem e as coordenadas da caixa delimitadora para as celebridades detectadas pela operação `RecognizeCelebrities`.

**nota**  
O suporte para estimar a orientação da imagem usando o campo `OrientationCorrection` foi interrompido a partir de agosto de 2021. Todos os valores retornados para esse campo incluídos em uma resposta da API sempre serão NULL.

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

O exemplo carrega uma imagem do sistema de arquivos local, chama a operação `RecognizeCelebrities`, determina a altura e a largura da imagem e calcula as coordenadas da caixa delimitadora da face para a imagem girada. O exemplo não mostra como processar as informações de orientação que estão armazenadas nos metadados do Exif.

Na função `main`, substitua o valor de `photo` pelo nome e o caminho de uma imagem armazenada localmente no formato .jpg ou .png.

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

Este exemplo usa a biblioteca de PIL/Pillow imagens para obter a largura e a altura da imagem. Para obter mais informações, consulte [Pillow](https://pillow.readthedocs.io/en/stable/). Este exemplo preserva metadados do exif que você talvez precise em outros lugares no aplicativo.

Na função `main`, substitua o valor de `photo` pelo nome e o caminho de uma imagem armazenada localmente no formato .jpg ou .png.

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

Esse código foi retirado do GitHub repositório de exemplos do SDK de AWS documentação. Veja o exemplo completo [aqui](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javav2/example_code/rekognition/src/main/java/com/example/rekognition/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()));
    }
}
```

------