{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# 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.Types.Label
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
module Amazonka.Rekognition.Types.Label where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import qualified Amazonka.Prelude as Prelude
import Amazonka.Rekognition.Types.Instance
import Amazonka.Rekognition.Types.LabelAlias
import Amazonka.Rekognition.Types.LabelCategory
import Amazonka.Rekognition.Types.Parent

-- | Structure containing details about the detected label, including the
-- name, detected instances, parent labels, and level of confidence.
--
-- /See:/ 'newLabel' smart constructor.
data Label = Label'
  { -- | A list of potential aliases for a given label.
    Label -> Maybe [LabelAlias]
aliases :: Prelude.Maybe [LabelAlias],
    -- | A list of the categories associated with a given label.
    Label -> Maybe [LabelCategory]
categories :: Prelude.Maybe [LabelCategory],
    -- | Level of confidence.
    Label -> Maybe Double
confidence :: Prelude.Maybe Prelude.Double,
    -- | If @Label@ represents an object, @Instances@ contains the bounding boxes
    -- for each instance of the detected object. Bounding boxes are returned
    -- for common object labels such as people, cars, furniture, apparel or
    -- pets.
    Label -> Maybe [Instance]
instances :: Prelude.Maybe [Instance],
    -- | The name (label) of the object or scene.
    Label -> Maybe Text
name :: Prelude.Maybe Prelude.Text,
    -- | The parent labels for a label. The response includes all ancestor
    -- labels.
    Label -> Maybe [Parent]
parents :: Prelude.Maybe [Parent]
  }
  deriving (Label -> Label -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Label -> Label -> Bool
$c/= :: Label -> Label -> Bool
== :: Label -> Label -> Bool
$c== :: Label -> Label -> Bool
Prelude.Eq, ReadPrec [Label]
ReadPrec Label
Int -> ReadS Label
ReadS [Label]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Label]
$creadListPrec :: ReadPrec [Label]
readPrec :: ReadPrec Label
$creadPrec :: ReadPrec Label
readList :: ReadS [Label]
$creadList :: ReadS [Label]
readsPrec :: Int -> ReadS Label
$creadsPrec :: Int -> ReadS Label
Prelude.Read, Int -> Label -> ShowS
[Label] -> ShowS
Label -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Label] -> ShowS
$cshowList :: [Label] -> ShowS
show :: Label -> String
$cshow :: Label -> String
showsPrec :: Int -> Label -> ShowS
$cshowsPrec :: Int -> Label -> ShowS
Prelude.Show, forall x. Rep Label x -> Label
forall x. Label -> Rep Label x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Label x -> Label
$cfrom :: forall x. Label -> Rep Label x
Prelude.Generic)

-- |
-- Create a value of 'Label' 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:
--
-- 'aliases', 'label_aliases' - A list of potential aliases for a given label.
--
-- 'categories', 'label_categories' - A list of the categories associated with a given label.
--
-- 'confidence', 'label_confidence' - Level of confidence.
--
-- 'instances', 'label_instances' - If @Label@ represents an object, @Instances@ contains the bounding boxes
-- for each instance of the detected object. Bounding boxes are returned
-- for common object labels such as people, cars, furniture, apparel or
-- pets.
--
-- 'name', 'label_name' - The name (label) of the object or scene.
--
-- 'parents', 'label_parents' - The parent labels for a label. The response includes all ancestor
-- labels.
newLabel ::
  Label
newLabel :: Label
newLabel =
  Label'
    { $sel:aliases:Label' :: Maybe [LabelAlias]
aliases = forall a. Maybe a
Prelude.Nothing,
      $sel:categories:Label' :: Maybe [LabelCategory]
categories = forall a. Maybe a
Prelude.Nothing,
      $sel:confidence:Label' :: Maybe Double
confidence = forall a. Maybe a
Prelude.Nothing,
      $sel:instances:Label' :: Maybe [Instance]
instances = forall a. Maybe a
Prelude.Nothing,
      $sel:name:Label' :: Maybe Text
name = forall a. Maybe a
Prelude.Nothing,
      $sel:parents:Label' :: Maybe [Parent]
parents = forall a. Maybe a
Prelude.Nothing
    }

-- | A list of potential aliases for a given label.
label_aliases :: Lens.Lens' Label (Prelude.Maybe [LabelAlias])
label_aliases :: Lens' Label (Maybe [LabelAlias])
label_aliases = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Label' {Maybe [LabelAlias]
aliases :: Maybe [LabelAlias]
$sel:aliases:Label' :: Label -> Maybe [LabelAlias]
aliases} -> Maybe [LabelAlias]
aliases) (\s :: Label
s@Label' {} Maybe [LabelAlias]
a -> Label
s {$sel:aliases:Label' :: Maybe [LabelAlias]
aliases = Maybe [LabelAlias]
a} :: Label) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. 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 forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | A list of the categories associated with a given label.
label_categories :: Lens.Lens' Label (Prelude.Maybe [LabelCategory])
label_categories :: Lens' Label (Maybe [LabelCategory])
label_categories = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Label' {Maybe [LabelCategory]
categories :: Maybe [LabelCategory]
$sel:categories:Label' :: Label -> Maybe [LabelCategory]
categories} -> Maybe [LabelCategory]
categories) (\s :: Label
s@Label' {} Maybe [LabelCategory]
a -> Label
s {$sel:categories:Label' :: Maybe [LabelCategory]
categories = Maybe [LabelCategory]
a} :: Label) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. 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 forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | Level of confidence.
label_confidence :: Lens.Lens' Label (Prelude.Maybe Prelude.Double)
label_confidence :: Lens' Label (Maybe Double)
label_confidence = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Label' {Maybe Double
confidence :: Maybe Double
$sel:confidence:Label' :: Label -> Maybe Double
confidence} -> Maybe Double
confidence) (\s :: Label
s@Label' {} Maybe Double
a -> Label
s {$sel:confidence:Label' :: Maybe Double
confidence = Maybe Double
a} :: Label)

-- | If @Label@ represents an object, @Instances@ contains the bounding boxes
-- for each instance of the detected object. Bounding boxes are returned
-- for common object labels such as people, cars, furniture, apparel or
-- pets.
label_instances :: Lens.Lens' Label (Prelude.Maybe [Instance])
label_instances :: Lens' Label (Maybe [Instance])
label_instances = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Label' {Maybe [Instance]
instances :: Maybe [Instance]
$sel:instances:Label' :: Label -> Maybe [Instance]
instances} -> Maybe [Instance]
instances) (\s :: Label
s@Label' {} Maybe [Instance]
a -> Label
s {$sel:instances:Label' :: Maybe [Instance]
instances = Maybe [Instance]
a} :: Label) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. 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 forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The name (label) of the object or scene.
label_name :: Lens.Lens' Label (Prelude.Maybe Prelude.Text)
label_name :: Lens' Label (Maybe Text)
label_name = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Label' {Maybe Text
name :: Maybe Text
$sel:name:Label' :: Label -> Maybe Text
name} -> Maybe Text
name) (\s :: Label
s@Label' {} Maybe Text
a -> Label
s {$sel:name:Label' :: Maybe Text
name = Maybe Text
a} :: Label)

-- | The parent labels for a label. The response includes all ancestor
-- labels.
label_parents :: Lens.Lens' Label (Prelude.Maybe [Parent])
label_parents :: Lens' Label (Maybe [Parent])
label_parents = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Label' {Maybe [Parent]
parents :: Maybe [Parent]
$sel:parents:Label' :: Label -> Maybe [Parent]
parents} -> Maybe [Parent]
parents) (\s :: Label
s@Label' {} Maybe [Parent]
a -> Label
s {$sel:parents:Label' :: Maybe [Parent]
parents = Maybe [Parent]
a} :: Label) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. 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 forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

instance Data.FromJSON Label where
  parseJSON :: Value -> Parser Label
parseJSON =
    forall a. String -> (Object -> Parser a) -> Value -> Parser a
Data.withObject
      String
"Label"
      ( \Object
x ->
          Maybe [LabelAlias]
-> Maybe [LabelCategory]
-> Maybe Double
-> Maybe [Instance]
-> Maybe Text
-> Maybe [Parent]
-> Label
Label'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"Aliases" forall a. Parser (Maybe a) -> a -> Parser a
Data..!= forall a. Monoid a => a
Prelude.mempty)
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"Categories" forall a. Parser (Maybe a) -> a -> Parser a
Data..!= forall a. Monoid a => a
Prelude.mempty)
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"Confidence")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"Instances" forall a. Parser (Maybe a) -> a -> Parser a
Data..!= forall a. Monoid a => a
Prelude.mempty)
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"Name")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"Parents" forall a. Parser (Maybe a) -> a -> Parser a
Data..!= forall a. Monoid a => a
Prelude.mempty)
      )

instance Prelude.Hashable Label where
  hashWithSalt :: Int -> Label -> Int
hashWithSalt Int
_salt Label' {Maybe Double
Maybe [Instance]
Maybe [LabelAlias]
Maybe [LabelCategory]
Maybe [Parent]
Maybe Text
parents :: Maybe [Parent]
name :: Maybe Text
instances :: Maybe [Instance]
confidence :: Maybe Double
categories :: Maybe [LabelCategory]
aliases :: Maybe [LabelAlias]
$sel:parents:Label' :: Label -> Maybe [Parent]
$sel:name:Label' :: Label -> Maybe Text
$sel:instances:Label' :: Label -> Maybe [Instance]
$sel:confidence:Label' :: Label -> Maybe Double
$sel:categories:Label' :: Label -> Maybe [LabelCategory]
$sel:aliases:Label' :: Label -> Maybe [LabelAlias]
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [LabelAlias]
aliases
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [LabelCategory]
categories
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Double
confidence
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Instance]
instances
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
name
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Parent]
parents

instance Prelude.NFData Label where
  rnf :: Label -> ()
rnf Label' {Maybe Double
Maybe [Instance]
Maybe [LabelAlias]
Maybe [LabelCategory]
Maybe [Parent]
Maybe Text
parents :: Maybe [Parent]
name :: Maybe Text
instances :: Maybe [Instance]
confidence :: Maybe Double
categories :: Maybe [LabelCategory]
aliases :: Maybe [LabelAlias]
$sel:parents:Label' :: Label -> Maybe [Parent]
$sel:name:Label' :: Label -> Maybe Text
$sel:instances:Label' :: Label -> Maybe [Instance]
$sel:confidence:Label' :: Label -> Maybe Double
$sel:categories:Label' :: Label -> Maybe [LabelCategory]
$sel:aliases:Label' :: Label -> Maybe [LabelAlias]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [LabelAlias]
aliases
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [LabelCategory]
categories
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Double
confidence
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Instance]
instances
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
name
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Parent]
parents