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

# Trabajar con imágenes
<a name="images"></a>

En esta sección, se describen los tipos de análisis que Amazon Rekognition Image puede realizar en las imágenes. 
+ [Detección de objetos y escenas](labels.md)
+ [Detección y comparación de rostros](faces.md)
+ [Búsqueda de rostros en una colección](collections.md)
+ [Reconocimiento de famosos](celebrities.md)
+ [Moderación de imágenes](moderation.md)
+ [Detección de texto en una imagen](text-detection.md)

Se llevan a cabo mediante operaciones de API sin almacenamiento en las que Amazon Rekognition Image no conserva la información detectada por la operación. Las operaciones API sin almacenamiento no conservan bytes de imagen de entrada. Para obtener más información, consulte [Descripción de operaciones de API con almacenamiento y sin almacenamiento](how-it-works-storage-non-storage.md).

Amazon Rekognition Image también puede almacenar metadatos faciales en colecciones para recuperación posterior. Para obtener más información, consulte [Búsqueda de rostros en una colección](collections.md).

En esta sección se utilizan las operaciones de API de Amazon Rekognition Image para analizar imágenes almacenadas en un bucket de Amazon S3 y bytes de imágenes subidos desde el sistema de archivos local. En esta sección también se explica cómo obtener información de orientación de imagen a partir de una imagen .jpg. 

 Rekognition solo usa canales RGB para realizar inferencias. AWS recomienda a los usuarios eliminar el canal alfa antes de utilizar una pantalla para inspeccionar visualmente (manualmente por una persona) la comparación. 

**Topics**
+ [Especificaciones de imagen](images-information.md)
+ [Análisis de imágenes almacenadas en un bucket de Amazon S3](images-s3.md)
+ [Análisis de una imagen subida desde un sistema de archivos local](images-bytes.md)
+ [Visualización de cuadros delimitadores](images-displaying-bounding-boxes.md)
+ [Obtención de coordenadas de cuadro delimitador y orientación de imagen](images-orientation.md)

# Especificaciones de imagen
<a name="images-information"></a>

Las operaciones de Amazon Rekognition Image pueden analizar imágenes en formato .jpg o .png.

Puede pasar bytes de imágenes a una operación de Amazon Rekognition Image como parte de la llamada o hacer referencia a un objeto de S3 existente. Para un ejemplo de análisis de una imagen almacenada en un bucket de Amazon S3, consulte [Análisis de imágenes almacenadas en un bucket de Amazon S3](images-s3.md). Para ver un ejemplo del paso de bytes de imagen a una operación API en Amazon Rekognition Image, consulte [Análisis de una imagen subida desde un sistema de archivos local](images-bytes.md).

Si utiliza HTTP y transfiere los bytes de imagen como parte de una operación de Amazon Rekognition Image, dichos bytes deben pasarse como una cadena codificada en base64. Si utiliza el AWS SDK y transfiere los bytes de imagen como parte de la llamada a la operación API, el requisito de codificar en base64 los bytes de la imagen dependerá del lenguaje que utilice. 

Las siguientes opciones comunes codifican AWS SDKs automáticamente en base64 las imágenes y no es necesario codificar los bytes de las imágenes antes de llamar a una operación de la API Amazon Rekognition Image.
+ Java
+ JavaScript
+ Python
+ PHP

Si utiliza otro AWS SDK y obtiene un error de formato de imagen al llamar a una operación API de Rekognition;, pruebe el cifrado en base64 de los bytes de imagen antes de transferirlos a una operación API de Rekognition.

Si utilizas el AWS CLI para llamar a las operaciones de Amazon Rekognition Image, no se admite el paso de bytes de imagen como parte de la llamada. Debe subir primero la imagen en un bucket de Amazon S3 y, a continuación, llamar a la operación que hace referencia a la imagen subida.

**nota**  
No es necesario que la imagen esté cifrada en base64 si transfiere una imagen almacenada en un `S3Object` en lugar de bytes de imagen.

Para obtener información acerca de garantizar la mínima latencia posible para operaciones de Amazon Rekognition Image, consulte [Latencia de operación de Amazon Rekognition Image](operation-latency.md). 

## Corrección de la orientación de imagen
<a name="images-image-orientation-correction"></a>

En varias operaciones API de Rekognition, se devuelve la orientación de una imagen analizada. Conocer la orientación de imagen es importante, ya que le permite reorientar las imágenes para su visualización. Las operaciones de API de Rekognition que analizan rostros también devuelven cuadros delimitadores para la ubicación de rostros dentro de una imagen. Puede utilizar los cuadros delimitadores para mostrar un recuadro alrededor de un rostro en una imagen. Las coordenadas del cuadro delimitador devueltas se ven afectadas por la orientación de la imagen y es posible que tenga que traducir las coordenadas del cuadro delimitador para mostrar correctamente un cuadro alrededor de un rostro. Para obtener más información, consulte [Obtención de coordenadas de cuadro delimitador y orientación de imagen](images-orientation.md). 

## Redimensionamiento de imagen
<a name="images-image-sizing"></a>

Durante el análisis, Amazon Rekognition cambia el tamaño interno de las imágenes mediante un conjunto de rangos predefinidos que mejor se adaptan a un modelo o algoritmo en particular. Por este motivo, Amazon Rekognition puede detectar un número diferente de objetos o proporcionar resultados distintos, en función de la resolución de la imagen de entrada. Por ejemplo, supongamos que tiene dos imágenes. La primera imagen tiene una resolución de 1024 x 768 píxeles. La segunda imagen, una versión redimensionada de la primera imagen, tiene una resolución de 640 x 480 píxeles. Si envía las imágenes a [DetectLabels](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectLabels.html), las respuestas de las dos llamadas `DetectLabels` pueden diferir ligeramente.

# Análisis de imágenes almacenadas en un bucket de Amazon S3
<a name="images-s3"></a>

Amazon Rekognition Image puede analizar imágenes almacenadas en un bucket de Amazon S3 o imágenes suministradas como bytes de imagen.

En este tema, utilizará la operación de [DetectLabels](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectLabels.html)API para detectar objetos, conceptos y escenas en una imagen (JPEG o PNG) almacenada en un bucket de Amazon S3. Puede transferir una imagen a una operación API de Amazon Rekognition Image mediante el parámetro de entrada [Image](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_Image.html). Dentro de `Image`, especifique la propiedad de objeto [S3Object](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_3Object.html) para hacer referencia a una imagen almacenada en un bucket de S3. Los bytes de imagen para las imágenes almacenadas en buckets de Amazon S3 no tienen por qué estar codificados en base64. Para obtener más información, consulte [Especificaciones de imagen](images-information.md). 

## Ejemplo de solicitud
<a name="images-s3-request"></a>

En este ejemplo de solicitud de JSON para `DetectLabels`, la imagen de origen (`input.jpg`) se sube desde un bucket de Amazon S3; llamado `amzn-s3-demo-bucket`. La región del bucket de Amazon S3 que contiene el objeto S3 debe coincidir con la región que utiliza para las operaciones de Amazon Rekognition Image.

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

En los ejemplos siguientes se utilizan varios AWS SDKs y la llamada AWS CLI to`DetectLabels`. Para obtener más información sobre la respuesta de la operación `DetectLabels`, consulte [DetectLabels respuesta](labels-detect-labels-image.md#detectlabels-response).

**Para detectar las etiquetas en una imagen**

1. Si aún no lo ha hecho:

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

   1. Instale y configure el AWS CLI y el AWS SDKs. Para obtener más información, consulte [Paso 2: Configure y AWS CLI AWS SDKs](setup-awscli-sdk.md). Asegúrese de haber otorgado al usuario que llama a las operaciones de la API los permisos adecuados para el acceso mediante programación; consulte las instrucciones de [Concesión de acceso programático](sdk-programmatic-access.md) sobre cómo hacerlo.

1. Suba una imagen que contenga uno o varios objetos, como árboles, casas o barcos, en el bucket de S3. La imagen debe estar en formato *.jpg* o *.png*.

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

1. Consulte los siguientes ejemplos para llamar a la operación `DetectLabels`.

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

   Este ejemplo muestra una lista de las etiquetas que se han detectado en la imagen de entrada. Reemplace los valores de `bucket` y `photo` por los nombre del bucket de Amazon S3 y de la imagen que utilizó en el paso 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 ]

   Este ejemplo muestra la salida de JSON de la operación `detect-labels` de la CLI. Reemplace los valores de `bucket` y `photo` por los nombre del bucket de Amazon S3 y de la imagen que utilizó en el paso 2. Sustituya el valor de `profile_name` en la línea que crea la sesión de Rekognition por el nombre de su perfil de desarrollador. 

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

   Si utiliza Windows, es posible que tenga que evitar las comillas, como se muestra en el siguiente ejemplo.

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

   Este código se ha tomado del GitHub repositorio de ejemplos del SDK de AWS documentación. Consulte el ejemplo completo [aquí](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javav2/example_code/rekognition/src/main/java/com/example/rekognition/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 ejemplo muestra las etiquetas que se han detectado en la imagen de entrada. Reemplace los valores de `bucket` y `photo` por los nombre del bucket de Amazon S3 y de la imagen que utilizó en el paso 2. Sustituya el valor de `profile_name` en la línea que crea la sesión de Rekognition por el nombre de su perfil de desarrollador.

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

   En este ejemplo se muestra información acerca de las etiquetas que se detectan en una imagen. 

   Cambie el valor de `photo` por la ruta y el nombre de un archivo de imagen que contenga uno o más rostros de famosos. Cambie el valor de `bucket` por el nombre del bucket de S3 que contiene el archivo de imagen proporcionado. Sustituya el valor de `REGION` por el nombre de la región asociada a su cuenta. Sustituya el valor de `profile_name` en la línea que crea la sesión de Rekognition por el nombre de su perfil de desarrollador. 

   ```
   // 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 ejemplo muestra una lista de las etiquetas que se han detectado en la imagen de entrada. Reemplace los valores de `bucket` y `photo` por los nombre del bucket de Amazon S3 y de la imagen que utilizó en el paso 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 ejemplo muestra una lista de las etiquetas que se han detectado en la imagen de entrada. Reemplace los valores de `bucket` y `photo` por los nombre del bucket de Amazon S3 y de la imagen que utilizó en el paso 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
   ```

------



## Ejemplo de respuesta
<a name="images-s3-response"></a>

La respuesta de `DetectLabels` es una matriz de las etiquetas detectadas en la imagen y el nivel de confianza por el que se detectan. 

Al realizar la operación `DetectLabels` en una imagen, Amazon Rekognition devuelve un resultado similar al siguiente ejemplo de respuesta.

La respuesta muestra que la operación ha detectado varias etiquetas, como Person (Persona), Vehicle (Vehículo) y Car (Automóvil). Cada etiqueta tiene un nivel de confianza asociado. Por ejemplo, el algoritmo de detección tiene una confianza del 98,991432 % en que la imagen contiene una persona.

La respuesta también incluye las etiquetas antecesoras de una etiqueta de la matriz `Parents`. Por ejemplo, la etiqueta Automobile (Automóvil) tiene dos etiquetas principales denominadas Vehicle (Vehículo) y Transportation (Transporte). 

La respuesta para las etiquetas de objetos comunes incluye información del cuadro delimitador para localizar la etiqueta en la imagen de entrada. Por ejemplo, la etiqueta Person (persona) tiene una matriz de instancias que contiene dos cuadros delimitadores. Se trata de las ubicaciones de dos personas detectadas en la imagen.

El campo `LabelModelVersion` contiene el número de versión del modelo de detección que `DetectLabels` utiliza. 

Para obtener más información acerca del uso de la operación `DetectLabels`, consulte [Detección de objetos y conceptos](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"
}

    
}
```

# Análisis de una imagen subida desde un sistema de archivos local
<a name="images-bytes"></a>

Las operaciones de Amazon Rekognition Image pueden analizar imágenes suministradas como bytes de imagen o almacenadas en un bucket de Amazon S3.

En estos temas se ofrecen ejemplos sobre el suministro de bytes de imágenes a operaciones de API de Amazon Rekognition Image mediante un archivo subido a partir de un sistema de archivos local. Puede transferir bytes de imágenes a una operación API de Amazon Rekognition; utilizando el parámetro de entrada [Image](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_Image.html). Dentro de `Image`, especifique la propiedad `Bytes` para transferir bytes de imágenes con codificación en base64.

Los bytes de imagen transferidos a una operación API de Amazon Rekognition; utilizando el parámetro de entrada `Bytes` deben estar cifrados en base64. La AWS SDKs que utilizan estos ejemplos codifica automáticamente las imágenes en base64. No es necesario codificar bytes de imágenes antes de llamar a una operación API de Amazon Rekognition. Para obtener más información, consulte [Especificaciones de imagen](images-information.md). 

En esta solicitud de ejemplo de JSON para `DetectLabels`, los bytes de imagen de origen se pasan al parámetro de entrada `Bytes`. 

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

En los siguientes ejemplos se utilizan varios AWS SDKs y el to call. AWS CLI `DetectLabels` Para obtener más información sobre la respuesta de la operación `DetectLabels`, consulte [DetectLabels respuesta](labels-detect-labels-image.md#detectlabels-response).

Para ver un JavaScript ejemplo del lado del cliente, consulte. [Usando JavaScript](image-bytes-javascript.md)

**Para detectar las etiquetas en una imagen local**

1. Si aún no lo ha hecho:

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

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

1. Consulte los siguientes ejemplos para llamar a la operación `DetectLabels`.

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

   El siguiente ejemplo de Java muestra cómo subir una imagen desde el sistema de archivos local y detectar etiquetas mediante la operación [detectLabels](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/rekognition/model/DetectLabelsRequest.html) del SDK de AWS. Cambie el valor de `photo` por la ruta y el nombre de un archivo de imagen (en formato .jpg o .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 ]

   El siguiente ejemplo de [AWS SDK for Python](https://aws.amazon.com/sdk-for-python/) muestra cómo subir una imagen desde el sistema de archivos local y llamar a la operación [detect\$1labels](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/rekognition.html#Rekognition.Client.detect_labels). Cambie el valor de `photo` por la ruta y el nombre de un archivo de imagen (en formato .jpg o .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 ]

   El siguiente ejemplo de muestra cómo subir una imagen desde el sistema de archivos local y detectar etiquetas utilizando la operación `DetectLabels`. Cambie el valor de `photo` por la ruta y el nombre de un archivo de imagen (en formato .jpg o .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 ]

   El siguiente ejemplo de [AWS SDK for PHP](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/welcome.html#getting-started) muestra cómo cargar una imagen desde el sistema de archivos local y llamar a la operación [DetectFaces](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-rekognition-2016-06-27.html#detectfaces)API. Cambie el valor de `photo` por la ruta y el nombre de un archivo de imagen (en formato .jpg o .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 ejemplo muestra una lista de las etiquetas que se han detectado en la imagen de entrada. Cambie el valor de `photo` por la ruta y el nombre de un archivo de imagen (en formato .jpg o .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 ]

   Este código se ha tomado del GitHub repositorio de ejemplos del SDK de AWS documentación. Consulte el ejemplo completo [aquí](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javav2/example_code/rekognition/src/main/java/com/example/rekognition/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>

El siguiente ejemplo de JavaScript página web permite al usuario elegir una imagen y ver las edades estimadas de los rostros que se detectan en la imagen. Las edades estimadas se devuelven mediante una llamada a [DetectFaces](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectFaces.html). 

La imagen elegida se carga mediante la JavaScript `FileReader.readAsDataURL` función, que codifica la imagen en base64. Esto resulta útil para mostrar la imagen en un lienzo HTML. Pero implica que los bytes de imagen se tienen que descodificar antes de transferirlos a una operación de Amazon Rekognition Image. En este ejemplo se muestra cómo descodificar los bytes de imagen subidos. Si los bytes de imagen codificados no le resultan útiles, use `FileReader.readAsArrayBuffer` en su lugar porque la imagen subida no está codificada. Esto significa que se puede llamar a las operaciones de Amazon Rekognition Image sin codificar primero los bytes de imagen. Para ver un ejemplo, consulta [Uso de Buffer readAsArray](#image-bytes-javascript-unencoded).

**Para ejecutar el ejemplo JavaScript**

1. Cargue el código fuente de ejemplo en un editor.

1. Obtenga el identificador de grupo de identidades de Amazon Cognito. Para obtener más información, consulte [Obtener el identificador de grupo de identidades de Amazon Cognito](#image-bytes-javascript-auth).

1. En la función `AnonLog` del código de ejemplo, cambie `IdentityPoolIdToUse` y `RegionToUse` por los valores que anotó en el paso 9 de [Obtener el identificador de grupo de identidades de Amazon Cognito](#image-bytes-javascript-auth). 

1. En la función `DetectFaces`, cambie `RegionToUse` por el valor que usó en el paso anterior.

1. Guarde el código fuente de ejemplo como un archivo `.html`.

1. Cargue el archivo en su navegador.

1. Haga clic en el botón **Examinar...** y elija una imagen que contenga una o más caras. Se muestra una tabla que contiene las edades estimadas para cada rostro detectado en la imagen. 

**nota**  
El siguiente ejemplo de código utiliza dos scripts que ya no forman parte de Amazon Cognito. [Para obtener estos archivos, siga los enlaces para [ aws-cognito-sdk.min.js y .min.js](https://raw.githubusercontent.com/aws/amazon-cognito-identity-js/master/dist/aws-cognito-sdk.js) y amazon-cognito-identity, a continuación, guarde el texto de cada uno como archivos separados.](https://raw.githubusercontent.com/aws/amazon-cognito-identity-js/master/dist/amazon-cognito-identity.min.js) `.js` 

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

El siguiente ejemplo de código usa JavaScript V2. Para ver un ejemplo de la JavaScript versión 3, consulte [el ejemplo en el GitHub repositorio de ejemplos del SDK de AWS documentación](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>
```

### Uso de Buffer readAsArray
<a name="image-bytes-javascript-unencoded"></a>

El siguiente fragmento de código es una implementación alternativa de la `ProcessImage` función en el código de ejemplo, utilizando JavaScript V2. Utiliza `readAsArrayBuffer` para subir una imagen y llama a `DetectFaces`. Dado que `readAsArrayBuffer` no codifica en base64 el archivo subido, no es necesario descodificar los bytes de imagen antes de llamar a una operación de 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);
  }
```

## Obtener el identificador de grupo de identidades de Amazon Cognito
<a name="image-bytes-javascript-auth"></a>

Para simplificar, el ejemplo utiliza un grupo de identidades de Amazon Cognito anónimas para proporcionar acceso sin autenticar a la API de Amazon Rekognition Image. Esto podría ser adecuado para sus necesidades. Por ejemplo, puede utilizar el acceso sin autenticar para proporcionar acceso gratuito, o de prueba, a su sitio web antes de que los usuarios se inscriban. Para proporcionar acceso autenticado, utilice un grupo de usuarios de Amazon Cognito. Para obtener más información, consulte [Grupos de usuarios de Amazon Cognito](https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools.html). 

En el siguiente procedimiento se muestra cómo crear un grupo de identidades que permite el acceso a identidades sin autenticar y cómo obtener el identificador de grupo de identidades que se necesita en el código de ejemplo.

**Para obtener el identificador de grupo de identidades**

1. Abra la [consola de Amazon Cognito](https://console.aws.amazon.com/cognito/federated).

1. Elija **Crear nuevo grupo de identidades**.

1. En **Nombre de grupo de identidades\$1**, escriba un nombre para su grupo de identidades.

1. En **Identidades sin autenticar**, elija **Habilitar el acceso a identidades sin autenticar**.

1. Elija **Crear grupo**.

1. Elija **Ver detalles** y anote el nombre de rol de las identidades sin autenticar.

1. Elija **Permitir**.

1. En **Plataforma, elija**. **JavaScript**

1. En **Obtener credenciales de AWS**, anote los valores de `AWS.config.region` y `IdentityPooldId` que se muestran en el fragmento de código.

1. Abra la consola de IAM en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. Seleccione **Roles** en el panel de navegación.

1. Elija el nombre de rol que anotó en el paso 6.

1. En la pestaña **Permisos**, elija **Asociar políticas**.

1. Elija **AmazonRekognitionReadOnlyAccess**.

1. Elija **Adjuntar política**.

# Visualización de cuadros delimitadores
<a name="images-displaying-bounding-boxes"></a>

Las operaciones de Amazon Rekognition Image pueden devolver las coordenadas de los cuadros delimitadores de los elementos que se han detectado en las imágenes. Por ejemplo, la operación [DetectFaces](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectFaces.html) devuelve un cuadro delimitador ([BoundingBox](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_BoundingBox.html)) para cada rostro detectado en una imagen. Puede utilizar las coordenadas del cuadro delimitador para mostrar un recuadro alrededor de los elementos detectados. Por ejemplo, en la imagen siguiente se muestra un cuadro delimitador que enmarca un rostro.

![\[Mujer joven sonriente con gafas y burbujas a su alrededor.\]](http://docs.aws.amazon.com/es_es/rekognition/latest/dg/images/face.png)


Un `BoundingBox` presenta las siguientes propiedades:
+ Height: la altura del cuadro delimitador expresada proporcionalmente respecto a la altura total de la imagen.
+ Left: la coordenada izquierda del cuadro delimitador expresada proporcionalmente respecto a la anchura total de la imagen.
+ Top: la coordenada superior del cuadro delimitador expresada proporcionalmente respecto a la altura total de la imagen.
+ Width: la anchura del cuadro delimitador expresada proporcionalmente respecto a la anchura total de la imagen.

Cada BoundingBox propiedad tiene un valor entre 0 y 1. El valor de cada propiedad es proporcional respecto a la anchura (`Left` y `Width`) o a la altura (`Height` y `Top`) totales de la imagen. Por ejemplo, si la imagen de entrada es de 700 x 200 píxeles y la coordenada superior izquierda del cuadro delimitador es de 350 x 50 píxeles, la API devuelve un valor de `Left` de 0,5 (350/700) y un valor de `Top` de 0,25 (50/200). 

En el siguiente diagrama se muestra el rango de una imagen que cubre cada propiedad del cuadro delimitador.

![\[Gráfico que muestra cómo se relaciona un cuadro delimitador con las dimensiones de una imagen.\]](http://docs.aws.amazon.com/es_es/rekognition/latest/dg/images/bounding-box.png)


Para mostrar el cuadro delimitador con la ubicación y el tamaño correctos, debe multiplicar BoundingBox los valores por el ancho o el alto de la imagen (según el valor que desee) para obtener los valores de los píxeles. Los valores en píxeles se utilizan para mostrar el cuadro delimitador. Por ejemplo, las dimensiones de la imagen anterior son 608 píxeles de anchura x 588 píxeles de altura. Los valores del cuadro delimitador del rostro son: 

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

La ubicación del cuadro delimitador del rostro en píxeles se calculan como se indica a continuación: 

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

Puede utilizar estos valores para mostrar un cuadro delimitador enmarcando el rostro.

**nota**  
Una imagen se pueden orientar de varias formas. La aplicación podría tener que rotar la imagen para mostrarla con la orientación correcta. La orientación de la imagen afecta a las coordenadas del cuadro delimitador. Es posible que tenga que traducir las coordenadas para poder mostrar el cuadro delimitador en la ubicación correcta. Para obtener más información, consulte [Obtención de coordenadas de cuadro delimitador y orientación de imagen](images-orientation.md).

En los siguientes ejemplos se indica cómo mostrar un cuadro delimitador que enmarca los rostros detectados llamando a [DetectFaces](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectFaces.html). En los ejemplos se da por hecho que las imágenes tienen una orientación de 0 grados. Además, en ellos también se indica cómo descargar la imagen desde un bucket de Amazon S3. 

**Para mostrar un cuadro delimitador**

1. Si aún no lo ha hecho:

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

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

1. Consulte los siguientes ejemplos para llamar a la operación `DetectFaces`.

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

   Cambie el valor de `bucket` por el bucket de Amazon S3 que contiene el archivo de imagen. Cambie el valor de `photo` por el nombre de un archivo de imagen (en formato .jpg o .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 ]

   Cambie el valor de `bucket` por el bucket de Amazon S3 que contiene el archivo de imagen. Cambie el valor de `photo` por el nombre de un archivo de imagen (en formato .jpg o .png). Sustituya el valor de `profile_name` en la línea que crea la sesión de Rekognition por el nombre de su perfil de desarrollador.

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

   Este código se ha tomado del GitHub repositorio de ejemplos del SDK de AWS documentación. Consulte el ejemplo completo [aquí](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javav2/example_code/rekognition/src/main/java/com/example/rekognition/DisplayFacesFrame.java).

   Tenga en cuenta que `s3` se refiere al cliente de Amazon S3 del SDK de AWS y `rekClient` al cliente de Amazon Rekognition del SDK de AWS. 

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

------

# Obtención de coordenadas de cuadro delimitador y orientación de imagen
<a name="images-orientation"></a>

Las aplicaciones que utilizan Amazon Rekognition Image habitualmente tienen que mostrar las imágenes detectadas por las operaciones de Amazon Rekognition Image y los cuadros alrededor de rostros detectados. Para visualizar una imagen correctamente en la aplicación, tiene que conocer la orientación. Tal vez tenga que corregir esta orientación. Para algunos archivos .jpg, la orientación de la imagen está contenida en los metadatos de formato de archivo de imagen intercambiable (EXIF) de la imagen. 

Para mostrar un cuadro alrededor de un rostro, necesita las coordenadas del cuadro delimitador del rostro. Si el cuadro no está orientado correctamente, es posible que tenga que ajustar esas coordenadas. Las operaciones de detección de rostros de Amazon Rekognition Image devuelven las coordenadas del cuadro delimitador de cada rostro detectado, pero no estiman las coordenadas de los archivos.jpg sin metadatos Exif.

Los siguientes ejemplos muestran cómo obtener las coordenadas del cuadro delimitador para los rostros detectados en una imagen.

Utilice la información de este ejemplo para garantizar que sus imágenes están correctamente orientadas y que los cuadros delimitadores se muestran en la ubicación correcta en su aplicación. 

Dado que el código que se utiliza para girar y mostrar imágenes y cuadros delimitadores depende del lenguaje y del entorno que utilice, no se explica cómo mostrar imágenes y cuadros delimitadores en el código o cómo obtener la información de orientación a partir de los metadatos Exif.



## Búsqueda de la orientación de una imagen
<a name="images-discovering-image-orientation"></a>

Para mostrar una imagen correctamente en su aplicación, es posible que tenga que girarla. La siguiente imagen está orientada a 0 grados y se muestra correctamente.

![\[Icono de perfil genérico que representa una cuenta de usuario o una imagen de perfil.\]](http://docs.aws.amazon.com/es_es/rekognition/latest/dg/images/00face.png)


Sin embargo, la siguiente imagen está girada 90 grados en sentido contrario a las agujas del reloj. Para mostrarla correctamente, tiene que encontrar la orientación de la imagen y utilizar dicha información en su código para girar la imagen a 0 grados. 

![\[Icono de perfil genérico que representa una cuenta de usuario o una imagen de perfil, con rotación de 90 grados en sentido contrario a las agujas del reloj.\]](http://docs.aws.amazon.com/es_es/rekognition/latest/dg/images/90face.png)


Algunas imágenes en formato .jpg contienen información de orientación en metadatos Exif. Si están disponibles, los metadatos Exif de la imagen contienen la orientación. En los metadatos Exif, puede encontrar la orientación de la imagen en el campo `orientation`. Aunque Amazon Rekognition Image identifica la presencia de información de orientación de imagen en los metadatos Exif, no proporciona acceso a la misma. Para acceder a los metadatos Exif en una imagen, utilice una biblioteca de terceros o escriba su propio código. Para obtener más información, consulte [Exif Version 2.32](http://cipa.jp/std/documents/download_e.html?DC-008-Translation-2019-E).

 



Cuando se conoce la orientación de una imagen, puede escribir código para girarla y mostrarla correctamente.

## Visualización de cuadros delimitadores
<a name="images-bounding-boxes"></a>

Las operaciones de Amazon Rekognition Image que analizan rostros en una imagen devuelven además las coordenadas de los cuadros delimitadores que rodean los rostros. Para obtener más información, consulte [BoundingBox](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_BoundingBox.html). 

Para mostrar un cuadro delimitador alrededor de un rostro similar al cuadro mostrado en la imagen siguiente en su aplicación, utilice las coordenadas de cuadro delimitador en su código. Las coordenadas del cuadro delimitador devueltas por una operación reflejan la orientación de la imagen. Si tiene que girar la imagen para mostrarla correctamente, es posible que tenga que traducir las coordenadas del cuadro delimitador.



![\[Icono de perfil con la cara resaltada en un cuadrado rojo.\]](http://docs.aws.amazon.com/es_es/rekognition/latest/dg/images/00facebounding.png)




### Mostrar cuadros delimitadores cuando la información de orientación está presente en los metadatos Exif
<a name="images-exif-metadata"></a>

Si la orientación de una imagen está incluida en metadatos Exif, las operaciones de Amazon Rekognition Image hacen lo siguiente:
+ Devolver nulo en el campo de corrección de orientación en la respuesta de la operación. Para girar la imagen, utilice la orientación proporcionada en los metadatos Exif en el código.
+ Devuelva las coordenadas del cuadro delimitador ya orientadas a 0 grados. Para mostrar el cuadro delimitador en la posición correcta, utilice las coordenadas que se devolvieron. No tiene que traducirlas.

## Ejemplo: obtención de coordenadas de cuadro delimitador y orientación de imagen para una imagen
<a name="images-correcting-image-orientation-java"></a>

En los siguientes ejemplos se muestra cómo se utiliza el SDK de AWS con el fin de obtener los datos de orientación de una imagen Exif y las coordenadas de los cuadros delimitadores para los famosos detectados mediante la operación `RecognizeCelebrities`.

**nota**  
El soporte para estimar la orientación de la imagen mediante el campo `OrientationCorrection` cesó en agosto de 2021. Todos los valores devueltos para este campo incluidos en una respuesta de la API siempre serán NULL.

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

Este ejemplo carga una imagen del sistema de archivos local, llama a la operación `RecognizeCelebrities`, determina la altura y la anchura de la imagen y calcula las coordenadas del cuadro delimitador del rostro para la imagen girada. El ejemplo no muestra cómo procesar la información de orientación que hay almacenada en los metadatos Exif.

En la función `main`, cambie el valor de `photo` por el nombre y la ruta de una imagen que esté almacenada localmente en formato .png o .jpg.

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

En este ejemplo, se usa la biblioteca de PIL/Pillow imágenes para obtener el ancho y el alto de la imagen. Para obtener más información, consulte [Pillow](https://pillow.readthedocs.io/en/stable/). En este ejemplo se conservan los metadatos exif porque los puede necesitar en otra parte de la aplicación.

En la función `main`, cambie el valor de `photo` por el nombre y la ruta de una imagen que esté almacenada localmente en formato .png o .jpg.

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

Este código se ha tomado del GitHub repositorio de ejemplos del SDK de AWS documentación. Consulte el ejemplo completo [aquí](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javav2/example_code/rekognition/src/main/java/com/example/rekognition/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()));
    }
}
```

------