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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

use crate::errors::Result;
use crate::types::*;
use uuid::Uuid;

/// Position on a photo where a mask is placed
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MaskPosition {
    #[doc(hidden)]
    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
    extra: Option<String>,
    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
    client_id: Option<i32>,
    /// Part of the face, relative to which the mask is placed

    #[serde(skip_serializing_if = "MaskPoint::_is_default")]
    point: MaskPoint,
    /// Shift by X-axis measured in widths of the mask scaled to the face size, from left to right. (For example, 1.0 will place the mask just to the left of the default mask position)

    #[serde(default)]
    x_shift: f32,
    /// Shift by Y-axis measured in heights of the mask scaled to the face size, from top to bottom. (For example, 1.0 will place the mask just below the default mask position)

    #[serde(default)]
    y_shift: f32,
    /// Mask scaling coefficient. (For example, 2.0 means a doubled size)

    #[serde(default)]
    scale: f32,
}

impl RObject for MaskPosition {
    #[doc(hidden)]
    fn extra(&self) -> Option<&str> {
        self.extra.as_deref()
    }
    #[doc(hidden)]
    fn client_id(&self) -> Option<i32> {
        self.client_id
    }
}

impl MaskPosition {
    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
        Ok(serde_json::from_str(json.as_ref())?)
    }
    pub fn builder() -> MaskPositionBuilder {
        let mut inner = MaskPosition::default();
        inner.extra = Some(Uuid::new_v4().to_string());

        MaskPositionBuilder { inner }
    }

    pub fn point(&self) -> &MaskPoint {
        &self.point
    }

    pub fn x_shift(&self) -> f32 {
        self.x_shift
    }

    pub fn y_shift(&self) -> f32 {
        self.y_shift
    }

    pub fn scale(&self) -> f32 {
        self.scale
    }
}

#[doc(hidden)]
pub struct MaskPositionBuilder {
    inner: MaskPosition,
}

#[deprecated]
pub type RTDMaskPositionBuilder = MaskPositionBuilder;

impl MaskPositionBuilder {
    pub fn build(&self) -> MaskPosition {
        self.inner.clone()
    }

    pub fn point<T: AsRef<MaskPoint>>(&mut self, point: T) -> &mut Self {
        self.inner.point = point.as_ref().clone();
        self
    }

    pub fn x_shift(&mut self, x_shift: f32) -> &mut Self {
        self.inner.x_shift = x_shift;
        self
    }

    pub fn y_shift(&mut self, y_shift: f32) -> &mut Self {
        self.inner.y_shift = y_shift;
        self
    }

    pub fn scale(&mut self, scale: f32) -> &mut Self {
        self.inner.scale = scale;
        self
    }
}

impl AsRef<MaskPosition> for MaskPosition {
    fn as_ref(&self) -> &MaskPosition {
        self
    }
}

impl AsRef<MaskPosition> for MaskPositionBuilder {
    fn as_ref(&self) -> &MaskPosition {
        &self.inner
    }
}