google-cloud 0.2.1

Asynchronous Rust bindings for Google Cloud Platform gRPC APIs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

use std::convert::TryFrom;

use crate::vision::api;
use crate::vision::{BoundingBox, Likelihood};

/// Represents a text annotation, from the text detector.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct FaceAnnotation {
    pub(crate) bounding_box: BoundingBox,
    pub(crate) joy_likelihood: Likelihood,
    pub(crate) sorrow_likelihood: Likelihood,
    pub(crate) anger_likelihood: Likelihood,
    pub(crate) surprise_likelihood: Likelihood,
    pub(crate) under_exposed_likelihood: Likelihood,
    pub(crate) blurred_likelihood: Likelihood,
    pub(crate) headwear_likelihood: Likelihood,
}

impl FaceAnnotation {
    /// Get the detected face's bounding box.
    pub fn bounding_box(&self) -> BoundingBox {
        self.bounding_box
    }

    /// Get the detected face's likelihood that it expresses joy.
    pub fn joy_likelihood(&self) -> Likelihood {
        self.joy_likelihood
    }

    /// Get the detected face's likelihood that it expresses sorrow.
    pub fn sorrow_likelihood(&self) -> Likelihood {
        self.sorrow_likelihood
    }

    /// Get the detected face's likelihood that it expresses anger.
    pub fn anger_likelihood(&self) -> Likelihood {
        self.anger_likelihood
    }

    /// Get the detected face's likelihood that it expresses surprise.
    pub fn surprise_likelihood(&self) -> Likelihood {
        self.surprise_likelihood
    }

    /// Get the detected face's likelihood that it is underexposed.
    pub fn under_exposed_likelihood(&self) -> Likelihood {
        self.under_exposed_likelihood
    }

    /// Get the detected face's likelihood that it is blurred.
    pub fn blurred_likelihood(&self) -> Likelihood {
        self.blurred_likelihood
    }

    /// Get the detected face's likelihood that it have headwear.
    pub fn headwear_likelihood(&self) -> Likelihood {
        self.headwear_likelihood
    }
}

impl TryFrom<api::FaceAnnotation> for FaceAnnotation {
    type Error = ();
    fn try_from(ann: api::FaceAnnotation) -> Result<FaceAnnotation, Self::Error> {
        Ok(FaceAnnotation {
            bounding_box: BoundingBox::from(ann.bounding_poly.unwrap()),
            joy_likelihood: Likelihood::try_from(ann.joy_likelihood)?,
            sorrow_likelihood: Likelihood::try_from(ann.sorrow_likelihood)?,
            anger_likelihood: Likelihood::try_from(ann.anger_likelihood)?,
            surprise_likelihood: Likelihood::try_from(ann.surprise_likelihood)?,
            under_exposed_likelihood: Likelihood::try_from(ann.under_exposed_likelihood)?,
            blurred_likelihood: Likelihood::try_from(ann.blurred_likelihood)?,
            headwear_likelihood: Likelihood::try_from(ann.headwear_likelihood)?,
        })
    }
}