blib/lib/Paws/Rekognition.pm untested

filter: Statementstmt 0.0% 0 / 277 Branchbran 0.0% 0 / 20 Conditioncond n/a MC/DCmcdc n/a Subroutinesub 0.0% 0 / 63 Podpod 0.0% 0 / 62 totaltotal 0.0% 0 / 422 CC 11 SCAR 14.0
CC
11
Cov
0%
DescribeAllProjects
12.0
DescribeAllProjectVersions
12.0
ListAllCollections
12.0
CRAP 4.1
1 package Paws::Rekognition;
2 use Moose;
3 sub service { 'rekognition' }
4 sub signing_name { 'rekognition' }
5 sub version { '2016-06-27' }
6 sub target_prefix { 'RekognitionService' }
7 sub json_version { "1.1" }
8 has max_attempts => (is => 'ro', isa => 'Int', default => 5);
9 has retry => (is => 'ro', isa => 'HashRef', default => sub {
10 { base => 'rand', type => 'exponential', growth_factor => 2 }
11 });
12 has retriables => (is => 'ro', isa => 'ArrayRef', default => sub { [
13 ] });
14  
15 with 'Paws::API::Caller', 'Paws::API::EndpointResolver', 'Paws::Net::V4Signature', 'Paws::Net::JsonCaller';
16  
17
18 sub CompareFaces {
19 my $self = shift;
20 my $call_object = $self->new_with_coercions('Paws::Rekognition::CompareFaces', @_);
21 return $self->caller->do_call($self, $call_object);
22 }
23 sub CreateCollection {
24 my $self = shift;
25 my $call_object = $self->new_with_coercions('Paws::Rekognition::CreateCollection', @_);
26 return $self->caller->do_call($self, $call_object);
27 }
28 sub CreateProject {
29 my $self = shift;
30 my $call_object = $self->new_with_coercions('Paws::Rekognition::CreateProject', @_);
31 return $self->caller->do_call($self, $call_object);
32 }
33 sub CreateProjectVersion {
34 my $self = shift;
35 my $call_object = $self->new_with_coercions('Paws::Rekognition::CreateProjectVersion', @_);
36 return $self->caller->do_call($self, $call_object);
37 }
38 sub CreateStreamProcessor {
39 my $self = shift;
40 my $call_object = $self->new_with_coercions('Paws::Rekognition::CreateStreamProcessor', @_);
41 return $self->caller->do_call($self, $call_object);
42 }
43 sub DeleteCollection {
44 my $self = shift;
45 my $call_object = $self->new_with_coercions('Paws::Rekognition::DeleteCollection', @_);
46 return $self->caller->do_call($self, $call_object);
47 }
48 sub DeleteFaces {
49 my $self = shift;
50 my $call_object = $self->new_with_coercions('Paws::Rekognition::DeleteFaces', @_);
51 return $self->caller->do_call($self, $call_object);
52 }
53 sub DeleteProject {
54 my $self = shift;
55 my $call_object = $self->new_with_coercions('Paws::Rekognition::DeleteProject', @_);
56 return $self->caller->do_call($self, $call_object);
57 }
58 sub DeleteProjectVersion {
59 my $self = shift;
60 my $call_object = $self->new_with_coercions('Paws::Rekognition::DeleteProjectVersion', @_);
61 return $self->caller->do_call($self, $call_object);
62 }
63 sub DeleteStreamProcessor {
64 my $self = shift;
65 my $call_object = $self->new_with_coercions('Paws::Rekognition::DeleteStreamProcessor', @_);
66 return $self->caller->do_call($self, $call_object);
67 }
68 sub DescribeCollection {
69 my $self = shift;
70 my $call_object = $self->new_with_coercions('Paws::Rekognition::DescribeCollection', @_);
71 return $self->caller->do_call($self, $call_object);
72 }
73 sub DescribeProjects {
74 my $self = shift;
75 my $call_object = $self->new_with_coercions('Paws::Rekognition::DescribeProjects', @_);
76 return $self->caller->do_call($self, $call_object);
77 }
78 sub DescribeProjectVersions {
79 my $self = shift;
80 my $call_object = $self->new_with_coercions('Paws::Rekognition::DescribeProjectVersions', @_);
81 return $self->caller->do_call($self, $call_object);
82 }
83 sub DescribeStreamProcessor {
84 my $self = shift;
85 my $call_object = $self->new_with_coercions('Paws::Rekognition::DescribeStreamProcessor', @_);
86 return $self->caller->do_call($self, $call_object);
87 }
88 sub DetectCustomLabels {
89 my $self = shift;
90 my $call_object = $self->new_with_coercions('Paws::Rekognition::DetectCustomLabels', @_);
91 return $self->caller->do_call($self, $call_object);
92 }
93 sub DetectFaces {
94 my $self = shift;
95 my $call_object = $self->new_with_coercions('Paws::Rekognition::DetectFaces', @_);
96 return $self->caller->do_call($self, $call_object);
97 }
98 sub DetectLabels {
99 my $self = shift;
100 my $call_object = $self->new_with_coercions('Paws::Rekognition::DetectLabels', @_);
101 return $self->caller->do_call($self, $call_object);
102 }
103 sub DetectModerationLabels {
104 my $self = shift;
105 my $call_object = $self->new_with_coercions('Paws::Rekognition::DetectModerationLabels', @_);
106 return $self->caller->do_call($self, $call_object);
107 }
108 sub DetectProtectiveEquipment {
109 my $self = shift;
110 my $call_object = $self->new_with_coercions('Paws::Rekognition::DetectProtectiveEquipment', @_);
111 return $self->caller->do_call($self, $call_object);
112 }
113 sub DetectText {
114 my $self = shift;
115 my $call_object = $self->new_with_coercions('Paws::Rekognition::DetectText', @_);
116 return $self->caller->do_call($self, $call_object);
117 }
118 sub GetCelebrityInfo {
119 my $self = shift;
120 my $call_object = $self->new_with_coercions('Paws::Rekognition::GetCelebrityInfo', @_);
121 return $self->caller->do_call($self, $call_object);
122 }
123 sub GetCelebrityRecognition {
124 my $self = shift;
125 my $call_object = $self->new_with_coercions('Paws::Rekognition::GetCelebrityRecognition', @_);
126 return $self->caller->do_call($self, $call_object);
127 }
128 sub GetContentModeration {
129 my $self = shift;
130 my $call_object = $self->new_with_coercions('Paws::Rekognition::GetContentModeration', @_);
131 return $self->caller->do_call($self, $call_object);
132 }
133 sub GetFaceDetection {
134 my $self = shift;
135 my $call_object = $self->new_with_coercions('Paws::Rekognition::GetFaceDetection', @_);
136 return $self->caller->do_call($self, $call_object);
137 }
138 sub GetFaceSearch {
139 my $self = shift;
140 my $call_object = $self->new_with_coercions('Paws::Rekognition::GetFaceSearch', @_);
141 return $self->caller->do_call($self, $call_object);
142 }
143 sub GetLabelDetection {
144 my $self = shift;
145 my $call_object = $self->new_with_coercions('Paws::Rekognition::GetLabelDetection', @_);
146 return $self->caller->do_call($self, $call_object);
147 }
148 sub GetPersonTracking {
149 my $self = shift;
150 my $call_object = $self->new_with_coercions('Paws::Rekognition::GetPersonTracking', @_);
151 return $self->caller->do_call($self, $call_object);
152 }
153 sub GetSegmentDetection {
154 my $self = shift;
155 my $call_object = $self->new_with_coercions('Paws::Rekognition::GetSegmentDetection', @_);
156 return $self->caller->do_call($self, $call_object);
157 }
158 sub GetTextDetection {
159 my $self = shift;
160 my $call_object = $self->new_with_coercions('Paws::Rekognition::GetTextDetection', @_);
161 return $self->caller->do_call($self, $call_object);
162 }
163 sub IndexFaces {
164 my $self = shift;
165 my $call_object = $self->new_with_coercions('Paws::Rekognition::IndexFaces', @_);
166 return $self->caller->do_call($self, $call_object);
167 }
168 sub ListCollections {
169 my $self = shift;
170 my $call_object = $self->new_with_coercions('Paws::Rekognition::ListCollections', @_);
171 return $self->caller->do_call($self, $call_object);
172 }
173 sub ListFaces {
174 my $self = shift;
175 my $call_object = $self->new_with_coercions('Paws::Rekognition::ListFaces', @_);
176 return $self->caller->do_call($self, $call_object);
177 }
178 sub ListStreamProcessors {
179 my $self = shift;
180 my $call_object = $self->new_with_coercions('Paws::Rekognition::ListStreamProcessors', @_);
181 return $self->caller->do_call($self, $call_object);
182 }
183 sub ListTagsForResource {
184 my $self = shift;
185 my $call_object = $self->new_with_coercions('Paws::Rekognition::ListTagsForResource', @_);
186 return $self->caller->do_call($self, $call_object);
187 }
188 sub RecognizeCelebrities {
189 my $self = shift;
190 my $call_object = $self->new_with_coercions('Paws::Rekognition::RecognizeCelebrities', @_);
191 return $self->caller->do_call($self, $call_object);
192 }
193 sub SearchFaces {
194 my $self = shift;
195 my $call_object = $self->new_with_coercions('Paws::Rekognition::SearchFaces', @_);
196 return $self->caller->do_call($self, $call_object);
197 }
198 sub SearchFacesByImage {
199 my $self = shift;
200 my $call_object = $self->new_with_coercions('Paws::Rekognition::SearchFacesByImage', @_);
201 return $self->caller->do_call($self, $call_object);
202 }
203 sub StartCelebrityRecognition {
204 my $self = shift;
205 my $call_object = $self->new_with_coercions('Paws::Rekognition::StartCelebrityRecognition', @_);
206 return $self->caller->do_call($self, $call_object);
207 }
208 sub StartContentModeration {
209 my $self = shift;
210 my $call_object = $self->new_with_coercions('Paws::Rekognition::StartContentModeration', @_);
211 return $self->caller->do_call($self, $call_object);
212 }
213 sub StartFaceDetection {
214 my $self = shift;
215 my $call_object = $self->new_with_coercions('Paws::Rekognition::StartFaceDetection', @_);
216 return $self->caller->do_call($self, $call_object);
217 }
218 sub StartFaceSearch {
219 my $self = shift;
220 my $call_object = $self->new_with_coercions('Paws::Rekognition::StartFaceSearch', @_);
221 return $self->caller->do_call($self, $call_object);
222 }
223 sub StartLabelDetection {
224 my $self = shift;
225 my $call_object = $self->new_with_coercions('Paws::Rekognition::StartLabelDetection', @_);
226 return $self->caller->do_call($self, $call_object);
227 }
228 sub StartPersonTracking {
229 my $self = shift;
230 my $call_object = $self->new_with_coercions('Paws::Rekognition::StartPersonTracking', @_);
231 return $self->caller->do_call($self, $call_object);
232 }
233 sub StartProjectVersion {
234 my $self = shift;
235 my $call_object = $self->new_with_coercions('Paws::Rekognition::StartProjectVersion', @_);
236 return $self->caller->do_call($self, $call_object);
237 }
238 sub StartSegmentDetection {
239 my $self = shift;
240 my $call_object = $self->new_with_coercions('Paws::Rekognition::StartSegmentDetection', @_);
241 return $self->caller->do_call($self, $call_object);
242 }
243 sub StartStreamProcessor {
244 my $self = shift;
245 my $call_object = $self->new_with_coercions('Paws::Rekognition::StartStreamProcessor', @_);
246 return $self->caller->do_call($self, $call_object);
247 }
248 sub StartTextDetection {
249 my $self = shift;
250 my $call_object = $self->new_with_coercions('Paws::Rekognition::StartTextDetection', @_);
251 return $self->caller->do_call($self, $call_object);
252 }
253 sub StopProjectVersion {
254 my $self = shift;
255 my $call_object = $self->new_with_coercions('Paws::Rekognition::StopProjectVersion', @_);
256 return $self->caller->do_call($self, $call_object);
257 }
258 sub StopStreamProcessor {
259 my $self = shift;
260 my $call_object = $self->new_with_coercions('Paws::Rekognition::StopStreamProcessor', @_);
261 return $self->caller->do_call($self, $call_object);
262 }
263 sub TagResource {
264 my $self = shift;
265 my $call_object = $self->new_with_coercions('Paws::Rekognition::TagResource', @_);
266 return $self->caller->do_call($self, $call_object);
267 }
268 sub UntagResource {
269 my $self = shift;
270 my $call_object = $self->new_with_coercions('Paws::Rekognition::UntagResource', @_);
271 return $self->caller->do_call($self, $call_object);
272 }
273
274 sub DescribeAllProjects {
275 my $self = shift;
276  
277 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
278 my $result = $self->DescribeProjects(@_);
279 my $next_result = $result;
280  
281 if (not defined $callback) {
282 while ($next_result->NextToken) {
283 $next_result = $self->DescribeProjects(@_, NextToken => $next_result->NextToken);
284 push @{ $result->ProjectDescriptions }, @{ $next_result->ProjectDescriptions };
285 }
286 return $result;
287 } else {
288 while ($result->NextToken) {
289 $callback->($_ => 'ProjectDescriptions') foreach (@{ $result->ProjectDescriptions });
290 $result = $self->DescribeProjects(@_, NextToken => $result->NextToken);
291 }
292 $callback->($_ => 'ProjectDescriptions') foreach (@{ $result->ProjectDescriptions });
293 }
294  
295 return undef
296 }
297 sub DescribeAllProjectVersions {
298 my $self = shift;
299  
300 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
301 my $result = $self->DescribeProjectVersions(@_);
302 my $next_result = $result;
303  
304 if (not defined $callback) {
305 while ($next_result->NextToken) {
306 $next_result = $self->DescribeProjectVersions(@_, NextToken => $next_result->NextToken);
307 push @{ $result->ProjectVersionDescriptions }, @{ $next_result->ProjectVersionDescriptions };
308 }
309 return $result;
310 } else {
311 while ($result->NextToken) {
312 $callback->($_ => 'ProjectVersionDescriptions') foreach (@{ $result->ProjectVersionDescriptions });
313 $result = $self->DescribeProjectVersions(@_, NextToken => $result->NextToken);
314 }
315 $callback->($_ => 'ProjectVersionDescriptions') foreach (@{ $result->ProjectVersionDescriptions });
316 }
317  
318 return undef
319 }
320 sub ListAllCollections {
321 my $self = shift;
322  
323 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
324 my $result = $self->ListCollections(@_);
325 my $next_result = $result;
326  
327 if (not defined $callback) {
328 while ($next_result->NextToken) {
329 $next_result = $self->ListCollections(@_, NextToken => $next_result->NextToken);
330 push @{ $result->CollectionIds }, @{ $next_result->CollectionIds };
331 push @{ $result->FaceModelVersions }, @{ $next_result->FaceModelVersions };
332 }
333 return $result;
334 } else {
335 while ($result->NextToken) {
336 $callback->($_ => 'CollectionIds') foreach (@{ $result->CollectionIds });
337 $callback->($_ => 'FaceModelVersions') foreach (@{ $result->FaceModelVersions });
338 $result = $self->ListCollections(@_, NextToken => $result->NextToken);
339 }
340 $callback->($_ => 'CollectionIds') foreach (@{ $result->CollectionIds });
341 $callback->($_ => 'FaceModelVersions') foreach (@{ $result->FaceModelVersions });
342 }
343  
344 return undef
345 }
346 sub ListAllFaces {
347 my $self = shift;
348  
349 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
350 my $result = $self->ListFaces(@_);
351 my $next_result = $result;
352  
353 if (not defined $callback) {
354 while ($next_result->NextToken) {
355 $next_result = $self->ListFaces(@_, NextToken => $next_result->NextToken);
356 push @{ $result->Faces }, @{ $next_result->Faces };
357 }
358 return $result;
359 } else {
360 while ($result->NextToken) {
361 $callback->($_ => 'Faces') foreach (@{ $result->Faces });
362 $result = $self->ListFaces(@_, NextToken => $result->NextToken);
363 }
364 $callback->($_ => 'Faces') foreach (@{ $result->Faces });
365 }
366  
367 return undef
368 }
369 sub ListAllStreamProcessors {
370 my $self = shift;
371  
372 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
373 my $result = $self->ListStreamProcessors(@_);
374 my $next_result = $result;
375  
376 if (not defined $callback) {
377 while ($next_result->NextToken) {
378 $next_result = $self->ListStreamProcessors(@_, NextToken => $next_result->NextToken);
379 push @{ $result->StreamProcessors }, @{ $next_result->StreamProcessors };
380 }
381 return $result;
382 } else {
383 while ($result->NextToken) {
384 $callback->($_ => 'StreamProcessors') foreach (@{ $result->StreamProcessors });
385 $result = $self->ListStreamProcessors(@_, NextToken => $result->NextToken);
386 }
387 $callback->($_ => 'StreamProcessors') foreach (@{ $result->StreamProcessors });
388 }
389  
390 return undef
391 }
392  
393  
394 sub operations { qw/CompareFaces CreateCollection CreateProject CreateProjectVersion CreateStreamProcessor DeleteCollection DeleteFaces DeleteProject DeleteProjectVersion DeleteStreamProcessor DescribeCollection DescribeProjects DescribeProjectVersions DescribeStreamProcessor DetectCustomLabels DetectFaces DetectLabels DetectModerationLabels DetectProtectiveEquipment DetectText GetCelebrityInfo GetCelebrityRecognition GetContentModeration GetFaceDetection GetFaceSearch GetLabelDetection GetPersonTracking GetSegmentDetection GetTextDetection IndexFaces ListCollections ListFaces ListStreamProcessors ListTagsForResource RecognizeCelebrities SearchFaces SearchFacesByImage StartCelebrityRecognition StartContentModeration StartFaceDetection StartFaceSearch StartLabelDetection StartPersonTracking StartProjectVersion StartSegmentDetection StartStreamProcessor StartTextDetection StopProjectVersion StopStreamProcessor TagResource UntagResource / }
395  
396 1;
397  
398 ### main pod documentation begin ###
399  
400 =head1 NAME
401  
402 Paws::Rekognition - Perl Interface to AWS Amazon Rekognition
403  
404 =head1 SYNOPSIS
405  
406 use Paws;
407  
408 my $obj = Paws->service('Rekognition');
409 my $res = $obj->Method(
410 Arg1 => $val1,
411 Arg2 => [ 'V1', 'V2' ],
412 # if Arg3 is an object, the HashRef will be used as arguments to the constructor
413 # of the arguments type
414 Arg3 => { Att1 => 'Val1' },
415 # if Arg4 is an array of objects, the HashRefs will be passed as arguments to
416 # the constructor of the arguments type
417 Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ],
418 );
419  
420 =head1 DESCRIPTION
421  
422 This is the Amazon Rekognition API reference.
423  
424 For the AWS API documentation, see L<https://docs.aws.amazon.com/goto/WebAPI/rekognition-2016-06-27>
425  
426  
427 =head1 METHODS
428  
429 =head2 CompareFaces
430  
431 =over
432  
433 =item SourceImage => L<Paws::Rekognition::Image>
434  
435 =item TargetImage => L<Paws::Rekognition::Image>
436  
437 =item [QualityFilter => Str]
438  
439 =item [SimilarityThreshold => Num]
440  
441  
442 =back
443  
444 Each argument is described in detail in: L<Paws::Rekognition::CompareFaces>
445  
446 Returns: a L<Paws::Rekognition::CompareFacesResponse> instance
447  
448 Compares a face in the I<source> input image with each of the 100
449 largest faces detected in the I<target> input image.
450  
451 If the source image contains multiple faces, the service detects the
452 largest face and compares it with each face detected in the target
453 image.
454  
455 CompareFaces uses machine learning algorithms, which are probabilistic.
456 A false negative is an incorrect prediction that a face in the target
457 image has a low similarity confidence score when compared to the face
458 in the source image. To reduce the probability of false negatives, we
459 recommend that you compare the target image against multiple source
460 images. If you plan to use C<CompareFaces> to make a decision that
461 impacts an individual's rights, privacy, or access to services, we
462 recommend that you pass the result to a human for review and further
463 validation before taking action.
464  
465 You pass the input and target images either as base64-encoded image
466 bytes or as references to images in an Amazon S3 bucket. If you use the
467 AWS CLI to call Amazon Rekognition operations, passing image bytes
468 isn't supported. The image must be formatted as a PNG or JPEG file.
469  
470 In response, the operation returns an array of face matches ordered by
471 similarity score in descending order. For each face match, the response
472 provides a bounding box of the face, facial landmarks, pose details
473 (pitch, role, and yaw), quality (brightness and sharpness), and
474 confidence value (indicating the level of confidence that the bounding
475 box contains a face). The response also provides a similarity score,
476 which indicates how closely the faces match.
477  
478 By default, only faces with a similarity score of greater than or equal
479 to 80% are returned in the response. You can change this value by
480 specifying the C<SimilarityThreshold> parameter.
481  
482 C<CompareFaces> also returns an array of faces that don't match the
483 source image. For each face, it returns a bounding box, confidence
484 value, landmarks, pose details, and quality. The response also returns
485 information about the face in the source image, including the bounding
486 box of the face and confidence value.
487  
488 The C<QualityFilter> input parameter allows you to filter out detected
489 faces that donE<rsquo>t meet a required quality bar. The quality bar is
490 based on a variety of common use cases. Use C<QualityFilter> to set the
491 quality bar by specifying C<LOW>, C<MEDIUM>, or C<HIGH>. If you do not
492 want to filter detected faces, specify C<NONE>. The default value is
493 C<NONE>.
494  
495 If the image doesn't contain Exif metadata, C<CompareFaces> returns
496 orientation information for the source and target images. Use these
497 values to display the images with the correct image orientation.
498  
499 If no faces are detected in the source or target images,
500 C<CompareFaces> returns an C<InvalidParameterException> error.
501  
502 This is a stateless API operation. That is, data returned by this
503 operation doesn't persist.
504  
505 For an example, see Comparing Faces in Images in the Amazon Rekognition
506 Developer Guide.
507  
508 This operation requires permissions to perform the
509 C<rekognition:CompareFaces> action.
510  
511  
512 =head2 CreateCollection
513  
514 =over
515  
516 =item CollectionId => Str
517  
518 =item [Tags => L<Paws::Rekognition::TagMap>]
519  
520  
521 =back
522  
523 Each argument is described in detail in: L<Paws::Rekognition::CreateCollection>
524  
525 Returns: a L<Paws::Rekognition::CreateCollectionResponse> instance
526  
527 Creates a collection in an AWS Region. You can add faces to the
528 collection using the IndexFaces operation.
529  
530 For example, you might create collections, one for each of your
531 application users. A user can then index faces using the C<IndexFaces>
532 operation and persist results in a specific collection. Then, a user
533 can search the collection for faces in the user-specific container.
534  
535 When you create a collection, it is associated with the latest version
536 of the face model version.
537  
538 Collection names are case-sensitive.
539  
540 This operation requires permissions to perform the
541 C<rekognition:CreateCollection> action. If you want to tag your
542 collection, you also require permission to perform the
543 C<rekognition:TagResource> operation.
544  
545  
546 =head2 CreateProject
547  
548 =over
549  
550 =item ProjectName => Str
551  
552  
553 =back
554  
555 Each argument is described in detail in: L<Paws::Rekognition::CreateProject>
556  
557 Returns: a L<Paws::Rekognition::CreateProjectResponse> instance
558  
559 Creates a new Amazon Rekognition Custom Labels project. A project is a
560 logical grouping of resources (images, Labels, models) and operations
561 (training, evaluation and detection).
562  
563 This operation requires permissions to perform the
564 C<rekognition:CreateProject> action.
565  
566  
567 =head2 CreateProjectVersion
568  
569 =over
570  
571 =item OutputConfig => L<Paws::Rekognition::OutputConfig>
572  
573 =item ProjectArn => Str
574  
575 =item TestingData => L<Paws::Rekognition::TestingData>
576  
577 =item TrainingData => L<Paws::Rekognition::TrainingData>
578  
579 =item VersionName => Str
580  
581 =item [KmsKeyId => Str]
582  
583 =item [Tags => L<Paws::Rekognition::TagMap>]
584  
585  
586 =back
587  
588 Each argument is described in detail in: L<Paws::Rekognition::CreateProjectVersion>
589  
590 Returns: a L<Paws::Rekognition::CreateProjectVersionResponse> instance
591  
592 Creates a new version of a model and begins training. Models are
593 managed as part of an Amazon Rekognition Custom Labels project. You can
594 specify one training dataset and one testing dataset. The response from
595 C<CreateProjectVersion> is an Amazon Resource Name (ARN) for the
596 version of the model.
597  
598 Training takes a while to complete. You can get the current status by
599 calling DescribeProjectVersions.
600  
601 Once training has successfully completed, call DescribeProjectVersions
602 to get the training results and evaluate the model.
603  
604 After evaluating the model, you start the model by calling
605 StartProjectVersion.
606  
607 This operation requires permissions to perform the
608 C<rekognition:CreateProjectVersion> action.
609  
610  
611 =head2 CreateStreamProcessor
612  
613 =over
614  
615 =item Input => L<Paws::Rekognition::StreamProcessorInput>
616  
617 =item Name => Str
618  
619 =item Output => L<Paws::Rekognition::StreamProcessorOutput>
620  
621 =item RoleArn => Str
622  
623 =item Settings => L<Paws::Rekognition::StreamProcessorSettings>
624  
625 =item [Tags => L<Paws::Rekognition::TagMap>]
626  
627  
628 =back
629  
630 Each argument is described in detail in: L<Paws::Rekognition::CreateStreamProcessor>
631  
632 Returns: a L<Paws::Rekognition::CreateStreamProcessorResponse> instance
633  
634 Creates an Amazon Rekognition stream processor that you can use to
635 detect and recognize faces in a streaming video.
636  
637 Amazon Rekognition Video is a consumer of live video from Amazon
638 Kinesis Video Streams. Amazon Rekognition Video sends analysis results
639 to Amazon Kinesis Data Streams.
640  
641 You provide as input a Kinesis video stream (C<Input>) and a Kinesis
642 data stream (C<Output>) stream. You also specify the face recognition
643 criteria in C<Settings>. For example, the collection containing faces
644 that you want to recognize. Use C<Name> to assign an identifier for the
645 stream processor. You use C<Name> to manage the stream processor. For
646 example, you can start processing the source video by calling
647 StartStreamProcessor with the C<Name> field.
648  
649 After you have finished analyzing a streaming video, use
650 StopStreamProcessor to stop processing. You can delete the stream
651 processor by calling DeleteStreamProcessor.
652  
653 This operation requires permissions to perform the
654 C<rekognition:CreateStreamProcessor> action. If you want to tag your
655 stream processor, you also require permission to perform the
656 C<rekognition:TagResource> operation.
657  
658  
659 =head2 DeleteCollection
660  
661 =over
662  
663 =item CollectionId => Str
664  
665  
666 =back
667  
668 Each argument is described in detail in: L<Paws::Rekognition::DeleteCollection>
669  
670 Returns: a L<Paws::Rekognition::DeleteCollectionResponse> instance
671  
672 Deletes the specified collection. Note that this operation removes all
673 faces in the collection. For an example, see
674 delete-collection-procedure.
675  
676 This operation requires permissions to perform the
677 C<rekognition:DeleteCollection> action.
678  
679  
680 =head2 DeleteFaces
681  
682 =over
683  
684 =item CollectionId => Str
685  
686 =item FaceIds => ArrayRef[Str|Undef]
687  
688  
689 =back
690  
691 Each argument is described in detail in: L<Paws::Rekognition::DeleteFaces>
692  
693 Returns: a L<Paws::Rekognition::DeleteFacesResponse> instance
694  
695 Deletes faces from a collection. You specify a collection ID and an
696 array of face IDs to remove from the collection.
697  
698 This operation requires permissions to perform the
699 C<rekognition:DeleteFaces> action.
700  
701  
702 =head2 DeleteProject
703  
704 =over
705  
706 =item ProjectArn => Str
707  
708  
709 =back
710  
711 Each argument is described in detail in: L<Paws::Rekognition::DeleteProject>
712  
713 Returns: a L<Paws::Rekognition::DeleteProjectResponse> instance
714  
715 Deletes an Amazon Rekognition Custom Labels project. To delete a
716 project you must first delete all models associated with the project.
717 To delete a model, see DeleteProjectVersion.
718  
719 This operation requires permissions to perform the
720 C<rekognition:DeleteProject> action.
721  
722  
723 =head2 DeleteProjectVersion
724  
725 =over
726  
727 =item ProjectVersionArn => Str
728  
729  
730 =back
731  
732 Each argument is described in detail in: L<Paws::Rekognition::DeleteProjectVersion>
733  
734 Returns: a L<Paws::Rekognition::DeleteProjectVersionResponse> instance
735  
736 Deletes an Amazon Rekognition Custom Labels model.
737  
738 You can't delete a model if it is running or if it is training. To
739 check the status of a model, use the C<Status> field returned from
740 DescribeProjectVersions. To stop a running model call
741 StopProjectVersion. If the model is training, wait until it finishes.
742  
743 This operation requires permissions to perform the
744 C<rekognition:DeleteProjectVersion> action.
745  
746  
747 =head2 DeleteStreamProcessor
748  
749 =over
750  
751 =item Name => Str
752  
753  
754 =back
755  
756 Each argument is described in detail in: L<Paws::Rekognition::DeleteStreamProcessor>
757  
758 Returns: a L<Paws::Rekognition::DeleteStreamProcessorResponse> instance
759  
760 Deletes the stream processor identified by C<Name>. You assign the
761 value for C<Name> when you create the stream processor with
762 CreateStreamProcessor. You might not be able to use the same name for a
763 stream processor for a few seconds after calling
764 C<DeleteStreamProcessor>.
765  
766  
767 =head2 DescribeCollection
768  
769 =over
770  
771 =item CollectionId => Str
772  
773  
774 =back
775  
776 Each argument is described in detail in: L<Paws::Rekognition::DescribeCollection>
777  
778 Returns: a L<Paws::Rekognition::DescribeCollectionResponse> instance
779  
780 Describes the specified collection. You can use C<DescribeCollection>
781 to get information, such as the number of faces indexed into a
782 collection and the version of the model used by the collection for face
783 detection.
784  
785 For more information, see Describing a Collection in the Amazon
786 Rekognition Developer Guide.
787  
788  
789 =head2 DescribeProjects
790  
791 =over
792  
793 =item [MaxResults => Int]
794  
795 =item [NextToken => Str]
796  
797  
798 =back
799  
800 Each argument is described in detail in: L<Paws::Rekognition::DescribeProjects>
801  
802 Returns: a L<Paws::Rekognition::DescribeProjectsResponse> instance
803  
804 Lists and gets information about your Amazon Rekognition Custom Labels
805 projects.
806  
807 This operation requires permissions to perform the
808 C<rekognition:DescribeProjects> action.
809  
810  
811 =head2 DescribeProjectVersions
812  
813 =over
814  
815 =item ProjectArn => Str
816  
817 =item [MaxResults => Int]
818  
819 =item [NextToken => Str]
820  
821 =item [VersionNames => ArrayRef[Str|Undef]]
822  
823  
824 =back
825  
826 Each argument is described in detail in: L<Paws::Rekognition::DescribeProjectVersions>
827  
828 Returns: a L<Paws::Rekognition::DescribeProjectVersionsResponse> instance
829  
830 Lists and describes the models in an Amazon Rekognition Custom Labels
831 project. You can specify up to 10 model versions in
832 C<ProjectVersionArns>. If you don't specify a value, descriptions for
833 all models are returned.
834  
835 This operation requires permissions to perform the
836 C<rekognition:DescribeProjectVersions> action.
837  
838  
839 =head2 DescribeStreamProcessor
840  
841 =over
842  
843 =item Name => Str
844  
845  
846 =back
847  
848 Each argument is described in detail in: L<Paws::Rekognition::DescribeStreamProcessor>
849  
850 Returns: a L<Paws::Rekognition::DescribeStreamProcessorResponse> instance
851  
852 Provides information about a stream processor created by
853 CreateStreamProcessor. You can get information about the input and
854 output streams, the input parameters for the face recognition being
855 performed, and the current status of the stream processor.
856  
857  
858 =head2 DetectCustomLabels
859  
860 =over
861  
862 =item Image => L<Paws::Rekognition::Image>
863  
864 =item ProjectVersionArn => Str
865  
866 =item [MaxResults => Int]
867  
868 =item [MinConfidence => Num]
869  
870  
871 =back
872  
873 Each argument is described in detail in: L<Paws::Rekognition::DetectCustomLabels>
874  
875 Returns: a L<Paws::Rekognition::DetectCustomLabelsResponse> instance
876  
877 Detects custom labels in a supplied image by using an Amazon
878 Rekognition Custom Labels model.
879  
880 You specify which version of a model version to use by using the
881 C<ProjectVersionArn> input parameter.
882  
883 You pass the input image as base64-encoded image bytes or as a
884 reference to an image in an Amazon S3 bucket. If you use the AWS CLI to
885 call Amazon Rekognition operations, passing image bytes is not
886 supported. The image must be either a PNG or JPEG formatted file.
887  
888 For each object that the model version detects on an image, the API
889 returns a (C<CustomLabel>) object in an array (C<CustomLabels>). Each
890 C<CustomLabel> object provides the label name (C<Name>), the level of
891 confidence that the image contains the object (C<Confidence>), and
892 object location information, if it exists, for the label on the image
893 (C<Geometry>).
894  
895 During training model calculates a threshold value that determines if a
896 prediction for a label is true. By default, C<DetectCustomLabels>
897 doesn't return labels whose confidence value is below the model's
898 calculated threshold value. To filter labels that are returned, specify
899 a value for C<MinConfidence> that is higher than the model's calculated
900 threshold. You can get the model's calculated threshold from the
901 model's training results shown in the Amazon Rekognition Custom Labels
902 console. To get all labels, regardless of confidence, specify a
903 C<MinConfidence> value of 0.
904  
905 You can also add the C<MaxResults> parameter to limit the number of
906 labels returned.
907  
908 This is a stateless API operation. That is, the operation does not
909 persist any data.
910  
911 This operation requires permissions to perform the
912 C<rekognition:DetectCustomLabels> action.
913  
914  
915 =head2 DetectFaces
916  
917 =over
918  
919 =item Image => L<Paws::Rekognition::Image>
920  
921 =item [Attributes => ArrayRef[Str|Undef]]
922  
923  
924 =back
925  
926 Each argument is described in detail in: L<Paws::Rekognition::DetectFaces>
927  
928 Returns: a L<Paws::Rekognition::DetectFacesResponse> instance
929  
930 Detects faces within an image that is provided as input.
931  
932 C<DetectFaces> detects the 100 largest faces in the image. For each
933 face detected, the operation returns face details. These details
934 include a bounding box of the face, a confidence value (that the
935 bounding box contains a face), and a fixed set of attributes such as
936 facial landmarks (for example, coordinates of eye and mouth), presence
937 of beard, sunglasses, and so on.
938  
939 The face-detection algorithm is most effective on frontal faces. For
940 non-frontal or obscured faces, the algorithm might not detect the faces
941 or might detect faces with lower confidence.
942  
943 You pass the input image either as base64-encoded image bytes or as a
944 reference to an image in an Amazon S3 bucket. If you use the AWS CLI to
945 call Amazon Rekognition operations, passing image bytes is not
946 supported. The image must be either a PNG or JPEG formatted file.
947  
948 This is a stateless API operation. That is, the operation does not
949 persist any data.
950  
951 This operation requires permissions to perform the
952 C<rekognition:DetectFaces> action.
953  
954  
955 =head2 DetectLabels
956  
957 =over
958  
959 =item Image => L<Paws::Rekognition::Image>
960  
961 =item [MaxLabels => Int]
962  
963 =item [MinConfidence => Num]
964  
965  
966 =back
967  
968 Each argument is described in detail in: L<Paws::Rekognition::DetectLabels>
969  
970 Returns: a L<Paws::Rekognition::DetectLabelsResponse> instance
971  
972 Detects instances of real-world entities within an image (JPEG or PNG)
973 provided as input. This includes objects like flower, tree, and table;
974 events like wedding, graduation, and birthday party; and concepts like
975 landscape, evening, and nature.
976  
977 For an example, see Analyzing Images Stored in an Amazon S3 Bucket in
978 the Amazon Rekognition Developer Guide.
979  
980 C<DetectLabels> does not support the detection of activities. However,
981 activity detection is supported for label detection in videos. For more
982 information, see StartLabelDetection in the Amazon Rekognition
983 Developer Guide.
984  
985 You pass the input image as base64-encoded image bytes or as a
986 reference to an image in an Amazon S3 bucket. If you use the AWS CLI to
987 call Amazon Rekognition operations, passing image bytes is not
988 supported. The image must be either a PNG or JPEG formatted file.
989  
990 For each object, scene, and concept the API returns one or more labels.
991 Each label provides the object name, and the level of confidence that
992 the image contains the object. For example, suppose the input image has
993 a lighthouse, the sea, and a rock. The response includes all three
994 labels, one for each object.
995  
996 C<{Name: lighthouse, Confidence: 98.4629}>
997  
998 C<{Name: rock,Confidence: 79.2097}>
999  
1000 C<{Name: sea,Confidence: 75.061}>
1001  
1002 In the preceding example, the operation returns one label for each of
1003 the three objects. The operation can also return multiple labels for
1004 the same object in the image. For example, if the input image shows a
1005 flower (for example, a tulip), the operation might return the following
1006 three labels.
1007  
1008 C<{Name: flower,Confidence: 99.0562}>
1009  
1010 C<{Name: plant,Confidence: 99.0562}>
1011  
1012 C<{Name: tulip,Confidence: 99.0562}>
1013  
1014 In this example, the detection algorithm more precisely identifies the
1015 flower as a tulip.
1016  
1017 In response, the API returns an array of labels. In addition, the
1018 response also includes the orientation correction. Optionally, you can
1019 specify C<MinConfidence> to control the confidence threshold for the
1020 labels returned. The default is 55%. You can also add the C<MaxLabels>
1021 parameter to limit the number of labels returned.
1022  
1023 If the object detected is a person, the operation doesn't provide the
1024 same facial details that the DetectFaces operation provides.
1025  
1026 C<DetectLabels> returns bounding boxes for instances of common object
1027 labels in an array of Instance objects. An C<Instance> object contains
1028 a BoundingBox object, for the location of the label on the image. It
1029 also includes the confidence by which the bounding box was detected.
1030  
1031 C<DetectLabels> also returns a hierarchical taxonomy of detected
1032 labels. For example, a detected car might be assigned the label I<car>.
1033 The label I<car> has two parent labels: I<Vehicle> (its parent) and
1034 I<Transportation> (its grandparent). The response returns the entire
1035 list of ancestors for a label. Each ancestor is a unique label in the
1036 response. In the previous example, I<Car>, I<Vehicle>, and
1037 I<Transportation> are returned as unique labels in the response.
1038  
1039 This is a stateless API operation. That is, the operation does not
1040 persist any data.
1041  
1042 This operation requires permissions to perform the
1043 C<rekognition:DetectLabels> action.
1044  
1045  
1046 =head2 DetectModerationLabels
1047  
1048 =over
1049  
1050 =item Image => L<Paws::Rekognition::Image>
1051  
1052 =item [HumanLoopConfig => L<Paws::Rekognition::HumanLoopConfig>]
1053  
1054 =item [MinConfidence => Num]
1055  
1056  
1057 =back
1058  
1059 Each argument is described in detail in: L<Paws::Rekognition::DetectModerationLabels>
1060  
1061 Returns: a L<Paws::Rekognition::DetectModerationLabelsResponse> instance
1062  
1063 Detects unsafe content in a specified JPEG or PNG format image. Use
1064 C<DetectModerationLabels> to moderate images depending on your
1065 requirements. For example, you might want to filter images that contain
1066 nudity, but not images containing suggestive content.
1067  
1068 To filter images, use the labels returned by C<DetectModerationLabels>
1069 to determine which types of content are appropriate.
1070  
1071 For information about moderation labels, see Detecting Unsafe Content
1072 in the Amazon Rekognition Developer Guide.
1073  
1074 You pass the input image either as base64-encoded image bytes or as a
1075 reference to an image in an Amazon S3 bucket. If you use the AWS CLI to
1076 call Amazon Rekognition operations, passing image bytes is not
1077 supported. The image must be either a PNG or JPEG formatted file.
1078  
1079  
1080 =head2 DetectProtectiveEquipment
1081  
1082 =over
1083  
1084 =item Image => L<Paws::Rekognition::Image>
1085  
1086 =item [SummarizationAttributes => L<Paws::Rekognition::ProtectiveEquipmentSummarizationAttributes>]
1087  
1088  
1089 =back
1090  
1091 Each argument is described in detail in: L<Paws::Rekognition::DetectProtectiveEquipment>
1092  
1093 Returns: a L<Paws::Rekognition::DetectProtectiveEquipmentResponse> instance
1094  
1095 Detects Personal Protective Equipment (PPE) worn by people detected in
1096 an image. Amazon Rekognition can detect the following types of PPE.
1097  
1098 =over
1099  
1100 =item *
1101  
1102 Face cover
1103  
1104 =item *
1105  
1106 Hand cover
1107  
1108 =item *
1109  
1110 Head cover
1111  
1112 =back
1113  
1114 You pass the input image as base64-encoded image bytes or as a
1115 reference to an image in an Amazon S3 bucket. The image must be either
1116 a PNG or JPG formatted file.
1117  
1118 C<DetectProtectiveEquipment> detects PPE worn by up to 15 persons
1119 detected in an image.
1120  
1121 For each person detected in the image the API returns an array of body
1122 parts (face, head, left-hand, right-hand). For each body part, an array
1123 of detected items of PPE is returned, including an indicator of whether
1124 or not the PPE covers the body part. The API returns the confidence it
1125 has in each detection (person, PPE, body part and body part coverage).
1126 It also returns a bounding box (BoundingBox) for each detected person
1127 and each detected item of PPE.
1128  
1129 You can optionally request a summary of detected PPE items with the
1130 C<SummarizationAttributes> input parameter. The summary provides the
1131 following information.
1132  
1133 =over
1134  
1135 =item *
1136  
1137 The persons detected as wearing all of the types of PPE that you
1138 specify.
1139  
1140 =item *
1141  
1142 The persons detected as not wearing all of the types PPE that you
1143 specify.
1144  
1145 =item *
1146  
1147 The persons detected where PPE adornment could not be determined.
1148  
1149 =back
1150  
1151 This is a stateless API operation. That is, the operation does not
1152 persist any data.
1153  
1154 This operation requires permissions to perform the
1155 C<rekognition:DetectProtectiveEquipment> action.
1156  
1157  
1158 =head2 DetectText
1159  
1160 =over
1161  
1162 =item Image => L<Paws::Rekognition::Image>
1163  
1164 =item [Filters => L<Paws::Rekognition::DetectTextFilters>]
1165  
1166  
1167 =back
1168  
1169 Each argument is described in detail in: L<Paws::Rekognition::DetectText>
1170  
1171 Returns: a L<Paws::Rekognition::DetectTextResponse> instance
1172  
1173 Detects text in the input image and converts it into machine-readable
1174 text.
1175  
1176 Pass the input image as base64-encoded image bytes or as a reference to
1177 an image in an Amazon S3 bucket. If you use the AWS CLI to call Amazon
1178 Rekognition operations, you must pass it as a reference to an image in
1179 an Amazon S3 bucket. For the AWS CLI, passing image bytes is not
1180 supported. The image must be either a .png or .jpeg formatted file.
1181  
1182 The C<DetectText> operation returns text in an array of TextDetection
1183 elements, C<TextDetections>. Each C<TextDetection> element provides
1184 information about a single word or line of text that was detected in
1185 the image.
1186  
1187 A word is one or more ISO basic latin script characters that are not
1188 separated by spaces. C<DetectText> can detect up to 50 words in an
1189 image.
1190  
1191 A line is a string of equally spaced words. A line isn't necessarily a
1192 complete sentence. For example, a driver's license number is detected
1193 as a line. A line ends when there is no aligned text after it. Also, a
1194 line ends when there is a large gap between words, relative to the
1195 length of the words. This means, depending on the gap between words,
1196 Amazon Rekognition may detect multiple lines in text aligned in the
1197 same direction. Periods don't represent the end of a line. If a
1198 sentence spans multiple lines, the C<DetectText> operation returns
1199 multiple lines.
1200  
1201 To determine whether a C<TextDetection> element is a line of text or a
1202 word, use the C<TextDetection> object C<Type> field.
1203  
1204 To be detected, text must be within +/- 90 degrees orientation of the
1205 horizontal axis.
1206  
1207 For more information, see DetectText in the Amazon Rekognition
1208 Developer Guide.
1209  
1210  
1211 =head2 GetCelebrityInfo
1212  
1213 =over
1214  
1215 =item Id => Str
1216  
1217  
1218 =back
1219  
1220 Each argument is described in detail in: L<Paws::Rekognition::GetCelebrityInfo>
1221  
1222 Returns: a L<Paws::Rekognition::GetCelebrityInfoResponse> instance
1223  
1224 Gets the name and additional information about a celebrity based on his
1225 or her Amazon Rekognition ID. The additional information is returned as
1226 an array of URLs. If there is no additional information about the
1227 celebrity, this list is empty.
1228  
1229 For more information, see Recognizing Celebrities in an Image in the
1230 Amazon Rekognition Developer Guide.
1231  
1232 This operation requires permissions to perform the
1233 C<rekognition:GetCelebrityInfo> action.
1234  
1235  
1236 =head2 GetCelebrityRecognition
1237  
1238 =over
1239  
1240 =item JobId => Str
1241  
1242 =item [MaxResults => Int]
1243  
1244 =item [NextToken => Str]
1245  
1246 =item [SortBy => Str]
1247  
1248  
1249 =back
1250  
1251 Each argument is described in detail in: L<Paws::Rekognition::GetCelebrityRecognition>
1252  
1253 Returns: a L<Paws::Rekognition::GetCelebrityRecognitionResponse> instance
1254  
1255 Gets the celebrity recognition results for a Amazon Rekognition Video
1256 analysis started by StartCelebrityRecognition.
1257  
1258 Celebrity recognition in a video is an asynchronous operation. Analysis
1259 is started by a call to StartCelebrityRecognition which returns a job
1260 identifier (C<JobId>). When the celebrity recognition operation
1261 finishes, Amazon Rekognition Video publishes a completion status to the
1262 Amazon Simple Notification Service topic registered in the initial call
1263 to C<StartCelebrityRecognition>. To get the results of the celebrity
1264 recognition analysis, first check that the status value published to
1265 the Amazon SNS topic is C<SUCCEEDED>. If so, call
1266 C<GetCelebrityDetection> and pass the job identifier (C<JobId>) from
1267 the initial call to C<StartCelebrityDetection>.
1268  
1269 For more information, see Working With Stored Videos in the Amazon
1270 Rekognition Developer Guide.
1271  
1272 C<GetCelebrityRecognition> returns detected celebrities and the time(s)
1273 they are detected in an array (C<Celebrities>) of CelebrityRecognition
1274 objects. Each C<CelebrityRecognition> contains information about the
1275 celebrity in a CelebrityDetail object and the time, C<Timestamp>, the
1276 celebrity was detected.
1277  
1278 C<GetCelebrityRecognition> only returns the default facial attributes
1279 (C<BoundingBox>, C<Confidence>, C<Landmarks>, C<Pose>, and C<Quality>).
1280 The other facial attributes listed in the C<Face> object of the
1281 following response syntax are not returned. For more information, see
1282 FaceDetail in the Amazon Rekognition Developer Guide.
1283  
1284 By default, the C<Celebrities> array is sorted by time (milliseconds
1285 from the start of the video). You can also sort the array by celebrity
1286 by specifying the value C<ID> in the C<SortBy> input parameter.
1287  
1288 The C<CelebrityDetail> object includes the celebrity identifer and
1289 additional information urls. If you don't store the additional
1290 information urls, you can get them later by calling GetCelebrityInfo
1291 with the celebrity identifer.
1292  
1293 No information is returned for faces not recognized as celebrities.
1294  
1295 Use MaxResults parameter to limit the number of labels returned. If
1296 there are more results than specified in C<MaxResults>, the value of
1297 C<NextToken> in the operation response contains a pagination token for
1298 getting the next set of results. To get the next page of results, call
1299 C<GetCelebrityDetection> and populate the C<NextToken> request
1300 parameter with the token value returned from the previous call to
1301 C<GetCelebrityRecognition>.
1302  
1303  
1304 =head2 GetContentModeration
1305  
1306 =over
1307  
1308 =item JobId => Str
1309  
1310 =item [MaxResults => Int]
1311  
1312 =item [NextToken => Str]
1313  
1314 =item [SortBy => Str]
1315  
1316  
1317 =back
1318  
1319 Each argument is described in detail in: L<Paws::Rekognition::GetContentModeration>
1320  
1321 Returns: a L<Paws::Rekognition::GetContentModerationResponse> instance
1322  
1323 Gets the unsafe content analysis results for a Amazon Rekognition Video
1324 analysis started by StartContentModeration.
1325  
1326 Unsafe content analysis of a video is an asynchronous operation. You
1327 start analysis by calling StartContentModeration which returns a job
1328 identifier (C<JobId>). When analysis finishes, Amazon Rekognition Video
1329 publishes a completion status to the Amazon Simple Notification Service
1330 topic registered in the initial call to C<StartContentModeration>. To
1331 get the results of the unsafe content analysis, first check that the
1332 status value published to the Amazon SNS topic is C<SUCCEEDED>. If so,
1333 call C<GetContentModeration> and pass the job identifier (C<JobId>)
1334 from the initial call to C<StartContentModeration>.
1335  
1336 For more information, see Working with Stored Videos in the Amazon
1337 Rekognition Devlopers Guide.
1338  
1339 C<GetContentModeration> returns detected unsafe content labels, and the
1340 time they are detected, in an array, C<ModerationLabels>, of
1341 ContentModerationDetection objects.
1342  
1343 By default, the moderated labels are returned sorted by time, in
1344 milliseconds from the start of the video. You can also sort them by
1345 moderated label by specifying C<NAME> for the C<SortBy> input
1346 parameter.
1347  
1348 Since video analysis can return a large number of results, use the
1349 C<MaxResults> parameter to limit the number of labels returned in a
1350 single call to C<GetContentModeration>. If there are more results than
1351 specified in C<MaxResults>, the value of C<NextToken> in the operation
1352 response contains a pagination token for getting the next set of
1353 results. To get the next page of results, call C<GetContentModeration>
1354 and populate the C<NextToken> request parameter with the value of
1355 C<NextToken> returned from the previous call to
1356 C<GetContentModeration>.
1357  
1358 For more information, see Detecting Unsafe Content in the Amazon
1359 Rekognition Developer Guide.
1360  
1361  
1362 =head2 GetFaceDetection
1363  
1364 =over
1365  
1366 =item JobId => Str
1367  
1368 =item [MaxResults => Int]
1369  
1370 =item [NextToken => Str]
1371  
1372  
1373 =back
1374  
1375 Each argument is described in detail in: L<Paws::Rekognition::GetFaceDetection>
1376  
1377 Returns: a L<Paws::Rekognition::GetFaceDetectionResponse> instance
1378  
1379 Gets face detection results for a Amazon Rekognition Video analysis
1380 started by StartFaceDetection.
1381  
1382 Face detection with Amazon Rekognition Video is an asynchronous
1383 operation. You start face detection by calling StartFaceDetection which
1384 returns a job identifier (C<JobId>). When the face detection operation
1385 finishes, Amazon Rekognition Video publishes a completion status to the
1386 Amazon Simple Notification Service topic registered in the initial call
1387 to C<StartFaceDetection>. To get the results of the face detection
1388 operation, first check that the status value published to the Amazon
1389 SNS topic is C<SUCCEEDED>. If so, call GetFaceDetection and pass the
1390 job identifier (C<JobId>) from the initial call to
1391 C<StartFaceDetection>.
1392  
1393 C<GetFaceDetection> returns an array of detected faces (C<Faces>)
1394 sorted by the time the faces were detected.
1395  
1396 Use MaxResults parameter to limit the number of labels returned. If
1397 there are more results than specified in C<MaxResults>, the value of
1398 C<NextToken> in the operation response contains a pagination token for
1399 getting the next set of results. To get the next page of results, call
1400 C<GetFaceDetection> and populate the C<NextToken> request parameter
1401 with the token value returned from the previous call to
1402 C<GetFaceDetection>.
1403  
1404  
1405 =head2 GetFaceSearch
1406  
1407 =over
1408  
1409 =item JobId => Str
1410  
1411 =item [MaxResults => Int]
1412  
1413 =item [NextToken => Str]
1414  
1415 =item [SortBy => Str]
1416  
1417  
1418 =back
1419  
1420 Each argument is described in detail in: L<Paws::Rekognition::GetFaceSearch>
1421  
1422 Returns: a L<Paws::Rekognition::GetFaceSearchResponse> instance
1423  
1424 Gets the face search results for Amazon Rekognition Video face search
1425 started by StartFaceSearch. The search returns faces in a collection
1426 that match the faces of persons detected in a video. It also includes
1427 the time(s) that faces are matched in the video.
1428  
1429 Face search in a video is an asynchronous operation. You start face
1430 search by calling to StartFaceSearch which returns a job identifier
1431 (C<JobId>). When the search operation finishes, Amazon Rekognition
1432 Video publishes a completion status to the Amazon Simple Notification
1433 Service topic registered in the initial call to C<StartFaceSearch>. To
1434 get the search results, first check that the status value published to
1435 the Amazon SNS topic is C<SUCCEEDED>. If so, call C<GetFaceSearch> and
1436 pass the job identifier (C<JobId>) from the initial call to
1437 C<StartFaceSearch>.
1438  
1439 For more information, see Searching Faces in a Collection in the Amazon
1440 Rekognition Developer Guide.
1441  
1442 The search results are retured in an array, C<Persons>, of PersonMatch
1443 objects. EachC<PersonMatch> element contains details about the matching
1444 faces in the input collection, person information (facial attributes,
1445 bounding boxes, and person identifer) for the matched person, and the
1446 time the person was matched in the video.
1447  
1448 C<GetFaceSearch> only returns the default facial attributes
1449 (C<BoundingBox>, C<Confidence>, C<Landmarks>, C<Pose>, and C<Quality>).
1450 The other facial attributes listed in the C<Face> object of the
1451 following response syntax are not returned. For more information, see
1452 FaceDetail in the Amazon Rekognition Developer Guide.
1453  
1454 By default, the C<Persons> array is sorted by the time, in milliseconds
1455 from the start of the video, persons are matched. You can also sort by
1456 persons by specifying C<INDEX> for the C<SORTBY> input parameter.
1457  
1458  
1459 =head2 GetLabelDetection
1460  
1461 =over
1462  
1463 =item JobId => Str
1464  
1465 =item [MaxResults => Int]
1466  
1467 =item [NextToken => Str]
1468  
1469 =item [SortBy => Str]
1470  
1471  
1472 =back
1473  
1474 Each argument is described in detail in: L<Paws::Rekognition::GetLabelDetection>
1475  
1476 Returns: a L<Paws::Rekognition::GetLabelDetectionResponse> instance
1477  
1478 Gets the label detection results of a Amazon Rekognition Video analysis
1479 started by StartLabelDetection.
1480  
1481 The label detection operation is started by a call to
1482 StartLabelDetection which returns a job identifier (C<JobId>). When the
1483 label detection operation finishes, Amazon Rekognition publishes a
1484 completion status to the Amazon Simple Notification Service topic
1485 registered in the initial call to C<StartlabelDetection>. To get the
1486 results of the label detection operation, first check that the status
1487 value published to the Amazon SNS topic is C<SUCCEEDED>. If so, call
1488 GetLabelDetection and pass the job identifier (C<JobId>) from the
1489 initial call to C<StartLabelDetection>.
1490  
1491 C<GetLabelDetection> returns an array of detected labels (C<Labels>)
1492 sorted by the time the labels were detected. You can also sort by the
1493 label name by specifying C<NAME> for the C<SortBy> input parameter.
1494  
1495 The labels returned include the label name, the percentage confidence
1496 in the accuracy of the detected label, and the time the label was
1497 detected in the video.
1498  
1499 The returned labels also include bounding box information for common
1500 objects, a hierarchical taxonomy of detected labels, and the version of
1501 the label model used for detection.
1502  
1503 Use MaxResults parameter to limit the number of labels returned. If
1504 there are more results than specified in C<MaxResults>, the value of
1505 C<NextToken> in the operation response contains a pagination token for
1506 getting the next set of results. To get the next page of results, call
1507 C<GetlabelDetection> and populate the C<NextToken> request parameter
1508 with the token value returned from the previous call to
1509 C<GetLabelDetection>.
1510  
1511  
1512 =head2 GetPersonTracking
1513  
1514 =over
1515  
1516 =item JobId => Str
1517  
1518 =item [MaxResults => Int]
1519  
1520 =item [NextToken => Str]
1521  
1522 =item [SortBy => Str]
1523  
1524  
1525 =back
1526  
1527 Each argument is described in detail in: L<Paws::Rekognition::GetPersonTracking>
1528  
1529 Returns: a L<Paws::Rekognition::GetPersonTrackingResponse> instance
1530  
1531 Gets the path tracking results of a Amazon Rekognition Video analysis
1532 started by StartPersonTracking.
1533  
1534 The person path tracking operation is started by a call to
1535 C<StartPersonTracking> which returns a job identifier (C<JobId>). When
1536 the operation finishes, Amazon Rekognition Video publishes a completion
1537 status to the Amazon Simple Notification Service topic registered in
1538 the initial call to C<StartPersonTracking>.
1539  
1540 To get the results of the person path tracking operation, first check
1541 that the status value published to the Amazon SNS topic is
1542 C<SUCCEEDED>. If so, call GetPersonTracking and pass the job identifier
1543 (C<JobId>) from the initial call to C<StartPersonTracking>.
1544  
1545 C<GetPersonTracking> returns an array, C<Persons>, of tracked persons
1546 and the time(s) their paths were tracked in the video.
1547  
1548 C<GetPersonTracking> only returns the default facial attributes
1549 (C<BoundingBox>, C<Confidence>, C<Landmarks>, C<Pose>, and C<Quality>).
1550 The other facial attributes listed in the C<Face> object of the
1551 following response syntax are not returned.
1552  
1553 For more information, see FaceDetail in the Amazon Rekognition
1554 Developer Guide.
1555  
1556 By default, the array is sorted by the time(s) a person's path is
1557 tracked in the video. You can sort by tracked persons by specifying
1558 C<INDEX> for the C<SortBy> input parameter.
1559  
1560 Use the C<MaxResults> parameter to limit the number of items returned.
1561 If there are more results than specified in C<MaxResults>, the value of
1562 C<NextToken> in the operation response contains a pagination token for
1563 getting the next set of results. To get the next page of results, call
1564 C<GetPersonTracking> and populate the C<NextToken> request parameter
1565 with the token value returned from the previous call to
1566 C<GetPersonTracking>.
1567  
1568  
1569 =head2 GetSegmentDetection
1570  
1571 =over
1572  
1573 =item JobId => Str
1574  
1575 =item [MaxResults => Int]
1576  
1577 =item [NextToken => Str]
1578  
1579  
1580 =back
1581  
1582 Each argument is described in detail in: L<Paws::Rekognition::GetSegmentDetection>
1583  
1584 Returns: a L<Paws::Rekognition::GetSegmentDetectionResponse> instance
1585  
1586 Gets the segment detection results of a Amazon Rekognition Video
1587 analysis started by StartSegmentDetection.
1588  
1589 Segment detection with Amazon Rekognition Video is an asynchronous
1590 operation. You start segment detection by calling StartSegmentDetection
1591 which returns a job identifier (C<JobId>). When the segment detection
1592 operation finishes, Amazon Rekognition publishes a completion status to
1593 the Amazon Simple Notification Service topic registered in the initial
1594 call to C<StartSegmentDetection>. To get the results of the segment
1595 detection operation, first check that the status value published to the
1596 Amazon SNS topic is C<SUCCEEDED>. if so, call C<GetSegmentDetection>
1597 and pass the job identifier (C<JobId>) from the initial call of
1598 C<StartSegmentDetection>.
1599  
1600 C<GetSegmentDetection> returns detected segments in an array
1601 (C<Segments>) of SegmentDetection objects. C<Segments> is sorted by the
1602 segment types specified in the C<SegmentTypes> input parameter of
1603 C<StartSegmentDetection>. Each element of the array includes the
1604 detected segment, the precentage confidence in the acuracy of the
1605 detected segment, the type of the segment, and the frame in which the
1606 segment was detected.
1607  
1608 Use C<SelectedSegmentTypes> to find out the type of segment detection
1609 requested in the call to C<StartSegmentDetection>.
1610  
1611 Use the C<MaxResults> parameter to limit the number of segment
1612 detections returned. If there are more results than specified in
1613 C<MaxResults>, the value of C<NextToken> in the operation response
1614 contains a pagination token for getting the next set of results. To get
1615 the next page of results, call C<GetSegmentDetection> and populate the
1616 C<NextToken> request parameter with the token value returned from the
1617 previous call to C<GetSegmentDetection>.
1618  
1619 For more information, see Detecting Video Segments in Stored Video in
1620 the Amazon Rekognition Developer Guide.
1621  
1622  
1623 =head2 GetTextDetection
1624  
1625 =over
1626  
1627 =item JobId => Str
1628  
1629 =item [MaxResults => Int]
1630  
1631 =item [NextToken => Str]
1632  
1633  
1634 =back
1635  
1636 Each argument is described in detail in: L<Paws::Rekognition::GetTextDetection>
1637  
1638 Returns: a L<Paws::Rekognition::GetTextDetectionResponse> instance
1639  
1640 Gets the text detection results of a Amazon Rekognition Video analysis
1641 started by StartTextDetection.
1642  
1643 Text detection with Amazon Rekognition Video is an asynchronous
1644 operation. You start text detection by calling StartTextDetection which
1645 returns a job identifier (C<JobId>) When the text detection operation
1646 finishes, Amazon Rekognition publishes a completion status to the
1647 Amazon Simple Notification Service topic registered in the initial call
1648 to C<StartTextDetection>. To get the results of the text detection
1649 operation, first check that the status value published to the Amazon
1650 SNS topic is C<SUCCEEDED>. if so, call C<GetTextDetection> and pass the
1651 job identifier (C<JobId>) from the initial call of
1652 C<StartLabelDetection>.
1653  
1654 C<GetTextDetection> returns an array of detected text
1655 (C<TextDetections>) sorted by the time the text was detected, up to 50
1656 words per frame of video.
1657  
1658 Each element of the array includes the detected text, the precentage
1659 confidence in the acuracy of the detected text, the time the text was
1660 detected, bounding box information for where the text was located, and
1661 unique identifiers for words and their lines.
1662  
1663 Use MaxResults parameter to limit the number of text detections
1664 returned. If there are more results than specified in C<MaxResults>,
1665 the value of C<NextToken> in the operation response contains a
1666 pagination token for getting the next set of results. To get the next
1667 page of results, call C<GetTextDetection> and populate the C<NextToken>
1668 request parameter with the token value returned from the previous call
1669 to C<GetTextDetection>.
1670  
1671  
1672 =head2 IndexFaces
1673  
1674 =over
1675  
1676 =item CollectionId => Str
1677  
1678 =item Image => L<Paws::Rekognition::Image>
1679  
1680 =item [DetectionAttributes => ArrayRef[Str|Undef]]
1681  
1682 =item [ExternalImageId => Str]
1683  
1684 =item [MaxFaces => Int]
1685  
1686 =item [QualityFilter => Str]
1687  
1688  
1689 =back
1690  
1691 Each argument is described in detail in: L<Paws::Rekognition::IndexFaces>
1692  
1693 Returns: a L<Paws::Rekognition::IndexFacesResponse> instance
1694  
1695 Detects faces in the input image and adds them to the specified
1696 collection.
1697  
1698 Amazon Rekognition doesn't save the actual faces that are detected.
1699 Instead, the underlying detection algorithm first detects the faces in
1700 the input image. For each face, the algorithm extracts facial features
1701 into a feature vector, and stores it in the backend database. Amazon
1702 Rekognition uses feature vectors when it performs face match and search
1703 operations using the SearchFaces and SearchFacesByImage operations.
1704  
1705 For more information, see Adding Faces to a Collection in the Amazon
1706 Rekognition Developer Guide.
1707  
1708 To get the number of faces in a collection, call DescribeCollection.
1709  
1710 If you're using version 1.0 of the face detection model, C<IndexFaces>
1711 indexes the 15 largest faces in the input image. Later versions of the
1712 face detection model index the 100 largest faces in the input image.
1713  
1714 If you're using version 4 or later of the face model, image orientation
1715 information is not returned in the C<OrientationCorrection> field.
1716  
1717 To determine which version of the model you're using, call
1718 DescribeCollection and supply the collection ID. You can also get the
1719 model version from the value of C<FaceModelVersion> in the response
1720 from C<IndexFaces>
1721  
1722 For more information, see Model Versioning in the Amazon Rekognition
1723 Developer Guide.
1724  
1725 If you provide the optional C<ExternalImageId> for the input image you
1726 provided, Amazon Rekognition associates this ID with all faces that it
1727 detects. When you call the ListFaces operation, the response returns
1728 the external ID. You can use this external image ID to create a
1729 client-side index to associate the faces with each image. You can then
1730 use the index to find all faces in an image.
1731  
1732 You can specify the maximum number of faces to index with the
1733 C<MaxFaces> input parameter. This is useful when you want to index the
1734 largest faces in an image and don't want to index smaller faces, such
1735 as those belonging to people standing in the background.
1736  
1737 The C<QualityFilter> input parameter allows you to filter out detected
1738 faces that donE<rsquo>t meet a required quality bar. The quality bar is
1739 based on a variety of common use cases. By default, C<IndexFaces>
1740 chooses the quality bar that's used to filter faces. You can also
1741 explicitly choose the quality bar. Use C<QualityFilter>, to set the
1742 quality bar by specifying C<LOW>, C<MEDIUM>, or C<HIGH>. If you do not
1743 want to filter detected faces, specify C<NONE>.
1744  
1745 To use quality filtering, you need a collection associated with version
1746 3 of the face model or higher. To get the version of the face model
1747 associated with a collection, call DescribeCollection.
1748  
1749 Information about faces detected in an image, but not indexed, is
1750 returned in an array of UnindexedFace objects, C<UnindexedFaces>. Faces
1751 aren't indexed for reasons such as:
1752  
1753 =over
1754  
1755 =item *
1756  
1757 The number of faces detected exceeds the value of the C<MaxFaces>
1758 request parameter.
1759  
1760 =item *
1761  
1762 The face is too small compared to the image dimensions.
1763  
1764 =item *
1765  
1766 The face is too blurry.
1767  
1768 =item *
1769  
1770 The image is too dark.
1771  
1772 =item *
1773  
1774 The face has an extreme pose.
1775  
1776 =item *
1777  
1778 The face doesnE<rsquo>t have enough detail to be suitable for face
1779 search.
1780  
1781 =back
1782  
1783 In response, the C<IndexFaces> operation returns an array of metadata
1784 for all detected faces, C<FaceRecords>. This includes:
1785  
1786 =over
1787  
1788 =item *
1789  
1790 The bounding box, C<BoundingBox>, of the detected face.
1791  
1792 =item *
1793  
1794 A confidence value, C<Confidence>, which indicates the confidence that
1795 the bounding box contains a face.
1796  
1797 =item *
1798  
1799 A face ID, C<FaceId>, assigned by the service for each face that's
1800 detected and stored.
1801  
1802 =item *
1803  
1804 An image ID, C<ImageId>, assigned by the service for the input image.
1805  
1806 =back
1807  
1808 If you request all facial attributes (by using the
1809 C<detectionAttributes> parameter), Amazon Rekognition returns detailed
1810 facial attributes, such as facial landmarks (for example, location of
1811 eye and mouth) and other facial attributes. If you provide the same
1812 image, specify the same collection, and use the same external ID in the
1813 C<IndexFaces> operation, Amazon Rekognition doesn't save duplicate face
1814 metadata.
1815  
1816 The input image is passed either as base64-encoded image bytes, or as a
1817 reference to an image in an Amazon S3 bucket. If you use the AWS CLI to
1818 call Amazon Rekognition operations, passing image bytes isn't
1819 supported. The image must be formatted as a PNG or JPEG file.
1820  
1821 This operation requires permissions to perform the
1822 C<rekognition:IndexFaces> action.
1823  
1824  
1825 =head2 ListCollections
1826  
1827 =over
1828  
1829 =item [MaxResults => Int]
1830  
1831 =item [NextToken => Str]
1832  
1833  
1834 =back
1835  
1836 Each argument is described in detail in: L<Paws::Rekognition::ListCollections>
1837  
1838 Returns: a L<Paws::Rekognition::ListCollectionsResponse> instance
1839  
1840 Returns list of collection IDs in your account. If the result is
1841 truncated, the response also provides a C<NextToken> that you can use
1842 in the subsequent request to fetch the next set of collection IDs.
1843  
1844 For an example, see Listing Collections in the Amazon Rekognition
1845 Developer Guide.
1846  
1847 This operation requires permissions to perform the
1848 C<rekognition:ListCollections> action.
1849  
1850  
1851 =head2 ListFaces
1852  
1853 =over
1854  
1855 =item CollectionId => Str
1856  
1857 =item [MaxResults => Int]
1858  
1859 =item [NextToken => Str]
1860  
1861  
1862 =back
1863  
1864 Each argument is described in detail in: L<Paws::Rekognition::ListFaces>
1865  
1866 Returns: a L<Paws::Rekognition::ListFacesResponse> instance
1867  
1868 Returns metadata for faces in the specified collection. This metadata
1869 includes information such as the bounding box coordinates, the
1870 confidence (that the bounding box contains a face), and face ID. For an
1871 example, see Listing Faces in a Collection in the Amazon Rekognition
1872 Developer Guide.
1873  
1874 This operation requires permissions to perform the
1875 C<rekognition:ListFaces> action.
1876  
1877  
1878 =head2 ListStreamProcessors
1879  
1880 =over
1881  
1882 =item [MaxResults => Int]
1883  
1884 =item [NextToken => Str]
1885  
1886  
1887 =back
1888  
1889 Each argument is described in detail in: L<Paws::Rekognition::ListStreamProcessors>
1890  
1891 Returns: a L<Paws::Rekognition::ListStreamProcessorsResponse> instance
1892  
1893 Gets a list of stream processors that you have created with
1894 CreateStreamProcessor.
1895  
1896  
1897 =head2 ListTagsForResource
1898  
1899 =over
1900  
1901 =item ResourceArn => Str
1902  
1903  
1904 =back
1905  
1906 Each argument is described in detail in: L<Paws::Rekognition::ListTagsForResource>
1907  
1908 Returns: a L<Paws::Rekognition::ListTagsForResourceResponse> instance
1909  
1910 Returns a list of tags in an Amazon Rekognition collection, stream
1911 processor, or Custom Labels model.
1912  
1913 This operation requires permissions to perform the
1914 C<rekognition:ListTagsForResource> action.
1915  
1916  
1917 =head2 RecognizeCelebrities
1918  
1919 =over
1920  
1921 =item Image => L<Paws::Rekognition::Image>
1922  
1923  
1924 =back
1925  
1926 Each argument is described in detail in: L<Paws::Rekognition::RecognizeCelebrities>
1927  
1928 Returns: a L<Paws::Rekognition::RecognizeCelebritiesResponse> instance
1929  
1930 Returns an array of celebrities recognized in the input image. For more
1931 information, see Recognizing Celebrities in the Amazon Rekognition
1932 Developer Guide.
1933  
1934 C<RecognizeCelebrities> returns the 64 largest faces in the image. It
1935 lists recognized celebrities in the C<CelebrityFaces> array and
1936 unrecognized faces in the C<UnrecognizedFaces> array.
1937 C<RecognizeCelebrities> doesn't return celebrities whose faces aren't
1938 among the largest 64 faces in the image.
1939  
1940 For each celebrity recognized, C<RecognizeCelebrities> returns a
1941 C<Celebrity> object. The C<Celebrity> object contains the celebrity
1942 name, ID, URL links to additional information, match confidence, and a
1943 C<ComparedFace> object that you can use to locate the celebrity's face
1944 on the image.
1945  
1946 Amazon Rekognition doesn't retain information about which images a
1947 celebrity has been recognized in. Your application must store this
1948 information and use the C<Celebrity> ID property as a unique identifier
1949 for the celebrity. If you don't store the celebrity name or additional
1950 information URLs returned by C<RecognizeCelebrities>, you will need the
1951 ID to identify the celebrity in a call to the GetCelebrityInfo
1952 operation.
1953  
1954 You pass the input image either as base64-encoded image bytes or as a
1955 reference to an image in an Amazon S3 bucket. If you use the AWS CLI to
1956 call Amazon Rekognition operations, passing image bytes is not
1957 supported. The image must be either a PNG or JPEG formatted file.
1958  
1959 For an example, see Recognizing Celebrities in an Image in the Amazon
1960 Rekognition Developer Guide.
1961  
1962 This operation requires permissions to perform the
1963 C<rekognition:RecognizeCelebrities> operation.
1964  
1965  
1966 =head2 SearchFaces
1967  
1968 =over
1969  
1970 =item CollectionId => Str
1971  
1972 =item FaceId => Str
1973  
1974 =item [FaceMatchThreshold => Num]
1975  
1976 =item [MaxFaces => Int]
1977  
1978  
1979 =back
1980  
1981 Each argument is described in detail in: L<Paws::Rekognition::SearchFaces>
1982  
1983 Returns: a L<Paws::Rekognition::SearchFacesResponse> instance
1984  
1985 For a given input face ID, searches for matching faces in the
1986 collection the face belongs to. You get a face ID when you add a face
1987 to the collection using the IndexFaces operation. The operation
1988 compares the features of the input face with faces in the specified
1989 collection.
1990  
1991 You can also search faces without indexing faces by using the
1992 C<SearchFacesByImage> operation.
1993  
1994 The operation response returns an array of faces that match, ordered by
1995 similarity score with the highest similarity first. More specifically,
1996 it is an array of metadata for each face match that is found. Along
1997 with the metadata, the response also includes a C<confidence> value for
1998 each face match, indicating the confidence that the specific face
1999 matches the input face.
2000  
2001 For an example, see Searching for a Face Using Its Face ID in the
2002 Amazon Rekognition Developer Guide.
2003  
2004 This operation requires permissions to perform the
2005 C<rekognition:SearchFaces> action.
2006  
2007  
2008 =head2 SearchFacesByImage
2009  
2010 =over
2011  
2012 =item CollectionId => Str
2013  
2014 =item Image => L<Paws::Rekognition::Image>
2015  
2016 =item [FaceMatchThreshold => Num]
2017  
2018 =item [MaxFaces => Int]
2019  
2020 =item [QualityFilter => Str]
2021  
2022  
2023 =back
2024  
2025 Each argument is described in detail in: L<Paws::Rekognition::SearchFacesByImage>
2026  
2027 Returns: a L<Paws::Rekognition::SearchFacesByImageResponse> instance
2028  
2029 For a given input image, first detects the largest face in the image,
2030 and then searches the specified collection for matching faces. The
2031 operation compares the features of the input face with faces in the
2032 specified collection.
2033  
2034 To search for all faces in an input image, you might first call the
2035 IndexFaces operation, and then use the face IDs returned in subsequent
2036 calls to the SearchFaces operation.
2037  
2038 You can also call the C<DetectFaces> operation and use the bounding
2039 boxes in the response to make face crops, which then you can pass in to
2040 the C<SearchFacesByImage> operation.
2041  
2042 You pass the input image either as base64-encoded image bytes or as a
2043 reference to an image in an Amazon S3 bucket. If you use the AWS CLI to
2044 call Amazon Rekognition operations, passing image bytes is not
2045 supported. The image must be either a PNG or JPEG formatted file.
2046  
2047 The response returns an array of faces that match, ordered by
2048 similarity score with the highest similarity first. More specifically,
2049 it is an array of metadata for each face match found. Along with the
2050 metadata, the response also includes a C<similarity> indicating how
2051 similar the face is to the input face. In the response, the operation
2052 also returns the bounding box (and a confidence level that the bounding
2053 box contains a face) of the face that Amazon Rekognition used for the
2054 input image.
2055  
2056 If no faces are detected in the input image, C<SearchFacesByImage>
2057 returns an C<InvalidParameterException> error.
2058  
2059 For an example, Searching for a Face Using an Image in the Amazon
2060 Rekognition Developer Guide.
2061  
2062 The C<QualityFilter> input parameter allows you to filter out detected
2063 faces that donE<rsquo>t meet a required quality bar. The quality bar is
2064 based on a variety of common use cases. Use C<QualityFilter> to set the
2065 quality bar for filtering by specifying C<LOW>, C<MEDIUM>, or C<HIGH>.
2066 If you do not want to filter detected faces, specify C<NONE>. The
2067 default value is C<NONE>.
2068  
2069 To use quality filtering, you need a collection associated with version
2070 3 of the face model or higher. To get the version of the face model
2071 associated with a collection, call DescribeCollection.
2072  
2073 This operation requires permissions to perform the
2074 C<rekognition:SearchFacesByImage> action.
2075  
2076  
2077 =head2 StartCelebrityRecognition
2078  
2079 =over
2080  
2081 =item Video => L<Paws::Rekognition::Video>
2082  
2083 =item [ClientRequestToken => Str]
2084  
2085 =item [JobTag => Str]
2086  
2087 =item [NotificationChannel => L<Paws::Rekognition::NotificationChannel>]
2088  
2089  
2090 =back
2091  
2092 Each argument is described in detail in: L<Paws::Rekognition::StartCelebrityRecognition>
2093  
2094 Returns: a L<Paws::Rekognition::StartCelebrityRecognitionResponse> instance
2095  
2096 Starts asynchronous recognition of celebrities in a stored video.
2097  
2098 Amazon Rekognition Video can detect celebrities in a video must be
2099 stored in an Amazon S3 bucket. Use Video to specify the bucket name and
2100 the filename of the video. C<StartCelebrityRecognition> returns a job
2101 identifier (C<JobId>) which you use to get the results of the analysis.
2102 When celebrity recognition analysis is finished, Amazon Rekognition
2103 Video publishes a completion status to the Amazon Simple Notification
2104 Service topic that you specify in C<NotificationChannel>. To get the
2105 results of the celebrity recognition analysis, first check that the
2106 status value published to the Amazon SNS topic is C<SUCCEEDED>. If so,
2107 call GetCelebrityRecognition and pass the job identifier (C<JobId>)
2108 from the initial call to C<StartCelebrityRecognition>.
2109  
2110 For more information, see Recognizing Celebrities in the Amazon
2111 Rekognition Developer Guide.
2112  
2113  
2114 =head2 StartContentModeration
2115  
2116 =over
2117  
2118 =item Video => L<Paws::Rekognition::Video>
2119  
2120 =item [ClientRequestToken => Str]
2121  
2122 =item [JobTag => Str]
2123  
2124 =item [MinConfidence => Num]
2125  
2126 =item [NotificationChannel => L<Paws::Rekognition::NotificationChannel>]
2127  
2128  
2129 =back
2130  
2131 Each argument is described in detail in: L<Paws::Rekognition::StartContentModeration>
2132  
2133 Returns: a L<Paws::Rekognition::StartContentModerationResponse> instance
2134  
2135 Starts asynchronous detection of unsafe content in a stored video.
2136  
2137 Amazon Rekognition Video can moderate content in a video stored in an
2138 Amazon S3 bucket. Use Video to specify the bucket name and the filename
2139 of the video. C<StartContentModeration> returns a job identifier
2140 (C<JobId>) which you use to get the results of the analysis. When
2141 unsafe content analysis is finished, Amazon Rekognition Video publishes
2142 a completion status to the Amazon Simple Notification Service topic
2143 that you specify in C<NotificationChannel>.
2144  
2145 To get the results of the unsafe content analysis, first check that the
2146 status value published to the Amazon SNS topic is C<SUCCEEDED>. If so,
2147 call GetContentModeration and pass the job identifier (C<JobId>) from
2148 the initial call to C<StartContentModeration>.
2149  
2150 For more information, see Detecting Unsafe Content in the Amazon
2151 Rekognition Developer Guide.
2152  
2153  
2154 =head2 StartFaceDetection
2155  
2156 =over
2157  
2158 =item Video => L<Paws::Rekognition::Video>
2159  
2160 =item [ClientRequestToken => Str]
2161  
2162 =item [FaceAttributes => Str]
2163  
2164 =item [JobTag => Str]
2165  
2166 =item [NotificationChannel => L<Paws::Rekognition::NotificationChannel>]
2167  
2168  
2169 =back
2170  
2171 Each argument is described in detail in: L<Paws::Rekognition::StartFaceDetection>
2172  
2173 Returns: a L<Paws::Rekognition::StartFaceDetectionResponse> instance
2174  
2175 Starts asynchronous detection of faces in a stored video.
2176  
2177 Amazon Rekognition Video can detect faces in a video stored in an
2178 Amazon S3 bucket. Use Video to specify the bucket name and the filename
2179 of the video. C<StartFaceDetection> returns a job identifier (C<JobId>)
2180 that you use to get the results of the operation. When face detection
2181 is finished, Amazon Rekognition Video publishes a completion status to
2182 the Amazon Simple Notification Service topic that you specify in
2183 C<NotificationChannel>. To get the results of the face detection
2184 operation, first check that the status value published to the Amazon
2185 SNS topic is C<SUCCEEDED>. If so, call GetFaceDetection and pass the
2186 job identifier (C<JobId>) from the initial call to
2187 C<StartFaceDetection>.
2188  
2189 For more information, see Detecting Faces in a Stored Video in the
2190 Amazon Rekognition Developer Guide.
2191  
2192  
2193 =head2 StartFaceSearch
2194  
2195 =over
2196  
2197 =item CollectionId => Str
2198  
2199 =item Video => L<Paws::Rekognition::Video>
2200  
2201 =item [ClientRequestToken => Str]
2202  
2203 =item [FaceMatchThreshold => Num]
2204  
2205 =item [JobTag => Str]
2206  
2207 =item [NotificationChannel => L<Paws::Rekognition::NotificationChannel>]
2208  
2209  
2210 =back
2211  
2212 Each argument is described in detail in: L<Paws::Rekognition::StartFaceSearch>
2213  
2214 Returns: a L<Paws::Rekognition::StartFaceSearchResponse> instance
2215  
2216 Starts the asynchronous search for faces in a collection that match the
2217 faces of persons detected in a stored video.
2218  
2219 The video must be stored in an Amazon S3 bucket. Use Video to specify
2220 the bucket name and the filename of the video. C<StartFaceSearch>
2221 returns a job identifier (C<JobId>) which you use to get the search
2222 results once the search has completed. When searching is finished,
2223 Amazon Rekognition Video publishes a completion status to the Amazon
2224 Simple Notification Service topic that you specify in
2225 C<NotificationChannel>. To get the search results, first check that the
2226 status value published to the Amazon SNS topic is C<SUCCEEDED>. If so,
2227 call GetFaceSearch and pass the job identifier (C<JobId>) from the
2228 initial call to C<StartFaceSearch>. For more information, see
2229 procedure-person-search-videos.
2230  
2231  
2232 =head2 StartLabelDetection
2233  
2234 =over
2235  
2236 =item Video => L<Paws::Rekognition::Video>
2237  
2238 =item [ClientRequestToken => Str]
2239  
2240 =item [JobTag => Str]
2241  
2242 =item [MinConfidence => Num]
2243  
2244 =item [NotificationChannel => L<Paws::Rekognition::NotificationChannel>]
2245  
2246  
2247 =back
2248  
2249 Each argument is described in detail in: L<Paws::Rekognition::StartLabelDetection>
2250  
2251 Returns: a L<Paws::Rekognition::StartLabelDetectionResponse> instance
2252  
2253 Starts asynchronous detection of labels in a stored video.
2254  
2255 Amazon Rekognition Video can detect labels in a video. Labels are
2256 instances of real-world entities. This includes objects like flower,
2257 tree, and table; events like wedding, graduation, and birthday party;
2258 concepts like landscape, evening, and nature; and activities like a
2259 person getting out of a car or a person skiing.
2260  
2261 The video must be stored in an Amazon S3 bucket. Use Video to specify
2262 the bucket name and the filename of the video. C<StartLabelDetection>
2263 returns a job identifier (C<JobId>) which you use to get the results of
2264 the operation. When label detection is finished, Amazon Rekognition
2265 Video publishes a completion status to the Amazon Simple Notification
2266 Service topic that you specify in C<NotificationChannel>.
2267  
2268 To get the results of the label detection operation, first check that
2269 the status value published to the Amazon SNS topic is C<SUCCEEDED>. If
2270 so, call GetLabelDetection and pass the job identifier (C<JobId>) from
2271 the initial call to C<StartLabelDetection>.
2272  
2273  
2274 =head2 StartPersonTracking
2275  
2276 =over
2277  
2278 =item Video => L<Paws::Rekognition::Video>
2279  
2280 =item [ClientRequestToken => Str]
2281  
2282 =item [JobTag => Str]
2283  
2284 =item [NotificationChannel => L<Paws::Rekognition::NotificationChannel>]
2285  
2286  
2287 =back
2288  
2289 Each argument is described in detail in: L<Paws::Rekognition::StartPersonTracking>
2290  
2291 Returns: a L<Paws::Rekognition::StartPersonTrackingResponse> instance
2292  
2293 Starts the asynchronous tracking of a person's path in a stored video.
2294  
2295 Amazon Rekognition Video can track the path of people in a video stored
2296 in an Amazon S3 bucket. Use Video to specify the bucket name and the
2297 filename of the video. C<StartPersonTracking> returns a job identifier
2298 (C<JobId>) which you use to get the results of the operation. When
2299 label detection is finished, Amazon Rekognition publishes a completion
2300 status to the Amazon Simple Notification Service topic that you specify
2301 in C<NotificationChannel>.
2302  
2303 To get the results of the person detection operation, first check that
2304 the status value published to the Amazon SNS topic is C<SUCCEEDED>. If
2305 so, call GetPersonTracking and pass the job identifier (C<JobId>) from
2306 the initial call to C<StartPersonTracking>.
2307  
2308  
2309 =head2 StartProjectVersion
2310  
2311 =over
2312  
2313 =item MinInferenceUnits => Int
2314  
2315 =item ProjectVersionArn => Str
2316  
2317  
2318 =back
2319  
2320 Each argument is described in detail in: L<Paws::Rekognition::StartProjectVersion>
2321  
2322 Returns: a L<Paws::Rekognition::StartProjectVersionResponse> instance
2323  
2324 Starts the running of the version of a model. Starting a model takes a
2325 while to complete. To check the current state of the model, use
2326 DescribeProjectVersions.
2327  
2328 Once the model is running, you can detect custom labels in new images
2329 by calling DetectCustomLabels.
2330  
2331 You are charged for the amount of time that the model is running. To
2332 stop a running model, call StopProjectVersion.
2333  
2334 This operation requires permissions to perform the
2335 C<rekognition:StartProjectVersion> action.
2336  
2337  
2338 =head2 StartSegmentDetection
2339  
2340 =over
2341  
2342 =item SegmentTypes => ArrayRef[Str|Undef]
2343  
2344 =item Video => L<Paws::Rekognition::Video>
2345  
2346 =item [ClientRequestToken => Str]
2347  
2348 =item [Filters => L<Paws::Rekognition::StartSegmentDetectionFilters>]
2349  
2350 =item [JobTag => Str]
2351  
2352 =item [NotificationChannel => L<Paws::Rekognition::NotificationChannel>]
2353  
2354  
2355 =back
2356  
2357 Each argument is described in detail in: L<Paws::Rekognition::StartSegmentDetection>
2358  
2359 Returns: a L<Paws::Rekognition::StartSegmentDetectionResponse> instance
2360  
2361 Starts asynchronous detection of segment detection in a stored video.
2362  
2363 Amazon Rekognition Video can detect segments in a video stored in an
2364 Amazon S3 bucket. Use Video to specify the bucket name and the filename
2365 of the video. C<StartSegmentDetection> returns a job identifier
2366 (C<JobId>) which you use to get the results of the operation. When
2367 segment detection is finished, Amazon Rekognition Video publishes a
2368 completion status to the Amazon Simple Notification Service topic that
2369 you specify in C<NotificationChannel>.
2370  
2371 You can use the C<Filters> (StartSegmentDetectionFilters) input
2372 parameter to specify the minimum detection confidence returned in the
2373 response. Within C<Filters>, use C<ShotFilter>
2374 (StartShotDetectionFilter) to filter detected shots. Use
2375 C<TechnicalCueFilter> (StartTechnicalCueDetectionFilter) to filter
2376 technical cues.
2377  
2378 To get the results of the segment detection operation, first check that
2379 the status value published to the Amazon SNS topic is C<SUCCEEDED>. if
2380 so, call GetSegmentDetection and pass the job identifier (C<JobId>)
2381 from the initial call to C<StartSegmentDetection>.
2382  
2383 For more information, see Detecting Video Segments in Stored Video in
2384 the Amazon Rekognition Developer Guide.
2385  
2386  
2387 =head2 StartStreamProcessor
2388  
2389 =over
2390  
2391 =item Name => Str
2392  
2393  
2394 =back
2395  
2396 Each argument is described in detail in: L<Paws::Rekognition::StartStreamProcessor>
2397  
2398 Returns: a L<Paws::Rekognition::StartStreamProcessorResponse> instance
2399  
2400 Starts processing a stream processor. You create a stream processor by
2401 calling CreateStreamProcessor. To tell C<StartStreamProcessor> which
2402 stream processor to start, use the value of the C<Name> field specified
2403 in the call to C<CreateStreamProcessor>.
2404  
2405  
2406 =head2 StartTextDetection
2407  
2408 =over
2409  
2410 =item Video => L<Paws::Rekognition::Video>
2411  
2412 =item [ClientRequestToken => Str]
2413  
2414 =item [Filters => L<Paws::Rekognition::StartTextDetectionFilters>]
2415  
2416 =item [JobTag => Str]
2417  
2418 =item [NotificationChannel => L<Paws::Rekognition::NotificationChannel>]
2419  
2420  
2421 =back
2422  
2423 Each argument is described in detail in: L<Paws::Rekognition::StartTextDetection>
2424  
2425 Returns: a L<Paws::Rekognition::StartTextDetectionResponse> instance
2426  
2427 Starts asynchronous detection of text in a stored video.
2428  
2429 Amazon Rekognition Video can detect text in a video stored in an Amazon
2430 S3 bucket. Use Video to specify the bucket name and the filename of the
2431 video. C<StartTextDetection> returns a job identifier (C<JobId>) which
2432 you use to get the results of the operation. When text detection is
2433 finished, Amazon Rekognition Video publishes a completion status to the
2434 Amazon Simple Notification Service topic that you specify in
2435 C<NotificationChannel>.
2436  
2437 To get the results of the text detection operation, first check that
2438 the status value published to the Amazon SNS topic is C<SUCCEEDED>. if
2439 so, call GetTextDetection and pass the job identifier (C<JobId>) from
2440 the initial call to C<StartTextDetection>.
2441  
2442  
2443 =head2 StopProjectVersion
2444  
2445 =over
2446  
2447 =item ProjectVersionArn => Str
2448  
2449  
2450 =back
2451  
2452 Each argument is described in detail in: L<Paws::Rekognition::StopProjectVersion>
2453  
2454 Returns: a L<Paws::Rekognition::StopProjectVersionResponse> instance
2455  
2456 Stops a running model. The operation might take a while to complete. To
2457 check the current status, call DescribeProjectVersions.
2458  
2459  
2460 =head2 StopStreamProcessor
2461  
2462 =over
2463  
2464 =item Name => Str
2465  
2466  
2467 =back
2468  
2469 Each argument is described in detail in: L<Paws::Rekognition::StopStreamProcessor>
2470  
2471 Returns: a L<Paws::Rekognition::StopStreamProcessorResponse> instance
2472  
2473 Stops a running stream processor that was created by
2474 CreateStreamProcessor.
2475  
2476  
2477 =head2 TagResource
2478  
2479 =over
2480  
2481 =item ResourceArn => Str
2482  
2483 =item Tags => L<Paws::Rekognition::TagMap>
2484  
2485  
2486 =back
2487  
2488 Each argument is described in detail in: L<Paws::Rekognition::TagResource>
2489  
2490 Returns: a L<Paws::Rekognition::TagResourceResponse> instance
2491  
2492 Adds one or more key-value tags to an Amazon Rekognition collection,
2493 stream processor, or Custom Labels model. For more information, see
2494 Tagging AWS Resources
2495 (https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html).
2496  
2497 This operation requires permissions to perform the
2498 C<rekognition:TagResource> action.
2499  
2500  
2501 =head2 UntagResource
2502  
2503 =over
2504  
2505 =item ResourceArn => Str
2506  
2507 =item TagKeys => ArrayRef[Str|Undef]
2508  
2509  
2510 =back
2511  
2512 Each argument is described in detail in: L<Paws::Rekognition::UntagResource>
2513  
2514 Returns: a L<Paws::Rekognition::UntagResourceResponse> instance
2515  
2516 Removes one or more tags from an Amazon Rekognition collection, stream
2517 processor, or Custom Labels model.
2518  
2519 This operation requires permissions to perform the
2520 C<rekognition:UntagResource> action.
2521  
2522  
2523  
2524  
2525 =head1 PAGINATORS
2526  
2527 Paginator methods are helpers that repetively call methods that return partial results
2528  
2529 =head2 DescribeAllProjects(sub { },[MaxResults => Int, NextToken => Str])
2530  
2531 =head2 DescribeAllProjects([MaxResults => Int, NextToken => Str])
2532  
2533  
2534 If passed a sub as first parameter, it will call the sub for each element found in :
2535  
2536 - ProjectDescriptions, passing the object as the first parameter, and the string 'ProjectDescriptions' as the second parameter
2537  
2538 If not, it will return a a L<Paws::Rekognition::DescribeProjectsResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
2539  
2540  
2541 =head2 DescribeAllProjectVersions(sub { },ProjectArn => Str, [MaxResults => Int, NextToken => Str, VersionNames => ArrayRef[Str|Undef]])
2542  
2543 =head2 DescribeAllProjectVersions(ProjectArn => Str, [MaxResults => Int, NextToken => Str, VersionNames => ArrayRef[Str|Undef]])
2544  
2545  
2546 If passed a sub as first parameter, it will call the sub for each element found in :
2547  
2548 - ProjectVersionDescriptions, passing the object as the first parameter, and the string 'ProjectVersionDescriptions' as the second parameter
2549  
2550 If not, it will return a a L<Paws::Rekognition::DescribeProjectVersionsResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
2551  
2552  
2553 =head2 ListAllCollections(sub { },[MaxResults => Int, NextToken => Str])
2554  
2555 =head2 ListAllCollections([MaxResults => Int, NextToken => Str])
2556  
2557  
2558 If passed a sub as first parameter, it will call the sub for each element found in :
2559  
2560 - CollectionIds, passing the object as the first parameter, and the string 'CollectionIds' as the second parameter
2561  
2562 - FaceModelVersions, passing the object as the first parameter, and the string 'FaceModelVersions' as the second parameter
2563  
2564 If not, it will return a a L<Paws::Rekognition::ListCollectionsResponse> instance with all the C<param>s; andC<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
2565  
2566  
2567 =head2 ListAllFaces(sub { },CollectionId => Str, [MaxResults => Int, NextToken => Str])
2568  
2569 =head2 ListAllFaces(CollectionId => Str, [MaxResults => Int, NextToken => Str])
2570  
2571  
2572 If passed a sub as first parameter, it will call the sub for each element found in :
2573  
2574 - Faces, passing the object as the first parameter, and the string 'Faces' as the second parameter
2575  
2576 If not, it will return a a L<Paws::Rekognition::ListFacesResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
2577  
2578  
2579 =head2 ListAllStreamProcessors(sub { },[MaxResults => Int, NextToken => Str])
2580  
2581 =head2 ListAllStreamProcessors([MaxResults => Int, NextToken => Str])
2582  
2583  
2584 If passed a sub as first parameter, it will call the sub for each element found in :
2585  
2586 - StreamProcessors, passing the object as the first parameter, and the string 'StreamProcessors' as the second parameter
2587  
2588 If not, it will return a a L<Paws::Rekognition::ListStreamProcessorsResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
2589  
2590  
2591  
2592  
2593  
2594 =head1 SEE ALSO
2595  
2596 This service class forms part of L<Paws>
2597  
2598 =head1 BUGS and CONTRIBUTIONS
2599  
2600 The source code is located here: L<https://github.com/pplu/aws-sdk-perl>
2601  
2602 Please report bugs to: L<https://github.com/pplu/aws-sdk-perl/issues>
2603  
2604 =cut
2605