jsonErrorUnmarshallers;
/**
* Constructs a new client to invoke service methods on AmazonRekognition. A
* credentials provider chain will be used that searches for credentials in
* this order:
*
* - Environment Variables - AWS_ACCESS_KEY_ID and AWS_SECRET_KEY
* - Java System Properties - aws.accessKeyId and aws.secretKey
* - Instance profile credentials delivered through the Amazon EC2
* metadata service
*
*
* All service calls made using this new client object are blocking, and
* will not return until the service call completes.
*
* @see DefaultAWSCredentialsProviderChain
*/
@Deprecated
public AmazonRekognitionClient() {
this(new DefaultAWSCredentialsProviderChain(), new ClientConfiguration());
}
/**
* Constructs a new client to invoke service methods on AmazonRekognition. A
* credentials provider chain will be used that searches for credentials in
* this order:
*
* - Environment Variables - AWS_ACCESS_KEY_ID and AWS_SECRET_KEY
* - Java System Properties - aws.accessKeyId and aws.secretKey
* - Instance profile credentials delivered through the Amazon EC2
* metadata service
*
*
* All service calls made using this new client object are blocking, and
* will not return until the service call completes.
*
* @param clientConfiguration The client configuration options controlling
* how this client connects to AmazonRekognition (ex: proxy
* settings, retry counts, etc.).
* @see DefaultAWSCredentialsProviderChain
*/
@Deprecated
public AmazonRekognitionClient(ClientConfiguration clientConfiguration) {
this(new DefaultAWSCredentialsProviderChain(), clientConfiguration);
}
/**
* Constructs a new client to invoke service methods on AmazonRekognition
* using the specified AWS account credentials.
*
* The client requests are authenticated using the {@link AWSCredentials}
* provided in this constructor. Static AWSCredentials can be passed for
* quick testing. However, it is strongly recommended to use Amazon Cognito
* vended temporary credentials for use in production. This can be achieved
* by using {@link AWSMobileClient}. Please see
* https://aws-amplify.github.io/docs/android/authentication for
* instructions on how to enable {@link AWSMobileClient}.
*
*
* AWSMobileClient.getInstance().initialize(getApplicationContext(), new Callback<UserStateDetails>() {
* @Override
* public void onResult(final UserStateDetails details) {
* AmazonRekognitionClient client = new AmazonRekognitionClient(AWSMobileClient.getInstance());
* }
*
* @Override
* public void onError(final Exception e) {
* e.printStackTrace();
* }
* });
*
*
* All service calls made using this new client object are blocking, and
* will not return until the service call completes.
*
* @param awsCredentials The AWS credentials (access key ID and secret key)
* to use when authenticating with AWS services.
*/
public AmazonRekognitionClient(AWSCredentials awsCredentials) {
this(awsCredentials, new ClientConfiguration());
}
/**
* Constructs a new client to invoke service methods on AmazonRekognition
* using the specified AWS account credentials and client configuration
* options.
*
* The client requests are authenticated using the {@link AWSCredentials}
* provided in this constructor. Static AWSCredentials can be passed for
* quick testing. However, it is strongly recommended to use Amazon Cognito
* vended temporary credentials for use in production. This can be achieved
* by using {@link AWSMobileClient}. Please see
* https://aws-amplify.github.io/docs/android/authentication for
* instructions on how to enable {@link AWSMobileClient}.
*
*
* AWSMobileClient.getInstance().initialize(getApplicationContext(), new Callback<UserStateDetails>() {
* @Override
* public void onResult(final UserStateDetails details) {
* AmazonRekognitionClient client = new AmazonRekognitionClient(AWSMobileClient.getInstance());
* }
*
* @Override
* public void onError(final Exception e) {
* e.printStackTrace();
* }
* });
*
*
* All service calls made using this new client object are blocking, and
* will not return until the service call completes.
*
* @param awsCredentials The AWS credentials (access key ID and secret key)
* to use when authenticating with AWS services.
* @param clientConfiguration The client configuration options controlling
* how this client connects to AmazonRekognition (ex: proxy
* settings, retry counts, etc.).
*/
public AmazonRekognitionClient(AWSCredentials awsCredentials,
ClientConfiguration clientConfiguration) {
this(new StaticCredentialsProvider(awsCredentials), clientConfiguration);
}
/**
* Constructs a new client to invoke service methods on AmazonRekognition
* using the specified AWS account credentials provider.
*
* The client requests are authenticated using the {@link AWSCredentials}
* provided by the {@link AWSCredentialsProvider}. Static AWSCredentials can
* be passed for quick testing. However, it is strongly recommended to use
* Amazon Cognito vended temporary credentials for use in production. This
* can be achieved by using {@link AWSMobileClient}. Please see
* https://aws-amplify.github.io/docs/android/authentication for
* instructions on how to enable {@link AWSMobileClient}.
*
*
* AWSMobileClient.getInstance().initialize(getApplicationContext(), new Callback<UserStateDetails>() {
* @Override
* public void onResult(final UserStateDetails details) {
* AmazonRekognitionClient client = new AmazonRekognitionClient(AWSMobileClient.getInstance());
* }
*
* @Override
* public void onError(final Exception e) {
* e.printStackTrace();
* }
* });
*
*
* All service calls made using this new client object are blocking, and
* will not return until the service call completes.
*
* @param awsCredentialsProvider The AWS credentials provider which will
* provide credentials to authenticate requests with AWS
* services.
*/
public AmazonRekognitionClient(AWSCredentialsProvider awsCredentialsProvider) {
this(awsCredentialsProvider, new ClientConfiguration());
}
/**
* Constructs a new client to invoke service methods on AmazonRekognition
* using the specified AWS account credentials provider and client
* configuration options.
*
* The client requests are authenticated using the {@link AWSCredentials}
* provided by the {@link AWSCredentialsProvider}. Static AWSCredentials can
* be passed for quick testing. However, it is strongly recommended to use
* Amazon Cognito vended temporary credentials for use in production. This
* can be achieved by using {@link AWSMobileClient}. Please see
* https://aws-amplify.github.io/docs/android/authentication for
* instructions on how to enable {@link AWSMobileClient}.
*
*
* AWSMobileClient.getInstance().initialize(getApplicationContext(), new Callback<UserStateDetails>() {
* @Override
* public void onResult(final UserStateDetails details) {
* AmazonRekognitionClient client = new AmazonRekognitionClient(AWSMobileClient.getInstance());
* }
*
* @Override
* public void onError(final Exception e) {
* e.printStackTrace();
* }
* });
*
*
* All service calls made using this new client object are blocking, and
* will not return until the service call completes.
*
* @param awsCredentialsProvider The AWS credentials provider which will
* provide credentials to authenticate requests with AWS
* services.
* @param clientConfiguration The client configuration options controlling
* how this client connects to AmazonRekognition (ex: proxy
* settings, retry counts, etc.).
*/
public AmazonRekognitionClient(AWSCredentialsProvider awsCredentialsProvider,
ClientConfiguration clientConfiguration) {
this(awsCredentialsProvider, clientConfiguration, new UrlHttpClient(clientConfiguration));
}
/**
* Constructs a new client to invoke service methods on AmazonRekognition
* using the specified AWS account credentials provider, client
* configuration options and request metric collector.
*
* All service calls made using this new client object are blocking, and
* will not return until the service call completes.
*
* @param awsCredentialsProvider The AWS credentials provider which will
* provide credentials to authenticate requests with AWS
* services.
* @param clientConfiguration The client configuration options controlling
* how this client connects to AmazonRekognition (ex: proxy
* settings, retry counts, etc.).
* @param requestMetricCollector optional request metric collector
*/
@Deprecated
public AmazonRekognitionClient(AWSCredentialsProvider awsCredentialsProvider,
ClientConfiguration clientConfiguration,
RequestMetricCollector requestMetricCollector) {
super(adjustClientConfiguration(clientConfiguration), requestMetricCollector);
this.awsCredentialsProvider = awsCredentialsProvider;
init();
}
/**
* Constructs a new client to invoke service methods on AmazonRekognition
* using the specified AWS account credentials provider, client
* configuration options and request metric collector.
*
* The client requests are authenticated using the {@link AWSCredentials}
* provided by the {@link AWSCredentialsProvider}. Static AWSCredentials can
* be passed for quick testing. However, it is strongly recommended to use
* Amazon Cognito vended temporary credentials for use in production. This
* can be achieved by using {@link AWSMobileClient}. Please see
* https://aws-amplify.github.io/docs/android/authentication for
* instructions on how to enable {@link AWSMobileClient}.
*
*
* AWSMobileClient.getInstance().initialize(getApplicationContext(), new Callback<UserStateDetails>() {
* @Override
* public void onResult(final UserStateDetails details) {
* AmazonRekognitionClient client = new AmazonRekognitionClient(AWSMobileClient.getInstance());
* }
*
* @Override
* public void onError(final Exception e) {
* e.printStackTrace();
* }
* });
*
*
* All service calls made using this new client object are blocking, and
* will not return until the service call completes.
*
* @param awsCredentialsProvider The AWS credentials provider which will
* provide credentials to authenticate requests with AWS
* services.
* @param clientConfiguration The client configuration options controlling
* how this client connects to AmazonRekognition (ex: proxy
* settings, retry counts, etc.).
* @param httpClient A http client
*/
public AmazonRekognitionClient(AWSCredentialsProvider awsCredentialsProvider,
ClientConfiguration clientConfiguration, HttpClient httpClient) {
super(adjustClientConfiguration(clientConfiguration), httpClient);
this.awsCredentialsProvider = awsCredentialsProvider;
init();
}
private void init() {
jsonErrorUnmarshallers = new ArrayList();
jsonErrorUnmarshallers.add(new AccessDeniedExceptionUnmarshaller());
jsonErrorUnmarshallers.add(new ConflictExceptionUnmarshaller());
jsonErrorUnmarshallers.add(new HumanLoopQuotaExceededExceptionUnmarshaller());
jsonErrorUnmarshallers.add(new IdempotentParameterMismatchExceptionUnmarshaller());
jsonErrorUnmarshallers.add(new ImageTooLargeExceptionUnmarshaller());
jsonErrorUnmarshallers.add(new InternalServerErrorExceptionUnmarshaller());
jsonErrorUnmarshallers.add(new InvalidImageFormatExceptionUnmarshaller());
jsonErrorUnmarshallers.add(new InvalidPaginationTokenExceptionUnmarshaller());
jsonErrorUnmarshallers.add(new InvalidParameterExceptionUnmarshaller());
jsonErrorUnmarshallers.add(new InvalidPolicyRevisionIdExceptionUnmarshaller());
jsonErrorUnmarshallers.add(new InvalidS3ObjectExceptionUnmarshaller());
jsonErrorUnmarshallers.add(new LimitExceededExceptionUnmarshaller());
jsonErrorUnmarshallers.add(new MalformedPolicyDocumentExceptionUnmarshaller());
jsonErrorUnmarshallers.add(new ProvisionedThroughputExceededExceptionUnmarshaller());
jsonErrorUnmarshallers.add(new ResourceAlreadyExistsExceptionUnmarshaller());
jsonErrorUnmarshallers.add(new ResourceInUseExceptionUnmarshaller());
jsonErrorUnmarshallers.add(new ResourceNotFoundExceptionUnmarshaller());
jsonErrorUnmarshallers.add(new ResourceNotReadyExceptionUnmarshaller());
jsonErrorUnmarshallers.add(new ServiceQuotaExceededExceptionUnmarshaller());
jsonErrorUnmarshallers.add(new SessionNotFoundExceptionUnmarshaller());
jsonErrorUnmarshallers.add(new ThrottlingExceptionUnmarshaller());
jsonErrorUnmarshallers.add(new VideoTooLargeExceptionUnmarshaller());
jsonErrorUnmarshallers.add(new JsonErrorUnmarshaller());
// calling this.setEndPoint(...) will also modify the signer accordingly
this.setEndpoint("rekognition.us-east-1.amazonaws.com");
this.endpointPrefix = "rekognition";
HandlerChainFactory chainFactory = new HandlerChainFactory();
requestHandler2s.addAll(chainFactory.newRequestHandlerChain(
"/com/amazonaws/services/rekognition/request.handlers"));
requestHandler2s.addAll(chainFactory.newRequestHandler2Chain(
"/com/amazonaws/services/rekognition/request.handler2s"));
}
private static ClientConfiguration adjustClientConfiguration(ClientConfiguration orig) {
ClientConfiguration config = orig;
return config;
}
/**
*
* Associates one or more faces with an existing UserID. Takes an array of
* FaceIds. Each FaceId that are present in the
* FaceIds list is associated with the provided UserID. The
* maximum number of total FaceIds per UserID is 100.
*
*
* The UserMatchThreshold parameter specifies the minimum user
* match confidence required for the face to be associated with a UserID
* that has at least one FaceID already associated. This
* ensures that the FaceIds are associated with the right
* UserID. The value ranges from 0-100 and default value is 75.
*
*
* If successful, an array of AssociatedFace objects containing
* the associated FaceIds is returned. If a given face is
* already associated with the given UserID, it will be ignored
* and will not be returned in the response. If a given face is already
* associated to a different UserID, isn't found in the
* collection, doesn’t meet the UserMatchThreshold, or there
* are already 100 faces associated with the UserID, it will be
* returned as part of an array of
* UnsuccessfulFaceAssociations.
*
*
* The UserStatus reflects the status of an operation which
* updates a UserID representation with a list of given faces. The
* UserStatus can be:
*
*
* -
*
* ACTIVE - All associations or disassociations of FaceID(s) for a UserID
* are complete.
*
*
* -
*
* CREATED - A UserID has been created, but has no FaceID(s) associated with
* it.
*
*
* -
*
* UPDATING - A UserID is being updated and there are current associations
* or disassociations of FaceID(s) taking place.
*
*
*
*
* @param associateFacesRequest
* @return associateFacesResult The response from the AssociateFaces service
* method, as returned by Amazon Rekognition.
* @throws InvalidParameterException
* @throws AccessDeniedException
* @throws InternalServerErrorException
* @throws ThrottlingException
* @throws ProvisionedThroughputExceededException
* @throws IdempotentParameterMismatchException
* @throws ResourceNotFoundException
* @throws ConflictException
* @throws ServiceQuotaExceededException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by Amazon
* Rekognition indicating either a problem with the data in the
* request, or a server side issue.
*/
public AssociateFacesResult associateFaces(AssociateFacesRequest associateFacesRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(associateFacesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new AssociateFacesRequestMarshaller().marshall(associateFacesRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new AssociateFacesResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Compares a face in the source input image with each of the 100
* largest faces detected in the target input image.
*
*
* If the source image contains multiple faces, the service detects the
* largest face and compares it with each face detected in the target image.
*
*
*
* CompareFaces uses machine learning algorithms, which are probabilistic. A
* false negative is an incorrect prediction that a face in the target image
* has a low similarity confidence score when compared to the face in the
* source image. To reduce the probability of false negatives, we recommend
* that you compare the target image against multiple source images. If you
* plan to use CompareFaces to make a decision that impacts an
* individual's rights, privacy, or access to services, we recommend that
* you pass the result to a human for review and further validation before
* taking action.
*
*
*
* You pass the input and target images either as base64-encoded image bytes
* or as references to images in an Amazon S3 bucket. If you use the AWS CLI
* to call Amazon Rekognition operations, passing image bytes isn't
* supported. The image must be formatted as a PNG or JPEG file.
*
*
* In response, the operation returns an array of face matches ordered by
* similarity score in descending order. For each face match, the response
* provides a bounding box of the face, facial landmarks, pose details
* (pitch, roll, and yaw), quality (brightness and sharpness), and
* confidence value (indicating the level of confidence that the bounding
* box contains a face). The response also provides a similarity score,
* which indicates how closely the faces match.
*
*
*
* By default, only faces with a similarity score of greater than or equal
* to 80% are returned in the response. You can change this value by
* specifying the SimilarityThreshold parameter.
*
*
*
* CompareFaces also returns an array of faces that don't match
* the source image. For each face, it returns a bounding box, confidence
* value, landmarks, pose details, and quality. The response also returns
* information about the face in the source image, including the bounding
* box of the face and confidence value.
*
*
* The QualityFilter input parameter allows you to filter out
* detected faces that don’t meet a required quality bar. The quality bar is
* based on a variety of common use cases. Use QualityFilter to
* set the quality bar by specifying LOW, MEDIUM,
* or HIGH. If you do not want to filter detected faces,
* specify NONE. The default value is NONE.
*
*
* If the image doesn't contain Exif metadata, CompareFaces
* returns orientation information for the source and target images. Use
* these values to display the images with the correct image orientation.
*
*
* If no faces are detected in the source or target images,
* CompareFaces returns an
* InvalidParameterException error.
*
*
*
* This is a stateless API operation. That is, data returned by this
* operation doesn't persist.
*
*
*
* For an example, see Comparing Faces in Images in the Amazon Rekognition
* Developer Guide.
*
*
* This operation requires permissions to perform the
* rekognition:CompareFaces action.
*
*
* @param compareFacesRequest
* @return compareFacesResult The response from the CompareFaces service
* method, as returned by Amazon Rekognition.
* @throws InvalidParameterException
* @throws InvalidS3ObjectException
* @throws ImageTooLargeException
* @throws AccessDeniedException
* @throws InternalServerErrorException
* @throws ThrottlingException
* @throws ProvisionedThroughputExceededException
* @throws InvalidImageFormatException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by Amazon
* Rekognition indicating either a problem with the data in the
* request, or a server side issue.
*/
public CompareFacesResult compareFaces(CompareFacesRequest compareFacesRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(compareFacesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CompareFacesRequestMarshaller().marshall(compareFacesRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new CompareFacesResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Copies a version of an Amazon Rekognition Custom Labels model from a
* source project to a destination project. The source and destination
* projects can be in different AWS accounts but must be in the same AWS
* Region. You can't copy a model to another AWS service.
*
*
* To copy a model version to a different AWS account, you need to create a
* resource-based policy known as a project policy. You attach the
* project policy to the source project by calling PutProjectPolicy.
* The project policy gives permission to copy the model version from a
* trusting AWS account to a trusted account.
*
*
* For more information creating and attaching a project policy, see
* Attaching a project policy (SDK) in the Amazon Rekognition Custom
* Labels Developer Guide.
*
*
* If you are copying a model version to a project in the same AWS account,
* you don't need to create a project policy.
*
*
*
* To copy a model, the destination project, source project, and source
* model version must already exist.
*
*
*
* Copying a model version takes a while to complete. To get the current
* status, call DescribeProjectVersions and check the value of
* Status in the ProjectVersionDescription object. The
* copy operation has finished when the value of Status is
* COPYING_COMPLETED.
*
*
* This operation requires permissions to perform the
* rekognition:CopyProjectVersion action.
*
*
* @param copyProjectVersionRequest
* @return copyProjectVersionResult The response from the CopyProjectVersion
* service method, as returned by Amazon Rekognition.
* @throws AccessDeniedException
* @throws InternalServerErrorException
* @throws InvalidParameterException
* @throws LimitExceededException
* @throws ResourceNotFoundException
* @throws ThrottlingException
* @throws ServiceQuotaExceededException
* @throws ProvisionedThroughputExceededException
* @throws ResourceInUseException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by Amazon
* Rekognition indicating either a problem with the data in the
* request, or a server side issue.
*/
public CopyProjectVersionResult copyProjectVersion(
CopyProjectVersionRequest copyProjectVersionRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(copyProjectVersionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CopyProjectVersionRequestMarshaller()
.marshall(copyProjectVersionRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new CopyProjectVersionResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Creates a collection in an AWS Region. You can add faces to the
* collection using the IndexFaces operation.
*
*
* For example, you might create collections, one for each of your
* application users. A user can then index faces using the
* IndexFaces operation and persist results in a specific
* collection. Then, a user can search the collection for faces in the
* user-specific container.
*
*
* When you create a collection, it is associated with the latest version of
* the face model version.
*
*
*
* Collection names are case-sensitive.
*
*
*
* This operation requires permissions to perform the
* rekognition:CreateCollection action. If you want to tag your
* collection, you also require permission to perform the
* rekognition:TagResource operation.
*
*
* @param createCollectionRequest
* @return createCollectionResult The response from the CreateCollection
* service method, as returned by Amazon Rekognition.
* @throws InvalidParameterException
* @throws AccessDeniedException
* @throws InternalServerErrorException
* @throws ThrottlingException
* @throws ProvisionedThroughputExceededException
* @throws ResourceAlreadyExistsException
* @throws ServiceQuotaExceededException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by Amazon
* Rekognition indicating either a problem with the data in the
* request, or a server side issue.
*/
public CreateCollectionResult createCollection(CreateCollectionRequest createCollectionRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(createCollectionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateCollectionRequestMarshaller().marshall(createCollectionRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new CreateCollectionResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Creates a new Amazon Rekognition Custom Labels dataset. You can create a
* dataset by using an Amazon Sagemaker format manifest file or by copying
* an existing Amazon Rekognition Custom Labels dataset.
*
*
* To create a training dataset for a project, specify train
* for the value of DatasetType. To create the test dataset for
* a project, specify test for the value of
* DatasetType.
*
*
* The response from CreateDataset is the Amazon Resource Name
* (ARN) for the dataset. Creating a dataset takes a while to complete. Use
* DescribeDataset to check the current status. The dataset created
* successfully if the value of Status is
* CREATE_COMPLETE.
*
*
* To check if any non-terminal errors occurred, call
* ListDatasetEntries and check for the presence of
* errors lists in the JSON Lines.
*
*
* Dataset creation fails if a terminal error occurs (Status =
* CREATE_FAILED). Currently, you can't access the terminal
* error information.
*
*
* For more information, see Creating dataset in the Amazon Rekognition
* Custom Labels Developer Guide.
*
*
* This operation requires permissions to perform the
* rekognition:CreateDataset action. If you want to copy an
* existing dataset, you also require permission to perform the
* rekognition:ListDatasetEntries action.
*
*
* @param createDatasetRequest
* @return createDatasetResult The response from the CreateDataset service
* method, as returned by Amazon Rekognition.
* @throws InternalServerErrorException
* @throws ThrottlingException
* @throws ProvisionedThroughputExceededException
* @throws InvalidParameterException
* @throws AccessDeniedException
* @throws LimitExceededException
* @throws InvalidS3ObjectException
* @throws ResourceAlreadyExistsException
* @throws ResourceNotFoundException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by Amazon
* Rekognition indicating either a problem with the data in the
* request, or a server side issue.
*/
public CreateDatasetResult createDataset(CreateDatasetRequest createDatasetRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(createDatasetRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateDatasetRequestMarshaller().marshall(createDatasetRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new CreateDatasetResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* This API operation initiates a Face Liveness session. It returns a
* SessionId, which you can use to start streaming Face
* Liveness video and get the results for a Face Liveness session. You can
* use the OutputConfig option in the Settings parameter to
* provide an Amazon S3 bucket location. The Amazon S3 bucket stores
* reference images and audit images. You can use
* AuditImagesLimit to limit the number of audit images
* returned. This number is between 0 and 4. By default, it is set to 0. The
* limit is best effort and based on the duration of the selfie-video.
*
*
* @param createFaceLivenessSessionRequest
* @return createFaceLivenessSessionResult The response from the
* CreateFaceLivenessSession service method, as returned by Amazon
* Rekognition.
* @throws AccessDeniedException
* @throws InternalServerErrorException
* @throws InvalidParameterException
* @throws ThrottlingException
* @throws ProvisionedThroughputExceededException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by Amazon
* Rekognition indicating either a problem with the data in the
* request, or a server side issue.
*/
public CreateFaceLivenessSessionResult createFaceLivenessSession(
CreateFaceLivenessSessionRequest createFaceLivenessSessionRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(createFaceLivenessSessionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateFaceLivenessSessionRequestMarshaller()
.marshall(createFaceLivenessSessionRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new CreateFaceLivenessSessionResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Creates a new Amazon Rekognition Custom Labels project. A project is a
* group of resources (datasets, model versions) that you use to create and
* manage Amazon Rekognition Custom Labels models.
*
*
* This operation requires permissions to perform the
* rekognition:CreateProject action.
*
*
* @param createProjectRequest
* @return createProjectResult The response from the CreateProject service
* method, as returned by Amazon Rekognition.
* @throws ResourceInUseException
* @throws LimitExceededException
* @throws InvalidParameterException
* @throws AccessDeniedException
* @throws InternalServerErrorException
* @throws ThrottlingException
* @throws ProvisionedThroughputExceededException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by Amazon
* Rekognition indicating either a problem with the data in the
* request, or a server side issue.
*/
public CreateProjectResult createProject(CreateProjectRequest createProjectRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(createProjectRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateProjectRequestMarshaller().marshall(createProjectRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new CreateProjectResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Creates a new version of a model and begins training. Models are managed
* as part of an Amazon Rekognition Custom Labels project. The response from
* CreateProjectVersion is an Amazon Resource Name (ARN) for
* the version of the model.
*
*
* Training uses the training and test datasets associated with the project.
* For more information, see Creating training and test dataset in the
* Amazon Rekognition Custom Labels Developer Guide.
*
*
*
* You can train a model in a project that doesn't have associated datasets
* by specifying manifest files in the TrainingData and
* TestingData fields.
*
*
* If you open the console after training a model with manifest files,
* Amazon Rekognition Custom Labels creates the datasets for you using the
* most recent manifest files. You can no longer train a model version for
* the project by specifying manifest files.
*
*
* Instead of training with a project without associated datasets, we
* recommend that you use the manifest files to create training and test
* datasets for the project.
*
*
*
* Training takes a while to complete. You can get the current status by
* calling DescribeProjectVersions. Training completed successfully
* if the value of the Status field is
* TRAINING_COMPLETED.
*
*
* If training fails, see Debugging a failed model training in the Amazon
* Rekognition Custom Labels developer guide.
*
*
* Once training has successfully completed, call
* DescribeProjectVersions to get the training results and evaluate
* the model. For more information, see Improving a trained Amazon
* Rekognition Custom Labels model in the Amazon Rekognition Custom
* Labels developers guide.
*
*
* After evaluating the model, you start the model by calling
* StartProjectVersion.
*
*
* This operation requires permissions to perform the
* rekognition:CreateProjectVersion action.
*
*
* @param createProjectVersionRequest
* @return createProjectVersionResult The response from the
* CreateProjectVersion service method, as returned by Amazon
* Rekognition.
* @throws ResourceInUseException
* @throws ResourceNotFoundException
* @throws LimitExceededException
* @throws InvalidParameterException
* @throws AccessDeniedException
* @throws InternalServerErrorException
* @throws ThrottlingException
* @throws ProvisionedThroughputExceededException
* @throws ServiceQuotaExceededException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by Amazon
* Rekognition indicating either a problem with the data in the
* request, or a server side issue.
*/
public CreateProjectVersionResult createProjectVersion(
CreateProjectVersionRequest createProjectVersionRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(createProjectVersionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateProjectVersionRequestMarshaller()
.marshall(createProjectVersionRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new CreateProjectVersionResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Creates an Amazon Rekognition stream processor that you can use to detect
* and recognize faces or to detect labels in a streaming video.
*
*
* Amazon Rekognition Video is a consumer of live video from Amazon Kinesis
* Video Streams. There are two different settings for stream processors in
* Amazon Rekognition: detecting faces and detecting labels.
*
*
* -
*
* If you are creating a stream processor for detecting faces, you provide
* as input a Kinesis video stream (Input) and a Kinesis data
* stream (Output) stream for receiving the output. You must
* use the FaceSearch option in Settings,
* specifying the collection that contains the faces you want to recognize.
* After you have finished analyzing a streaming video, use
* StopStreamProcessor to stop processing.
*
*
* -
*
* If you are creating a stream processor to detect labels, you provide as
* input a Kinesis video stream (Input), Amazon S3 bucket
* information (Output), and an Amazon SNS topic ARN (
* NotificationChannel). You can also provide a KMS key ID to
* encrypt the data sent to your Amazon S3 bucket. You specify what you want
* to detect by using the ConnectedHome option in settings, and
* selecting one of the following: PERSON, PET,
* PACKAGE, ALL You can also specify where in the
* frame you want Amazon Rekognition to monitor with
* RegionsOfInterest. When you run the
* StartStreamProcessor operation on a label detection stream
* processor, you input start and stop information to determine the length
* of the processing time.
*
*
*
*
* Use Name to assign an identifier for the stream processor.
* You use Name to manage the stream processor. For example,
* you can start processing the source video by calling
* StartStreamProcessor with the Name field.
*
*
* This operation requires permissions to perform the
* rekognition:CreateStreamProcessor action. If you want to tag
* your stream processor, you also require permission to perform the
* rekognition:TagResource operation.
*
*
* @param createStreamProcessorRequest
* @return createStreamProcessorResult The response from the
* CreateStreamProcessor service method, as returned by Amazon
* Rekognition.
* @throws AccessDeniedException
* @throws InternalServerErrorException
* @throws ThrottlingException
* @throws InvalidParameterException
* @throws LimitExceededException
* @throws ResourceInUseException
* @throws ProvisionedThroughputExceededException
* @throws ServiceQuotaExceededException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by Amazon
* Rekognition indicating either a problem with the data in the
* request, or a server side issue.
*/
public CreateStreamProcessorResult createStreamProcessor(
CreateStreamProcessorRequest createStreamProcessorRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(createStreamProcessorRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateStreamProcessorRequestMarshaller()
.marshall(createStreamProcessorRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new CreateStreamProcessorResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Creates a new User within a collection specified by
* CollectionId. Takes UserId as a parameter,
* which is a user provided ID which should be unique within the collection.
* The provided UserId will alias the system generated UUID to
* make the UserId more user friendly.
*
*
* Uses a ClientToken, an idempotency token that ensures a call
* to CreateUser completes only once. If the value is not
* supplied, the AWS SDK generates an idempotency token for the requests.
* This prevents retries after a network error results from making multiple
* CreateUser calls.
*
*
* @param createUserRequest
* @return createUserResult The response from the CreateUser service method,
* as returned by Amazon Rekognition.
* @throws InvalidParameterException
* @throws ConflictException
* @throws ResourceNotFoundException
* @throws ServiceQuotaExceededException
* @throws ProvisionedThroughputExceededException
* @throws IdempotentParameterMismatchException
* @throws AccessDeniedException
* @throws InternalServerErrorException
* @throws ThrottlingException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by Amazon
* Rekognition indicating either a problem with the data in the
* request, or a server side issue.
*/
public CreateUserResult createUser(CreateUserRequest createUserRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(createUserRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateUserRequestMarshaller().marshall(createUserRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new CreateUserResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Deletes the specified collection. Note that this operation removes all
* faces in the collection. For an example, see Deleting a collection.
*
*
* This operation requires permissions to perform the
* rekognition:DeleteCollection action.
*
*
* @param deleteCollectionRequest
* @return deleteCollectionResult The response from the DeleteCollection
* service method, as returned by Amazon Rekognition.
* @throws InvalidParameterException
* @throws AccessDeniedException
* @throws InternalServerErrorException
* @throws ThrottlingException
* @throws ProvisionedThroughputExceededException
* @throws ResourceNotFoundException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by Amazon
* Rekognition indicating either a problem with the data in the
* request, or a server side issue.
*/
public DeleteCollectionResult deleteCollection(DeleteCollectionRequest deleteCollectionRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(deleteCollectionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteCollectionRequestMarshaller().marshall(deleteCollectionRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new DeleteCollectionResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Deletes an existing Amazon Rekognition Custom Labels dataset. Deleting a
* dataset might take while. Use DescribeDataset to check the current
* status. The dataset is still deleting if the value of Status
* is DELETE_IN_PROGRESS. If you try to access the dataset
* after it is deleted, you get a ResourceNotFoundException
* exception.
*
*
* You can't delete a dataset while it is creating (Status =
* CREATE_IN_PROGRESS) or if the dataset is updating (
* Status = UPDATE_IN_PROGRESS).
*
*
* This operation requires permissions to perform the
* rekognition:DeleteDataset action.
*
*
* @param deleteDatasetRequest
* @return deleteDatasetResult The response from the DeleteDataset service
* method, as returned by Amazon Rekognition.
* @throws InternalServerErrorException
* @throws ThrottlingException
* @throws ProvisionedThroughputExceededException
* @throws InvalidParameterException
* @throws AccessDeniedException
* @throws LimitExceededException
* @throws ResourceInUseException
* @throws ResourceNotFoundException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by Amazon
* Rekognition indicating either a problem with the data in the
* request, or a server side issue.
*/
public DeleteDatasetResult deleteDataset(DeleteDatasetRequest deleteDatasetRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(deleteDatasetRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteDatasetRequestMarshaller().marshall(deleteDatasetRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new DeleteDatasetResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Deletes faces from a collection. You specify a collection ID and an array
* of face IDs to remove from the collection.
*
*
* This operation requires permissions to perform the
* rekognition:DeleteFaces action.
*
*
* @param deleteFacesRequest
* @return deleteFacesResult The response from the DeleteFaces service
* method, as returned by Amazon Rekognition.
* @throws InvalidParameterException
* @throws AccessDeniedException
* @throws InternalServerErrorException
* @throws ThrottlingException
* @throws ProvisionedThroughputExceededException
* @throws ResourceNotFoundException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by Amazon
* Rekognition indicating either a problem with the data in the
* request, or a server side issue.
*/
public DeleteFacesResult deleteFaces(DeleteFacesRequest deleteFacesRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(deleteFacesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteFacesRequestMarshaller().marshall(deleteFacesRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new DeleteFacesResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Deletes an Amazon Rekognition Custom Labels project. To delete a project
* you must first delete all models associated with the project. To delete a
* model, see DeleteProjectVersion.
*
*
* DeleteProject is an asynchronous operation. To check if the
* project is deleted, call DescribeProjects. The project is deleted
* when the project no longer appears in the response. Be aware that
* deleting a given project will also delete any
* ProjectPolicies associated with that project.
*
*
* This operation requires permissions to perform the
* rekognition:DeleteProject action.
*
*
* @param deleteProjectRequest
* @return deleteProjectResult The response from the DeleteProject service
* method, as returned by Amazon Rekognition.
* @throws ResourceInUseException
* @throws ResourceNotFoundException
* @throws InvalidParameterException
* @throws AccessDeniedException
* @throws InternalServerErrorException
* @throws ThrottlingException
* @throws ProvisionedThroughputExceededException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by Amazon
* Rekognition indicating either a problem with the data in the
* request, or a server side issue.
*/
public DeleteProjectResult deleteProject(DeleteProjectRequest deleteProjectRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(deleteProjectRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteProjectRequestMarshaller().marshall(deleteProjectRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new DeleteProjectResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Deletes an existing project policy.
*
*
* To get a list of project policies attached to a project, call
* ListProjectPolicies. To attach a project policy to a project, call
* PutProjectPolicy.
*
*
* This operation requires permissions to perform the
* rekognition:DeleteProjectPolicy action.
*
*
* @param deleteProjectPolicyRequest
* @return deleteProjectPolicyResult The response from the
* DeleteProjectPolicy service method, as returned by Amazon
* Rekognition.
* @throws AccessDeniedException
* @throws InternalServerErrorException
* @throws InvalidParameterException
* @throws ResourceNotFoundException
* @throws ThrottlingException
* @throws ProvisionedThroughputExceededException
* @throws InvalidPolicyRevisionIdException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by Amazon
* Rekognition indicating either a problem with the data in the
* request, or a server side issue.
*/
public DeleteProjectPolicyResult deleteProjectPolicy(
DeleteProjectPolicyRequest deleteProjectPolicyRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(deleteProjectPolicyRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteProjectPolicyRequestMarshaller()
.marshall(deleteProjectPolicyRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new DeleteProjectPolicyResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Deletes an Amazon Rekognition Custom Labels model.
*
*
* You can't delete a model if it is running or if it is training. To check
* the status of a model, use the Status field returned from
* DescribeProjectVersions. To stop a running model call
* StopProjectVersion. If the model is training, wait until it
* finishes.
*
*
* This operation requires permissions to perform the
* rekognition:DeleteProjectVersion action.
*
*
* @param deleteProjectVersionRequest
* @return deleteProjectVersionResult The response from the
* DeleteProjectVersion service method, as returned by Amazon
* Rekognition.
* @throws ResourceNotFoundException
* @throws ResourceInUseException
* @throws InvalidParameterException
* @throws AccessDeniedException
* @throws InternalServerErrorException
* @throws ThrottlingException
* @throws ProvisionedThroughputExceededException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by Amazon
* Rekognition indicating either a problem with the data in the
* request, or a server side issue.
*/
public DeleteProjectVersionResult deleteProjectVersion(
DeleteProjectVersionRequest deleteProjectVersionRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(deleteProjectVersionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteProjectVersionRequestMarshaller()
.marshall(deleteProjectVersionRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new DeleteProjectVersionResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Deletes the stream processor identified by Name. You assign
* the value for Name when you create the stream processor with
* CreateStreamProcessor. You might not be able to use the same name
* for a stream processor for a few seconds after calling
* DeleteStreamProcessor.
*
*
* @param deleteStreamProcessorRequest
* @return deleteStreamProcessorResult The response from the
* DeleteStreamProcessor service method, as returned by Amazon
* Rekognition.
* @throws AccessDeniedException
* @throws InternalServerErrorException
* @throws ThrottlingException
* @throws InvalidParameterException
* @throws ResourceNotFoundException
* @throws ResourceInUseException
* @throws ProvisionedThroughputExceededException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by Amazon
* Rekognition indicating either a problem with the data in the
* request, or a server side issue.
*/
public DeleteStreamProcessorResult deleteStreamProcessor(
DeleteStreamProcessorRequest deleteStreamProcessorRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(deleteStreamProcessorRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteStreamProcessorRequestMarshaller()
.marshall(deleteStreamProcessorRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new DeleteStreamProcessorResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Deletes the specified UserID within the collection. Faces that are
* associated with the UserID are disassociated from the UserID before
* deleting the specified UserID. If the specified Collection
* or UserID is already deleted or not found, a
* ResourceNotFoundException will be thrown. If the action is
* successful with a 200 response, an empty HTTP body is returned.
*
*
* @param deleteUserRequest
* @return deleteUserResult The response from the DeleteUser service method,
* as returned by Amazon Rekognition.
* @throws InvalidParameterException
* @throws ConflictException
* @throws ResourceNotFoundException
* @throws ProvisionedThroughputExceededException
* @throws IdempotentParameterMismatchException
* @throws AccessDeniedException
* @throws InternalServerErrorException
* @throws ThrottlingException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by Amazon
* Rekognition indicating either a problem with the data in the
* request, or a server side issue.
*/
public DeleteUserResult deleteUser(DeleteUserRequest deleteUserRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(deleteUserRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteUserRequestMarshaller().marshall(deleteUserRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new DeleteUserResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Describes the specified collection. You can use
* DescribeCollection to get information, such as the number of
* faces indexed into a collection and the version of the model used by the
* collection for face detection.
*
*
* For more information, see Describing a Collection in the Amazon
* Rekognition Developer Guide.
*
*
* @param describeCollectionRequest
* @return describeCollectionResult The response from the DescribeCollection
* service method, as returned by Amazon Rekognition.
* @throws InvalidParameterException
* @throws AccessDeniedException
* @throws InternalServerErrorException
* @throws ThrottlingException
* @throws ProvisionedThroughputExceededException
* @throws ResourceNotFoundException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by Amazon
* Rekognition indicating either a problem with the data in the
* request, or a server side issue.
*/
public DescribeCollectionResult describeCollection(
DescribeCollectionRequest describeCollectionRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(describeCollectionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeCollectionRequestMarshaller()
.marshall(describeCollectionRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new DescribeCollectionResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Describes an Amazon Rekognition Custom Labels dataset. You can get
* information such as the current status of a dataset and statistics about
* the images and labels in a dataset.
*
*
* This operation requires permissions to perform the
* rekognition:DescribeDataset action.
*
*
* @param describeDatasetRequest
* @return describeDatasetResult The response from the DescribeDataset
* service method, as returned by Amazon Rekognition.
* @throws InternalServerErrorException
* @throws ThrottlingException
* @throws ProvisionedThroughputExceededException
* @throws InvalidParameterException
* @throws AccessDeniedException
* @throws ResourceNotFoundException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by Amazon
* Rekognition indicating either a problem with the data in the
* request, or a server side issue.
*/
public DescribeDatasetResult describeDataset(DescribeDatasetRequest describeDatasetRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(describeDatasetRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeDatasetRequestMarshaller().marshall(describeDatasetRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new DescribeDatasetResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Lists and describes the versions of a model in an Amazon Rekognition
* Custom Labels project. You can specify up to 10 model versions in
* ProjectVersionArns. If you don't specify a value,
* descriptions for all model versions in the project are returned.
*
*
* This operation requires permissions to perform the
* rekognition:DescribeProjectVersions action.
*
*
* @param describeProjectVersionsRequest
* @return describeProjectVersionsResult The response from the
* DescribeProjectVersions service method, as returned by Amazon
* Rekognition.
* @throws ResourceNotFoundException
* @throws InvalidPaginationTokenException
* @throws InvalidParameterException
* @throws AccessDeniedException
* @throws InternalServerErrorException
* @throws ThrottlingException
* @throws ProvisionedThroughputExceededException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by Amazon
* Rekognition indicating either a problem with the data in the
* request, or a server side issue.
*/
public DescribeProjectVersionsResult describeProjectVersions(
DescribeProjectVersionsRequest describeProjectVersionsRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(describeProjectVersionsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeProjectVersionsRequestMarshaller()
.marshall(describeProjectVersionsRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new DescribeProjectVersionsResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Gets information about your Amazon Rekognition Custom Labels projects.
*
*
* This operation requires permissions to perform the
* rekognition:DescribeProjects action.
*
*
* @param describeProjectsRequest
* @return describeProjectsResult The response from the DescribeProjects
* service method, as returned by Amazon Rekognition.
* @throws InvalidPaginationTokenException
* @throws InvalidParameterException
* @throws AccessDeniedException
* @throws InternalServerErrorException
* @throws ThrottlingException
* @throws ProvisionedThroughputExceededException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by Amazon
* Rekognition indicating either a problem with the data in the
* request, or a server side issue.
*/
public DescribeProjectsResult describeProjects(DescribeProjectsRequest describeProjectsRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(describeProjectsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeProjectsRequestMarshaller().marshall(describeProjectsRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new DescribeProjectsResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Provides information about a stream processor created by
* CreateStreamProcessor. You can get information about the input and
* output streams, the input parameters for the face recognition being
* performed, and the current status of the stream processor.
*
*
* @param describeStreamProcessorRequest
* @return describeStreamProcessorResult The response from the
* DescribeStreamProcessor service method, as returned by Amazon
* Rekognition.
* @throws AccessDeniedException
* @throws InternalServerErrorException
* @throws ThrottlingException
* @throws InvalidParameterException
* @throws ResourceNotFoundException
* @throws ProvisionedThroughputExceededException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by Amazon
* Rekognition indicating either a problem with the data in the
* request, or a server side issue.
*/
public DescribeStreamProcessorResult describeStreamProcessor(
DescribeStreamProcessorRequest describeStreamProcessorRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(describeStreamProcessorRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeStreamProcessorRequestMarshaller()
.marshall(describeStreamProcessorRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new DescribeStreamProcessorResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Detects custom labels in a supplied image by using an Amazon Rekognition
* Custom Labels model.
*
*
* You specify which version of a model version to use by using the
* ProjectVersionArn input parameter.
*
*
* You pass the input image as base64-encoded image bytes or as a reference
* to an image in an Amazon S3 bucket. If you use the AWS CLI to call Amazon
* Rekognition operations, passing image bytes is not supported. The image
* must be either a PNG or JPEG formatted file.
*
*
* For each object that the model version detects on an image, the API
* returns a (CustomLabel) object in an array (
* CustomLabels). Each CustomLabel object provides
* the label name (Name), the level of confidence that the
* image contains the object (Confidence), and object location
* information, if it exists, for the label on the image (
* Geometry).
*
*
* To filter labels that are returned, specify a value for
* MinConfidence. DetectCustomLabelsLabels only
* returns labels with a confidence that's higher than the specified value.
* The value of MinConfidence maps to the assumed threshold
* values created during training. For more information, see Assumed
* threshold in the Amazon Rekognition Custom Labels Developer Guide.
* Amazon Rekognition Custom Labels metrics expresses an assumed threshold
* as a floating point value between 0-1. The range of
* MinConfidence normalizes the threshold value to a percentage
* value (0-100). Confidence responses from DetectCustomLabels
* are also returned as a percentage. You can use MinConfidence
* to change the precision and recall or your model. For more information,
* see Analyzing an image in the Amazon Rekognition Custom Labels
* Developer Guide.
*
*
* If you don't specify a value for MinConfidence,
* DetectCustomLabels returns labels based on the assumed
* threshold of each label.
*
*
* This is a stateless API operation. That is, the operation does not
* persist any data.
*
*
* This operation requires permissions to perform the
* rekognition:DetectCustomLabels action.
*
*
* For more information, see Analyzing an image in the Amazon
* Rekognition Custom Labels Developer Guide.
*
*
* @param detectCustomLabelsRequest
* @return detectCustomLabelsResult The response from the DetectCustomLabels
* service method, as returned by Amazon Rekognition.
* @throws ResourceNotFoundException
* @throws ResourceNotReadyException
* @throws InvalidS3ObjectException
* @throws InvalidParameterException
* @throws ImageTooLargeException
* @throws LimitExceededException
* @throws AccessDeniedException
* @throws InternalServerErrorException
* @throws ThrottlingException
* @throws ProvisionedThroughputExceededException
* @throws InvalidImageFormatException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by Amazon
* Rekognition indicating either a problem with the data in the
* request, or a server side issue.
*/
public DetectCustomLabelsResult detectCustomLabels(
DetectCustomLabelsRequest detectCustomLabelsRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(detectCustomLabelsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DetectCustomLabelsRequestMarshaller()
.marshall(detectCustomLabelsRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new DetectCustomLabelsResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Detects faces within an image that is provided as input.
*
*
* DetectFaces detects the 100 largest faces in the image. For
* each face detected, the operation returns face details. These details
* include a bounding box of the face, a confidence value (that the bounding
* box contains a face), and a fixed set of attributes such as facial
* landmarks (for example, coordinates of eye and mouth), pose, presence of
* facial occlusion, and so on.
*
*
* The face-detection algorithm is most effective on frontal faces. For
* non-frontal or obscured faces, the algorithm might not detect the faces
* or might detect faces with lower confidence.
*
*
* You pass the input image either as base64-encoded image bytes or as a
* reference to an image in an Amazon S3 bucket. If you use the AWS CLI to
* call Amazon Rekognition operations, passing image bytes is not supported.
* The image must be either a PNG or JPEG formatted file.
*
*
*
* This is a stateless API operation. That is, the operation does not
* persist any data.
*
*
*
* This operation requires permissions to perform the
* rekognition:DetectFaces action.
*
*
* @param detectFacesRequest
* @return detectFacesResult The response from the DetectFaces service
* method, as returned by Amazon Rekognition.
* @throws InvalidS3ObjectException
* @throws InvalidParameterException
* @throws ImageTooLargeException
* @throws AccessDeniedException
* @throws InternalServerErrorException
* @throws ThrottlingException
* @throws ProvisionedThroughputExceededException
* @throws InvalidImageFormatException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by Amazon
* Rekognition indicating either a problem with the data in the
* request, or a server side issue.
*/
public DetectFacesResult detectFaces(DetectFacesRequest detectFacesRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(detectFacesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DetectFacesRequestMarshaller().marshall(detectFacesRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new DetectFacesResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Detects instances of real-world entities within an image (JPEG or PNG)
* provided as input. This includes objects like flower, tree, and table;
* events like wedding, graduation, and birthday party; and concepts like
* landscape, evening, and nature.
*
*
* For an example, see Analyzing images stored in an Amazon S3 bucket in the
* Amazon Rekognition Developer Guide.
*
*
* You pass the input image as base64-encoded image bytes or as a reference
* to an image in an Amazon S3 bucket. If you use the AWS CLI to call Amazon
* Rekognition operations, passing image bytes is not supported. The image
* must be either a PNG or JPEG formatted file.
*
*
* Optional Parameters
*
*
* You can specify one or both of the GENERAL_LABELS and
* IMAGE_PROPERTIES feature types when calling the DetectLabels
* API. Including GENERAL_LABELS will ensure the response
* includes the labels detected in the input image, while including
* IMAGE_PROPERTIES will ensure the response includes
* information about the image quality and color.
*
*
* When using GENERAL_LABELS and/or
* IMAGE_PROPERTIES you can provide filtering criteria to the
* Settings parameter. You can filter with sets of individual labels or with
* label categories. You can specify inclusive filters, exclusive filters,
* or a combination of inclusive and exclusive filters. For more information
* on filtering see Detecting Labels in an Image.
*
*
* You can specify MinConfidence to control the confidence
* threshold for the labels returned. The default is 55%. You can also add
* the MaxLabels parameter to limit the number of labels
* returned. The default and upper limit is 1000 labels.
*
*
* Response Elements
*
*
* For each object, scene, and concept the API returns one or more labels.
* The API returns the following types of information about labels:
*
*
* -
*
* Name - The name of the detected label.
*
*
* -
*
* Confidence - The level of confidence in the label assigned to a detected
* object.
*
*
* -
*
* Parents - The ancestor labels for a detected label. DetectLabels returns
* a hierarchical taxonomy of detected labels. For example, a detected car
* might be assigned the label car. The label car has two parent labels:
* Vehicle (its parent) and Transportation (its grandparent). The response
* includes the all ancestors for a label, where every ancestor is a unique
* label. In the previous example, Car, Vehicle, and Transportation are
* returned as unique labels in the response.
*
*
* -
*
* Aliases - Possible Aliases for the label.
*
*
* -
*
* Categories - The label categories that the detected label belongs to.
*
*
* -
*
* BoundingBox — Bounding boxes are described for all instances of detected
* common object labels, returned in an array of Instance objects. An
* Instance object contains a BoundingBox object, describing the location of
* the label on the input image. It also includes the confidence for the
* accuracy of the detected bounding box.
*
*
*
*
* The API returns the following information regarding the image, as part of
* the ImageProperties structure:
*
*
* -
*
* Quality - Information about the Sharpness, Brightness, and Contrast of
* the input image, scored between 0 to 100. Image quality is returned for
* the entire image, as well as the background and the foreground.
*
*
* -
*
* Dominant Color - An array of the dominant colors in the image.
*
*
* -
*
* Foreground - Information about the sharpness, brightness, and dominant
* colors of the input image’s foreground.
*
*
* -
*
* Background - Information about the sharpness, brightness, and dominant
* colors of the input image’s background.
*
*
*
*
* The list of returned labels will include at least one label for every
* detected object, along with information about that label. In the
* following example, suppose the input image has a lighthouse, the sea, and
* a rock. The response includes all three labels, one for each object, as
* well as the confidence in the label:
*
*
* {Name: lighthouse, Confidence: 98.4629}
*
*
* {Name: rock,Confidence: 79.2097}
*
*
* {Name: sea,Confidence: 75.061}
*
*
* The list of labels can include multiple labels for the same object. For
* example, if the input image shows a flower (for example, a tulip), the
* operation might return the following three labels.
*
*
* {Name: flower,Confidence: 99.0562}
*
*
* {Name: plant,Confidence: 99.0562}
*
*
* {Name: tulip,Confidence: 99.0562}
*
*
* In this example, the detection algorithm more precisely identifies the
* flower as a tulip.
*
*
*
* If the object detected is a person, the operation doesn't provide the
* same facial details that the DetectFaces operation provides.
*
*
*
* This is a stateless API operation that doesn't return any data.
*
*
* This operation requires permissions to perform the
* rekognition:DetectLabels action.
*
*
* @param detectLabelsRequest
* @return detectLabelsResult The response from the DetectLabels service
* method, as returned by Amazon Rekognition.
* @throws InvalidS3ObjectException
* @throws InvalidParameterException
* @throws ImageTooLargeException
* @throws AccessDeniedException
* @throws InternalServerErrorException
* @throws ThrottlingException
* @throws ProvisionedThroughputExceededException
* @throws InvalidImageFormatException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by Amazon
* Rekognition indicating either a problem with the data in the
* request, or a server side issue.
*/
public DetectLabelsResult detectLabels(DetectLabelsRequest detectLabelsRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(detectLabelsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DetectLabelsRequestMarshaller().marshall(detectLabelsRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new DetectLabelsResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Detects unsafe content in a specified JPEG or PNG format image. Use
* DetectModerationLabels to moderate images depending on your
* requirements. For example, you might want to filter images that contain
* nudity, but not images containing suggestive content.
*
*
* To filter images, use the labels returned by
* DetectModerationLabels to determine which types of content
* are appropriate.
*
*
* For information about moderation labels, see Detecting Unsafe Content in
* the Amazon Rekognition Developer Guide.
*
*
* You pass the input image either as base64-encoded image bytes or as a
* reference to an image in an Amazon S3 bucket. If you use the AWS CLI to
* call Amazon Rekognition operations, passing image bytes is not supported.
* The image must be either a PNG or JPEG formatted file.
*
*
* @param detectModerationLabelsRequest
* @return detectModerationLabelsResult The response from the
* DetectModerationLabels service method, as returned by Amazon
* Rekognition.
* @throws InvalidS3ObjectException
* @throws InvalidParameterException
* @throws ImageTooLargeException
* @throws AccessDeniedException
* @throws InternalServerErrorException
* @throws ThrottlingException
* @throws ProvisionedThroughputExceededException
* @throws InvalidImageFormatException
* @throws HumanLoopQuotaExceededException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by Amazon
* Rekognition indicating either a problem with the data in the
* request, or a server side issue.
*/
public DetectModerationLabelsResult detectModerationLabels(
DetectModerationLabelsRequest detectModerationLabelsRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(detectModerationLabelsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DetectModerationLabelsRequestMarshaller()
.marshall(detectModerationLabelsRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new DetectModerationLabelsResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Detects Personal Protective Equipment (PPE) worn by people detected in an
* image. Amazon Rekognition can detect the following types of PPE.
*
*
* -
*
* Face cover
*
*
* -
*
* Hand cover
*
*
* -
*
* Head cover
*
*
*
*
* You pass the input image as base64-encoded image bytes or as a reference
* to an image in an Amazon S3 bucket. The image must be either a PNG or JPG
* formatted file.
*
*
* DetectProtectiveEquipment detects PPE worn by up to 15
* persons detected in an image.
*
*
* For each person detected in the image the API returns an array of body
* parts (face, head, left-hand, right-hand). For each body part, an array
* of detected items of PPE is returned, including an indicator of whether
* or not the PPE covers the body part. The API returns the confidence it
* has in each detection (person, PPE, body part and body part coverage). It
* also returns a bounding box (BoundingBox) for each detected person
* and each detected item of PPE.
*
*
* You can optionally request a summary of detected PPE items with the
* SummarizationAttributes input parameter. The summary
* provides the following information.
*
*
* -
*
* The persons detected as wearing all of the types of PPE that you specify.
*
*
* -
*
* The persons detected as not wearing all of the types PPE that you
* specify.
*
*
* -
*
* The persons detected where PPE adornment could not be determined.
*
*
*
*
* This is a stateless API operation. That is, the operation does not
* persist any data.
*
*
* This operation requires permissions to perform the
* rekognition:DetectProtectiveEquipment action.
*
*
* @param detectProtectiveEquipmentRequest
* @return detectProtectiveEquipmentResult The response from the
* DetectProtectiveEquipment service method, as returned by Amazon
* Rekognition.
* @throws InvalidS3ObjectException
* @throws InvalidParameterException
* @throws ImageTooLargeException
* @throws AccessDeniedException
* @throws InternalServerErrorException
* @throws ThrottlingException
* @throws ProvisionedThroughputExceededException
* @throws InvalidImageFormatException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by Amazon
* Rekognition indicating either a problem with the data in the
* request, or a server side issue.
*/
public DetectProtectiveEquipmentResult detectProtectiveEquipment(
DetectProtectiveEquipmentRequest detectProtectiveEquipmentRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(detectProtectiveEquipmentRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DetectProtectiveEquipmentRequestMarshaller()
.marshall(detectProtectiveEquipmentRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new DetectProtectiveEquipmentResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Detects text in the input image and converts it into machine-readable
* text.
*
*
* Pass the input image as base64-encoded image bytes or as a reference to
* an image in an Amazon S3 bucket. If you use the AWS CLI to call Amazon
* Rekognition operations, you must pass it as a reference to an image in an
* Amazon S3 bucket. For the AWS CLI, passing image bytes is not supported.
* The image must be either a .png or .jpeg formatted file.
*
*
* The DetectText operation returns text in an array of
* TextDetection elements, TextDetections. Each
* TextDetection element provides information about a single
* word or line of text that was detected in the image.
*
*
* A word is one or more script characters that are not separated by spaces.
* DetectText can detect up to 100 words in an image.
*
*
* A line is a string of equally spaced words. A line isn't necessarily a
* complete sentence. For example, a driver's license number is detected as
* a line. A line ends when there is no aligned text after it. Also, a line
* ends when there is a large gap between words, relative to the length of
* the words. This means, depending on the gap between words, Amazon
* Rekognition may detect multiple lines in text aligned in the same
* direction. Periods don't represent the end of a line. If a sentence spans
* multiple lines, the DetectText operation returns multiple
* lines.
*
*
* To determine whether a TextDetection element is a line of
* text or a word, use the TextDetection object
* Type field.
*
*
* To be detected, text must be within +/- 90 degrees orientation of the
* horizontal axis.
*
*
* For more information, see Detecting text in the Amazon Rekognition
* Developer Guide.
*
*
* @param detectTextRequest
* @return detectTextResult The response from the DetectText service method,
* as returned by Amazon Rekognition.
* @throws InvalidS3ObjectException
* @throws InvalidParameterException
* @throws ImageTooLargeException
* @throws AccessDeniedException
* @throws InternalServerErrorException
* @throws ThrottlingException
* @throws ProvisionedThroughputExceededException
* @throws InvalidImageFormatException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by Amazon
* Rekognition indicating either a problem with the data in the
* request, or a server side issue.
*/
public DetectTextResult detectText(DetectTextRequest detectTextRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(detectTextRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DetectTextRequestMarshaller().marshall(detectTextRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new DetectTextResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Removes the association between a Face supplied in an array
* of FaceIds and the User. If the User is not present already,
* then a ResourceNotFound exception is thrown. If successful,
* an array of faces that are disassociated from the User is returned. If a
* given face is already disassociated from the given UserID, it will be
* ignored and not be returned in the response. If a given face is already
* associated with a different User or not found in the collection it will
* be returned as part of UnsuccessfulDisassociations. You can
* remove 1 - 100 face IDs from a user at one time.
*
*
* @param disassociateFacesRequest
* @return disassociateFacesResult The response from the DisassociateFaces
* service method, as returned by Amazon Rekognition.
* @throws InvalidParameterException
* @throws AccessDeniedException
* @throws InternalServerErrorException
* @throws ThrottlingException
* @throws ProvisionedThroughputExceededException
* @throws IdempotentParameterMismatchException
* @throws ResourceNotFoundException
* @throws ConflictException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by Amazon
* Rekognition indicating either a problem with the data in the
* request, or a server side issue.
*/
public DisassociateFacesResult disassociateFaces(
DisassociateFacesRequest disassociateFacesRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(disassociateFacesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DisassociateFacesRequestMarshaller()
.marshall(disassociateFacesRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new DisassociateFacesResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Distributes the entries (images) in a training dataset across the
* training dataset and the test dataset for a project.
* DistributeDatasetEntries moves 20% of the training dataset
* images to the test dataset. An entry is a JSON Line that describes an
* image.
*
*
* You supply the Amazon Resource Names (ARN) of a project's training
* dataset and test dataset. The training dataset must contain the images
* that you want to split. The test dataset must be empty. The datasets must
* belong to the same project. To create training and test datasets for a
* project, call CreateDataset.
*
*
* Distributing a dataset takes a while to complete. To check the status
* call DescribeDataset. The operation is complete when the
* Status field for the training dataset and the test dataset
* is UPDATE_COMPLETE. If the dataset split fails, the value of
* Status is UPDATE_FAILED.
*
*
* This operation requires permissions to perform the
* rekognition:DistributeDatasetEntries action.
*
*
* @param distributeDatasetEntriesRequest
* @return distributeDatasetEntriesResult The response from the
* DistributeDatasetEntries service method, as returned by Amazon
* Rekognition.
* @throws ResourceNotFoundException
* @throws InvalidParameterException
* @throws AccessDeniedException
* @throws InternalServerErrorException
* @throws ThrottlingException
* @throws ProvisionedThroughputExceededException
* @throws ResourceNotReadyException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by Amazon
* Rekognition indicating either a problem with the data in the
* request, or a server side issue.
*/
public DistributeDatasetEntriesResult distributeDatasetEntries(
DistributeDatasetEntriesRequest distributeDatasetEntriesRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(distributeDatasetEntriesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DistributeDatasetEntriesRequestMarshaller()
.marshall(distributeDatasetEntriesRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new DistributeDatasetEntriesResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Gets the name and additional information about a celebrity based on their
* Amazon Rekognition ID. The additional information is returned as an array
* of URLs. If there is no additional information about the celebrity, this
* list is empty.
*
*
* For more information, see Getting information about a celebrity in the
* Amazon Rekognition Developer Guide.
*
*
* This operation requires permissions to perform the
* rekognition:GetCelebrityInfo action.
*
*
* @param getCelebrityInfoRequest
* @return getCelebrityInfoResult The response from the GetCelebrityInfo
* service method, as returned by Amazon Rekognition.
* @throws InvalidParameterException
* @throws AccessDeniedException
* @throws InternalServerErrorException
* @throws ThrottlingException
* @throws ProvisionedThroughputExceededException
* @throws ResourceNotFoundException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by Amazon
* Rekognition indicating either a problem with the data in the
* request, or a server side issue.
*/
public GetCelebrityInfoResult getCelebrityInfo(GetCelebrityInfoRequest getCelebrityInfoRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(getCelebrityInfoRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetCelebrityInfoRequestMarshaller().marshall(getCelebrityInfoRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new GetCelebrityInfoResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Gets the celebrity recognition results for a Amazon Rekognition Video
* analysis started by StartCelebrityRecognition.
*
*
* Celebrity recognition in a video is an asynchronous operation. Analysis
* is started by a call to StartCelebrityRecognition which returns a
* job identifier (JobId).
*
*
* When the celebrity recognition operation finishes, Amazon Rekognition
* Video publishes a completion status to the Amazon Simple Notification
* Service topic registered in the initial call to
* StartCelebrityRecognition. To get the results of the
* celebrity recognition analysis, first check that the status value
* published to the Amazon SNS topic is SUCCEEDED. If so, call
* GetCelebrityDetection and pass the job identifier (
* JobId) from the initial call to
* StartCelebrityDetection.
*
*
* For more information, see Working With Stored Videos in the Amazon
* Rekognition Developer Guide.
*
*
* GetCelebrityRecognition returns detected celebrities and the
* time(s) they are detected in an array (Celebrities) of
* CelebrityRecognition objects. Each
* CelebrityRecognition contains information about the
* celebrity in a CelebrityDetail object and the time,
* Timestamp, the celebrity was detected. This
* CelebrityDetail object stores information about the detected
* celebrity's face attributes, a face bounding box, known gender, the
* celebrity's name, and a confidence estimate.
*
*
*
* GetCelebrityRecognition only returns the default facial
* attributes (BoundingBox, Confidence,
* Landmarks, Pose, and Quality). The
* BoundingBox field only applies to the detected face
* instance. The other facial attributes listed in the Face
* object of the following response syntax are not returned. For more
* information, see FaceDetail in the Amazon Rekognition Developer Guide.
*
*
*
* By default, the Celebrities array is sorted by time
* (milliseconds from the start of the video). You can also sort the array
* by celebrity by specifying the value ID in the
* SortBy input parameter.
*
*
* The CelebrityDetail object includes the celebrity identifer
* and additional information urls. If you don't store the additional
* information urls, you can get them later by calling
* GetCelebrityInfo with the celebrity identifer.
*
*
* No information is returned for faces not recognized as celebrities.
*
*
* Use MaxResults parameter to limit the number of labels returned. If there
* are more results than specified in MaxResults, the value of
* NextToken in the operation response contains a pagination
* token for getting the next set of results. To get the next page of
* results, call GetCelebrityDetection and populate the
* NextToken request parameter with the token value returned
* from the previous call to GetCelebrityRecognition.
*
*
* @param getCelebrityRecognitionRequest
* @return getCelebrityRecognitionResult The response from the
* GetCelebrityRecognition service method, as returned by Amazon
* Rekognition.
* @throws AccessDeniedException
* @throws InternalServerErrorException
* @throws InvalidParameterException
* @throws InvalidPaginationTokenException
* @throws ProvisionedThroughputExceededException
* @throws ResourceNotFoundException
* @throws ThrottlingException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by Amazon
* Rekognition indicating either a problem with the data in the
* request, or a server side issue.
*/
public GetCelebrityRecognitionResult getCelebrityRecognition(
GetCelebrityRecognitionRequest getCelebrityRecognitionRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(getCelebrityRecognitionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetCelebrityRecognitionRequestMarshaller()
.marshall(getCelebrityRecognitionRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new GetCelebrityRecognitionResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Gets the inappropriate, unwanted, or offensive content analysis results
* for a Amazon Rekognition Video analysis started by
* StartContentModeration. For a list of moderation labels in Amazon
* Rekognition, see Using the image and video moderation APIs.
*
*
* Amazon Rekognition Video inappropriate or offensive content detection in
* a stored video is an asynchronous operation. You start analysis by
* calling StartContentModeration which returns a job identifier (
* JobId). When analysis finishes, Amazon Rekognition Video
* publishes a completion status to the Amazon Simple Notification Service
* topic registered in the initial call to
* StartContentModeration. To get the results of the content
* analysis, first check that the status value published to the Amazon SNS
* topic is SUCCEEDED. If so, call
* GetContentModeration and pass the job identifier (
* JobId) from the initial call to
* StartContentModeration.
*
*
* For more information, see Working with Stored Videos in the Amazon
* Rekognition Devlopers Guide.
*
*
* GetContentModeration returns detected inappropriate,
* unwanted, or offensive content moderation labels, and the time they are
* detected, in an array, ModerationLabels, of
* ContentModerationDetection objects.
*
*
* By default, the moderated labels are returned sorted by time, in
* milliseconds from the start of the video. You can also sort them by
* moderated label by specifying NAME for the
* SortBy input parameter.
*
*
* Since video analysis can return a large number of results, use the
* MaxResults parameter to limit the number of labels returned
* in a single call to GetContentModeration. If there are more
* results than specified in MaxResults, the value of
* NextToken in the operation response contains a pagination
* token for getting the next set of results. To get the next page of
* results, call GetContentModeration and populate the
* NextToken request parameter with the value of
* NextToken returned from the previous call to
* GetContentModeration.
*
*
* For more information, see moderating content in the Amazon Rekognition
* Developer Guide.
*
*
* @param getContentModerationRequest
* @return getContentModerationResult The response from the
* GetContentModeration service method, as returned by Amazon
* Rekognition.
* @throws AccessDeniedException
* @throws InternalServerErrorException
* @throws InvalidParameterException
* @throws InvalidPaginationTokenException
* @throws ProvisionedThroughputExceededException
* @throws ResourceNotFoundException
* @throws ThrottlingException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by Amazon
* Rekognition indicating either a problem with the data in the
* request, or a server side issue.
*/
public GetContentModerationResult getContentModeration(
GetContentModerationRequest getContentModerationRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(getContentModerationRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetContentModerationRequestMarshaller()
.marshall(getContentModerationRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new GetContentModerationResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Gets face detection results for a Amazon Rekognition Video analysis
* started by StartFaceDetection.
*
*
* Face detection with Amazon Rekognition Video is an asynchronous
* operation. You start face detection by calling StartFaceDetection
* which returns a job identifier (JobId). When the face
* detection operation finishes, Amazon Rekognition Video publishes a
* completion status to the Amazon Simple Notification Service topic
* registered in the initial call to StartFaceDetection. To get
* the results of the face detection operation, first check that the status
* value published to the Amazon SNS topic is SUCCEEDED. If so,
* call GetFaceDetection and pass the job identifier (
* JobId) from the initial call to
* StartFaceDetection.
*
*
* GetFaceDetection returns an array of detected faces (
* Faces) sorted by the time the faces were detected.
*
*
* Use MaxResults parameter to limit the number of labels returned. If there
* are more results than specified in MaxResults, the value of
* NextToken in the operation response contains a pagination
* token for getting the next set of results. To get the next page of
* results, call GetFaceDetection and populate the
* NextToken request parameter with the token value returned
* from the previous call to GetFaceDetection.
*
*
* @param getFaceDetectionRequest
* @return getFaceDetectionResult The response from the GetFaceDetection
* service method, as returned by Amazon Rekognition.
* @throws AccessDeniedException
* @throws InternalServerErrorException
* @throws InvalidParameterException
* @throws InvalidPaginationTokenException
* @throws ProvisionedThroughputExceededException
* @throws ResourceNotFoundException
* @throws ThrottlingException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by Amazon
* Rekognition indicating either a problem with the data in the
* request, or a server side issue.
*/
public GetFaceDetectionResult getFaceDetection(GetFaceDetectionRequest getFaceDetectionRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(getFaceDetectionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetFaceDetectionRequestMarshaller().marshall(getFaceDetectionRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new GetFaceDetectionResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Retrieves the results of a specific Face Liveness session. It requires
* the sessionId as input, which was created using
* CreateFaceLivenessSession. Returns the corresponding Face
* Liveness confidence score, a reference image that includes a face
* bounding box, and audit images that also contain face bounding boxes. The
* Face Liveness confidence score ranges from 0 to 100. The reference image
* can optionally be returned.
*
*
* @param getFaceLivenessSessionResultsRequest
* @return getFaceLivenessSessionResultsResult The response from the
* GetFaceLivenessSessionResults service method, as returned by
* Amazon Rekognition.
* @throws AccessDeniedException
* @throws InternalServerErrorException
* @throws InvalidParameterException
* @throws SessionNotFoundException
* @throws ThrottlingException
* @throws ProvisionedThroughputExceededException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by Amazon
* Rekognition indicating either a problem with the data in the
* request, or a server side issue.
*/
public GetFaceLivenessSessionResultsResult getFaceLivenessSessionResults(
GetFaceLivenessSessionResultsRequest getFaceLivenessSessionResultsRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(getFaceLivenessSessionResultsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetFaceLivenessSessionResultsRequestMarshaller()
.marshall(getFaceLivenessSessionResultsRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new GetFaceLivenessSessionResultsResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Gets the face search results for Amazon Rekognition Video face search
* started by StartFaceSearch. The search returns faces in a
* collection that match the faces of persons detected in a video. It also
* includes the time(s) that faces are matched in the video.
*
*
* Face search in a video is an asynchronous operation. You start face
* search by calling to StartFaceSearch which returns a job
* identifier (JobId). When the search operation finishes,
* Amazon Rekognition Video publishes a completion status to the Amazon
* Simple Notification Service topic registered in the initial call to
* StartFaceSearch. To get the search results, first check that
* the status value published to the Amazon SNS topic is
* SUCCEEDED. If so, call GetFaceSearch and pass
* the job identifier (JobId) from the initial call to
* StartFaceSearch.
*
*
* For more information, see Searching Faces in a Collection in the Amazon
* Rekognition Developer Guide.
*
*
* The search results are retured in an array, Persons, of
* PersonMatch objects. EachPersonMatch element contains
* details about the matching faces in the input collection, person
* information (facial attributes, bounding boxes, and person identifer) for
* the matched person, and the time the person was matched in the video.
*
*
*
* GetFaceSearch only returns the default facial attributes (
* BoundingBox, Confidence, Landmarks, Pose, and Quality). The other facial
* attributes listed in the Face object of the following
* response syntax are not returned. For more information, see FaceDetail in
* the Amazon Rekognition Developer Guide.
*
*
*
* By default, the Persons array is sorted by the time, in
* milliseconds from the start of the video, persons are matched. You can
* also sort by persons by specifying INDEX for the
* SORTBY input parameter.
*
*
* @param getFaceSearchRequest
* @return getFaceSearchResult The response from the GetFaceSearch service
* method, as returned by Amazon Rekognition.
* @throws AccessDeniedException
* @throws InternalServerErrorException
* @throws InvalidParameterException
* @throws InvalidPaginationTokenException
* @throws ProvisionedThroughputExceededException
* @throws ResourceNotFoundException
* @throws ThrottlingException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by Amazon
* Rekognition indicating either a problem with the data in the
* request, or a server side issue.
*/
public GetFaceSearchResult getFaceSearch(GetFaceSearchRequest getFaceSearchRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(getFaceSearchRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetFaceSearchRequestMarshaller().marshall(getFaceSearchRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new GetFaceSearchResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Gets the label detection results of a Amazon Rekognition Video analysis
* started by StartLabelDetection.
*
*
* The label detection operation is started by a call to
* StartLabelDetection which returns a job identifier (
* JobId). When the label detection operation finishes, Amazon
* Rekognition publishes a completion status to the Amazon Simple
* Notification Service topic registered in the initial call to
* StartlabelDetection.
*
*
* To get the results of the label detection operation, first check that the
* status value published to the Amazon SNS topic is SUCCEEDED.
* If so, call GetLabelDetection and pass the job identifier (
* JobId) from the initial call to
* StartLabelDetection.
*
*
* GetLabelDetection returns an array of detected labels (
* Labels) sorted by the time the labels were detected. You can
* also sort by the label name by specifying NAME for the
* SortBy input parameter. If there is no NAME
* specified, the default sort is by timestamp.
*
*
* You can select how results are aggregated by using the
* AggregateBy input parameter. The default aggregation method
* is TIMESTAMPS. You can also aggregate by
* SEGMENTS, which aggregates all instances of labels detected
* in a given segment.
*
*
* The returned Labels array may include the following attributes:
*
*
* -
*
* Name - The name of the detected label.
*
*
* -
*
* Confidence - The level of confidence in the label assigned to a detected
* object.
*
*
* -
*
* Parents - The ancestor labels for a detected label. GetLabelDetection
* returns a hierarchical taxonomy of detected labels. For example, a
* detected car might be assigned the label car. The label car has two
* parent labels: Vehicle (its parent) and Transportation (its grandparent).
* The response includes the all ancestors for a label, where every ancestor
* is a unique label. In the previous example, Car, Vehicle, and
* Transportation are returned as unique labels in the response.
*
*
* -
*
* Aliases - Possible Aliases for the label.
*
*
* -
*
* Categories - The label categories that the detected label belongs to.
*
*
* -
*
* BoundingBox — Bounding boxes are described for all instances of detected
* common object labels, returned in an array of Instance objects. An
* Instance object contains a BoundingBox object, describing the location of
* the label on the input image. It also includes the confidence for the
* accuracy of the detected bounding box.
*
*
* -
*
* Timestamp - Time, in milliseconds from the start of the video, that the
* label was detected. For aggregation by SEGMENTS, the
* StartTimestampMillis, EndTimestampMillis, and
* DurationMillis structures are what define a segment.
* Although the “Timestamp” structure is still returned with each label, its
* value is set to be the same as StartTimestampMillis.
*
*
*
*
* Timestamp and Bounding box information are returned for detected
* Instances, only if aggregation is done by TIMESTAMPS. If
* aggregating by SEGMENTS, information about detected
* instances isn’t returned.
*
*
* The version of the label model used for the detection is also returned.
*
*
* Note DominantColors isn't returned for
* Instances, although it is shown as part of the response in
* the sample seen below.
*
*
* Use MaxResults parameter to limit the number of labels
* returned. If there are more results than specified in
* MaxResults, the value of NextToken in the
* operation response contains a pagination token for getting the next set
* of results. To get the next page of results, call
* GetlabelDetection and populate the NextToken
* request parameter with the token value returned from the previous call to
* GetLabelDetection.
*
*
* @param getLabelDetectionRequest
* @return getLabelDetectionResult The response from the GetLabelDetection
* service method, as returned by Amazon Rekognition.
* @throws AccessDeniedException
* @throws InternalServerErrorException
* @throws InvalidParameterException
* @throws InvalidPaginationTokenException
* @throws ProvisionedThroughputExceededException
* @throws ResourceNotFoundException
* @throws ThrottlingException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by Amazon
* Rekognition indicating either a problem with the data in the
* request, or a server side issue.
*/
public GetLabelDetectionResult getLabelDetection(
GetLabelDetectionRequest getLabelDetectionRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(getLabelDetectionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetLabelDetectionRequestMarshaller()
.marshall(getLabelDetectionRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new GetLabelDetectionResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Gets the path tracking results of a Amazon Rekognition Video analysis
* started by StartPersonTracking.
*
*
* The person path tracking operation is started by a call to
* StartPersonTracking which returns a job identifier (
* JobId). When the operation finishes, Amazon Rekognition
* Video publishes a completion status to the Amazon Simple Notification
* Service topic registered in the initial call to
* StartPersonTracking.
*
*
* To get the results of the person path tracking operation, first check
* that the status value published to the Amazon SNS topic is
* SUCCEEDED. If so, call GetPersonTracking and pass the
* job identifier (JobId) from the initial call to
* StartPersonTracking.
*
*
* GetPersonTracking returns an array, Persons, of
* tracked persons and the time(s) their paths were tracked in the video.
*
*
*
* GetPersonTracking only returns the default facial attributes
* (BoundingBox, Confidence,
* Landmarks, Pose, and Quality). The
* other facial attributes listed in the Face object of the
* following response syntax are not returned.
*
*
* For more information, see FaceDetail in the Amazon Rekognition Developer
* Guide.
*
*
*
* By default, the array is sorted by the time(s) a person's path is tracked
* in the video. You can sort by tracked persons by specifying
* INDEX for the SortBy input parameter.
*
*
* Use the MaxResults parameter to limit the number of items
* returned. If there are more results than specified in
* MaxResults, the value of NextToken in the
* operation response contains a pagination token for getting the next set
* of results. To get the next page of results, call
* GetPersonTracking and populate the NextToken
* request parameter with the token value returned from the previous call to
* GetPersonTracking.
*
*
* @param getPersonTrackingRequest
* @return getPersonTrackingResult The response from the GetPersonTracking
* service method, as returned by Amazon Rekognition.
* @throws AccessDeniedException
* @throws InternalServerErrorException
* @throws InvalidParameterException
* @throws InvalidPaginationTokenException
* @throws ProvisionedThroughputExceededException
* @throws ResourceNotFoundException
* @throws ThrottlingException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by Amazon
* Rekognition indicating either a problem with the data in the
* request, or a server side issue.
*/
public GetPersonTrackingResult getPersonTracking(
GetPersonTrackingRequest getPersonTrackingRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(getPersonTrackingRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetPersonTrackingRequestMarshaller()
.marshall(getPersonTrackingRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new GetPersonTrackingResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Gets the segment detection results of a Amazon Rekognition Video analysis
* started by StartSegmentDetection.
*
*
* Segment detection with Amazon Rekognition Video is an asynchronous
* operation. You start segment detection by calling
* StartSegmentDetection which returns a job identifier (
* JobId). When the segment detection operation finishes,
* Amazon Rekognition publishes a completion status to the Amazon Simple
* Notification Service topic registered in the initial call to
* StartSegmentDetection. To get the results of the segment
* detection operation, first check that the status value published to the
* Amazon SNS topic is SUCCEEDED. if so, call
* GetSegmentDetection and pass the job identifier (
* JobId) from the initial call of
* StartSegmentDetection.
*
*
* GetSegmentDetection returns detected segments in an array (
* Segments) of SegmentDetection objects.
* Segments is sorted by the segment types specified in the
* SegmentTypes input parameter of
* StartSegmentDetection. Each element of the array includes
* the detected segment, the precentage confidence in the acuracy of the
* detected segment, the type of the segment, and the frame in which the
* segment was detected.
*
*
* Use SelectedSegmentTypes to find out the type of segment
* detection requested in the call to StartSegmentDetection.
*
*
* Use the MaxResults parameter to limit the number of segment
* detections returned. If there are more results than specified in
* MaxResults, the value of NextToken in the
* operation response contains a pagination token for getting the next set
* of results. To get the next page of results, call
* GetSegmentDetection and populate the NextToken
* request parameter with the token value returned from the previous call to
* GetSegmentDetection.
*
*
* For more information, see Detecting video segments in stored video in the
* Amazon Rekognition Developer Guide.
*
*
* @param getSegmentDetectionRequest
* @return getSegmentDetectionResult The response from the
* GetSegmentDetection service method, as returned by Amazon
* Rekognition.
* @throws AccessDeniedException
* @throws InternalServerErrorException
* @throws InvalidParameterException
* @throws InvalidPaginationTokenException
* @throws ProvisionedThroughputExceededException
* @throws ResourceNotFoundException
* @throws ThrottlingException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by Amazon
* Rekognition indicating either a problem with the data in the
* request, or a server side issue.
*/
public GetSegmentDetectionResult getSegmentDetection(
GetSegmentDetectionRequest getSegmentDetectionRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(getSegmentDetectionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetSegmentDetectionRequestMarshaller()
.marshall(getSegmentDetectionRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new GetSegmentDetectionResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Gets the text detection results of a Amazon Rekognition Video analysis
* started by StartTextDetection.
*
*
* Text detection with Amazon Rekognition Video is an asynchronous
* operation. You start text detection by calling StartTextDetection
* which returns a job identifier (JobId) When the text
* detection operation finishes, Amazon Rekognition publishes a completion
* status to the Amazon Simple Notification Service topic registered in the
* initial call to StartTextDetection. To get the results of
* the text detection operation, first check that the status value published
* to the Amazon SNS topic is SUCCEEDED. if so, call
* GetTextDetection and pass the job identifier (
* JobId) from the initial call of
* StartLabelDetection.
*
*
* GetTextDetection returns an array of detected text (
* TextDetections) sorted by the time the text was detected, up
* to 50 words per frame of video.
*
*
* Each element of the array includes the detected text, the precentage
* confidence in the acuracy of the detected text, the time the text was
* detected, bounding box information for where the text was located, and
* unique identifiers for words and their lines.
*
*
* Use MaxResults parameter to limit the number of text detections returned.
* If there are more results than specified in MaxResults, the
* value of NextToken in the operation response contains a
* pagination token for getting the next set of results. To get the next
* page of results, call GetTextDetection and populate the
* NextToken request parameter with the token value returned
* from the previous call to GetTextDetection.
*
*
* @param getTextDetectionRequest
* @return getTextDetectionResult The response from the GetTextDetection
* service method, as returned by Amazon Rekognition.
* @throws AccessDeniedException
* @throws InternalServerErrorException
* @throws InvalidParameterException
* @throws InvalidPaginationTokenException
* @throws ProvisionedThroughputExceededException
* @throws ResourceNotFoundException
* @throws ThrottlingException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by Amazon
* Rekognition indicating either a problem with the data in the
* request, or a server side issue.
*/
public GetTextDetectionResult getTextDetection(GetTextDetectionRequest getTextDetectionRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(getTextDetectionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetTextDetectionRequestMarshaller().marshall(getTextDetectionRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new GetTextDetectionResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Detects faces in the input image and adds them to the specified
* collection.
*
*
* Amazon Rekognition doesn't save the actual faces that are detected.
* Instead, the underlying detection algorithm first detects the faces in
* the input image. For each face, the algorithm extracts facial features
* into a feature vector, and stores it in the backend database. Amazon
* Rekognition uses feature vectors when it performs face match and search
* operations using the SearchFaces and SearchFacesByImage
* operations.
*
*
* For more information, see Adding faces to a collection in the Amazon
* Rekognition Developer Guide.
*
*
* To get the number of faces in a collection, call
* DescribeCollection.
*
*
* If you're using version 1.0 of the face detection model,
* IndexFaces indexes the 15 largest faces in the input image.
* Later versions of the face detection model index the 100 largest faces in
* the input image.
*
*
* If you're using version 4 or later of the face model, image orientation
* information is not returned in the OrientationCorrection
* field.
*
*
* To determine which version of the model you're using, call
* DescribeCollection and supply the collection ID. You can also get
* the model version from the value of FaceModelVersion in the
* response from IndexFaces
*
*
* For more information, see Model Versioning in the Amazon Rekognition
* Developer Guide.
*
*
* If you provide the optional ExternalImageId for the input
* image you provided, Amazon Rekognition associates this ID with all faces
* that it detects. When you call the ListFaces operation, the
* response returns the external ID. You can use this external image ID to
* create a client-side index to associate the faces with each image. You
* can then use the index to find all faces in an image.
*
*
* You can specify the maximum number of faces to index with the
* MaxFaces input parameter. This is useful when you want to
* index the largest faces in an image and don't want to index smaller
* faces, such as those belonging to people standing in the background.
*
*
* The QualityFilter input parameter allows you to filter out
* detected faces that don’t meet a required quality bar. The quality bar is
* based on a variety of common use cases. By default,
* IndexFaces chooses the quality bar that's used to filter
* faces. You can also explicitly choose the quality bar. Use
* QualityFilter, to set the quality bar by specifying
* LOW, MEDIUM, or HIGH. If you do
* not want to filter detected faces, specify NONE.
*
*
*
* To use quality filtering, you need a collection associated with version 3
* of the face model or higher. To get the version of the face model
* associated with a collection, call DescribeCollection.
*
*
*
* Information about faces detected in an image, but not indexed, is
* returned in an array of UnindexedFace objects,
* UnindexedFaces. Faces aren't indexed for reasons such as:
*
*
* -
*
* The number of faces detected exceeds the value of the
* MaxFaces request parameter.
*
*
* -
*
* The face is too small compared to the image dimensions.
*
*
* -
*
* The face is too blurry.
*
*
* -
*
* The image is too dark.
*
*
* -
*
* The face has an extreme pose.
*
*
* -
*
* The face doesn’t have enough detail to be suitable for face search.
*
*
*
*
* In response, the IndexFaces operation returns an array of
* metadata for all detected faces, FaceRecords. This includes:
*
*
* -
*
* The bounding box, BoundingBox, of the detected face.
*
*
* -
*
* A confidence value, Confidence, which indicates the
* confidence that the bounding box contains a face.
*
*
* -
*
* A face ID, FaceId, assigned by the service for each face
* that's detected and stored.
*
*
* -
*
* An image ID, ImageId, assigned by the service for the input
* image.
*
*
*
*
* If you request ALL or specific facial attributes (e.g.,
* FACE_OCCLUDED) by using the detectionAttributes parameter,
* Amazon Rekognition returns detailed facial attributes, such as facial
* landmarks (for example, location of eye and mouth), facial occlusion, and
* other facial attributes.
*
*
* If you provide the same image, specify the same collection, and use the
* same external ID in the IndexFaces operation, Amazon
* Rekognition doesn't save duplicate face metadata.
*
*
*
* The input image is passed either as base64-encoded image bytes, or as a
* reference to an image in an Amazon S3 bucket. If you use the AWS CLI to
* call Amazon Rekognition operations, passing image bytes isn't supported.
* The image must be formatted as a PNG or JPEG file.
*
*
* This operation requires permissions to perform the
* rekognition:IndexFaces action.
*
*
* @param indexFacesRequest
* @return indexFacesResult The response from the IndexFaces service method,
* as returned by Amazon Rekognition.
* @throws InvalidS3ObjectException
* @throws InvalidParameterException
* @throws ImageTooLargeException
* @throws AccessDeniedException
* @throws InternalServerErrorException
* @throws ThrottlingException
* @throws ProvisionedThroughputExceededException
* @throws ResourceNotFoundException
* @throws InvalidImageFormatException
* @throws ServiceQuotaExceededException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by Amazon
* Rekognition indicating either a problem with the data in the
* request, or a server side issue.
*/
public IndexFacesResult indexFaces(IndexFacesRequest indexFacesRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(indexFacesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new IndexFacesRequestMarshaller().marshall(indexFacesRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new IndexFacesResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Returns list of collection IDs in your account. If the result is
* truncated, the response also provides a NextToken that you
* can use in the subsequent request to fetch the next set of collection
* IDs.
*
*
* For an example, see Listing collections in the Amazon Rekognition
* Developer Guide.
*
*
* This operation requires permissions to perform the
* rekognition:ListCollections action.
*
*
* @param listCollectionsRequest
* @return listCollectionsResult The response from the ListCollections
* service method, as returned by Amazon Rekognition.
* @throws InvalidParameterException
* @throws AccessDeniedException
* @throws InternalServerErrorException
* @throws ThrottlingException
* @throws ProvisionedThroughputExceededException
* @throws InvalidPaginationTokenException
* @throws ResourceNotFoundException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by Amazon
* Rekognition indicating either a problem with the data in the
* request, or a server side issue.
*/
public ListCollectionsResult listCollections(ListCollectionsRequest listCollectionsRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(listCollectionsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListCollectionsRequestMarshaller().marshall(listCollectionsRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new ListCollectionsResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Lists the entries (images) within a dataset. An entry is a JSON Line that
* contains the information for a single image, including the image
* location, assigned labels, and object location bounding boxes. For more
* information, see Creating a manifest file.
*
*
* JSON Lines in the response include information about non-terminal errors
* found in the dataset. Non terminal errors are reported in
* errors lists within each JSON Line. The same information is
* reported in the training and testing validation result manifests that
* Amazon Rekognition Custom Labels creates during model training.
*
*
* You can filter the response in variety of ways, such as choosing which
* labels to return and returning JSON Lines created after a specific date.
*
*
* This operation requires permissions to perform the
* rekognition:ListDatasetEntries action.
*
*
* @param listDatasetEntriesRequest
* @return listDatasetEntriesResult The response from the ListDatasetEntries
* service method, as returned by Amazon Rekognition.
* @throws InternalServerErrorException
* @throws ThrottlingException
* @throws ProvisionedThroughputExceededException
* @throws InvalidParameterException
* @throws AccessDeniedException
* @throws ResourceInUseException
* @throws ResourceNotFoundException
* @throws InvalidPaginationTokenException
* @throws ResourceNotReadyException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by Amazon
* Rekognition indicating either a problem with the data in the
* request, or a server side issue.
*/
public ListDatasetEntriesResult listDatasetEntries(
ListDatasetEntriesRequest listDatasetEntriesRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(listDatasetEntriesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListDatasetEntriesRequestMarshaller()
.marshall(listDatasetEntriesRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new ListDatasetEntriesResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Lists the labels in a dataset. Amazon Rekognition Custom Labels uses
* labels to describe images. For more information, see Labeling images.
*
*
* Lists the labels in a dataset. Amazon Rekognition Custom Labels uses
* labels to describe images. For more information, see Labeling images in
* the Amazon Rekognition Custom Labels Developer Guide.
*
*
* @param listDatasetLabelsRequest
* @return listDatasetLabelsResult The response from the ListDatasetLabels
* service method, as returned by Amazon Rekognition.
* @throws InternalServerErrorException
* @throws ThrottlingException
* @throws ProvisionedThroughputExceededException
* @throws InvalidParameterException
* @throws AccessDeniedException
* @throws ResourceInUseException
* @throws InvalidPaginationTokenException
* @throws ResourceNotFoundException
* @throws ResourceNotReadyException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by Amazon
* Rekognition indicating either a problem with the data in the
* request, or a server side issue.
*/
public ListDatasetLabelsResult listDatasetLabels(
ListDatasetLabelsRequest listDatasetLabelsRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(listDatasetLabelsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListDatasetLabelsRequestMarshaller()
.marshall(listDatasetLabelsRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new ListDatasetLabelsResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Returns metadata for faces in the specified collection. This metadata
* includes information such as the bounding box coordinates, the confidence
* (that the bounding box contains a face), and face ID. For an example, see
* Listing Faces in a Collection in the Amazon Rekognition Developer Guide.
*
*
* This operation requires permissions to perform the
* rekognition:ListFaces action.
*
*
* @param listFacesRequest
* @return listFacesResult The response from the ListFaces service method,
* as returned by Amazon Rekognition.
* @throws InvalidParameterException
* @throws AccessDeniedException
* @throws InternalServerErrorException
* @throws ThrottlingException
* @throws ProvisionedThroughputExceededException
* @throws InvalidPaginationTokenException
* @throws ResourceNotFoundException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by Amazon
* Rekognition indicating either a problem with the data in the
* request, or a server side issue.
*/
public ListFacesResult listFaces(ListFacesRequest listFacesRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(listFacesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListFacesRequestMarshaller().marshall(listFacesRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new ListFacesResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Gets a list of the project policies attached to a project.
*
*
* To attach a project policy to a project, call PutProjectPolicy. To
* remove a project policy from a project, call DeleteProjectPolicy.
*
*
* This operation requires permissions to perform the
* rekognition:ListProjectPolicies action.
*
*
* @param listProjectPoliciesRequest
* @return listProjectPoliciesResult The response from the
* ListProjectPolicies service method, as returned by Amazon
* Rekognition.
* @throws AccessDeniedException
* @throws InternalServerErrorException
* @throws InvalidParameterException
* @throws ResourceNotFoundException
* @throws ThrottlingException
* @throws ProvisionedThroughputExceededException
* @throws InvalidPaginationTokenException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by Amazon
* Rekognition indicating either a problem with the data in the
* request, or a server side issue.
*/
public ListProjectPoliciesResult listProjectPolicies(
ListProjectPoliciesRequest listProjectPoliciesRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(listProjectPoliciesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListProjectPoliciesRequestMarshaller()
.marshall(listProjectPoliciesRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new ListProjectPoliciesResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Gets a list of stream processors that you have created with
* CreateStreamProcessor.
*
*
* @param listStreamProcessorsRequest
* @return listStreamProcessorsResult The response from the
* ListStreamProcessors service method, as returned by Amazon
* Rekognition.
* @throws AccessDeniedException
* @throws InternalServerErrorException
* @throws ThrottlingException
* @throws InvalidParameterException
* @throws InvalidPaginationTokenException
* @throws ProvisionedThroughputExceededException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by Amazon
* Rekognition indicating either a problem with the data in the
* request, or a server side issue.
*/
public ListStreamProcessorsResult listStreamProcessors(
ListStreamProcessorsRequest listStreamProcessorsRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(listStreamProcessorsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListStreamProcessorsRequestMarshaller()
.marshall(listStreamProcessorsRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new ListStreamProcessorsResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Returns a list of tags in an Amazon Rekognition collection, stream
* processor, or Custom Labels model.
*
*
* This operation requires permissions to perform the
* rekognition:ListTagsForResource action.
*
*
* @param listTagsForResourceRequest
* @return listTagsForResourceResult The response from the
* ListTagsForResource service method, as returned by Amazon
* Rekognition.
* @throws ResourceNotFoundException
* @throws InvalidParameterException
* @throws AccessDeniedException
* @throws InternalServerErrorException
* @throws ThrottlingException
* @throws ProvisionedThroughputExceededException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by Amazon
* Rekognition indicating either a problem with the data in the
* request, or a server side issue.
*/
public ListTagsForResourceResult listTagsForResource(
ListTagsForResourceRequest listTagsForResourceRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(listTagsForResourceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListTagsForResourceRequestMarshaller()
.marshall(listTagsForResourceRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new ListTagsForResourceResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Returns metadata of the User such as UserID in the specified
* collection. Anonymous User (to reserve faces without any identity) is not
* returned as part of this request. The results are sorted by system
* generated primary key ID. If the response is truncated,
* NextToken is returned in the response that can be used in
* the subsequent request to retrieve the next set of identities.
*
*
* @param listUsersRequest
* @return listUsersResult The response from the ListUsers service method,
* as returned by Amazon Rekognition.
* @throws InvalidParameterException
* @throws ResourceNotFoundException
* @throws InvalidPaginationTokenException
* @throws ProvisionedThroughputExceededException
* @throws AccessDeniedException
* @throws InternalServerErrorException
* @throws ThrottlingException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by Amazon
* Rekognition indicating either a problem with the data in the
* request, or a server side issue.
*/
public ListUsersResult listUsers(ListUsersRequest listUsersRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(listUsersRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListUsersRequestMarshaller().marshall(listUsersRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new ListUsersResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*