Skip to main content

ocio_rs/transform/
exponent.rs

1use std::ffi::c_void;
2use std::ptr::NonNull;
3
4use crate::{NegativeStyle, OcioError, Result, TransformDirection};
5use ocio_sys;
6
7/// Raises RGBA channels to per-channel exponent values.
8pub struct ExponentTransform {
9    pub(crate) handle: NonNull<c_void>,
10}
11
12impl ExponentTransform {
13    /// Create a new identity exponent transform.
14    pub fn create() -> Result<Self> {
15        crate::clear_last_error();
16        let handle = unsafe { ocio_sys::ocio_exponent_transform_create() };
17        crate::handle_result(handle).map(|handle| Self { handle })
18    }
19
20    /// Return the per-channel exponent values.
21    pub fn value(&self) -> Result<[f64; 4]> {
22        let mut v = [1.0f64; 4];
23        crate::clear_last_error();
24        unsafe {
25            ocio_sys::ocio_exponent_transform_get_value(self.handle.as_ptr(), v.as_mut_ptr())
26        };
27        crate::ocio_call_status()?;
28        Ok(v)
29    }
30
31    /// Set the per-channel exponent values.
32    pub fn set_value(&self, vec4: &[f64; 4]) -> Result<()> {
33        crate::clear_last_error();
34        unsafe { ocio_sys::ocio_exponent_transform_set_value(self.handle.as_ptr(), vec4.as_ptr()) };
35        crate::ocio_call_status()
36    }
37
38    /// Return the negative value handling style.
39    pub fn negative_style(&self) -> NegativeStyle {
40        let s =
41            unsafe { ocio_sys::ocio_exponent_transform_get_negative_style(self.handle.as_ptr()) };
42        match s {
43            1 => NegativeStyle::Mirror,
44            2 => NegativeStyle::PassThru,
45            3 => NegativeStyle::Linear,
46            _ => NegativeStyle::Clamp,
47        }
48    }
49
50    /// Set the negative value handling style.
51    pub fn set_negative_style(&self, style: NegativeStyle) -> Result<()> {
52        crate::clear_last_error();
53        unsafe {
54            ocio_sys::ocio_exponent_transform_set_negative_style(
55                self.handle.as_ptr(),
56                style as i32,
57            );
58        }
59        crate::ocio_call_status()
60    }
61
62    /// Return the transform direction.
63    pub fn direction(&self) -> TransformDirection {
64        let dir = unsafe { ocio_sys::ocio_exponent_transform_get_direction(self.handle.as_ptr()) };
65        match dir {
66            1 => TransformDirection::Inverse,
67            _ => TransformDirection::Forward,
68        }
69    }
70
71    /// Set the transform direction.
72    pub fn set_direction(&self, direction: TransformDirection) {
73        self.try_set_direction(direction)
74            .expect("failed to set exponent transform direction");
75    }
76
77    /// Set the transform direction and surface any OCIO validation error.
78    pub fn try_set_direction(&self, direction: TransformDirection) -> crate::Result<()> {
79        crate::clear_last_error();
80        unsafe {
81            ocio_sys::ocio_exponent_transform_set_direction(self.handle.as_ptr(), direction as i32);
82        }
83        crate::ocio_call_status()
84    }
85
86    /// Create an independent copy of this transform.
87    pub fn create_editable_copy(&self) -> Result<Self> {
88        crate::clear_last_error();
89        let handle = unsafe { ocio_sys::ocio_transform_create_editable_copy(self.handle.as_ptr()) };
90        crate::handle_result(handle).map(|handle| Self { handle })
91    }
92
93    /// Return format metadata attached to the transform, when available.
94    pub fn format_metadata(&self) -> Option<crate::FormatMetadata> {
95        let handle = unsafe { ocio_sys::ocio_transform_get_format_metadata(self.handle.as_ptr()) };
96        NonNull::new(handle).map(|h| crate::FormatMetadata { handle: h })
97    }
98
99    #[deprecated(since = "0.2.0", note = "compat alias; prefer format_metadata()")]
100    pub fn format_metadata_v1(&self) -> Option<crate::FormatMetadata> {
101        self.format_metadata()
102    }
103
104    #[deprecated(since = "0.2.0", note = "compat alias; prefer format_metadata()")]
105    pub fn format_metadata_v2(&self) -> Option<crate::FormatMetadata> {
106        self.format_metadata()
107    }
108
109    /// Return whether this transform is equivalent to `other`.
110    pub fn equals(&self, other: &Self) -> bool {
111        unsafe {
112            ocio_sys::ocio_exponent_transform_equals(self.handle.as_ptr(), other.handle.as_ptr())
113        }
114    }
115}
116
117impl Drop for ExponentTransform {
118    fn drop(&mut self) {
119        unsafe { ocio_sys::ocio_exponent_transform_destroy(self.handle.as_ptr()) };
120    }
121}
122
123#[cfg(test)]
124mod tests {
125    use super::*;
126
127    #[test]
128    fn create_exponent() {
129        let et = ExponentTransform::create();
130        assert!(et.is_ok());
131    }
132
133    #[test]
134    fn value_no_crash() {
135        let et = ExponentTransform::create().unwrap();
136        let _ = et.value();
137        let _ = et.set_value(&[2.2, 2.2, 2.2, 1.0]);
138    }
139
140    #[test]
141    fn negative_style_no_crash() {
142        let et = ExponentTransform::create().unwrap();
143        let _ = et.negative_style();
144        let _ = et.set_negative_style(NegativeStyle::Mirror);
145    }
146
147    #[test]
148    fn create_editable_copy_no_crash() {
149        let et = ExponentTransform::create().unwrap();
150        let _ = et.create_editable_copy();
151    }
152
153    #[test]
154    fn format_metadata_no_crash() {
155        let et = ExponentTransform::create().unwrap();
156        let _ = et.format_metadata();
157    }
158
159    #[test]
160    fn equals_no_crash() {
161        let a = ExponentTransform::create().unwrap();
162        let b = ExponentTransform::create().unwrap();
163        let _ = a.equals(&b);
164    }
165}