{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_GHC -fno-warn-unused-binds #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-unused-matches #-}

-- Derived from AWS service descriptions, licensed under Apache 2.0.

-- |
-- Module      : Amazonka.Rekognition.CompareFaces
-- Copyright   : (c) 2013-2021 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay <brendan.g.hay+amazonka@gmail.com>
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Compares a face in the /source/ input image with each of the 100 largest
-- faces detected in the /target/ input image.
--
-- If the source image contains multiple faces, the service detects the
-- largest face and compares it with each face detected in the target
-- image.
--
-- CompareFaces uses machine learning algorithms, which are probabilistic.
-- A false negative is an incorrect prediction that a face in the target
-- image has a low similarity confidence score when compared to the face in
-- the source image. To reduce the probability of false negatives, we
-- recommend that you compare the target image against multiple source
-- images. If you plan to use @CompareFaces@ to make a decision that
-- impacts an individual\'s rights, privacy, or access to services, we
-- recommend that you pass the result to a human for review and further
-- validation before taking action.
--
-- You pass the input and target images either as base64-encoded image
-- bytes or as references to images in an Amazon S3 bucket. If you use the
-- AWS CLI to call Amazon Rekognition operations, passing image bytes
-- isn\'t supported. The image must be formatted as a PNG or JPEG file.
--
-- In response, the operation returns an array of face matches ordered by
-- similarity score in descending order. For each face match, the response
-- provides a bounding box of the face, facial landmarks, pose details
-- (pitch, role, and yaw), quality (brightness and sharpness), and
-- confidence value (indicating the level of confidence that the bounding
-- box contains a face). The response also provides a similarity score,
-- which indicates how closely the faces match.
--
-- By default, only faces with a similarity score of greater than or equal
-- to 80% are returned in the response. You can change this value by
-- specifying the @SimilarityThreshold@ parameter.
--
-- @CompareFaces@ also returns an array of faces that don\'t match the
-- source image. For each face, it returns a bounding box, confidence
-- value, landmarks, pose details, and quality. The response also returns
-- information about the face in the source image, including the bounding
-- box of the face and confidence value.
--
-- The @QualityFilter@ input parameter allows you to filter out detected
-- faces that don’t meet a required quality bar. The quality bar is based
-- on a variety of common use cases. Use @QualityFilter@ to set the quality
-- bar by specifying @LOW@, @MEDIUM@, or @HIGH@. If you do not want to
-- filter detected faces, specify @NONE@. The default value is @NONE@.
--
-- If the image doesn\'t contain Exif metadata, @CompareFaces@ returns
-- orientation information for the source and target images. Use these
-- values to display the images with the correct image orientation.
--
-- If no faces are detected in the source or target images, @CompareFaces@
-- returns an @InvalidParameterException@ error.
--
-- This is a stateless API operation. That is, data returned by this
-- operation doesn\'t persist.
--
-- For an example, see Comparing Faces in Images in the Amazon Rekognition
-- Developer Guide.
--
-- This operation requires permissions to perform the
-- @rekognition:CompareFaces@ action.
module Amazonka.Rekognition.CompareFaces
  ( -- * Creating a Request
    CompareFaces (..),
    newCompareFaces,

    -- * Request Lenses
    compareFaces_qualityFilter,
    compareFaces_similarityThreshold,
    compareFaces_sourceImage,
    compareFaces_targetImage,

    -- * Destructuring the Response
    CompareFacesResponse (..),
    newCompareFacesResponse,

    -- * Response Lenses
    compareFacesResponse_faceMatches,
    compareFacesResponse_unmatchedFaces,
    compareFacesResponse_targetImageOrientationCorrection,
    compareFacesResponse_sourceImageOrientationCorrection,
    compareFacesResponse_sourceImageFace,
    compareFacesResponse_httpStatus,
  )
where

import qualified Amazonka.Core as Core
import qualified Amazonka.Lens as Lens
import qualified Amazonka.Prelude as Prelude
import Amazonka.Rekognition.Types
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response

-- | /See:/ 'newCompareFaces' smart constructor.
data CompareFaces = CompareFaces'
  { -- | A filter that specifies a quality bar for how much filtering is done to
    -- identify faces. Filtered faces aren\'t compared. If you specify @AUTO@,
    -- Amazon Rekognition chooses the quality bar. If you specify @LOW@,
    -- @MEDIUM@, or @HIGH@, filtering removes all faces that don’t meet the
    -- chosen quality bar. The quality bar is based on a variety of common use
    -- cases. Low-quality detections can occur for a number of reasons. Some
    -- examples are an object that\'s misidentified as a face, a face that\'s
    -- too blurry, or a face with a pose that\'s too extreme to use. If you
    -- specify @NONE@, no filtering is performed. The default value is @NONE@.
    --
    -- To use quality filtering, the collection you are using must be
    -- associated with version 3 of the face model or higher.
    CompareFaces -> Maybe QualityFilter
qualityFilter :: Prelude.Maybe QualityFilter,
    -- | The minimum level of confidence in the face matches that a match must
    -- meet to be included in the @FaceMatches@ array.
    CompareFaces -> Maybe Double
similarityThreshold :: Prelude.Maybe Prelude.Double,
    -- | The input image as base64-encoded bytes or an S3 object. If you use the
    -- AWS CLI to call Amazon Rekognition operations, passing base64-encoded
    -- image bytes is not supported.
    --
    -- If you are using an AWS SDK to call Amazon Rekognition, you might not
    -- need to base64-encode image bytes passed using the @Bytes@ field. For
    -- more information, see Images in the Amazon Rekognition developer guide.
    CompareFaces -> Image
sourceImage :: Image,
    -- | The target image as base64-encoded bytes or an S3 object. If you use the
    -- AWS CLI to call Amazon Rekognition operations, passing base64-encoded
    -- image bytes is not supported.
    --
    -- If you are using an AWS SDK to call Amazon Rekognition, you might not
    -- need to base64-encode image bytes passed using the @Bytes@ field. For
    -- more information, see Images in the Amazon Rekognition developer guide.
    CompareFaces -> Image
targetImage :: Image
  }
  deriving (CompareFaces -> CompareFaces -> Bool
(CompareFaces -> CompareFaces -> Bool)
-> (CompareFaces -> CompareFaces -> Bool) -> Eq CompareFaces
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CompareFaces -> CompareFaces -> Bool
$c/= :: CompareFaces -> CompareFaces -> Bool
== :: CompareFaces -> CompareFaces -> Bool
$c== :: CompareFaces -> CompareFaces -> Bool
Prelude.Eq, ReadPrec [CompareFaces]
ReadPrec CompareFaces
Int -> ReadS CompareFaces
ReadS [CompareFaces]
(Int -> ReadS CompareFaces)
-> ReadS [CompareFaces]
-> ReadPrec CompareFaces
-> ReadPrec [CompareFaces]
-> Read CompareFaces
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CompareFaces]
$creadListPrec :: ReadPrec [CompareFaces]
readPrec :: ReadPrec CompareFaces
$creadPrec :: ReadPrec CompareFaces
readList :: ReadS [CompareFaces]
$creadList :: ReadS [CompareFaces]
readsPrec :: Int -> ReadS CompareFaces
$creadsPrec :: Int -> ReadS CompareFaces
Prelude.Read, Int -> CompareFaces -> ShowS
[CompareFaces] -> ShowS
CompareFaces -> String
(Int -> CompareFaces -> ShowS)
-> (CompareFaces -> String)
-> ([CompareFaces] -> ShowS)
-> Show CompareFaces
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CompareFaces] -> ShowS
$cshowList :: [CompareFaces] -> ShowS
show :: CompareFaces -> String
$cshow :: CompareFaces -> String
showsPrec :: Int -> CompareFaces -> ShowS
$cshowsPrec :: Int -> CompareFaces -> ShowS
Prelude.Show, (forall x. CompareFaces -> Rep CompareFaces x)
-> (forall x. Rep CompareFaces x -> CompareFaces)
-> Generic CompareFaces
forall x. Rep CompareFaces x -> CompareFaces
forall x. CompareFaces -> Rep CompareFaces x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CompareFaces x -> CompareFaces
$cfrom :: forall x. CompareFaces -> Rep CompareFaces x
Prelude.Generic)

-- |
-- Create a value of 'CompareFaces' with all optional fields omitted.
--
-- Use <https://hackage.haskell.org/package/generic-lens generic-lens> or <https://hackage.haskell.org/package/optics optics> to modify other optional fields.
--
-- The following record fields are available, with the corresponding lenses provided
-- for backwards compatibility:
--
-- 'qualityFilter', 'compareFaces_qualityFilter' - A filter that specifies a quality bar for how much filtering is done to
-- identify faces. Filtered faces aren\'t compared. If you specify @AUTO@,
-- Amazon Rekognition chooses the quality bar. If you specify @LOW@,
-- @MEDIUM@, or @HIGH@, filtering removes all faces that don’t meet the
-- chosen quality bar. The quality bar is based on a variety of common use
-- cases. Low-quality detections can occur for a number of reasons. Some
-- examples are an object that\'s misidentified as a face, a face that\'s
-- too blurry, or a face with a pose that\'s too extreme to use. If you
-- specify @NONE@, no filtering is performed. The default value is @NONE@.
--
-- To use quality filtering, the collection you are using must be
-- associated with version 3 of the face model or higher.
--
-- 'similarityThreshold', 'compareFaces_similarityThreshold' - The minimum level of confidence in the face matches that a match must
-- meet to be included in the @FaceMatches@ array.
--
-- 'sourceImage', 'compareFaces_sourceImage' - The input image as base64-encoded bytes or an S3 object. If you use the
-- AWS CLI to call Amazon Rekognition operations, passing base64-encoded
-- image bytes is not supported.
--
-- If you are using an AWS SDK to call Amazon Rekognition, you might not
-- need to base64-encode image bytes passed using the @Bytes@ field. For
-- more information, see Images in the Amazon Rekognition developer guide.
--
-- 'targetImage', 'compareFaces_targetImage' - The target image as base64-encoded bytes or an S3 object. If you use the
-- AWS CLI to call Amazon Rekognition operations, passing base64-encoded
-- image bytes is not supported.
--
-- If you are using an AWS SDK to call Amazon Rekognition, you might not
-- need to base64-encode image bytes passed using the @Bytes@ field. For
-- more information, see Images in the Amazon Rekognition developer guide.
newCompareFaces ::
  -- | 'sourceImage'
  Image ->
  -- | 'targetImage'
  Image ->
  CompareFaces
newCompareFaces :: Image -> Image -> CompareFaces
newCompareFaces Image
pSourceImage_ Image
pTargetImage_ =
  CompareFaces' :: Maybe QualityFilter
-> Maybe Double -> Image -> Image -> CompareFaces
CompareFaces'
    { $sel:qualityFilter:CompareFaces' :: Maybe QualityFilter
qualityFilter = Maybe QualityFilter
forall a. Maybe a
Prelude.Nothing,
      $sel:similarityThreshold:CompareFaces' :: Maybe Double
similarityThreshold = Maybe Double
forall a. Maybe a
Prelude.Nothing,
      $sel:sourceImage:CompareFaces' :: Image
sourceImage = Image
pSourceImage_,
      $sel:targetImage:CompareFaces' :: Image
targetImage = Image
pTargetImage_
    }

-- | A filter that specifies a quality bar for how much filtering is done to
-- identify faces. Filtered faces aren\'t compared. If you specify @AUTO@,
-- Amazon Rekognition chooses the quality bar. If you specify @LOW@,
-- @MEDIUM@, or @HIGH@, filtering removes all faces that don’t meet the
-- chosen quality bar. The quality bar is based on a variety of common use
-- cases. Low-quality detections can occur for a number of reasons. Some
-- examples are an object that\'s misidentified as a face, a face that\'s
-- too blurry, or a face with a pose that\'s too extreme to use. If you
-- specify @NONE@, no filtering is performed. The default value is @NONE@.
--
-- To use quality filtering, the collection you are using must be
-- associated with version 3 of the face model or higher.
compareFaces_qualityFilter :: Lens.Lens' CompareFaces (Prelude.Maybe QualityFilter)
compareFaces_qualityFilter :: (Maybe QualityFilter -> f (Maybe QualityFilter))
-> CompareFaces -> f CompareFaces
compareFaces_qualityFilter = (CompareFaces -> Maybe QualityFilter)
-> (CompareFaces -> Maybe QualityFilter -> CompareFaces)
-> Lens
     CompareFaces
     CompareFaces
     (Maybe QualityFilter)
     (Maybe QualityFilter)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CompareFaces' {Maybe QualityFilter
qualityFilter :: Maybe QualityFilter
$sel:qualityFilter:CompareFaces' :: CompareFaces -> Maybe QualityFilter
qualityFilter} -> Maybe QualityFilter
qualityFilter) (\s :: CompareFaces
s@CompareFaces' {} Maybe QualityFilter
a -> CompareFaces
s {$sel:qualityFilter:CompareFaces' :: Maybe QualityFilter
qualityFilter = Maybe QualityFilter
a} :: CompareFaces)

-- | The minimum level of confidence in the face matches that a match must
-- meet to be included in the @FaceMatches@ array.
compareFaces_similarityThreshold :: Lens.Lens' CompareFaces (Prelude.Maybe Prelude.Double)
compareFaces_similarityThreshold :: (Maybe Double -> f (Maybe Double))
-> CompareFaces -> f CompareFaces
compareFaces_similarityThreshold = (CompareFaces -> Maybe Double)
-> (CompareFaces -> Maybe Double -> CompareFaces)
-> Lens CompareFaces CompareFaces (Maybe Double) (Maybe Double)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CompareFaces' {Maybe Double
similarityThreshold :: Maybe Double
$sel:similarityThreshold:CompareFaces' :: CompareFaces -> Maybe Double
similarityThreshold} -> Maybe Double
similarityThreshold) (\s :: CompareFaces
s@CompareFaces' {} Maybe Double
a -> CompareFaces
s {$sel:similarityThreshold:CompareFaces' :: Maybe Double
similarityThreshold = Maybe Double
a} :: CompareFaces)

-- | The input image as base64-encoded bytes or an S3 object. If you use the
-- AWS CLI to call Amazon Rekognition operations, passing base64-encoded
-- image bytes is not supported.
--
-- If you are using an AWS SDK to call Amazon Rekognition, you might not
-- need to base64-encode image bytes passed using the @Bytes@ field. For
-- more information, see Images in the Amazon Rekognition developer guide.
compareFaces_sourceImage :: Lens.Lens' CompareFaces Image
compareFaces_sourceImage :: (Image -> f Image) -> CompareFaces -> f CompareFaces
compareFaces_sourceImage = (CompareFaces -> Image)
-> (CompareFaces -> Image -> CompareFaces)
-> Lens CompareFaces CompareFaces Image Image
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CompareFaces' {Image
sourceImage :: Image
$sel:sourceImage:CompareFaces' :: CompareFaces -> Image
sourceImage} -> Image
sourceImage) (\s :: CompareFaces
s@CompareFaces' {} Image
a -> CompareFaces
s {$sel:sourceImage:CompareFaces' :: Image
sourceImage = Image
a} :: CompareFaces)

-- | The target image as base64-encoded bytes or an S3 object. If you use the
-- AWS CLI to call Amazon Rekognition operations, passing base64-encoded
-- image bytes is not supported.
--
-- If you are using an AWS SDK to call Amazon Rekognition, you might not
-- need to base64-encode image bytes passed using the @Bytes@ field. For
-- more information, see Images in the Amazon Rekognition developer guide.
compareFaces_targetImage :: Lens.Lens' CompareFaces Image
compareFaces_targetImage :: (Image -> f Image) -> CompareFaces -> f CompareFaces
compareFaces_targetImage = (CompareFaces -> Image)
-> (CompareFaces -> Image -> CompareFaces)
-> Lens CompareFaces CompareFaces Image Image
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CompareFaces' {Image
targetImage :: Image
$sel:targetImage:CompareFaces' :: CompareFaces -> Image
targetImage} -> Image
targetImage) (\s :: CompareFaces
s@CompareFaces' {} Image
a -> CompareFaces
s {$sel:targetImage:CompareFaces' :: Image
targetImage = Image
a} :: CompareFaces)

instance Core.AWSRequest CompareFaces where
  type AWSResponse CompareFaces = CompareFacesResponse
  request :: CompareFaces -> Request CompareFaces
request = Service -> CompareFaces -> Request CompareFaces
forall a. (ToRequest a, ToJSON a) => Service -> a -> Request a
Request.postJSON Service
defaultService
  response :: Logger
-> Service
-> Proxy CompareFaces
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse CompareFaces)))
response =
    (Int
 -> ResponseHeaders
 -> Object
 -> Either String (AWSResponse CompareFaces))
-> Logger
-> Service
-> Proxy CompareFaces
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse CompareFaces)))
forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> Object -> Either String (AWSResponse a))
-> Logger
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveJSON
      ( \Int
s ResponseHeaders
h Object
x ->
          Maybe [CompareFacesMatch]
-> Maybe [ComparedFace]
-> Maybe OrientationCorrection
-> Maybe OrientationCorrection
-> Maybe ComparedSourceImageFace
-> Int
-> CompareFacesResponse
CompareFacesResponse'
            (Maybe [CompareFacesMatch]
 -> Maybe [ComparedFace]
 -> Maybe OrientationCorrection
 -> Maybe OrientationCorrection
 -> Maybe ComparedSourceImageFace
 -> Int
 -> CompareFacesResponse)
-> Either String (Maybe [CompareFacesMatch])
-> Either
     String
     (Maybe [ComparedFace]
      -> Maybe OrientationCorrection
      -> Maybe OrientationCorrection
      -> Maybe ComparedSourceImageFace
      -> Int
      -> CompareFacesResponse)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x Object -> Key -> Either String (Maybe (Maybe [CompareFacesMatch]))
forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Core..?> Key
"FaceMatches" Either String (Maybe (Maybe [CompareFacesMatch]))
-> Maybe [CompareFacesMatch]
-> Either String (Maybe [CompareFacesMatch])
forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ Maybe [CompareFacesMatch]
forall a. Monoid a => a
Prelude.mempty)
            Either
  String
  (Maybe [ComparedFace]
   -> Maybe OrientationCorrection
   -> Maybe OrientationCorrection
   -> Maybe ComparedSourceImageFace
   -> Int
   -> CompareFacesResponse)
-> Either String (Maybe [ComparedFace])
-> Either
     String
     (Maybe OrientationCorrection
      -> Maybe OrientationCorrection
      -> Maybe ComparedSourceImageFace
      -> Int
      -> CompareFacesResponse)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Key -> Either String (Maybe (Maybe [ComparedFace]))
forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Core..?> Key
"UnmatchedFaces" Either String (Maybe (Maybe [ComparedFace]))
-> Maybe [ComparedFace] -> Either String (Maybe [ComparedFace])
forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ Maybe [ComparedFace]
forall a. Monoid a => a
Prelude.mempty)
            Either
  String
  (Maybe OrientationCorrection
   -> Maybe OrientationCorrection
   -> Maybe ComparedSourceImageFace
   -> Int
   -> CompareFacesResponse)
-> Either String (Maybe OrientationCorrection)
-> Either
     String
     (Maybe OrientationCorrection
      -> Maybe ComparedSourceImageFace -> Int -> CompareFacesResponse)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Key -> Either String (Maybe OrientationCorrection)
forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Core..?> Key
"TargetImageOrientationCorrection")
            Either
  String
  (Maybe OrientationCorrection
   -> Maybe ComparedSourceImageFace -> Int -> CompareFacesResponse)
-> Either String (Maybe OrientationCorrection)
-> Either
     String
     (Maybe ComparedSourceImageFace -> Int -> CompareFacesResponse)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Key -> Either String (Maybe OrientationCorrection)
forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Core..?> Key
"SourceImageOrientationCorrection")
            Either
  String
  (Maybe ComparedSourceImageFace -> Int -> CompareFacesResponse)
-> Either String (Maybe ComparedSourceImageFace)
-> Either String (Int -> CompareFacesResponse)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Key -> Either String (Maybe ComparedSourceImageFace)
forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Core..?> Key
"SourceImageFace")
            Either String (Int -> CompareFacesResponse)
-> Either String Int -> Either String CompareFacesResponse
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Int -> Either String Int
forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (Int -> Int
forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
      )

instance Prelude.Hashable CompareFaces

instance Prelude.NFData CompareFaces

instance Core.ToHeaders CompareFaces where
  toHeaders :: CompareFaces -> ResponseHeaders
toHeaders =
    ResponseHeaders -> CompareFaces -> ResponseHeaders
forall a b. a -> b -> a
Prelude.const
      ( [ResponseHeaders] -> ResponseHeaders
forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"X-Amz-Target"
              HeaderName -> ByteString -> ResponseHeaders
forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Core.=# ( ByteString
"RekognitionService.CompareFaces" ::
                          Prelude.ByteString
                      ),
            HeaderName
"Content-Type"
              HeaderName -> ByteString -> ResponseHeaders
forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Core.=# ( ByteString
"application/x-amz-json-1.1" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Core.ToJSON CompareFaces where
  toJSON :: CompareFaces -> Value
toJSON CompareFaces' {Maybe Double
Maybe QualityFilter
Image
targetImage :: Image
sourceImage :: Image
similarityThreshold :: Maybe Double
qualityFilter :: Maybe QualityFilter
$sel:targetImage:CompareFaces' :: CompareFaces -> Image
$sel:sourceImage:CompareFaces' :: CompareFaces -> Image
$sel:similarityThreshold:CompareFaces' :: CompareFaces -> Maybe Double
$sel:qualityFilter:CompareFaces' :: CompareFaces -> Maybe QualityFilter
..} =
    [Pair] -> Value
Core.object
      ( [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"QualityFilter" Key -> QualityFilter -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Core..=) (QualityFilter -> Pair) -> Maybe QualityFilter -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe QualityFilter
qualityFilter,
            (Key
"SimilarityThreshold" Key -> Double -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Core..=)
              (Double -> Pair) -> Maybe Double -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Double
similarityThreshold,
            Pair -> Maybe Pair
forall a. a -> Maybe a
Prelude.Just (Key
"SourceImage" Key -> Image -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Core..= Image
sourceImage),
            Pair -> Maybe Pair
forall a. a -> Maybe a
Prelude.Just (Key
"TargetImage" Key -> Image -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Core..= Image
targetImage)
          ]
      )

instance Core.ToPath CompareFaces where
  toPath :: CompareFaces -> ByteString
toPath = ByteString -> CompareFaces -> ByteString
forall a b. a -> b -> a
Prelude.const ByteString
"/"

instance Core.ToQuery CompareFaces where
  toQuery :: CompareFaces -> QueryString
toQuery = QueryString -> CompareFaces -> QueryString
forall a b. a -> b -> a
Prelude.const QueryString
forall a. Monoid a => a
Prelude.mempty

-- | /See:/ 'newCompareFacesResponse' smart constructor.
data CompareFacesResponse = CompareFacesResponse'
  { -- | An array of faces in the target image that match the source image face.
    -- Each @CompareFacesMatch@ object provides the bounding box, the
    -- confidence level that the bounding box contains a face, and the
    -- similarity score for the face in the bounding box and the face in the
    -- source image.
    CompareFacesResponse -> Maybe [CompareFacesMatch]
faceMatches :: Prelude.Maybe [CompareFacesMatch],
    -- | An array of faces in the target image that did not match the source
    -- image face.
    CompareFacesResponse -> Maybe [ComparedFace]
unmatchedFaces :: Prelude.Maybe [ComparedFace],
    -- | The value of @TargetImageOrientationCorrection@ is always null.
    --
    -- If the input image is in .jpeg format, it might contain exchangeable
    -- image file format (Exif) metadata that includes the image\'s
    -- orientation. Amazon Rekognition uses this orientation information to
    -- perform image correction. The bounding box coordinates are translated to
    -- represent object locations after the orientation information in the Exif
    -- metadata is used to correct the image orientation. Images in .png format
    -- don\'t contain Exif metadata.
    --
    -- Amazon Rekognition doesn’t perform image correction for images in .png
    -- format and .jpeg images without orientation information in the image
    -- Exif metadata. The bounding box coordinates aren\'t translated and
    -- represent the object locations before the image is rotated.
    CompareFacesResponse -> Maybe OrientationCorrection
targetImageOrientationCorrection :: Prelude.Maybe OrientationCorrection,
    -- | The value of @SourceImageOrientationCorrection@ is always null.
    --
    -- If the input image is in .jpeg format, it might contain exchangeable
    -- image file format (Exif) metadata that includes the image\'s
    -- orientation. Amazon Rekognition uses this orientation information to
    -- perform image correction. The bounding box coordinates are translated to
    -- represent object locations after the orientation information in the Exif
    -- metadata is used to correct the image orientation. Images in .png format
    -- don\'t contain Exif metadata.
    --
    -- Amazon Rekognition doesn’t perform image correction for images in .png
    -- format and .jpeg images without orientation information in the image
    -- Exif metadata. The bounding box coordinates aren\'t translated and
    -- represent the object locations before the image is rotated.
    CompareFacesResponse -> Maybe OrientationCorrection
sourceImageOrientationCorrection :: Prelude.Maybe OrientationCorrection,
    -- | The face in the source image that was used for comparison.
    CompareFacesResponse -> Maybe ComparedSourceImageFace
sourceImageFace :: Prelude.Maybe ComparedSourceImageFace,
    -- | The response's http status code.
    CompareFacesResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (CompareFacesResponse -> CompareFacesResponse -> Bool
(CompareFacesResponse -> CompareFacesResponse -> Bool)
-> (CompareFacesResponse -> CompareFacesResponse -> Bool)
-> Eq CompareFacesResponse
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CompareFacesResponse -> CompareFacesResponse -> Bool
$c/= :: CompareFacesResponse -> CompareFacesResponse -> Bool
== :: CompareFacesResponse -> CompareFacesResponse -> Bool
$c== :: CompareFacesResponse -> CompareFacesResponse -> Bool
Prelude.Eq, ReadPrec [CompareFacesResponse]
ReadPrec CompareFacesResponse
Int -> ReadS CompareFacesResponse
ReadS [CompareFacesResponse]
(Int -> ReadS CompareFacesResponse)
-> ReadS [CompareFacesResponse]
-> ReadPrec CompareFacesResponse
-> ReadPrec [CompareFacesResponse]
-> Read CompareFacesResponse
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CompareFacesResponse]
$creadListPrec :: ReadPrec [CompareFacesResponse]
readPrec :: ReadPrec CompareFacesResponse
$creadPrec :: ReadPrec CompareFacesResponse
readList :: ReadS [CompareFacesResponse]
$creadList :: ReadS [CompareFacesResponse]
readsPrec :: Int -> ReadS CompareFacesResponse
$creadsPrec :: Int -> ReadS CompareFacesResponse
Prelude.Read, Int -> CompareFacesResponse -> ShowS
[CompareFacesResponse] -> ShowS
CompareFacesResponse -> String
(Int -> CompareFacesResponse -> ShowS)
-> (CompareFacesResponse -> String)
-> ([CompareFacesResponse] -> ShowS)
-> Show CompareFacesResponse
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CompareFacesResponse] -> ShowS
$cshowList :: [CompareFacesResponse] -> ShowS
show :: CompareFacesResponse -> String
$cshow :: CompareFacesResponse -> String
showsPrec :: Int -> CompareFacesResponse -> ShowS
$cshowsPrec :: Int -> CompareFacesResponse -> ShowS
Prelude.Show, (forall x. CompareFacesResponse -> Rep CompareFacesResponse x)
-> (forall x. Rep CompareFacesResponse x -> CompareFacesResponse)
-> Generic CompareFacesResponse
forall x. Rep CompareFacesResponse x -> CompareFacesResponse
forall x. CompareFacesResponse -> Rep CompareFacesResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CompareFacesResponse x -> CompareFacesResponse
$cfrom :: forall x. CompareFacesResponse -> Rep CompareFacesResponse x
Prelude.Generic)

-- |
-- Create a value of 'CompareFacesResponse' with all optional fields omitted.
--
-- Use <https://hackage.haskell.org/package/generic-lens generic-lens> or <https://hackage.haskell.org/package/optics optics> to modify other optional fields.
--
-- The following record fields are available, with the corresponding lenses provided
-- for backwards compatibility:
--
-- 'faceMatches', 'compareFacesResponse_faceMatches' - An array of faces in the target image that match the source image face.
-- Each @CompareFacesMatch@ object provides the bounding box, the
-- confidence level that the bounding box contains a face, and the
-- similarity score for the face in the bounding box and the face in the
-- source image.
--
-- 'unmatchedFaces', 'compareFacesResponse_unmatchedFaces' - An array of faces in the target image that did not match the source
-- image face.
--
-- 'targetImageOrientationCorrection', 'compareFacesResponse_targetImageOrientationCorrection' - The value of @TargetImageOrientationCorrection@ is always null.
--
-- If the input image is in .jpeg format, it might contain exchangeable
-- image file format (Exif) metadata that includes the image\'s
-- orientation. Amazon Rekognition uses this orientation information to
-- perform image correction. The bounding box coordinates are translated to
-- represent object locations after the orientation information in the Exif
-- metadata is used to correct the image orientation. Images in .png format
-- don\'t contain Exif metadata.
--
-- Amazon Rekognition doesn’t perform image correction for images in .png
-- format and .jpeg images without orientation information in the image
-- Exif metadata. The bounding box coordinates aren\'t translated and
-- represent the object locations before the image is rotated.
--
-- 'sourceImageOrientationCorrection', 'compareFacesResponse_sourceImageOrientationCorrection' - The value of @SourceImageOrientationCorrection@ is always null.
--
-- If the input image is in .jpeg format, it might contain exchangeable
-- image file format (Exif) metadata that includes the image\'s
-- orientation. Amazon Rekognition uses this orientation information to
-- perform image correction. The bounding box coordinates are translated to
-- represent object locations after the orientation information in the Exif
-- metadata is used to correct the image orientation. Images in .png format
-- don\'t contain Exif metadata.
--
-- Amazon Rekognition doesn’t perform image correction for images in .png
-- format and .jpeg images without orientation information in the image
-- Exif metadata. The bounding box coordinates aren\'t translated and
-- represent the object locations before the image is rotated.
--
-- 'sourceImageFace', 'compareFacesResponse_sourceImageFace' - The face in the source image that was used for comparison.
--
-- 'httpStatus', 'compareFacesResponse_httpStatus' - The response's http status code.
newCompareFacesResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CompareFacesResponse
newCompareFacesResponse :: Int -> CompareFacesResponse
newCompareFacesResponse Int
pHttpStatus_ =
  CompareFacesResponse' :: Maybe [CompareFacesMatch]
-> Maybe [ComparedFace]
-> Maybe OrientationCorrection
-> Maybe OrientationCorrection
-> Maybe ComparedSourceImageFace
-> Int
-> CompareFacesResponse
CompareFacesResponse'
    { $sel:faceMatches:CompareFacesResponse' :: Maybe [CompareFacesMatch]
faceMatches =
        Maybe [CompareFacesMatch]
forall a. Maybe a
Prelude.Nothing,
      $sel:unmatchedFaces:CompareFacesResponse' :: Maybe [ComparedFace]
unmatchedFaces = Maybe [ComparedFace]
forall a. Maybe a
Prelude.Nothing,
      $sel:targetImageOrientationCorrection:CompareFacesResponse' :: Maybe OrientationCorrection
targetImageOrientationCorrection = Maybe OrientationCorrection
forall a. Maybe a
Prelude.Nothing,
      $sel:sourceImageOrientationCorrection:CompareFacesResponse' :: Maybe OrientationCorrection
sourceImageOrientationCorrection = Maybe OrientationCorrection
forall a. Maybe a
Prelude.Nothing,
      $sel:sourceImageFace:CompareFacesResponse' :: Maybe ComparedSourceImageFace
sourceImageFace = Maybe ComparedSourceImageFace
forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:CompareFacesResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | An array of faces in the target image that match the source image face.
-- Each @CompareFacesMatch@ object provides the bounding box, the
-- confidence level that the bounding box contains a face, and the
-- similarity score for the face in the bounding box and the face in the
-- source image.
compareFacesResponse_faceMatches :: Lens.Lens' CompareFacesResponse (Prelude.Maybe [CompareFacesMatch])
compareFacesResponse_faceMatches :: (Maybe [CompareFacesMatch] -> f (Maybe [CompareFacesMatch]))
-> CompareFacesResponse -> f CompareFacesResponse
compareFacesResponse_faceMatches = (CompareFacesResponse -> Maybe [CompareFacesMatch])
-> (CompareFacesResponse
    -> Maybe [CompareFacesMatch] -> CompareFacesResponse)
-> Lens
     CompareFacesResponse
     CompareFacesResponse
     (Maybe [CompareFacesMatch])
     (Maybe [CompareFacesMatch])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CompareFacesResponse' {Maybe [CompareFacesMatch]
faceMatches :: Maybe [CompareFacesMatch]
$sel:faceMatches:CompareFacesResponse' :: CompareFacesResponse -> Maybe [CompareFacesMatch]
faceMatches} -> Maybe [CompareFacesMatch]
faceMatches) (\s :: CompareFacesResponse
s@CompareFacesResponse' {} Maybe [CompareFacesMatch]
a -> CompareFacesResponse
s {$sel:faceMatches:CompareFacesResponse' :: Maybe [CompareFacesMatch]
faceMatches = Maybe [CompareFacesMatch]
a} :: CompareFacesResponse) ((Maybe [CompareFacesMatch] -> f (Maybe [CompareFacesMatch]))
 -> CompareFacesResponse -> f CompareFacesResponse)
-> ((Maybe [CompareFacesMatch] -> f (Maybe [CompareFacesMatch]))
    -> Maybe [CompareFacesMatch] -> f (Maybe [CompareFacesMatch]))
-> (Maybe [CompareFacesMatch] -> f (Maybe [CompareFacesMatch]))
-> CompareFacesResponse
-> f CompareFacesResponse
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso
  [CompareFacesMatch]
  [CompareFacesMatch]
  [CompareFacesMatch]
  [CompareFacesMatch]
-> Iso
     (Maybe [CompareFacesMatch])
     (Maybe [CompareFacesMatch])
     (Maybe [CompareFacesMatch])
     (Maybe [CompareFacesMatch])
forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping AnIso
  [CompareFacesMatch]
  [CompareFacesMatch]
  [CompareFacesMatch]
  [CompareFacesMatch]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | An array of faces in the target image that did not match the source
-- image face.
compareFacesResponse_unmatchedFaces :: Lens.Lens' CompareFacesResponse (Prelude.Maybe [ComparedFace])
compareFacesResponse_unmatchedFaces :: (Maybe [ComparedFace] -> f (Maybe [ComparedFace]))
-> CompareFacesResponse -> f CompareFacesResponse
compareFacesResponse_unmatchedFaces = (CompareFacesResponse -> Maybe [ComparedFace])
-> (CompareFacesResponse
    -> Maybe [ComparedFace] -> CompareFacesResponse)
-> Lens
     CompareFacesResponse
     CompareFacesResponse
     (Maybe [ComparedFace])
     (Maybe [ComparedFace])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CompareFacesResponse' {Maybe [ComparedFace]
unmatchedFaces :: Maybe [ComparedFace]
$sel:unmatchedFaces:CompareFacesResponse' :: CompareFacesResponse -> Maybe [ComparedFace]
unmatchedFaces} -> Maybe [ComparedFace]
unmatchedFaces) (\s :: CompareFacesResponse
s@CompareFacesResponse' {} Maybe [ComparedFace]
a -> CompareFacesResponse
s {$sel:unmatchedFaces:CompareFacesResponse' :: Maybe [ComparedFace]
unmatchedFaces = Maybe [ComparedFace]
a} :: CompareFacesResponse) ((Maybe [ComparedFace] -> f (Maybe [ComparedFace]))
 -> CompareFacesResponse -> f CompareFacesResponse)
-> ((Maybe [ComparedFace] -> f (Maybe [ComparedFace]))
    -> Maybe [ComparedFace] -> f (Maybe [ComparedFace]))
-> (Maybe [ComparedFace] -> f (Maybe [ComparedFace]))
-> CompareFacesResponse
-> f CompareFacesResponse
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso [ComparedFace] [ComparedFace] [ComparedFace] [ComparedFace]
-> Iso
     (Maybe [ComparedFace])
     (Maybe [ComparedFace])
     (Maybe [ComparedFace])
     (Maybe [ComparedFace])
forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping AnIso [ComparedFace] [ComparedFace] [ComparedFace] [ComparedFace]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The value of @TargetImageOrientationCorrection@ is always null.
--
-- If the input image is in .jpeg format, it might contain exchangeable
-- image file format (Exif) metadata that includes the image\'s
-- orientation. Amazon Rekognition uses this orientation information to
-- perform image correction. The bounding box coordinates are translated to
-- represent object locations after the orientation information in the Exif
-- metadata is used to correct the image orientation. Images in .png format
-- don\'t contain Exif metadata.
--
-- Amazon Rekognition doesn’t perform image correction for images in .png
-- format and .jpeg images without orientation information in the image
-- Exif metadata. The bounding box coordinates aren\'t translated and
-- represent the object locations before the image is rotated.
compareFacesResponse_targetImageOrientationCorrection :: Lens.Lens' CompareFacesResponse (Prelude.Maybe OrientationCorrection)
compareFacesResponse_targetImageOrientationCorrection :: (Maybe OrientationCorrection -> f (Maybe OrientationCorrection))
-> CompareFacesResponse -> f CompareFacesResponse
compareFacesResponse_targetImageOrientationCorrection = (CompareFacesResponse -> Maybe OrientationCorrection)
-> (CompareFacesResponse
    -> Maybe OrientationCorrection -> CompareFacesResponse)
-> Lens
     CompareFacesResponse
     CompareFacesResponse
     (Maybe OrientationCorrection)
     (Maybe OrientationCorrection)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CompareFacesResponse' {Maybe OrientationCorrection
targetImageOrientationCorrection :: Maybe OrientationCorrection
$sel:targetImageOrientationCorrection:CompareFacesResponse' :: CompareFacesResponse -> Maybe OrientationCorrection
targetImageOrientationCorrection} -> Maybe OrientationCorrection
targetImageOrientationCorrection) (\s :: CompareFacesResponse
s@CompareFacesResponse' {} Maybe OrientationCorrection
a -> CompareFacesResponse
s {$sel:targetImageOrientationCorrection:CompareFacesResponse' :: Maybe OrientationCorrection
targetImageOrientationCorrection = Maybe OrientationCorrection
a} :: CompareFacesResponse)

-- | The value of @SourceImageOrientationCorrection@ is always null.
--
-- If the input image is in .jpeg format, it might contain exchangeable
-- image file format (Exif) metadata that includes the image\'s
-- orientation. Amazon Rekognition uses this orientation information to
-- perform image correction. The bounding box coordinates are translated to
-- represent object locations after the orientation information in the Exif
-- metadata is used to correct the image orientation. Images in .png format
-- don\'t contain Exif metadata.
--
-- Amazon Rekognition doesn’t perform image correction for images in .png
-- format and .jpeg images without orientation information in the image
-- Exif metadata. The bounding box coordinates aren\'t translated and
-- represent the object locations before the image is rotated.
compareFacesResponse_sourceImageOrientationCorrection :: Lens.Lens' CompareFacesResponse (Prelude.Maybe OrientationCorrection)
compareFacesResponse_sourceImageOrientationCorrection :: (Maybe OrientationCorrection -> f (Maybe OrientationCorrection))
-> CompareFacesResponse -> f CompareFacesResponse
compareFacesResponse_sourceImageOrientationCorrection = (CompareFacesResponse -> Maybe OrientationCorrection)
-> (CompareFacesResponse
    -> Maybe OrientationCorrection -> CompareFacesResponse)
-> Lens
     CompareFacesResponse
     CompareFacesResponse
     (Maybe OrientationCorrection)
     (Maybe OrientationCorrection)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CompareFacesResponse' {Maybe OrientationCorrection
sourceImageOrientationCorrection :: Maybe OrientationCorrection
$sel:sourceImageOrientationCorrection:CompareFacesResponse' :: CompareFacesResponse -> Maybe OrientationCorrection
sourceImageOrientationCorrection} -> Maybe OrientationCorrection
sourceImageOrientationCorrection) (\s :: CompareFacesResponse
s@CompareFacesResponse' {} Maybe OrientationCorrection
a -> CompareFacesResponse
s {$sel:sourceImageOrientationCorrection:CompareFacesResponse' :: Maybe OrientationCorrection
sourceImageOrientationCorrection = Maybe OrientationCorrection
a} :: CompareFacesResponse)

-- | The face in the source image that was used for comparison.
compareFacesResponse_sourceImageFace :: Lens.Lens' CompareFacesResponse (Prelude.Maybe ComparedSourceImageFace)
compareFacesResponse_sourceImageFace :: (Maybe ComparedSourceImageFace
 -> f (Maybe ComparedSourceImageFace))
-> CompareFacesResponse -> f CompareFacesResponse
compareFacesResponse_sourceImageFace = (CompareFacesResponse -> Maybe ComparedSourceImageFace)
-> (CompareFacesResponse
    -> Maybe ComparedSourceImageFace -> CompareFacesResponse)
-> Lens
     CompareFacesResponse
     CompareFacesResponse
     (Maybe ComparedSourceImageFace)
     (Maybe ComparedSourceImageFace)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CompareFacesResponse' {Maybe ComparedSourceImageFace
sourceImageFace :: Maybe ComparedSourceImageFace
$sel:sourceImageFace:CompareFacesResponse' :: CompareFacesResponse -> Maybe ComparedSourceImageFace
sourceImageFace} -> Maybe ComparedSourceImageFace
sourceImageFace) (\s :: CompareFacesResponse
s@CompareFacesResponse' {} Maybe ComparedSourceImageFace
a -> CompareFacesResponse
s {$sel:sourceImageFace:CompareFacesResponse' :: Maybe ComparedSourceImageFace
sourceImageFace = Maybe ComparedSourceImageFace
a} :: CompareFacesResponse)

-- | The response's http status code.
compareFacesResponse_httpStatus :: Lens.Lens' CompareFacesResponse Prelude.Int
compareFacesResponse_httpStatus :: (Int -> f Int) -> CompareFacesResponse -> f CompareFacesResponse
compareFacesResponse_httpStatus = (CompareFacesResponse -> Int)
-> (CompareFacesResponse -> Int -> CompareFacesResponse)
-> Lens CompareFacesResponse CompareFacesResponse Int Int
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CompareFacesResponse' {Int
httpStatus :: Int
$sel:httpStatus:CompareFacesResponse' :: CompareFacesResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: CompareFacesResponse
s@CompareFacesResponse' {} Int
a -> CompareFacesResponse
s {$sel:httpStatus:CompareFacesResponse' :: Int
httpStatus = Int
a} :: CompareFacesResponse)

instance Prelude.NFData CompareFacesResponse