SearchFacesByImage richiesta di operazione SearchFacesByImage risposta operativa

Ricerca di un volto tramite immagine

È possibile utilizzare l'operazione SearchFacesByImage per cercare i volti in una raccolta che corrispondono al volto più grande in un'immagine fornita.

Per ulteriori informazioni, consulta Ricerca di volti e utenti all'interno di una raccolta.

Per cercare un volto in una raccolta utilizzando un'immagine (SDK)

Se non lo si è già fatto:
1. Crea o aggiorna un utente con le autorizzazioni AmazonRekognitionFullAccess e AmazonS3ReadOnlyAccess. Per ulteriori informazioni, consulta Fase 1: impostazione di un account AWS e creazione di un utente.
2. Installa e configura gli AWS CLI AWS SDK. Per ulteriori informazioni, consulta Fase 2: configurazione di AWS CLI e SDK AWS.
Carica un'immagine (contenente uno o più volti) nel bucket S3.

Per le istruzioni, consulta Caricamento di oggetti in Amazon S3 nella Guida per l'utente di Amazon Simple Storage Service.

Utilizzare i seguenti esempi per richiamare l'operazione SearchFacesByImage.

Java

In questo esempio vengono visualizzate le informazioni relative ai volti che corrispondono al volto più grande in un'immagine. L'esempio di codice specifica i parametri FaceMatchThreshold e MaxFaces per limitare i risultati restituiti nella risposta.

Nel seguente esempio, modifica quanto segue: il valore di collectionId per la raccolta da ricercare, il valore di bucket nel bucket contenente l'immagine di input e il valore di photo nell'immagine di input.


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

Questo codice è tratto dal repository degli esempi GitHub di AWS Documentation SDK. Guarda l'esempio completo qui.


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

Questo AWS CLI comando visualizza l'output JSON per l'operazione search-faces-by-image CLI. Sostituisci il valore di Bucket con il bucket S3 utilizzato nella fase 2. Sostituisci il valore di Name con il nome del file delle immagini utilizzato nella fase 2. Sostituisci il valore di collection-id con il nome della raccolta in cui eseguire la ricerca. Sostituisci il valore di profile_name nella riga che crea la sessione di Rekognition con il nome del tuo profilo di sviluppatore.



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

Se accedi alla CLI da un dispositivo Windows, usa le virgolette doppie anziché le virgolette singole ed evita le virgolette doppie interne tramite barra rovesciata (ovvero, \) per risolvere eventuali errori del parser che potresti riscontrare. Per un esempio, consulta quanto segue:


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

Python

Nel seguente esempio, effettua queste operazioni: modifica il valore di collectionId per la raccolta da ricercare e sostituisci i valori di bucket e photo con i nomi del bucket Amazon S3 e dell'immagine utilizzati nella fase 2. Sostituisci il valore di profile_name nella riga che crea la sessione di Rekognition con il nome del tuo profilo di sviluppatore.


#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 richiesta di operazione

I parametri di input per SearchFacesImageByImage sono la raccolta in cui eseguire la ricerca e l'ubicazione dell'immagine di origine. In questo esempio, l'immagine di origine è archiviata in un bucket Amazon S3 (S3Object). Sono specificati anche il numero massimo di volti da restituire (Maxfaces) e l'affidabilità minima che deve corrispondere a un volto affinché venga restituito (FaceMatchThreshold).


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

SearchFacesByImage risposta operativa

Fornita un'immagine di input (.jpeg or .png), l'operazione rileva prima il volto nell'immagine di input, quindi ricerca nella raccolta specificata i volti simili.

Nota

Se il servizio rileva più volti nell'immagine di input, per la ricerca nella raccolta utilizza il volto più grande rilevato.

L'operazione restituisce una matrice di corrispondenze di volti e le informazioni relative al volto di input. Le informazioni includono il riquadro di delimitazione, insieme al valore di affidabilità, che indica il livello di affidabilità relativo al fatto che il riquadro di delimitazione contenga un volto.

Per impostazione predefinita, SearchFacesByImage restituisce volti per cui l'algoritmo rileva una somiglianza superiore all'80%. La somiglianza indica il livello di corrispondenza del volto con il volto di input. È possibile utilizzare FaceMatchThreshold per specificare un valore diverso. Per ogni corrispondenza di volto trovata, la risposta include la somiglianza e i metadati del volto, come indicato nella risposta di esempio seguente:


{
    "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
}

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Ricerca di un volto (ID volto)

Ricerca di utenti (ID volto/ ID utente)