SearchFacesByImage solicitação de operação SearchFacesByImage resposta da operação

Procurando um rosto com uma imagem

Você pode usar a SearchFacesByImageoperação para pesquisar faces em uma coleção que correspondam à maior face em uma imagem fornecida.

Para obter mais informações, consulte Pesquisa de faces e usuários em uma coleção.

Para pesquisar um rosto em uma coleção usando uma imagem (SDK)

Se ainda não tiver feito isso:
1. Crie ou atualize um usuário com permissões AmazonRekognitionFullAccess e AmazonS3ReadOnlyAccess. Para obter mais informações, consulte Etapa 1: configurar uma AWS conta e criar um usuário.
2. Instale e configure o AWS CLI e AWS SDKs o. Para obter mais informações, consulte Etapa 2: configurar o AWS CLI e AWS SDKs.
Carregue uma imagem (que contenha uma ou mais faces) no bucket do S3.

Para obter instruções, consulte Como fazer upload de objetos no Amazon S3 no Guia do usuário do Amazon Simple Storage Service.

Use os exemplos a seguir para chamar a operação SearchFacesByImage.

Java

Este exemplo exibe informações sobre faces correspondentes à maior face em uma imagem. O exemplo de código especifica os parâmetros FaceMatchThreshold e MaxFaces para limitar os resultados retornados na resposta.

No exemplo a seguir, altere o seguinte: altere o valor de collectionId para a coleção que você deseja pesquisar, altere o valor de bucket para o bucket que contém a imagem de entrada e altere o valor de photo para a imagem de entrada.


//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.FaceMatch;
import com.amazonaws.services.rekognition.model.Image;
import com.amazonaws.services.rekognition.model.S3Object;
import com.amazonaws.services.rekognition.model.SearchFacesByImageRequest;
import com.amazonaws.services.rekognition.model.SearchFacesByImageResult;
import java.util.List;
import com.fasterxml.jackson.databind.ObjectMapper;


public class SearchFaceMatchingImageCollection {
    public static final String collectionId = "MyCollection";
    public static final String bucket = "bucket";
    public static final String photo = "input.jpg";
      
    public static void main(String[] args) throws Exception {

       AmazonRekognition rekognitionClient = AmazonRekognitionClientBuilder.defaultClient();
        
      ObjectMapper objectMapper = new ObjectMapper();
      
       // Get an image object from S3 bucket.
      Image image=new Image()
              .withS3Object(new S3Object()
                      .withBucket(bucket)
                      .withName(photo));
      
      // Search collection for faces similar to the largest face in the image.
      SearchFacesByImageRequest searchFacesByImageRequest = new SearchFacesByImageRequest()
              .withCollectionId(collectionId)
              .withImage(image)
              .withFaceMatchThreshold(70F)
              .withMaxFaces(2);
           
       SearchFacesByImageResult searchFacesByImageResult = 
               rekognitionClient.searchFacesByImage(searchFacesByImageRequest);

       System.out.println("Faces matching largest face in image from" + photo);
      List < FaceMatch > faceImageMatches = searchFacesByImageResult.getFaceMatches();
      for (FaceMatch face: faceImageMatches) {
          System.out.println(objectMapper.writerWithDefaultPrettyPrinter()
                  .writeValueAsString(face));
         System.out.println();
      }
   }
}

Java V2

Esse código foi retirado do GitHub repositório de SDK exemplos de AWS documentação. Veja o exemplo completo aqui.


// snippet-start:[rekognition.java2.search_faces_collection.import]
import software.amazon.awssdk.auth.credentials.ProfileCredentialsProvider;
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.RekognitionException;
import software.amazon.awssdk.services.rekognition.model.SearchFacesByImageRequest;
import software.amazon.awssdk.services.rekognition.model.Image;
import software.amazon.awssdk.services.rekognition.model.SearchFacesByImageResponse;
import software.amazon.awssdk.services.rekognition.model.FaceMatch;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.util.List;
// snippet-end:[rekognition.java2.search_faces_collection.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 SearchFaceMatchingImageCollection {

    public static void main(String[] args) {

        final String usage = "\n" +
            "Usage: " +
            "   <collectionId> <sourceImage>\n\n" +
            "Where:\n" +
            "   collectionId - The id of the collection.  \n" +
            "   sourceImage - The path to the image (for example, C:\\AWS\\pic1.png). \n\n";

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

        String collectionId = args[0];
        String sourceImage = args[1];
        Region region = Region.US_EAST_1;
        RekognitionClient rekClient = RekognitionClient.builder()
            .region(region)
            .credentialsProvider(ProfileCredentialsProvider.create("profile-name"))
            .build();

        System.out.println("Searching for a face in a collections");
        searchFaceInCollection(rekClient, collectionId, sourceImage ) ;
        rekClient.close();
    }

    // snippet-start:[rekognition.java2.search_faces_collection.main]
    public static void searchFaceInCollection(RekognitionClient rekClient,String collectionId, String sourceImage) {

        try {
            InputStream sourceStream = new FileInputStream(new File(sourceImage));
            SdkBytes sourceBytes = SdkBytes.fromInputStream(sourceStream);
            Image souImage = Image.builder()
                .bytes(sourceBytes)
                .build();

            SearchFacesByImageRequest facesByImageRequest = SearchFacesByImageRequest.builder()
                .image(souImage)
                .maxFaces(10)
                .faceMatchThreshold(70F)
                .collectionId(collectionId)
                .build();

            SearchFacesByImageResponse imageResponse = rekClient.searchFacesByImage(facesByImageRequest) ;
            System.out.println("Faces matching in the collection");
            List<FaceMatch> faceImageMatches = imageResponse.faceMatches();
            for (FaceMatch face: faceImageMatches) {
                System.out.println("The similarity level is  "+face.similarity());
                System.out.println();
            }

        } catch (RekognitionException | FileNotFoundException e) {
            System.out.println(e.getMessage());
            System.exit(1);
        }
    }
    // snippet-end:[rekognition.java2.search_faces_collection.main]
}

AWS CLI

Esse AWS CLI comando exibe a JSON saída da search-faces-by-image CLI operação. Substitua o valor de Bucket pelo bucket do S3 usado na etapa 2. Substitua o valor de Name pelo nome de arquivo da imagem usado na etapa 2. Substitua o valor de collection-id pela coleção na qual você deseja pesquisar. Substitua o valor de profile_name na linha que cria a sessão do Rekognition pelo nome do seu perfil de desenvolvedor.



aws rekognition search-faces-by-image --image '{"S3Object":{"Bucket":"bucket-name","Name":"image-name"}}' \
--collection-id "collection-id" --profile profile-name

Se você estiver acessando o CLI em um dispositivo Windows, use aspas duplas em vez de aspas simples e escape das aspas duplas internas usando barra invertida (ou seja,\) para solucionar quaisquer erros do analisador que você possa encontrar. Para obter um exemplo, veja o seguinte:


aws rekognition search-faces-by-image --image "{\"S3Object\":{\"Bucket\":\"bucket-name\",\"Name\":\"image-name\"}}" \
--collection-id "collection-id" --profile profile-name

Python

No exemplo a seguir, altere o seguinte: altere o valor da coleção collectionId que você deseja pesquisar e substitua os valores de bucket e photo pelos nomes do bucket e da imagem do Amazon S3 que você usou na etapa 2. Substitua o valor de profile_name na linha que cria a sessão do Rekognition pelo nome do seu perfil de desenvolvedor.


#Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
#PDX-License-Identifier: MIT-0 (For details, see https://github.com/awsdocs/amazon-rekognition-developer-guide/blob/master/LICENSE-SAMPLECODE.)

import boto3

if __name__ == "__main__":

    bucket='bucket'
    collectionId='MyCollection'
    fileName='input.jpg'
    threshold = 70
    maxFaces=2

    client=boto3.client('rekognition')

  
    response=client.search_faces_by_image(CollectionId=collectionId,
                                Image={'S3Object':{'Bucket':bucket,'Name':fileName}},
                                FaceMatchThreshold=threshold,
                                MaxFaces=maxFaces)

                                
    faceMatches=response['FaceMatches']
    print ('Matching faces')
    for match in faceMatches:
            print ('FaceId:' + match['Face']['FaceId'])
            print ('Similarity: ' + "{:.2f}".format(match['Similarity']) + "%")
            print

.NET


//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 SearchFacesMatchingImage
{
    public static void Example()
    {
        String collectionId = "MyCollection";
        String bucket = "bucket";
        String photo = "input.jpg";

        AmazonRekognitionClient rekognitionClient = new AmazonRekognitionClient();

        // Get an image object from S3 bucket.
        Image image = new Image()
        {
            S3Object = new S3Object()
            {
                Bucket = bucket,
                Name = photo
            }
        };

        SearchFacesByImageRequest searchFacesByImageRequest = new SearchFacesByImageRequest()
        {
            CollectionId = collectionId,
            Image = image,
            FaceMatchThreshold = 70F,
            MaxFaces = 2
        };

        SearchFacesByImageResponse searchFacesByImageResponse = rekognitionClient.SearchFacesByImage(searchFacesByImageRequest);

        Console.WriteLine("Faces matching largest face in image from " + photo);
        foreach (FaceMatch face in searchFacesByImageResponse.FaceMatches)
            Console.WriteLine("FaceId: " + face.Face.FaceId + ", Similarity: " + face.Similarity);
    }
}

SearchFacesByImage solicitação de operação

Os parâmetros de entrada SearchFacesImageByImage são a coleção para pesquisa e o local da imagem de origem. Neste exemplo, a imagem de origem é armazenada em um bucket do Amazon S3 (S3Object). Também especificados estão o número máximo de faces a serem retornadas (Maxfaces) e o mínimo de confiança que deve ser correspondido para uma face ser retornada (FaceMatchThreshold).


{
    "CollectionId": "MyCollection",
    "Image": {
        "S3Object": {
            "Bucket": "bucket",
            "Name": "input.jpg"
        }
    },
    "MaxFaces": 2,
    "FaceMatchThreshold": 99
}

SearchFacesByImage resposta da operação

Dada uma determinada imagem de entrada (.jpeg ou .png), a operação primeiro detecta a face na imagem de entrada e, em seguida, pesquisa faces semelhantes na coleção de faces especificada.

nota

Se detectar várias faces na imagem de entrada, o serviço usará a maior face detectada para pesquisar a coleção de faces.

A operação retorna uma matriz de correspondências de face encontradas e informações sobre a face de entrada. Isso inclui informações como a caixa delimitadora, além do valor que indica o nível de confiança da caixa delimitadora que contém uma face.

Por padrão, SearchFacesByImage retorna faces nas quais o algoritmo detecta semelhança maior que 80%. A semelhança indica o nível de proximidade da face com a face de entrada. Você também pode usar FaceMatchThreshold para especificar um valor diferente. Para cada correspondência de face encontrada, a resposta inclui metadados de semelhança e face, conforme mostrado na seguinte resposta de exemplo:


{
    "FaceMatches": [
        {
            "Face": {
                "BoundingBox": {
                    "Height": 0.06333330273628235,
                    "Left": 0.1718519926071167,
                    "Top": 0.7366669774055481,
                    "Width": 0.11061699688434601
                },
                "Confidence": 100,
                "ExternalImageId": "input.jpg",
                "FaceId": "578e2e1b-d0b0-493c-aa39-ba476a421a34",
                "ImageId": "9ba38e68-35b6-5509-9d2e-fcffa75d1653"
            },
            "Similarity": 99.9764175415039
        }
    ],
    "FaceModelVersion": "3.0",
    "SearchedFaceBoundingBox": {
        "Height": 0.06333333253860474,
        "Left": 0.17185185849666595,
        "Top": 0.7366666793823242,
        "Width": 0.11061728745698929
    },
    "SearchedFaceConfidence": 99.99999237060547
}

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Procurando por uma face (ID facial)

Pesquisando usuários (ID facial/ID de usuário)