Skip to main content

ocio_rs/transform/
log_camera.rs

1use std::ffi::c_void;
2use std::ptr::NonNull;
3
4use crate::{Result, TransformDirection};
5use ocio_sys;
6
7/// Camera log OCIO transform with per-channel log-domain parameters.
8pub struct LogCameraTransform {
9    pub(crate) handle: NonNull<c_void>,
10}
11
12impl LogCameraTransform {
13    /// Create a log camera transform with the given linear-side break values.
14    pub fn create_with_lin_side_break(lin_side_break_values: &[f64; 3]) -> Result<Self> {
15        Self::create(lin_side_break_values)
16    }
17
18    /// Create a log camera transform with the given linear-side break values.
19    pub fn create(lin_side_break_values: &[f64; 3]) -> Result<Self> {
20        crate::clear_last_error();
21        let handle = unsafe {
22            ocio_sys::ocio_log_camera_transform_create_with_lin_side_break(
23                lin_side_break_values.as_ptr(),
24            )
25        };
26        crate::handle_result(handle).map(|handle| Self { handle })
27    }
28
29    /// Create an editable copy that is independent from the original transform.
30    pub fn create_editable_copy(&self) -> Result<Self> {
31        crate::clear_last_error();
32        let handle = unsafe { ocio_sys::ocio_transform_create_editable_copy(self.handle.as_ptr()) };
33        crate::handle_result(handle).map(|handle| Self { handle })
34    }
35
36    /// Return the log base value.
37    pub fn base(&self) -> Result<f64> {
38        crate::clear_last_error();
39        let value = unsafe { ocio_sys::ocio_log_camera_transform_get_base(self.handle.as_ptr()) };
40        crate::ocio_call_status()?;
41        Ok(value)
42    }
43
44    /// Set the log base value.
45    pub fn set_base(&self, base: f64) -> Result<()> {
46        crate::clear_last_error();
47        unsafe {
48            ocio_sys::ocio_log_camera_transform_set_base(self.handle.as_ptr(), base);
49        }
50        crate::ocio_call_status()
51    }
52
53    /// Return the per-channel log-side slope values.
54    pub fn log_side_slope_value(&self) -> Result<[f64; 3]> {
55        let mut v = [0.0f64; 3];
56        crate::clear_last_error();
57        unsafe {
58            ocio_sys::ocio_log_camera_transform_get_log_side_slope_value(
59                self.handle.as_ptr(),
60                v.as_mut_ptr(),
61            );
62        }
63        crate::ocio_call_status()?;
64        Ok(v)
65    }
66
67    /// Set the per-channel log-side slope values.
68    pub fn set_log_side_slope_value(&self, values: &[f64; 3]) -> Result<()> {
69        crate::clear_last_error();
70        unsafe {
71            ocio_sys::ocio_log_camera_transform_set_log_side_slope_value(
72                self.handle.as_ptr(),
73                values.as_ptr(),
74            );
75        }
76        crate::ocio_call_status()
77    }
78
79    /// Return the per-channel log-side offset values.
80    pub fn log_side_offset_value(&self) -> Result<[f64; 3]> {
81        let mut v = [0.0f64; 3];
82        crate::clear_last_error();
83        unsafe {
84            ocio_sys::ocio_log_camera_transform_get_log_side_offset_value(
85                self.handle.as_ptr(),
86                v.as_mut_ptr(),
87            );
88        }
89        crate::ocio_call_status()?;
90        Ok(v)
91    }
92
93    /// Set the per-channel log-side offset values.
94    pub fn set_log_side_offset_value(&self, values: &[f64; 3]) -> Result<()> {
95        crate::clear_last_error();
96        unsafe {
97            ocio_sys::ocio_log_camera_transform_set_log_side_offset_value(
98                self.handle.as_ptr(),
99                values.as_ptr(),
100            );
101        }
102        crate::ocio_call_status()
103    }
104
105    /// Return the per-channel linear-side slope values.
106    pub fn lin_side_slope_value(&self) -> Result<[f64; 3]> {
107        let mut v = [0.0f64; 3];
108        crate::clear_last_error();
109        unsafe {
110            ocio_sys::ocio_log_camera_transform_get_lin_side_slope_value(
111                self.handle.as_ptr(),
112                v.as_mut_ptr(),
113            );
114        }
115        crate::ocio_call_status()?;
116        Ok(v)
117    }
118
119    /// Set the per-channel linear-side slope values.
120    pub fn set_lin_side_slope_value(&self, values: &[f64; 3]) -> Result<()> {
121        crate::clear_last_error();
122        unsafe {
123            ocio_sys::ocio_log_camera_transform_set_lin_side_slope_value(
124                self.handle.as_ptr(),
125                values.as_ptr(),
126            );
127        }
128        crate::ocio_call_status()
129    }
130
131    /// Return the per-channel linear-side offset values.
132    pub fn lin_side_offset_value(&self) -> Result<[f64; 3]> {
133        let mut v = [0.0f64; 3];
134        crate::clear_last_error();
135        unsafe {
136            ocio_sys::ocio_log_camera_transform_get_lin_side_offset_value(
137                self.handle.as_ptr(),
138                v.as_mut_ptr(),
139            );
140        }
141        crate::ocio_call_status()?;
142        Ok(v)
143    }
144
145    /// Set the per-channel linear-side offset values.
146    pub fn set_lin_side_offset_value(&self, values: &[f64; 3]) -> Result<()> {
147        crate::clear_last_error();
148        unsafe {
149            ocio_sys::ocio_log_camera_transform_set_lin_side_offset_value(
150                self.handle.as_ptr(),
151                values.as_ptr(),
152            );
153        }
154        crate::ocio_call_status()
155    }
156
157    /// Return the per-channel linear-side break values.
158    pub fn lin_side_break_value(&self) -> Result<[f64; 3]> {
159        let mut v = [0.0f64; 3];
160        crate::clear_last_error();
161        unsafe {
162            ocio_sys::ocio_log_camera_transform_get_lin_side_break_value(
163                self.handle.as_ptr(),
164                v.as_mut_ptr(),
165            );
166        }
167        crate::ocio_call_status()?;
168        Ok(v)
169    }
170
171    /// Set the per-channel linear-side break values.
172    pub fn set_lin_side_break_value(&self, values: &[f64; 3]) -> Result<()> {
173        crate::clear_last_error();
174        unsafe {
175            ocio_sys::ocio_log_camera_transform_set_lin_side_break_value(
176                self.handle.as_ptr(),
177                values.as_ptr(),
178            );
179        }
180        crate::ocio_call_status()
181    }
182
183    /// Return the per-channel linear slope values, if set.
184    pub fn linear_slope_value(&self) -> Result<Option<[f64; 3]>> {
185        let mut v = [0.0f64; 3];
186        crate::clear_last_error();
187        let ok = unsafe {
188            ocio_sys::ocio_log_camera_transform_get_linear_slope_value(
189                self.handle.as_ptr(),
190                v.as_mut_ptr(),
191            )
192        };
193        crate::ocio_call_status()?;
194        if ok {
195            Ok(Some(v))
196        } else {
197            Ok(None)
198        }
199    }
200
201    /// Set the per-channel linear slope values.
202    pub fn set_linear_slope_value(&self, values: &[f64; 3]) -> Result<()> {
203        crate::clear_last_error();
204        unsafe {
205            ocio_sys::ocio_log_camera_transform_set_linear_slope_value(
206                self.handle.as_ptr(),
207                values.as_ptr(),
208            );
209        }
210        crate::ocio_call_status()
211    }
212
213    /// Clear the linear slope values, reverting to the default.
214    pub fn unset_linear_slope_value(&self) -> Result<()> {
215        crate::clear_last_error();
216        unsafe {
217            ocio_sys::ocio_log_camera_transform_unset_linear_slope_value(self.handle.as_ptr());
218        }
219        crate::ocio_call_status()
220    }
221
222    /// Return the evaluation direction.
223    pub fn direction(&self) -> TransformDirection {
224        let dir =
225            unsafe { ocio_sys::ocio_log_camera_transform_get_direction(self.handle.as_ptr()) };
226        match dir {
227            1 => TransformDirection::Inverse,
228            _ => TransformDirection::Forward,
229        }
230    }
231
232    /// Set the evaluation direction, panicking on validation error.
233    pub fn set_direction(&self, direction: TransformDirection) {
234        self.try_set_direction(direction)
235            .expect("failed to set log camera transform direction");
236    }
237
238    /// Set evaluation direction and surface any OCIO validation error.
239    pub fn try_set_direction(&self, direction: TransformDirection) -> Result<()> {
240        crate::clear_last_error();
241        unsafe {
242            ocio_sys::ocio_log_camera_transform_set_direction(
243                self.handle.as_ptr(),
244                direction as i32,
245            );
246        }
247        crate::ocio_call_status()
248    }
249
250    /// Return format metadata attached to the transform, when available.
251    pub fn format_metadata(&self) -> Option<crate::FormatMetadata> {
252        let handle = unsafe { ocio_sys::ocio_transform_get_format_metadata(self.handle.as_ptr()) };
253        NonNull::new(handle).map(|h| crate::FormatMetadata { handle: h })
254    }
255
256    #[deprecated(since = "0.2.0", note = "compat alias; prefer format_metadata()")]
257    pub fn format_metadata_v1(&self) -> Option<crate::FormatMetadata> {
258        self.format_metadata()
259    }
260
261    #[deprecated(since = "0.2.0", note = "compat alias; prefer format_metadata()")]
262    pub fn format_metadata_v2(&self) -> Option<crate::FormatMetadata> {
263        self.format_metadata()
264    }
265
266    /// Return whether `other` is equivalent to this transform.
267    pub fn equals(&self, other: &Self) -> bool {
268        unsafe {
269            ocio_sys::ocio_log_camera_transform_equals(self.handle.as_ptr(), other.handle.as_ptr())
270        }
271    }
272}
273
274impl Drop for LogCameraTransform {
275    fn drop(&mut self) {
276        unsafe { ocio_sys::ocio_log_camera_transform_destroy(self.handle.as_ptr()) };
277    }
278}
279
280#[cfg(test)]
281mod tests {
282    use super::*;
283
284    #[test]
285    fn create_log_camera_transform() {
286        let t = LogCameraTransform::create(&[0.01, 0.01, 0.01]);
287        assert!(t.is_ok());
288    }
289
290    #[test]
291    fn log_camera_transform_methods_no_crash() {
292        let t = LogCameraTransform::create(&[0.01, 0.01, 0.01]).unwrap();
293        let _ = t.base();
294        let _ = t.log_side_slope_value();
295        let _ = t.log_side_offset_value();
296        let _ = t.lin_side_slope_value();
297        let _ = t.lin_side_offset_value();
298        let _ = t.lin_side_break_value();
299        let _ = t.linear_slope_value();
300    }
301
302    #[test]
303    fn set_values_no_crash() {
304        let t = LogCameraTransform::create(&[0.01, 0.01, 0.01]).unwrap();
305        let _ = t.set_base(10.0);
306        let _ = t.set_log_side_slope_value(&[1.0, 1.0, 1.0]);
307        let _ = t.set_log_side_offset_value(&[0.0, 0.0, 0.0]);
308        let _ = t.set_lin_side_slope_value(&[1.0, 1.0, 1.0]);
309        let _ = t.set_lin_side_offset_value(&[0.0, 0.0, 0.0]);
310        let _ = t.set_lin_side_break_value(&[0.01, 0.01, 0.01]);
311        let _ = t.set_linear_slope_value(&[1.0, 1.0, 1.0]);
312        let _ = t.unset_linear_slope_value();
313    }
314
315    #[test]
316    fn create_editable_copy_no_crash() {
317        let t = LogCameraTransform::create(&[0.01, 0.01, 0.01]).unwrap();
318        let _ = t.create_editable_copy();
319    }
320
321    #[test]
322    fn equals_no_crash() {
323        let a = LogCameraTransform::create(&[0.01, 0.01, 0.01]).unwrap();
324        let b = LogCameraTransform::create(&[0.01, 0.01, 0.01]).unwrap();
325        let _ = a.equals(&b);
326    }
327
328    #[test]
329    fn direction_no_crash() {
330        let t = LogCameraTransform::create(&[0.01, 0.01, 0.01]).unwrap();
331        let _ = t.direction();
332        t.try_set_direction(TransformDirection::Inverse).unwrap();
333    }
334
335    #[test]
336    fn format_metadata_no_crash() {
337        let t = LogCameraTransform::create(&[0.01, 0.01, 0.01]).unwrap();
338        let _ = t.format_metadata();
339    }
340}