Skip to main content

ocio_rs/transform/
exponent_with_linear.rs

1use std::ffi::c_void;
2use std::ptr::NonNull;
3
4use crate::{NegativeStyle, OcioError, Result, TransformDirection};
5use ocio_sys;
6
7/// Exponent transform with an additional linear section around zero.
8pub struct ExponentWithLinearTransform {
9    pub(crate) handle: NonNull<c_void>,
10}
11
12impl ExponentWithLinearTransform {
13    /// Create a new exponent-with-linear transform.
14    pub fn create() -> Result<Self> {
15        crate::clear_last_error();
16        let handle = unsafe { ocio_sys::ocio_exponent_with_linear_transform_create() };
17        crate::handle_result(handle).map(|handle| Self { handle })
18    }
19
20    /// Return the per-channel gamma values.
21    pub fn gamma(&self) -> Result<[f64; 4]> {
22        let mut vec4 = [1.0f64; 4];
23        crate::clear_last_error();
24        unsafe {
25            ocio_sys::ocio_exponent_with_linear_transform_get_gamma(
26                self.handle.as_ptr(),
27                vec4.as_mut_ptr(),
28            );
29        }
30        crate::ocio_call_status()?;
31        Ok(vec4)
32    }
33
34    /// Set the per-channel gamma values.
35    pub fn set_gamma(&self, vec4: &[f64; 4]) -> Result<()> {
36        crate::clear_last_error();
37        unsafe {
38            ocio_sys::ocio_exponent_with_linear_transform_set_gamma(
39                self.handle.as_ptr(),
40                vec4.as_ptr(),
41            );
42        }
43        crate::ocio_call_status()
44    }
45
46    /// Return the per-channel offset values.
47    pub fn offset(&self) -> Result<[f64; 4]> {
48        let mut vec4 = [0.0f64; 4];
49        crate::clear_last_error();
50        unsafe {
51            ocio_sys::ocio_exponent_with_linear_transform_get_offset(
52                self.handle.as_ptr(),
53                vec4.as_mut_ptr(),
54            );
55        }
56        crate::ocio_call_status()?;
57        Ok(vec4)
58    }
59
60    /// Set the per-channel offset values.
61    pub fn set_offset(&self, vec4: &[f64; 4]) -> Result<()> {
62        crate::clear_last_error();
63        unsafe {
64            ocio_sys::ocio_exponent_with_linear_transform_set_offset(
65                self.handle.as_ptr(),
66                vec4.as_ptr(),
67            );
68        }
69        crate::ocio_call_status()
70    }
71
72    /// Return the negative value handling style.
73    pub fn negative_style(&self) -> NegativeStyle {
74        let s = unsafe {
75            ocio_sys::ocio_exponent_with_linear_transform_get_negative_style(self.handle.as_ptr())
76        };
77        match s {
78            1 => NegativeStyle::Mirror,
79            2 => NegativeStyle::PassThru,
80            3 => NegativeStyle::Linear,
81            _ => NegativeStyle::Clamp,
82        }
83    }
84
85    /// Set the negative value handling style.
86    pub fn set_negative_style(&self, style: NegativeStyle) -> Result<()> {
87        crate::clear_last_error();
88        unsafe {
89            ocio_sys::ocio_exponent_with_linear_transform_set_negative_style(
90                self.handle.as_ptr(),
91                style as i32,
92            );
93        }
94        crate::ocio_call_status()
95    }
96
97    /// Return the transform direction.
98    pub fn direction(&self) -> TransformDirection {
99        let dir = unsafe {
100            ocio_sys::ocio_exponent_with_linear_transform_get_direction(self.handle.as_ptr())
101        };
102        match dir {
103            1 => TransformDirection::Inverse,
104            _ => TransformDirection::Forward,
105        }
106    }
107
108    /// Set the transform direction.
109    pub fn set_direction(&self, direction: TransformDirection) {
110        self.try_set_direction(direction)
111            .expect("failed to set exponent-with-linear transform direction");
112    }
113
114    /// Set the transform direction and surface any OCIO validation error.
115    pub fn try_set_direction(&self, direction: TransformDirection) -> crate::Result<()> {
116        crate::clear_last_error();
117        unsafe {
118            ocio_sys::ocio_exponent_with_linear_transform_set_direction(
119                self.handle.as_ptr(),
120                direction as i32,
121            );
122        }
123        crate::ocio_call_status()
124    }
125
126    /// Create an independent copy of this transform.
127    pub fn create_editable_copy(&self) -> Result<Self> {
128        crate::clear_last_error();
129        let handle = unsafe { ocio_sys::ocio_transform_create_editable_copy(self.handle.as_ptr()) };
130        crate::handle_result(handle).map(|handle| Self { handle })
131    }
132
133    /// Return format metadata attached to the transform, when available.
134    pub fn format_metadata(&self) -> Option<crate::FormatMetadata> {
135        let handle = unsafe { ocio_sys::ocio_transform_get_format_metadata(self.handle.as_ptr()) };
136        NonNull::new(handle).map(|h| crate::FormatMetadata { handle: h })
137    }
138
139    #[deprecated(since = "0.2.0", note = "compat alias; prefer format_metadata()")]
140    pub fn format_metadata_v1(&self) -> Option<crate::FormatMetadata> {
141        self.format_metadata()
142    }
143
144    #[deprecated(since = "0.2.0", note = "compat alias; prefer format_metadata()")]
145    pub fn format_metadata_v2(&self) -> Option<crate::FormatMetadata> {
146        self.format_metadata()
147    }
148
149    /// Return whether this transform is equivalent to `other`.
150    pub fn equals(&self, other: &Self) -> bool {
151        unsafe {
152            ocio_sys::ocio_exponent_with_linear_transform_equals(
153                self.handle.as_ptr(),
154                other.handle.as_ptr(),
155            )
156        }
157    }
158}
159
160impl Drop for ExponentWithLinearTransform {
161    fn drop(&mut self) {
162        unsafe { ocio_sys::ocio_exponent_with_linear_transform_destroy(self.handle.as_ptr()) };
163    }
164}
165
166#[cfg(test)]
167mod tests {
168    use super::*;
169
170    #[test]
171    fn create_exponent_with_linear() {
172        let t = ExponentWithLinearTransform::create();
173        assert!(t.is_ok());
174    }
175
176    #[test]
177    fn gamma_no_crash() {
178        let t = ExponentWithLinearTransform::create().unwrap();
179        let _ = t.gamma();
180        let _ = t.set_gamma(&[1.0, 1.0, 1.0, 1.0]);
181    }
182
183    #[test]
184    fn offset_no_crash() {
185        let t = ExponentWithLinearTransform::create().unwrap();
186        let _ = t.offset();
187        let _ = t.set_offset(&[0.0, 0.0, 0.0, 0.0]);
188    }
189
190    #[test]
191    fn negative_style_no_crash() {
192        let t = ExponentWithLinearTransform::create().unwrap();
193        let _ = t.negative_style();
194        let _ = t.set_negative_style(NegativeStyle::Mirror);
195    }
196
197    #[test]
198    fn direction_no_crash() {
199        let t = ExponentWithLinearTransform::create().unwrap();
200        let _ = t.direction();
201        t.set_direction(TransformDirection::Inverse);
202    }
203
204    #[test]
205    fn create_editable_copy_no_crash() {
206        let t = ExponentWithLinearTransform::create().unwrap();
207        let _ = t.create_editable_copy();
208    }
209
210    #[test]
211    fn format_metadata_no_crash() {
212        let t = ExponentWithLinearTransform::create().unwrap();
213        let _ = t.format_metadata();
214    }
215
216    #[test]
217    fn equals_no_crash() {
218        let a = ExponentWithLinearTransform::create().unwrap();
219        let b = ExponentWithLinearTransform::create().unwrap();
220        let _ = a.equals(&b);
221    }
222}