Criação do processador de stream de pesquisa facial Amazon Rekognition Video Iniciando o processador de stream de pesquisa facial do Amazon Rekognition Video Usando processadores de stream para pesquisa facial (exemplo de Java V2)Usando processadores de stream para pesquisa facial (exemplo de Java V1)

Pesquisanda faces em um streaming de vídeo

O Amazon Rekognition Video pode pesquisar faces em uma coleção que correspondam às faces detectadas em um vídeo de streaming. Para obter mais informações sobre coleções, consulte Pesquisa de faces em uma coleção.

Tópicos

Criação do processador de stream de pesquisa facial Amazon Rekognition Video
Iniciando o processador de stream de pesquisa facial do Amazon Rekognition Video
Usando processadores de stream para pesquisa facial (exemplo de Java V2)
Usando processadores de stream para pesquisa facial (exemplo de Java V1)
Lendo os resultados da análise de streaming de vídeo
Referência: Registro de reconhecimento facial do Kinesis

O diagrama a seguir mostra como o Amazon Rekognition Video detecta e reconhece faces em um streaming de vídeo.

Diagrama do fluxo de trabalho para usar o Amazon Rekognition Video para processar streams de vídeo do Amazon Kinesis.

Criação do processador de stream de pesquisa facial Amazon Rekognition Video

Antes de poder analisar um streaming de vídeo, você cria um processador de streaming de vídeo Amazon Rekognition Video (). CreateStreamProcessor O processador de stream contém informações sobre o fluxo de dados do Kinesis e o stream de vídeo do Kinesis. Ele também contém o identificador para a coleção que contém as faces que você deseja reconhecer no streaming de vídeo de entrada. Você também especifica um nome para o processador de fluxo. Veja a seguir um exemplo de JSON para a solicitação CreateStreamProcessor.


{
       "Name": "streamProcessorForCam",
       "Input": {
              "KinesisVideoStream": {
                     "Arn": "arn:aws:kinesisvideo:us-east-1:nnnnnnnnnnnn:stream/inputVideo"
              }
       },
       "Output": {
              "KinesisDataStream": {
                     "Arn": "arn:aws:kinesis:us-east-1:nnnnnnnnnnnn:stream/outputData"
              }
       },
       "RoleArn": "arn:aws:iam::nnnnnnnnnnn:role/roleWithKinesisPermission",
       "Settings": {
              "FaceSearch": {
                     "CollectionId": "collection-with-100-faces",
                     "FaceMatchThreshold": 85.5
              }
       }
}

Esta é uma resposta de exemplo de CreateStreamProcessor.


{
       “StreamProcessorArn”: “arn:aws:rekognition:us-east-1:nnnnnnnnnnnn:streamprocessor/streamProcessorForCam”
}

Iniciando o processador de stream de pesquisa facial do Amazon Rekognition Video

Você começa a analisar o streaming de vídeo ligando StartStreamProcessorcom o nome do processador de streaming especificado emCreateStreamProcessor. Veja a seguir um exemplo de JSON para a solicitação StartStreamProcessor.


{
       "Name": "streamProcessorForCam"
}

Se o processador de fluxo iniciar com êxito, uma resposta HTTP 200 é retornada, junto com um corpo JSON vazio.

Usando processadores de stream para pesquisa facial (exemplo de Java V2)

O código de exemplo a seguir mostra como chamar várias operações do processador de stream, como CreateStreamProcessore StartStreamProcessor, usando o AWS SDK for Java versão 2.

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


import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.rekognition.RekognitionClient;
import software.amazon.awssdk.services.rekognition.model.CreateStreamProcessorRequest;
import software.amazon.awssdk.services.rekognition.model.CreateStreamProcessorResponse;
import software.amazon.awssdk.services.rekognition.model.FaceSearchSettings;
import software.amazon.awssdk.services.rekognition.model.KinesisDataStream;
import software.amazon.awssdk.services.rekognition.model.KinesisVideoStream;
import software.amazon.awssdk.services.rekognition.model.ListStreamProcessorsRequest;
import software.amazon.awssdk.services.rekognition.model.ListStreamProcessorsResponse;
import software.amazon.awssdk.services.rekognition.model.RekognitionException;
import software.amazon.awssdk.services.rekognition.model.StreamProcessor;
import software.amazon.awssdk.services.rekognition.model.StreamProcessorInput;
import software.amazon.awssdk.services.rekognition.model.StreamProcessorSettings;
import software.amazon.awssdk.services.rekognition.model.StreamProcessorOutput;
import software.amazon.awssdk.services.rekognition.model.StartStreamProcessorRequest;
import software.amazon.awssdk.services.rekognition.model.DescribeStreamProcessorRequest;
import software.amazon.awssdk.services.rekognition.model.DescribeStreamProcessorResponse;

/**
 * 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 CreateStreamProcessor {
        public static void main(String[] args) {
                final String usage = """

                                Usage:    <role> <kinInputStream> <kinOutputStream> <collectionName> <StreamProcessorName>

                                Where:
                                   role - The ARN of the AWS Identity and Access Management (IAM) role to use. \s
                                   kinInputStream - The ARN of the Kinesis video stream.\s
                                   kinOutputStream - The ARN of the Kinesis data stream.\s
                                   collectionName - The name of the collection to use that contains content. \s
                                   StreamProcessorName - The name of the Stream Processor. \s
                                """;

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

                String role = args[0];
                String kinInputStream = args[1];
                String kinOutputStream = args[2];
                String collectionName = args[3];
                String streamProcessorName = args[4];

                Region region = Region.US_EAST_1;
                RekognitionClient rekClient = RekognitionClient.builder()
                                .region(region)
                                .build();

                processCollection(rekClient, streamProcessorName, kinInputStream, kinOutputStream, collectionName,
                                role);
                startSpecificStreamProcessor(rekClient, streamProcessorName);
                listStreamProcessors(rekClient);
                describeStreamProcessor(rekClient, streamProcessorName);
                deleteSpecificStreamProcessor(rekClient, streamProcessorName);
        }

        public static void listStreamProcessors(RekognitionClient rekClient) {
                ListStreamProcessorsRequest request = ListStreamProcessorsRequest.builder()
                                .maxResults(15)
                                .build();

                ListStreamProcessorsResponse listStreamProcessorsResult = rekClient.listStreamProcessors(request);
                for (StreamProcessor streamProcessor : listStreamProcessorsResult.streamProcessors()) {
                        System.out.println("StreamProcessor name - " + streamProcessor.name());
                        System.out.println("Status - " + streamProcessor.status());
                }
        }

        private static void describeStreamProcessor(RekognitionClient rekClient, String StreamProcessorName) {
                DescribeStreamProcessorRequest streamProcessorRequest = DescribeStreamProcessorRequest.builder()
                                .name(StreamProcessorName)
                                .build();

                DescribeStreamProcessorResponse describeStreamProcessorResult = rekClient
                                .describeStreamProcessor(streamProcessorRequest);
                System.out.println("Arn - " + describeStreamProcessorResult.streamProcessorArn());
                System.out.println("Input kinesisVideo stream - "
                                + describeStreamProcessorResult.input().kinesisVideoStream().arn());
                System.out.println("Output kinesisData stream - "
                                + describeStreamProcessorResult.output().kinesisDataStream().arn());
                System.out.println("RoleArn - " + describeStreamProcessorResult.roleArn());
                System.out.println(
                                "CollectionId - "
                                                + describeStreamProcessorResult.settings().faceSearch().collectionId());
                System.out.println("Status - " + describeStreamProcessorResult.status());
                System.out.println("Status message - " + describeStreamProcessorResult.statusMessage());
                System.out.println("Creation timestamp - " + describeStreamProcessorResult.creationTimestamp());
                System.out.println("Last update timestamp - " + describeStreamProcessorResult.lastUpdateTimestamp());
        }

        private static void startSpecificStreamProcessor(RekognitionClient rekClient, String StreamProcessorName) {
                try {
                        StartStreamProcessorRequest streamProcessorRequest = StartStreamProcessorRequest.builder()
                                        .name(StreamProcessorName)
                                        .build();

                        rekClient.startStreamProcessor(streamProcessorRequest);
                        System.out.println("Stream Processor " + StreamProcessorName + " started.");

                } catch (RekognitionException e) {
                        System.out.println(e.getMessage());
                        System.exit(1);
                }
        }

        private static void processCollection(RekognitionClient rekClient, String StreamProcessorName,
                        String kinInputStream, String kinOutputStream, String collectionName, String role) {
                try {
                        KinesisVideoStream videoStream = KinesisVideoStream.builder()
                                        .arn(kinInputStream)
                                        .build();

                        KinesisDataStream dataStream = KinesisDataStream.builder()
                                        .arn(kinOutputStream)
                                        .build();

                        StreamProcessorOutput processorOutput = StreamProcessorOutput.builder()
                                        .kinesisDataStream(dataStream)
                                        .build();

                        StreamProcessorInput processorInput = StreamProcessorInput.builder()
                                        .kinesisVideoStream(videoStream)
                                        .build();

                        FaceSearchSettings searchSettings = FaceSearchSettings.builder()
                                        .faceMatchThreshold(75f)
                                        .collectionId(collectionName)
                                        .build();

                        StreamProcessorSettings processorSettings = StreamProcessorSettings.builder()
                                        .faceSearch(searchSettings)
                                        .build();

                        CreateStreamProcessorRequest processorRequest = CreateStreamProcessorRequest.builder()
                                        .name(StreamProcessorName)
                                        .input(processorInput)
                                        .output(processorOutput)
                                        .roleArn(role)
                                        .settings(processorSettings)
                                        .build();

                        CreateStreamProcessorResponse response = rekClient.createStreamProcessor(processorRequest);
                        System.out.println("The ARN for the newly create stream processor is "
                                        + response.streamProcessorArn());

                } catch (RekognitionException e) {
                        System.out.println(e.getMessage());
                        System.exit(1);
                }
        }

        private static void deleteSpecificStreamProcessor(RekognitionClient rekClient, String StreamProcessorName) {
                rekClient.stopStreamProcessor(a -> a.name(StreamProcessorName));
                rekClient.deleteStreamProcessor(a -> a.name(StreamProcessorName));
                System.out.println("Stream Processor " + StreamProcessorName + " deleted.");
        }
}

Usando processadores de stream para pesquisa facial (exemplo de Java V1)

O código de exemplo a seguir mostra como chamar várias operações do processador de fluxo, como CreateStreamProcessore StartStreamProcessor, usando o Java V1. O exemplo inclui uma classe de gerenciador de processador de fluxo (StreamManager) que fornece métodos para chamar operações do processador de fluxo. A classe inicial (Starter) cria um StreamManager objeto e chama várias operações.

Para configurar o exemplo:

Defina os valores dos campos de membro de classe Starter para seus valores desejados.
Na função de classe Starter main, exclua a função chamada de função desejada.

Classe inicial


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

// Starter class. Use to create a StreamManager class
// and call stream processor operations.
package com.amazonaws.samples;
import com.amazonaws.samples.*;

public class Starter {

	public static void main(String[] args) {
		
		
    	String streamProcessorName="Stream Processor Name";
    	String kinesisVideoStreamArn="Kinesis Video Stream Arn";
    	String kinesisDataStreamArn="Kinesis Data Stream Arn";
    	String roleArn="Role Arn";
    	String collectionId="Collection ID";
    	Float matchThreshold=50F;

		try {
			StreamManager sm= new StreamManager(streamProcessorName,
					kinesisVideoStreamArn,
					kinesisDataStreamArn,
					roleArn,
					collectionId,
					matchThreshold);
			//sm.createStreamProcessor();
			//sm.startStreamProcessor();
			//sm.deleteStreamProcessor();
			//sm.deleteStreamProcessor();
			//sm.stopStreamProcessor();
			//sm.listStreamProcessors();
			//sm.describeStreamProcessor();
		}
		catch(Exception e){
			System.out.println(e.getMessage());
		}
	}
}

StreamManager classe


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

// Stream manager class. Provides methods for calling
// Stream Processor operations.
package com.amazonaws.samples;

import com.amazonaws.services.rekognition.AmazonRekognition;
import com.amazonaws.services.rekognition.AmazonRekognitionClientBuilder;
import com.amazonaws.services.rekognition.model.CreateStreamProcessorRequest;
import com.amazonaws.services.rekognition.model.CreateStreamProcessorResult;
import com.amazonaws.services.rekognition.model.DeleteStreamProcessorRequest;
import com.amazonaws.services.rekognition.model.DeleteStreamProcessorResult;
import com.amazonaws.services.rekognition.model.DescribeStreamProcessorRequest;
import com.amazonaws.services.rekognition.model.DescribeStreamProcessorResult;
import com.amazonaws.services.rekognition.model.FaceSearchSettings;
import com.amazonaws.services.rekognition.model.KinesisDataStream;
import com.amazonaws.services.rekognition.model.KinesisVideoStream;
import com.amazonaws.services.rekognition.model.ListStreamProcessorsRequest;
import com.amazonaws.services.rekognition.model.ListStreamProcessorsResult;
import com.amazonaws.services.rekognition.model.StartStreamProcessorRequest;
import com.amazonaws.services.rekognition.model.StartStreamProcessorResult;
import com.amazonaws.services.rekognition.model.StopStreamProcessorRequest;
import com.amazonaws.services.rekognition.model.StopStreamProcessorResult;
import com.amazonaws.services.rekognition.model.StreamProcessor;
import com.amazonaws.services.rekognition.model.StreamProcessorInput;
import com.amazonaws.services.rekognition.model.StreamProcessorOutput;
import com.amazonaws.services.rekognition.model.StreamProcessorSettings;

public class StreamManager {

    private String streamProcessorName;
    private String kinesisVideoStreamArn;
    private String kinesisDataStreamArn;
    private String roleArn;
    private String collectionId;
    private float matchThreshold;

    private AmazonRekognition rekognitionClient;
    

    public StreamManager(String spName,
    		String kvStreamArn,
    		String kdStreamArn,
    		String iamRoleArn,
    		String collId,
    		Float threshold){
    	streamProcessorName=spName;
    	kinesisVideoStreamArn=kvStreamArn;
    	kinesisDataStreamArn=kdStreamArn;
    	roleArn=iamRoleArn;
    	collectionId=collId;
    	matchThreshold=threshold;
    	rekognitionClient=AmazonRekognitionClientBuilder.defaultClient();
    	
    }
    
    public void createStreamProcessor() {
    	//Setup input parameters
        KinesisVideoStream kinesisVideoStream = new KinesisVideoStream().withArn(kinesisVideoStreamArn);
        StreamProcessorInput streamProcessorInput =
                new StreamProcessorInput().withKinesisVideoStream(kinesisVideoStream);
        KinesisDataStream kinesisDataStream = new KinesisDataStream().withArn(kinesisDataStreamArn);
        StreamProcessorOutput streamProcessorOutput =
                new StreamProcessorOutput().withKinesisDataStream(kinesisDataStream);
        FaceSearchSettings faceSearchSettings =
                new FaceSearchSettings().withCollectionId(collectionId).withFaceMatchThreshold(matchThreshold);
        StreamProcessorSettings streamProcessorSettings =
                new StreamProcessorSettings().withFaceSearch(faceSearchSettings);

        //Create the stream processor
        CreateStreamProcessorResult createStreamProcessorResult = rekognitionClient.createStreamProcessor(
                new CreateStreamProcessorRequest().withInput(streamProcessorInput).withOutput(streamProcessorOutput)
                        .withSettings(streamProcessorSettings).withRoleArn(roleArn).withName(streamProcessorName));

        //Display result
        System.out.println("Stream Processor " + streamProcessorName + " created.");
        System.out.println("StreamProcessorArn - " + createStreamProcessorResult.getStreamProcessorArn());
    }

    public void startStreamProcessor() {
        StartStreamProcessorResult startStreamProcessorResult =
                rekognitionClient.startStreamProcessor(new StartStreamProcessorRequest().withName(streamProcessorName));
        System.out.println("Stream Processor " + streamProcessorName + " started.");
    }

    public void stopStreamProcessor() {
        StopStreamProcessorResult stopStreamProcessorResult =
                rekognitionClient.stopStreamProcessor(new StopStreamProcessorRequest().withName(streamProcessorName));
        System.out.println("Stream Processor " + streamProcessorName + " stopped.");
    }

    public void deleteStreamProcessor() {
        DeleteStreamProcessorResult deleteStreamProcessorResult = rekognitionClient
                .deleteStreamProcessor(new DeleteStreamProcessorRequest().withName(streamProcessorName));
        System.out.println("Stream Processor " + streamProcessorName + " deleted.");
    }

    public void describeStreamProcessor() {
        DescribeStreamProcessorResult describeStreamProcessorResult = rekognitionClient
                .describeStreamProcessor(new DescribeStreamProcessorRequest().withName(streamProcessorName));

        //Display various stream processor attributes.
        System.out.println("Arn - " + describeStreamProcessorResult.getStreamProcessorArn());
        System.out.println("Input kinesisVideo stream - "
                + describeStreamProcessorResult.getInput().getKinesisVideoStream().getArn());
        System.out.println("Output kinesisData stream - "
                + describeStreamProcessorResult.getOutput().getKinesisDataStream().getArn());
        System.out.println("RoleArn - " + describeStreamProcessorResult.getRoleArn());
        System.out.println(
                "CollectionId - " + describeStreamProcessorResult.getSettings().getFaceSearch().getCollectionId());
        System.out.println("Status - " + describeStreamProcessorResult.getStatus());
        System.out.println("Status message - " + describeStreamProcessorResult.getStatusMessage());
        System.out.println("Creation timestamp - " + describeStreamProcessorResult.getCreationTimestamp());
        System.out.println("Last update timestamp - " + describeStreamProcessorResult.getLastUpdateTimestamp());
    }

    public void listStreamProcessors() {
        ListStreamProcessorsResult listStreamProcessorsResult =
                rekognitionClient.listStreamProcessors(new ListStreamProcessorsRequest().withMaxResults(100));

        //List all stream processors (and state) returned from Rekognition
        for (StreamProcessor streamProcessor : listStreamProcessorsResult.getStreamProcessors()) {
            System.out.println("StreamProcessor name - " + streamProcessor.getName());
            System.out.println("Status - " + streamProcessor.getStatus());
        }
    }
}

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

Conceder ao Amazon Rekognition Video acesso aos recursos

Lendo os resultados da análise