Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés. # Detección y análisis de rostros Amazon Rekognition APIs le proporciona una herramienta que puede utilizar para detectar y analizar rostros en imágenes y vídeos. Esta sección proporciona información general sobre las operaciones sin almacenamiento para el análisis de rostros. Entre estas se incluyen funcionalidades como la detección de referencias faciales, el análisis de emociones y la comparación de rostros. Amazon Rekognition puede identificar referencias faciales (por ejemplo, la posición de los ojos), detectar emociones (por ejemplo, felicidad o tristeza) y otros atributos (por ejemplo, la presencia de gafas o el ocultamiento facial). Cuando se detecta un rostro, el sistema analiza los atributos faciales y devuelve una puntuación de confianza para cada atributo. ![\[Mujer sonriente con gafas de sol que conduce un coche clásico amarillo en carretera abierta.\]](http://docs.aws.amazon.com/es_es/rekognition/latest/dg/images/sample-detect-faces.png) Esta sección contiene ejemplos de operaciones de imágenes y vídeo. Para obtener más información acerca de cómo usar las operaciones de imágenes de Rekognition, consulte [Trabajar con imágenes](images.md). Para obtener más información acerca de cómo usar las operaciones de vídeo de Rekognition, consulte [Cómo trabajar con operaciones de análisis de vídeos almacenados](video.md). Tenga en cuenta que estas operaciones son sin almacenamiento. Puede utilizar las operaciones de almacenamiento y las colecciones de rostros para guardar los metadatos faciales de los rostros detectados en una imagen. Posteriormente puede buscar los rostros almacenados en imágenes y vídeos. Por ejemplo, esto le permite buscar una persona específica en un vídeo. Para obtener más información, consulte [Búsqueda de rostros en una colección](collections.md). Para obtener más información, consulte la sección Rostros de [Amazon Rekognition. FAQs](https://aws.amazon.com/rekognition/faqs/) **nota** Los modelos de detección de rostros que utilizan Amazon Rekognition Image y Amazon Rekognition Video no admiten la detección de rostros en personajes o entidades no humanas. cartoon/animated Si quiere detectar personajes de dibujos animados en imágenes o vídeos, le recomendamos que utilice Etiquetas personalizadas de Amazon Rekognition. Para más información, consulte la [Guía para desarrolladores de Etiquetas personalizadas de Amazon Rekognition](https://docs.aws.amazon.com/rekognition/latest/customlabels-dg/what-is.html). **Topics** + [Información general sobre la detección y la comparación de rostros](face-feature-differences.md) + [Directrices sobre los atributos faciales](guidance-face-attributes.md) + [Detección de rostros en una imagen](faces-detect-images.md) + [Comparación de rostros en imágenes](faces-comparefaces.md) + [Detección de rostros en un vídeo almacenado](faces-sqs-video.md) # Información general sobre la detección y la comparación de rostros Amazon Rekognition proporciona acceso a los usuarios a dos aplicaciones principales de machine learning para imágenes que contienen rostros: detección de rostros y comparación de rostros. Posibilitan características cruciales, como el análisis facial y la verificación de identidad, por lo que son imprescindibles para diversas aplicaciones, desde la seguridad hasta la organización de fotografías personales. **Detección de rostros** Los sistemas de detección de rostros abordan la pregunta: “¿aparece algún rostro en esta imagen?” al usarlos. Entre los aspectos clave de la detección de rostros se incluyen los siguientes: + **Ubicación y orientación**: determina la presencia, ubicación, escala y orientación de los rostros en las imágenes o los fotogramas de vídeo. + **Atributos faciales**: detecta los rostros con independencia de atributos como el género, la edad o el vello facial. + **Información adicional**: proporciona detalles sobre el ocultamiento facial y la dirección de la mirada. **Comparación de rostros** Los sistemas de comparación de rostros se centran en la pregunta: “¿coincide el rostro de una imagen con un rostro de otra imagen?” al usarlos. Entre las funcionalidades del sistema de comparación de rostros se incluyen las siguientes: + **Predicciones de coincidencia de rostros**: compara un rostro de una imagen con un rostro de una base de datos proporcionada para predecir las coincidencias. + **Manejo de atributos faciales**: maneja los atributos para comparar rostros con independencia de la expresión, el vello facial y la edad. **Puntuaciones de confianza y detecciones perdidas** Tanto los sistemas de detección como de comparación de rostros utilizan puntuaciones de confianza. Una puntuación de confianza indica la probabilidad de las predicciones, como la presencia de un rostro o una coincidencia entre rostros. Las puntuaciones más altas indican mayor probabilidad. Por ejemplo, un 90 % de confianza sugiere una probabilidad de detección o coincidencia correcta superior al 60 %. Si un sistema de detección de rostros no detecta correctamente un rostro o proporciona una predicción de baja fiabilidad para un rostro real, se omite el dato negativo. detection/false Si el sistema predice incorrectamente la presencia de un rostro con un nivel de confianza alto, se trata de un falso alarm/false positivo. Del mismo modo, un sistema de comparación facial puede no hacer coincidir dos rostros que pertenezcan a la misma persona ( detection/false negativo omitido) o puede predecir erróneamente que dos rostros de personas diferentes son de la misma persona (falso alarm/false positivo). **Diseño de aplicaciones y establecimiento de umbrales** + Puede establecer un umbral que especifique el nivel de confianza mínimo necesario para devolver un resultado. Elegir los umbrales de confianza adecuados es esencial para el diseño de las aplicaciones y la toma de decisiones en función de los resultados del sistema. + El nivel de confianza que elija debe reflejar su caso de uso. A continuación, se indican algunos ejemplos de casos de uso y umbrales de confianza: + + **Aplicaciones fotográficas**: un umbral más bajo (por ejemplo, el 80 %) puede ser suficiente para identificar a los miembros de una familia en las fotos. + **Escenarios de alto riesgo**: en los casos de uso en los que el riesgo de detección perdida o de falsa alarma es mayor, como en las aplicaciones de seguridad, el sistema debe utilizar un nivel de confianza más alto. En estos casos, se recomienda un umbral más alto (por ejemplo, el 99 %) para conseguir coincidencias faciales precisas. Para obtener más información acerca de cómo establecer y comprender los requisitos de confianza, consulte [Búsqueda de rostros en una colección](collections.md). # Directrices sobre los atributos faciales A continuación, se incluye información detallada sobre cómo procesa y devuelve los atributos faciales Amazon Rekognition. + **FaceDetail Objeto**: por cada rostro detectado, se devuelve un FaceDetail objeto. FaceDetail Contiene datos sobre los puntos de referencia del rostro, la calidad, la postura y más. + **Predicciones de atributos:** se predicen atributos como la emoción, el género, la edad y otros. Se asigna un nivel de confianza a cada predicción y las predicciones se devuelven con la puntuación de confianza correspondiente. Se recomienda un umbral de confianza del 99 % para los casos de uso confidenciales. Para la estimación de la edad, el punto medio del rango de edad previsto ofrece la mejor aproximación. Tenga en cuenta que las predicciones de género y de emociones se basan en la apariencia física y no deben usarse para determinar la identidad de género o el estado emocional real. La predicción binaria del sexo (masculino/femenino) utiliza la apariencia física de un rostro de una imagen determinada. No indica la identidad de género de una persona y no debe utilizarse Rekognition para realizar esta determinación. No es recomendable utilizar predicciones binarias de género para tomar decisiones que podrían afectar a los derechos, la privacidad o el acceso de una persona a los servicios. Del mismo modo, la predicción de emociones no indica el estado emocional interno real de una persona y no debe utilizarse Rekognition para realizar esta determinación. Una persona que pone cara de felicidad en una imagen puede parecer contenta, si bien puede que no se sienta feliz. **Aplicación y casos de uso** A continuación, se describen algunas aplicaciones y casos de uso prácticos para estos atributos: + **Aplicaciones**: atributos como la sonrisa, la postura y la nitidez se pueden utilizar para seleccionar imágenes de perfil o realizar estimaciones demográficas de forma anónima. + **Casos de uso comunes**: las aplicaciones de redes sociales y la estimación demográfica en eventos o tiendas minoristas son ejemplos típicos. Para obtener información más detallada sobre cada atributo, consulte [FaceDetail](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_FaceDetail.html). # Detección de rostros en una imagen Amazon Rekognition Image [DetectFaces](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectFaces.html)proporciona la operación que busca rasgos faciales clave, como los ojos, la nariz y la boca, para detectar rostros en una imagen de entrada. Amazon Rekognition Image detecta las 100 caras más grandes de una imagen. Puede proporcionar la imagen de entrada como una matriz de bytes de imagen (con codificación en base64) o especificar un objeto de Amazon S3. En este procedimiento subirá una imagen (JPEG o PNG) en su bucket de S3; y especificará el nombre de clave del objeto. **Detección de rostros 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 y el AWS CLI . AWS SDKs Para obtener más información, consulte [Paso 2: Configure y AWS CLI AWS SDKs](setup-awscli-sdk.md). 1. Suba una imagen (que contenga uno o varios rostros) en el bucket de S3. Para ver las instrucciones, consulte [Carga de objetos en Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UploadingObjectsintoAmazonS3.html) en la *Guía del usuario de Amazon Simple Storage Service*. 1. Utilice los siguientes ejemplos para llamar a `DetectFaces`. ------ #### [ Java ] Este ejemplo muestra el rango de edades estimado de los rostros detectados y muestra el código JSON para todos los atributos faciales detectados. Cambie el valor de `photo` por el nombre de archivo de la imagen. Cambie el valor de `amzn-s3-demo-bucket` por el bucket de Amazon S3 donde se almacena la imagen. ``` //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 com.amazonaws.services.rekognition.AmazonRekognition; import com.amazonaws.services.rekognition.AmazonRekognitionClientBuilder; import com.amazonaws.services.rekognition.model.AmazonRekognitionException; import com.amazonaws.services.rekognition.model.Image; import com.amazonaws.services.rekognition.model.S3Object; import com.amazonaws.services.rekognition.model.AgeRange; import com.amazonaws.services.rekognition.model.Attribute; import com.amazonaws.services.rekognition.model.DetectFacesRequest; import com.amazonaws.services.rekognition.model.DetectFacesResult; import com.amazonaws.services.rekognition.model.FaceDetail; import com.fasterxml.jackson.databind.ObjectMapper; import java.util.List; public class DetectFaces { public static void main(String[] args) throws Exception { String photo = "input.jpg"; String bucket = "bucket"; AmazonRekognition rekognitionClient = AmazonRekognitionClientBuilder.defaultClient(); DetectFacesRequest request = new DetectFacesRequest() .withImage(new Image() .withS3Object(new S3Object() .withName(photo) .withBucket(bucket))) .withAttributes(Attribute.ALL); // Replace Attribute.ALL with Attribute.DEFAULT to get default values. try { DetectFacesResult result = rekognitionClient.detectFaces(request); List < FaceDetail > faceDetails = result.getFaceDetails(); for (FaceDetail face: faceDetails) { if (request.getAttributes().contains("ALL")) { AgeRange ageRange = face.getAgeRange(); System.out.println("The detected face is estimated to be between " + ageRange.getLow().toString() + " and " + ageRange.getHigh().toString() + " years old."); System.out.println("Here's the complete set of attributes:"); } else { // non-default attributes have null values. System.out.println("Here's the default set of attributes:"); } ObjectMapper objectMapper = new ObjectMapper(); System.out.println(objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(face)); } } catch (AmazonRekognitionException e) { e.printStackTrace(); } } } ``` ------ #### [ 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/DetectFaces.java). ``` import java.util.List; //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.RekognitionException; import software.amazon.awssdk.services.rekognition.model.S3Object; import software.amazon.awssdk.services.rekognition.model.DetectFacesRequest; import software.amazon.awssdk.services.rekognition.model.DetectFacesResponse; import software.amazon.awssdk.services.rekognition.model.Image; import software.amazon.awssdk.services.rekognition.model.Attribute; import software.amazon.awssdk.services.rekognition.model.FaceDetail; import software.amazon.awssdk.services.rekognition.model.AgeRange; //snippet-end:[rekognition.java2.detect_labels.import] public class DetectFaces { public static void main(String[] args) { final String usage = "\n" + "Usage: " + " \n\n" + "Where:\n" + " bucket - The name of the Amazon S3 bucket that contains the image (for example, ,amzn-s3-demo-bucket)." + " 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(); DetectFacesRequest facesRequest = DetectFacesRequest.builder() .attributes(Attribute.ALL) .image(myImage) .build(); DetectFacesResponse facesResponse = rekClient.detectFaces(facesRequest); List faceDetails = facesResponse.faceDetails(); for (FaceDetail face : faceDetails) { AgeRange ageRange = face.ageRange(); System.out.println("The detected face is estimated to be between " + ageRange.low().toString() + " and " + ageRange.high().toString() + " years old."); System.out.println("There is a smile : "+face.smile().value().toString()); } } catch (RekognitionException e) { System.out.println(e.getMessage()); System.exit(1); } } // snippet-end:[rekognition.java2.detect_labels.main] } ``` ------ #### [ AWS CLI ] En este ejemplo, se muestra el resultado JSON de la `detect-faces` AWS CLI operación. Reemplace `file` por el nombre de un archivo de imagen. Sustituya `amzn-s3-demo-bucket` por el nombre del bucket de Amazon S3; que contiene el archivo de imagen. ``` aws rekognition detect-faces --image "{"S3Object":{"Bucket":"amzn-s3-demo-bucket,"Name":"image-name"}}"\ --attributes "ALL" --profile profile-name --region region-name ``` Si accede a la CLI en un dispositivo Windows, utilice comillas dobles en lugar de comillas simples y evite las comillas dobles internas con una barra invertida (es decir, \$1) para corregir cualquier error del analizador que pueda encontrar. Por ver un ejemplo, consulte lo siguiente: ``` aws rekognition detect-faces --image "{\"S3Object\":{\"Bucket\":\"amzn-s3-demo-bucket\",\"Name\":\"image-name\"}}" --attributes "ALL" --profile profile-name --region region-name ``` ------ #### [ Python ] Este ejemplo muestra el rango de edades estimado y otros atributos de los rostros detectados y muestra el código JSON para todos los atributos faciales detectados. Cambie el valor de `photo` por el nombre de archivo de la imagen. Cambie el valor de `amzn-s3-demo-bucket` por el bucket de Amazon S3 donde se almacena la imagen. Sustituya el valor de `profile_name` en la línea que crea la sesión de Rekognition por el nombre de su perfil de desarrollador. ``` import boto3 import json def detect_faces(photo, bucket, region): session = boto3.Session(profile_name='profile-name', region_name=region) client = session.client('rekognition', region_name=region) response = client.detect_faces(Image={'S3Object':{'Bucket':bucket,'Name':photo}}, Attributes=['ALL']) 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') print('Here are the other attributes:') print(json.dumps(faceDetail, indent=4, sort_keys=True)) # Access predictions for individual face details and print them print("Gender: " + str(faceDetail['Gender'])) print("Smile: " + str(faceDetail['Smile'])) print("Eyeglasses: " + str(faceDetail['Eyeglasses'])) print("Face Occluded: " + str(faceDetail['FaceOccluded'])) print("Emotions: " + str(faceDetail['Emotions'][0])) return len(response['FaceDetails']) def main(): photo='photo' bucket='amzn-s3-demo-bucket' region='region' face_count=detect_faces(photo, bucket, region) print("Faces detected: " + str(face_count)) if __name__ == "__main__": main() ``` ------ #### [ .NET ] Este ejemplo muestra el rango de edades estimado de los rostros detectados y muestra el código JSON para todos los atributos faciales detectados. Cambie el valor de `photo` por el nombre de archivo de la imagen. Cambie el valor de `amzn-s3-demo-bucket` por el bucket de Amazon S3 donde se almacena la imagen. ``` //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.Collections.Generic; using Amazon.Rekognition; using Amazon.Rekognition.Model; public class DetectFaces { public static void Example() { String photo = "input.jpg"; String bucket = "amzn-s3-demo-bucket"; AmazonRekognitionClient rekognitionClient = new AmazonRekognitionClient(); DetectFacesRequest detectFacesRequest = new DetectFacesRequest() { Image = new Image() { S3Object = new S3Object() { Name = photo, Bucket = bucket }, }, // Attributes can be "ALL" or "DEFAULT". // "DEFAULT": BoundingBox, Confidence, Landmarks, Pose, and Quality. // "ALL": See https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/Rekognition/TFaceDetail.html Attributes = new List() { "ALL" } }; try { DetectFacesResponse detectFacesResponse = rekognitionClient.DetectFaces(detectFacesRequest); bool hasAll = detectFacesRequest.Attributes.Contains("ALL"); foreach(FaceDetail face in detectFacesResponse.FaceDetails) { Console.WriteLine("BoundingBox: top={0} left={1} width={2} height={3}", face.BoundingBox.Left, face.BoundingBox.Top, face.BoundingBox.Width, face.BoundingBox.Height); Console.WriteLine("Confidence: {0}\nLandmarks: {1}\nPose: pitch={2} roll={3} yaw={4}\nQuality: {5}", face.Confidence, face.Landmarks.Count, face.Pose.Pitch, face.Pose.Roll, face.Pose.Yaw, face.Quality); if (hasAll) Console.WriteLine("The detected face is estimated to be between " + face.AgeRange.Low + " and " + face.AgeRange.High + " years old."); } } catch (Exception e) { Console.WriteLine(e.Message); } } } ``` ------ #### [ Ruby ] En este ejemplo, se muestra el rango de edad estimado de los rostros detectados y se enumeran varios atributos faciales. Cambie el valor de `photo` por el nombre de archivo de la imagen. Cambie el valor de `amzn-s3-demo-bucket` por el bucket de Amazon S3 donde se almacena la imagen. ``` # 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 bucketname without s3:// photo = 'input.jpg'# the name of file client = Aws::Rekognition::Client.new credentials: credentials attrs = { image: { s3_object: { bucket: bucket, name: photo }, }, attributes: ['ALL'] } response = client.detect_faces attrs puts "Detected faces for: #{photo}" response.face_details.each do |face_detail| low = face_detail.age_range.low high = face_detail.age_range.high puts "The detected face is between: #{low} and #{high} years old" puts "All other attributes:" puts " bounding_box.width: #{face_detail.bounding_box.width}" puts " bounding_box.height: #{face_detail.bounding_box.height}" puts " bounding_box.left: #{face_detail.bounding_box.left}" puts " bounding_box.top: #{face_detail.bounding_box.top}" puts " age.range.low: #{face_detail.age_range.low}" puts " age.range.high: #{face_detail.age_range.high}" puts " smile.value: #{face_detail.smile.value}" puts " smile.confidence: #{face_detail.smile.confidence}" puts " eyeglasses.value: #{face_detail.eyeglasses.value}" puts " eyeglasses.confidence: #{face_detail.eyeglasses.confidence}" puts " sunglasses.value: #{face_detail.sunglasses.value}" puts " sunglasses.confidence: #{face_detail.sunglasses.confidence}" puts " gender.value: #{face_detail.gender.value}" puts " gender.confidence: #{face_detail.gender.confidence}" puts " beard.value: #{face_detail.beard.value}" puts " beard.confidence: #{face_detail.beard.confidence}" puts " mustache.value: #{face_detail.mustache.value}" puts " mustache.confidence: #{face_detail.mustache.confidence}" puts " eyes_open.value: #{face_detail.eyes_open.value}" puts " eyes_open.confidence: #{face_detail.eyes_open.confidence}" puts " mout_open.value: #{face_detail.mouth_open.value}" puts " mout_open.confidence: #{face_detail.mouth_open.confidence}" puts " emotions[0].type: #{face_detail.emotions[0].type}" puts " emotions[0].confidence: #{face_detail.emotions[0].confidence}" puts " landmarks[0].type: #{face_detail.landmarks[0].type}" puts " landmarks[0].x: #{face_detail.landmarks[0].x}" puts " landmarks[0].y: #{face_detail.landmarks[0].y}" puts " pose.roll: #{face_detail.pose.roll}" puts " pose.yaw: #{face_detail.pose.yaw}" puts " pose.pitch: #{face_detail.pose.pitch}" puts " quality.brightness: #{face_detail.quality.brightness}" puts " quality.sharpness: #{face_detail.quality.sharpness}" puts " confidence: #{face_detail.confidence}" puts "------------" puts "" end ``` ------ #### [ Node.js ] En este ejemplo, se muestra el rango de edad estimado de los rostros detectados y se enumeran varios atributos faciales. Cambie el valor de `photo` por el nombre de archivo de la imagen. Cambie el valor de `amzn-s3-demo-bucket` por el bucket de Amazon S3 donde se almacena la imagen. Sustituya el valor de `profile_name` en la línea que crea la sesión de Rekognition por el nombre de su perfil de desarrollador. Si utiliza TypeScript definiciones, puede que necesite utilizarlas en `import AWS from 'aws-sdk'` lugar de`const AWS = require('aws-sdk')`, para ejecutar el programa con Node.js. Puede consultar el [AWS SDK para Javascript](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/) si quiere obtener más información. En función de cómo tenga establecidas las opciones de configuración, es posible que también tenga que especificar su región con `AWS.config.update({region:region});`. ``` // Load the SDK var AWS = require('aws-sdk'); const bucket = 'bucket-name' // the bucketname without s3:// const photo = 'photo-name' // the name of file var credentials = new AWS.SharedIniFileCredentials({profile: 'profile-name'}); AWS.config.credentials = credentials; AWS.config.update({region:'region-name'}); const client = new AWS.Rekognition(); const params = { Image: { S3Object: { Bucket: bucket, Name: photo }, }, Attributes: ['ALL'] } client.detectFaces(params, function(err, response) { if (err) { console.log(err, err.stack); // an error occurred } else { console.log(`Detected faces for: ${photo}`) response.FaceDetails.forEach(data => { let low = data.AgeRange.Low let high = data.AgeRange.High console.log(`The detected face is between: ${low} and ${high} years old`) console.log("All other attributes:") console.log(` BoundingBox.Width: ${data.BoundingBox.Width}`) console.log(` BoundingBox.Height: ${data.BoundingBox.Height}`) console.log(` BoundingBox.Left: ${data.BoundingBox.Left}`) console.log(` BoundingBox.Top: ${data.BoundingBox.Top}`) console.log(` Age.Range.Low: ${data.AgeRange.Low}`) console.log(` Age.Range.High: ${data.AgeRange.High}`) console.log(` Smile.Value: ${data.Smile.Value}`) console.log(` Smile.Confidence: ${data.Smile.Confidence}`) console.log(` Eyeglasses.Value: ${data.Eyeglasses.Value}`) console.log(` Eyeglasses.Confidence: ${data.Eyeglasses.Confidence}`) console.log(` Sunglasses.Value: ${data.Sunglasses.Value}`) console.log(` Sunglasses.Confidence: ${data.Sunglasses.Confidence}`) console.log(` Gender.Value: ${data.Gender.Value}`) console.log(` Gender.Confidence: ${data.Gender.Confidence}`) console.log(` Beard.Value: ${data.Beard.Value}`) console.log(` Beard.Confidence: ${data.Beard.Confidence}`) console.log(` Mustache.Value: ${data.Mustache.Value}`) console.log(` Mustache.Confidence: ${data.Mustache.Confidence}`) console.log(` EyesOpen.Value: ${data.EyesOpen.Value}`) console.log(` EyesOpen.Confidence: ${data.EyesOpen.Confidence}`) console.log(` MouthOpen.Value: ${data.MouthOpen.Value}`) console.log(` MouthOpen.Confidence: ${data.MouthOpen.Confidence}`) console.log(` Emotions[0].Type: ${data.Emotions[0].Type}`) console.log(` Emotions[0].Confidence: ${data.Emotions[0].Confidence}`) console.log(` Landmarks[0].Type: ${data.Landmarks[0].Type}`) console.log(` Landmarks[0].X: ${data.Landmarks[0].X}`) console.log(` Landmarks[0].Y: ${data.Landmarks[0].Y}`) console.log(` Pose.Roll: ${data.Pose.Roll}`) console.log(` Pose.Yaw: ${data.Pose.Yaw}`) console.log(` Pose.Pitch: ${data.Pose.Pitch}`) console.log(` Quality.Brightness: ${data.Quality.Brightness}`) console.log(` Quality.Sharpness: ${data.Quality.Sharpness}`) console.log(` Confidence: ${data.Confidence}`) console.log("------------") console.log("") }) // for response.faceDetails } // if }); ``` ------ ## DetectFaces solicitud de operación La entrada de `DetectFaces` es una imagen. En este ejemplo, la imagen se carga desde un bucket de Amazon S3. El parámetro `Attributes` especifica que se deben devolver todos los atributos faciales. Para obtener más información, consulte [Trabajar con imágenes](images.md). ``` { "Image": { "S3Object": { "Bucket": "amzn-s3-demo-bucket", "Name": "input.jpg" } }, "Attributes": [ "ALL" ] } ``` ## DetectFaces respuesta de operación `DetectFaces` devuelve la siguiente información por cada rostro detectado: + **Cuadro delimitador**: las coordenadas del cuadro delimitador que rodea el rostro. + **Confianza**: grado de confianza de que el cuadro delimitador contiene un rostro. + **Referencias faciales**: una matriz de referencias faciales. Para cada referencia (como el ojo izquierdo, el ojo derecho y la boca), la respuesta proporciona las coordenadas x, y. + **Atributos faciales**: conjunto de atributos faciales, como si el rostro está oculto, que se devuelve como un objeto `FaceDetail`. El set incluye: barba AgeRange, emociones EyeDirection, anteojos, género, bigote EyesOpen FaceOccluded, sonrisa MouthOpen y gafas de sol. Para cada atributo, la respuesta proporciona un valor. El valor puede ser de diferentes tipos, como un tipo booleano (si la persona lleva gafas de sol), una cadena (si la persona es hombre o mujer) o un valor de grado angular (para pitch/yaw la dirección de la mirada). Además, para la mayoría de los atributos la respuesta proporciona también una confianza en el valor detectado para el atributo. Tenga en cuenta que, si bien EyeDirection los atributos FaceOccluded y se admiten cuando se utilizan`DetectFaces`, no se admiten cuando se analizan vídeos con `StartFaceDetection` y. `GetFaceDetection` + **Calidad**: describe el brillo y la nitidez del rostro. Para obtener información acerca de cómo optimizar la detección de rostros, consulte [Recomendaciones para la comparación de rostros en las imágenes de entrada](recommendations-facial-input-images.md). + **Postura**: describe la rotación del rostro dentro de la imagen. La solicitud puede incluir una serie de atributos faciales que quiera que se devuelvan. Siempre se mostrará un subconjunto `DEFAULT` de atributos faciales: `BoundingBox`, `Confidence`, `Pose`, `Quality` y `Landmarks`. Puede solicitar la devolución de atributos faciales específicos (además de la lista predeterminada), utilizando `["DEFAULT", "FACE_OCCLUDED", "EYE_DIRECTION"]` o solo un atributo, por ejemplo `["FACE_OCCLUDED"]`. Puede solicitar todos los atributos faciales usando `["ALL"]`. Solicitar más atributos puede aumentar el tiempo de respuesta. A continuación se muestra un ejemplo de respuesta de una llamada a la API `DetectFaces`: ``` { "FaceDetails": [ { "BoundingBox": { "Width": 0.7919622659683228, "Height": 0.7510867118835449, "Left": 0.08881539851427078, "Top": 0.151064932346344 }, "AgeRange": { "Low": 18, "High": 26 }, "Smile": { "Value": false, "Confidence": 89.77348327636719 }, "Eyeglasses": { "Value": true, "Confidence": 99.99996948242188 }, "Sunglasses": { "Value": true, "Confidence": 93.65237426757812 }, "Gender": { "Value": "Female", "Confidence": 99.85968780517578 }, "Beard": { "Value": false, "Confidence": 77.52591705322266 }, "Mustache": { "Value": false, "Confidence": 94.48904418945312 }, "EyesOpen": { "Value": true, "Confidence": 98.57169342041016 }, "MouthOpen": { "Value": false, "Confidence": 74.33953094482422 }, "Emotions": [ { "Type": "SAD", "Confidence": 65.56403350830078 }, { "Type": "CONFUSED", "Confidence": 31.277774810791016 }, { "Type": "DISGUSTED", "Confidence": 15.553778648376465 }, { "Type": "ANGRY", "Confidence": 8.012762069702148 }, { "Type": "SURPRISED", "Confidence": 7.621500015258789 }, { "Type": "FEAR", "Confidence": 7.243380546569824 }, { "Type": "CALM", "Confidence": 5.8196024894714355 }, { "Type": "HAPPY", "Confidence": 2.2830512523651123 } ], "Landmarks": [ { "Type": "eyeLeft", "X": 0.30225440859794617, "Y": 0.41018882393836975 }, { "Type": "eyeRight", "X": 0.6439348459243774, "Y": 0.40341562032699585 }, { "Type": "mouthLeft", "X": 0.343580037355423, "Y": 0.6951127648353577 }, { "Type": "mouthRight", "X": 0.6306480765342712, "Y": 0.6898072361946106 }, { "Type": "nose", "X": 0.47164231538772583, "Y": 0.5763645172119141 }, { "Type": "leftEyeBrowLeft", "X": 0.1732882857322693, "Y": 0.34452149271965027 }, { "Type": "leftEyeBrowRight", "X": 0.3655243515968323, "Y": 0.33231860399246216 }, { "Type": "leftEyeBrowUp", "X": 0.2671719491481781, "Y": 0.31669262051582336 }, { "Type": "rightEyeBrowLeft", "X": 0.5613729953765869, "Y": 0.32813435792922974 }, { "Type": "rightEyeBrowRight", "X": 0.7665090560913086, "Y": 0.3318614959716797 }, { "Type": "rightEyeBrowUp", "X": 0.6612788438796997, "Y": 0.3082450032234192 }, { "Type": "leftEyeLeft", "X": 0.2416982799768448, "Y": 0.4085965156555176 }, { "Type": "leftEyeRight", "X": 0.36943578720092773, "Y": 0.41230902075767517 }, { "Type": "leftEyeUp", "X": 0.29974061250686646, "Y": 0.3971870541572571 }, { "Type": "leftEyeDown", "X": 0.30360740423202515, "Y": 0.42347756028175354 }, { "Type": "rightEyeLeft", "X": 0.5755768418312073, "Y": 0.4081145226955414 }, { "Type": "rightEyeRight", "X": 0.7050536870956421, "Y": 0.39924031496047974 }, { "Type": "rightEyeUp", "X": 0.642906129360199, "Y": 0.39026668667793274 }, { "Type": "rightEyeDown", "X": 0.6423097848892212, "Y": 0.41669243574142456 }, { "Type": "noseLeft", "X": 0.4122826159000397, "Y": 0.5987403392791748 }, { "Type": "noseRight", "X": 0.5394935011863708, "Y": 0.5960900187492371 }, { "Type": "mouthUp", "X": 0.478581964969635, "Y": 0.6660456657409668 }, { "Type": "mouthDown", "X": 0.483366996049881, "Y": 0.7497162818908691 }, { "Type": "leftPupil", "X": 0.30225440859794617, "Y": 0.41018882393836975 }, { "Type": "rightPupil", "X": 0.6439348459243774, "Y": 0.40341562032699585 }, { "Type": "upperJawlineLeft", "X": 0.11031254380941391, "Y": 0.3980775475502014 }, { "Type": "midJawlineLeft", "X": 0.19301874935626984, "Y": 0.7034031748771667 }, { "Type": "chinBottom", "X": 0.4939905107021332, "Y": 0.8877836465835571 }, { "Type": "midJawlineRight", "X": 0.7990140914916992, "Y": 0.6899225115776062 }, { "Type": "upperJawlineRight", "X": 0.8548634648323059, "Y": 0.38160091638565063 } ], "Pose": { "Roll": -5.83309268951416, "Yaw": -2.4244730472564697, "Pitch": 2.6216139793395996 }, "Quality": { "Brightness": 96.16363525390625, "Sharpness": 95.51618957519531 }, "Confidence": 99.99872589111328, "FaceOccluded": { "Value": true, "Confidence": 99.99726104736328 }, "EyeDirection": { "Yaw": 16.299732, "Pitch": -6.407457, "Confidence": 99.968704 } } ], "ResponseMetadata": { "RequestId": "8bf02607-70b7-4f20-be55-473fe1bba9a2", "HTTPStatusCode": 200, "HTTPHeaders": { "x-amzn-requestid": "8bf02607-70b7-4f20-be55-473fe1bba9a2", "content-type": "application/x-amz-json-1.1", "content-length": "3409", "date": "Wed, 26 Apr 2023 20:18:50 GMT" }, "RetryAttempts": 0 } } ``` Tenga en cuenta lo siguiente: + Los datos de `Pose` describen la rotación del rostro detectado. Puede utilizar la combinación de los datos de `BoundingBox` y `Pose` para dibujar el cuadro delimitador en los rostros mostrados por la aplicación. + `Quality` describe el brillo y la nitidez del rostro. Tal vez le resulte útil comparar rostros de imágenes para encontrar el mejor. + La respuesta anterior muestra todos los valores de `landmarks` que el servicio puede detectar: todos los atributos faciales y las emociones. Para obtener todos estos atributos en la respuesta, debe especificar el parámetro `attributes` con el valor `ALL`. De forma predeterminada, la API `DetectFaces` devuelve solo los siguientes cinco atributos faciales: `BoundingBox`, `Confidence`, `Pose`, `Quality` y `landmarks`. Las referencias predeterminadas que se devuelve son: `eyeLeft`, `eyeRight`, `nose`, `mouthLeft` y `mouthRight`. # Comparación de rostros en imágenes Con Rekognition puedes comparar rostros entre dos imágenes mediante la operación. [CompareFaces](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CompareFaces.html) Esta característica es útil para aplicaciones como la verificación de identidad o la coincidencia de fotos. CompareFaces *compara un rostro de la imagen de *origen* con cada rostro de la imagen de destino.* Las imágenes se pasan a una de CompareFaces las siguientes formas: + Representación de una imagen codificada en base64 + Objetos de Amazon S3 **Detección de rostros frente a comparación de rostros** La comparación de rostros es distinta de la detección de rostros. La detección de rostros (que utiliza DetectFaces) solo identifica la presencia y ubicación de rostros en una imagen o vídeo. Por el contrario, la comparación de rostros implica comparar un rostro que se ha detectado en una imagen de origen con los rostros de una imagen de destino para encontrar coincidencias. **Umbrales de similitud** Utilice el parámetro `similarityThreshold` para definir el nivel de confianza mínimo necesario para que las coincidencias se incluyan en la respuesta. De forma predeterminada, en la respuesta solo se devuelven los rostros con una puntuación de similitud superior o igual al 80 %. **nota** `CompareFaces` utiliza algoritmos de machine learning, basados en probabilidades. Un falso negativo es una predicción incorrecta de que un rostro de la imagen objetivo tiene una puntuación de confianza de similitud baja en comparación con el rostro de la imagen original. Para reducir la probabilidad de que se produzcan falsos negativos, le recomendamos que compare la imagen de destino con varias imágenes de origen. Si piensa utilizar `CompareFaces` para tomar una decisión que afecte a los derechos, la privacidad o el acceso de una persona a los servicios, le recomendamos que transmita el resultado a una persona para que lo revise y lo valide antes de tomar medidas. Los siguientes ejemplos de código muestran cómo utilizar las CompareFaces operaciones para varios tipos de operaciones AWS SDKs. En el AWS CLI ejemplo, carga dos imágenes JPEG a su bucket de Amazon S3 y especifica el nombre de la clave del objeto. En los demás ejemplos, puede subir dos archivos desde el sistema de archivos local e introducirlos como una matriz de bytes de imagen. **Para comparar rostros** 1. Si aún no lo ha hecho: 1. Cree o actualice un usuario con `AmazonRekognitionFullAccess` permisos `AmazonS3ReadOnlyAccess` (solo de AWS CLI ejemplo). 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 los AWS CLI y los AWS SDKs. Para obtener más información, consulte [Paso 2: Configure y AWS CLI AWS SDKs](setup-awscli-sdk.md). 1. Utilice el siguiente código de ejemplo para realizar llamadas a la operación `CompareFaces`. ------ #### [ Java ] Este ejemplo muestra información sobre rostros coincidentes de las imágenes de origen y de destino que se cargan desde el sistema de archivos local. Reemplace los valores de `sourceImage` y `targetImage` por la ruta y el nombre de archivo de las imágenes de origen y de destino. ``` //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 com.amazonaws.services.rekognition.AmazonRekognition; import com.amazonaws.services.rekognition.AmazonRekognitionClientBuilder; import com.amazonaws.services.rekognition.model.Image; import com.amazonaws.services.rekognition.model.BoundingBox; import com.amazonaws.services.rekognition.model.CompareFacesMatch; import com.amazonaws.services.rekognition.model.CompareFacesRequest; import com.amazonaws.services.rekognition.model.CompareFacesResult; import com.amazonaws.services.rekognition.model.ComparedFace; import java.util.List; import java.io.File; import java.io.FileInputStream; import java.io.InputStream; import java.nio.ByteBuffer; import com.amazonaws.util.IOUtils; public class CompareFaces { public static void main(String[] args) throws Exception{ Float similarityThreshold = 70F; String sourceImage = "source.jpg"; String targetImage = "target.jpg"; ByteBuffer sourceImageBytes=null; ByteBuffer targetImageBytes=null; AmazonRekognition rekognitionClient = AmazonRekognitionClientBuilder.defaultClient(); //Load source and target images and create input parameters try (InputStream inputStream = new FileInputStream(new File(sourceImage))) { sourceImageBytes = ByteBuffer.wrap(IOUtils.toByteArray(inputStream)); } catch(Exception e) { System.out.println("Failed to load source image " + sourceImage); System.exit(1); } try (InputStream inputStream = new FileInputStream(new File(targetImage))) { targetImageBytes = ByteBuffer.wrap(IOUtils.toByteArray(inputStream)); } catch(Exception e) { System.out.println("Failed to load target images: " + targetImage); System.exit(1); } Image source=new Image() .withBytes(sourceImageBytes); Image target=new Image() .withBytes(targetImageBytes); CompareFacesRequest request = new CompareFacesRequest() .withSourceImage(source) .withTargetImage(target) .withSimilarityThreshold(similarityThreshold); // Call operation CompareFacesResult compareFacesResult=rekognitionClient.compareFaces(request); // Display results List faceDetails = compareFacesResult.getFaceMatches(); for (CompareFacesMatch match: faceDetails){ ComparedFace face= match.getFace(); BoundingBox position = face.getBoundingBox(); System.out.println("Face at " + position.getLeft().toString() + " " + position.getTop() + " matches with " + match.getSimilarity().toString() + "% confidence."); } List uncompared = compareFacesResult.getUnmatchedFaces(); System.out.println("There was " + uncompared.size() + " face(s) that did not match"); } } ``` ------ #### [ 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/CompareFaces.java). ``` import java.util.List; 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.RekognitionException; import software.amazon.awssdk.services.rekognition.model.Image; import software.amazon.awssdk.services.rekognition.model.BoundingBox; import software.amazon.awssdk.services.rekognition.model.CompareFacesMatch; import software.amazon.awssdk.services.rekognition.model.CompareFacesRequest; import software.amazon.awssdk.services.rekognition.model.CompareFacesResponse; import software.amazon.awssdk.services.rekognition.model.ComparedFace; import software.amazon.awssdk.core.SdkBytes; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.InputStream; // snippet-end:[rekognition.java2.detect_faces.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 CompareFaces { public static void main(String[] args) { final String usage = "\n" + "Usage: " + " \n\n" + "Where:\n" + " pathSource - The path to the source image (for example, C:\\AWS\\pic1.png). \n " + " pathTarget - The path to the target image (for example, C:\\AWS\\pic2.png). \n\n"; if (args.length != 2) { System.out.println(usage); System.exit(1); } Float similarityThreshold = 70F; String sourceImage = args[0]; String targetImage = args[1]; Region region = Region.US_EAST_1; RekognitionClient rekClient = RekognitionClient.builder() .region(region) .credentialsProvider(ProfileCredentialsProvider.create("profile-name")) .build(); compareTwoFaces(rekClient, similarityThreshold, sourceImage, targetImage); rekClient.close(); } // snippet-start:[rekognition.java2.compare_faces.main] public static void compareTwoFaces(RekognitionClient rekClient, Float similarityThreshold, String sourceImage, String targetImage) { try { InputStream sourceStream = new FileInputStream(sourceImage); InputStream tarStream = new FileInputStream(targetImage); SdkBytes sourceBytes = SdkBytes.fromInputStream(sourceStream); SdkBytes targetBytes = SdkBytes.fromInputStream(tarStream); // Create an Image object for the source image. Image souImage = Image.builder() .bytes(sourceBytes) .build(); Image tarImage = Image.builder() .bytes(targetBytes) .build(); CompareFacesRequest facesRequest = CompareFacesRequest.builder() .sourceImage(souImage) .targetImage(tarImage) .similarityThreshold(similarityThreshold) .build(); // Compare the two images. CompareFacesResponse compareFacesResult = rekClient.compareFaces(facesRequest); List faceDetails = compareFacesResult.faceMatches(); for (CompareFacesMatch match: faceDetails){ ComparedFace face= match.face(); BoundingBox position = face.boundingBox(); System.out.println("Face at " + position.left().toString() + " " + position.top() + " matches with " + face.confidence().toString() + "% confidence."); } List uncompared = compareFacesResult.unmatchedFaces(); System.out.println("There was " + uncompared.size() + " face(s) that did not match"); System.out.println("Source image rotation: " + compareFacesResult.sourceImageOrientationCorrection()); System.out.println("target image rotation: " + compareFacesResult.targetImageOrientationCorrection()); } catch(RekognitionException | FileNotFoundException e) { System.out.println("Failed to load source image " + sourceImage); System.exit(1); } } // snippet-end:[rekognition.java2.compare_faces.main] } ``` ------ #### [ AWS CLI ] En este ejemplo, se muestra el resultado JSON de la `compare-faces` AWS CLI operación. Sustituya `amzn-s3-demo-bucket` por el nombre del bucket de Amazon S3 que contiene las imágenes de origen y destino. Reemplace `source.jpg` y `target.jpg` por los nombres de archivo de las imágenes de origen y destino. ``` aws rekognition compare-faces --target-image \ "{"S3Object":{"Bucket":"amzn-s3-demo-bucket","Name":"image-name"}}" \ --source-image "{"S3Object":{"Bucket":"amzn-s3-demo-bucket","Name":"image-name"}}" --profile profile-name ``` Si accede a la CLI en un dispositivo Windows, utilice comillas dobles en lugar de comillas simples y evite las comillas dobles internas con una barra invertida (es decir, \$1) para corregir cualquier error del analizador que pueda encontrar. Por ver un ejemplo, consulte lo siguiente: ``` aws rekognition compare-faces --target-image "{\"S3Object\":{\"Bucket\":\"amzn-s3-demo-bucket\",\"Name\":\"image-name\"}}" \ --source-image "{\"S3Object\":{\"Bucket\":\"amzn-s3-demo-bucket\",\"Name\":\"image-name\"}}" --profile profile-name ``` ------ #### [ Python ] Este ejemplo muestra información sobre rostros coincidentes de las imágenes de origen y de destino que se cargan desde el sistema de archivos local. Reemplace los valores de `source_file` y `target_file` por la ruta y el nombre de archivo de las imágenes de origen y de destino. 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 compare_faces(sourceFile, targetFile): session = boto3.Session(profile_name='profile-name') client = session.client('rekognition') imageSource = open(sourceFile, 'rb') imageTarget = open(targetFile, 'rb') response = client.compare_faces(SimilarityThreshold=80, SourceImage={'Bytes': imageSource.read()}, TargetImage={'Bytes': imageTarget.read()}) for faceMatch in response['FaceMatches']: position = faceMatch['Face']['BoundingBox'] similarity = str(faceMatch['Similarity']) print('The face at ' + str(position['Left']) + ' ' + str(position['Top']) + ' matches with ' + similarity + '% confidence') imageSource.close() imageTarget.close() return len(response['FaceMatches']) def main(): source_file = 'source-file-name' target_file = 'target-file-name' face_matches = compare_faces(source_file, target_file) print("Face matches: " + str(face_matches)) if __name__ == "__main__": main() ``` ------ #### [ .NET ] Este ejemplo muestra información sobre rostros coincidentes de las imágenes de origen y de destino que se cargan desde el sistema de archivos local. Reemplace los valores de `sourceImage` y `targetImage` por la ruta y el nombre de archivo de las imágenes de origen y de destino. ``` //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 CompareFaces { public static void Example() { float similarityThreshold = 70F; String sourceImage = "source.jpg"; String targetImage = "target.jpg"; AmazonRekognitionClient rekognitionClient = new AmazonRekognitionClient(); Amazon.Rekognition.Model.Image imageSource = new Amazon.Rekognition.Model.Image(); try { using (FileStream fs = new FileStream(sourceImage, FileMode.Open, FileAccess.Read)) { byte[] data = new byte[fs.Length]; fs.Read(data, 0, (int)fs.Length); imageSource.Bytes = new MemoryStream(data); } } catch (Exception) { Console.WriteLine("Failed to load source image: " + sourceImage); return; } Amazon.Rekognition.Model.Image imageTarget = new Amazon.Rekognition.Model.Image(); try { using (FileStream fs = new FileStream(targetImage, FileMode.Open, FileAccess.Read)) { byte[] data = new byte[fs.Length]; data = new byte[fs.Length]; fs.Read(data, 0, (int)fs.Length); imageTarget.Bytes = new MemoryStream(data); } } catch (Exception) { Console.WriteLine("Failed to load target image: " + targetImage); return; } CompareFacesRequest compareFacesRequest = new CompareFacesRequest() { SourceImage = imageSource, TargetImage = imageTarget, SimilarityThreshold = similarityThreshold }; // Call operation CompareFacesResponse compareFacesResponse = rekognitionClient.CompareFaces(compareFacesRequest); // Display results foreach(CompareFacesMatch match in compareFacesResponse.FaceMatches) { ComparedFace face = match.Face; BoundingBox position = face.BoundingBox; Console.WriteLine("Face at " + position.Left + " " + position.Top + " matches with " + match.Similarity + "% confidence."); } Console.WriteLine("There was " + compareFacesResponse.UnmatchedFaces.Count + " face(s) that did not match"); } } ``` ------ #### [ Ruby ] Este ejemplo muestra información sobre rostros coincidentes de las imágenes de origen y de destino que se cargan desde el sistema de archivos local. Reemplace los valores de `photo_source` y `photo_target` por la ruta y el nombre de archivo de las imágenes de origen y de destino. ``` # 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 bucketname without s3:// photo_source = 'source.jpg' photo_target = 'target.jpg' client = Aws::Rekognition::Client.new credentials: credentials attrs = { source_image: { s3_object: { bucket: bucket, name: photo_source }, }, target_image: { s3_object: { bucket: bucket, name: photo_target }, }, similarity_threshold: 70 } response = client.compare_faces attrs response.face_matches.each do |face_match| position = face_match.face.bounding_box similarity = face_match.similarity puts "The face at: #{position.left}, #{position.top} matches with #{similarity} % confidence" end ``` ------ #### [ Node.js ] Este ejemplo muestra información sobre rostros coincidentes de las imágenes de origen y de destino que se cargan desde el sistema de archivos local. Reemplace los valores de `photo_source` y `photo_target` por la ruta y el nombre de archivo de las imágenes de origen y de destino. 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. ``` // Load the SDK var AWS = require('aws-sdk'); const bucket = 'bucket-name' // the bucket name without s3:// const photo_source = 'photo-source-name' // path and the name of file const photo_target = 'photo-target-name' var credentials = new AWS.SharedIniFileCredentials({profile: 'profile-name'}); AWS.config.credentials = credentials; AWS.config.update({region:'region-name'}); const client = new AWS.Rekognition(); const params = { SourceImage: { S3Object: { Bucket: bucket, Name: photo_source }, }, TargetImage: { S3Object: { Bucket: bucket, Name: photo_target }, }, SimilarityThreshold: 70 } client.compareFaces(params, function(err, response) { if (err) { console.log(err, err.stack); // an error occurred } else { response.FaceMatches.forEach(data => { let position = data.Face.BoundingBox let similarity = data.Similarity console.log(`The face at: ${position.Left}, ${position.Top} matches with ${similarity} % confidence`) }) // for response.faceDetails } // if }); ``` ------ ## CompareFaces solicitud de operación La entrada de `CompareFaces` es una imagen. En este ejemplo, las imágenes de origen y destino se cargan desde el sistema de archivos local. El parámetro `SimilarityThreshold` de entrada especifica el mínimo de confianza que la comparación de rostros debe tener para incluirse en la respuesta. Para obtener más información, consulte [Trabajar con imágenes](images.md). ``` { "SourceImage": { "Bytes": "/9j/4AAQSk2Q==..." }, "TargetImage": { "Bytes": "/9j/4O1Q==..." }, "SimilarityThreshold": 70 } ``` ## CompareFaces respuesta de operación La respuesta incluye: + Una matriz de los rostros coincidentes: una lista de los rostros coincidentes con puntuaciones de similitud y metadatos para cada uno de ellos. Si coinciden varios rostros, la matriz `faceMatches` incluye todos los rostros coincidentes. + Detalles de la coincidencia de rostros: con cada rostro coincidente se proporciona también un cuadro delimitador, un valor de confianza, ubicaciones de referencia y una puntuación de similitud. + Lista de rostros sin coincidencias: la respuesta también incluye los rostros de la imagen de destino que no coinciden con el rostro de la imagen de origen. Incluye un cuadro delimitador para cada rostro sin coincidencia. + Información del rostro de origen: incluye información sobre el rostro de la imagen de origen que se ha utilizado para la comparación, incluido el cuadro delimitador y el valor de confianza. El ejemplo muestra que se ha encontrado una coincidencia de rostro en la imagen de destino. Para esa coincidencia de rostro, proporciona un cuadro delimitador y un valor de confianza (el nivel de confianza que tiene Amazon Rekognition de que el cuadro delimitador contenga un rostro). La puntuación de similitud de 99,99 indica la similitud entre los rostros. El ejemplo también muestra un rostro que Amazon Rekognition ha encontrado en la imagen de destino y que no coincide con el rostro analizado en la imagen de origen. ``` { "FaceMatches": [{ "Face": { "BoundingBox": { "Width": 0.5521978139877319, "Top": 0.1203877404332161, "Left": 0.23626373708248138, "Height": 0.3126954436302185 }, "Confidence": 99.98751068115234, "Pose": { "Yaw": -82.36799621582031, "Roll": -62.13221740722656, "Pitch": 0.8652129173278809 }, "Quality": { "Sharpness": 99.99880981445312, "Brightness": 54.49755096435547 }, "Landmarks": [{ "Y": 0.2996366024017334, "X": 0.41685718297958374, "Type": "eyeLeft" }, { "Y": 0.2658946216106415, "X": 0.4414493441581726, "Type": "eyeRight" }, { "Y": 0.3465650677680969, "X": 0.48636093735694885, "Type": "nose" }, { "Y": 0.30935320258140564, "X": 0.6251809000968933, "Type": "mouthLeft" }, { "Y": 0.26942989230155945, "X": 0.6454493403434753, "Type": "mouthRight" } ] }, "Similarity": 100.0 }], "SourceImageOrientationCorrection": "ROTATE_90", "TargetImageOrientationCorrection": "ROTATE_90", "UnmatchedFaces": [{ "BoundingBox": { "Width": 0.4890109896659851, "Top": 0.6566604375839233, "Left": 0.10989011079072952, "Height": 0.278298944234848 }, "Confidence": 99.99992370605469, "Pose": { "Yaw": 51.51519012451172, "Roll": -110.32493591308594, "Pitch": -2.322134017944336 }, "Quality": { "Sharpness": 99.99671173095703, "Brightness": 57.23163986206055 }, "Landmarks": [{ "Y": 0.8288310766220093, "X": 0.3133862614631653, "Type": "eyeLeft" }, { "Y": 0.7632885575294495, "X": 0.28091415762901306, "Type": "eyeRight" }, { "Y": 0.7417283654212952, "X": 0.3631140887737274, "Type": "nose" }, { "Y": 0.8081989884376526, "X": 0.48565614223480225, "Type": "mouthLeft" }, { "Y": 0.7548204660415649, "X": 0.46090251207351685, "Type": "mouthRight" } ] }], "SourceImageFace": { "BoundingBox": { "Width": 0.5521978139877319, "Top": 0.1203877404332161, "Left": 0.23626373708248138, "Height": 0.3126954436302185 }, "Confidence": 99.98751068115234 } } ``` # Detección de rostros en un vídeo almacenado Amazon Rekognition Video puede detectar rostros en vídeos almacenados en un bucket de Amazon S3 y proporcionar información como: + Las veces que los rostros se detectan en un vídeo. + La ubicación de los rostros en un fotograma de vídeo a la hora en la que se detectan. + Referencias faciales como, por ejemplo, la posición del ojo izquierdo. + Atributos adicionales, tal y como se explica en la página [Directrices sobre los atributos faciales](guidance-face-attributes.md). La detección de rostros de Amazon Rekognition Video en vídeos almacenados una operación asíncrona. Para iniciar la detección de rostros en los videos, llame [StartFaceDetection](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_StartFaceDetection.html). Amazon Rekognition Video publica el estado de finalización de una operación de análisis de vídeo en un tema de Amazon Simple Notification Service (Amazon SNS). Si el análisis de vídeo es correcto, puede llamar a [GetFaceDetection](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_GetFaceDetection.html) para obtener los resultados del análisis de vídeo. Para obtener más información sobre cómo iniciar el análisis de vídeo y obtener los resultados, consulte [Cómo llamar a las operaciones de Amazon Rekognition Video](api-video.md). Este procedimiento amplía el código de [Análisis de un vídeo almacenado en un bucket de Amazon S3 con Java o Python (SDK)](video-analyzing-with-sqs.md), que utiliza una cola de Amazon Simple Queue Service (Amazon SQS) para obtener el estado de realización de una solicitud de análisis de vídeo. **Para detectar rostros en un vídeo almacenado en un bucket de Amazon S3 (SDK)** 1. Realice [Análisis de un vídeo almacenado en un bucket de Amazon S3 con Java o Python (SDK)](video-analyzing-with-sqs.md). 1. Añada el código siguiente a la clase `VideoDetect` que ha creado en el paso 1. ------ #### [ AWS CLI ] + En el siguiente ejemplo de código, cambie `amzn-s3-demo-bucket` y `video-name` por el nombre del bucket de Amazon S3 y el nombre de archivo que especificó en el paso 2. + Cambie `region-name` por la región de AWS que está utilizando. Sustituya el valor de `profile_name` de por el nombre de su perfil de desarrollador. + Reemplace `TopicARN` por el ARN del tema de Amazon SNS que creó en el paso 3 de [Configuración de Amazon Rekognition Video](api-video-roles.md). + Cambie `RoleARN` por el ARN del rol de servicio de IAM que creó en el paso 7 de [Configuración de Amazon Rekognition Video](api-video-roles.md). ``` aws rekognition start-face-detection --video "{"S3Object":{"Bucket":"amzn-s3-demo-bucket","Name":"Video-Name"}}" --notification-channel "{"SNSTopicArn":"Topic-ARN","RoleArn":"Role-ARN"}" --region region-name --profile profile-name ``` Si accede a la CLI en un dispositivo Windows, utilice comillas dobles en lugar de comillas simples y evite las comillas dobles internas con una barra invertida (es decir, \$1) para corregir cualquier error del analizador que pueda encontrar. Por ver un ejemplo, consulte lo siguiente: ``` aws rekognition start-face-detection --video "{\"S3Object\":{\"Bucket\":\"amzn-s3-demo-bucket\",\"Name\":\"Video-Name\"}}" --notification-channel "{\"SNSTopicArn\":\"Topic-ARN\",\"RoleArn\":\"Role-ARN\"}" --region region-name --profile profile-name ``` Tras ejecutar la operación `StartFaceDetection` y obtener el número de ID del trabajo, ejecute la siguiente operación `GetFaceDetection` e indique el número de ID del trabajo: ``` aws rekognition get-face-detection --job-id job-id-number --profile profile-name ``` ------ #### [ Java ] ``` //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.) private static void StartFaceDetection(String bucket, String video) throws Exception{ NotificationChannel channel= new NotificationChannel() .withSNSTopicArn(snsTopicArn) .withRoleArn(roleArn); StartFaceDetectionRequest req = new StartFaceDetectionRequest() .withVideo(new Video() .withS3Object(new S3Object() .withBucket(bucket) .withName(video))) .withNotificationChannel(channel); StartFaceDetectionResult startLabelDetectionResult = rek.startFaceDetection(req); startJobId=startLabelDetectionResult.getJobId(); } private static void GetFaceDetectionResults() throws Exception{ int maxResults=10; String paginationToken=null; GetFaceDetectionResult faceDetectionResult=null; do{ if (faceDetectionResult !=null){ paginationToken = faceDetectionResult.getNextToken(); } faceDetectionResult = rek.getFaceDetection(new GetFaceDetectionRequest() .withJobId(startJobId) .withNextToken(paginationToken) .withMaxResults(maxResults)); VideoMetadata videoMetaData=faceDetectionResult.getVideoMetadata(); System.out.println("Format: " + videoMetaData.getFormat()); System.out.println("Codec: " + videoMetaData.getCodec()); System.out.println("Duration: " + videoMetaData.getDurationMillis()); System.out.println("FrameRate: " + videoMetaData.getFrameRate()); //Show faces, confidence and detection times List faces= faceDetectionResult.getFaces(); for (FaceDetection face: faces) { long seconds=face.getTimestamp()/1000; System.out.print("Sec: " + Long.toString(seconds) + " "); System.out.println(face.getFace().toString()); System.out.println(); } } while (faceDetectionResult !=null && faceDetectionResult.getNextToken() != null); } ``` En la función `main`, reemplace las líneas: ``` StartLabelDetection(amzn-s3-demo-bucket, video); if (GetSQSMessageSuccess()==true) GetLabelDetectionResults(); ``` por: ``` StartFaceDetection(amzn-s3-demo-bucket, video); if (GetSQSMessageSuccess()==true) GetFaceDetectionResults(); ``` ------ #### [ 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/VideoDetectFaces.java). ``` //snippet-start:[rekognition.java2.recognize_video_faces.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.*; import java.util.List; //snippet-end:[rekognition.java2.recognize_video_faces.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 VideoDetectFaces { private static String startJobId =""; public static void main(String[] args) { final String usage = "\n" + "Usage: " + "