ocio 0.1.1

A pure Rust port of OpenColorIO, the color management framework for visual effects and animation.
Documentation 
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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

//! Displays and views (port of `Display.cpp`).

use super::utils::{compare, intersect_case_ignore};
use crate::types::OCIO_VIEW_USE_DISPLAY_NAME;

/// A view of a display (or a shared view).
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct View {
    /// The view name.
    pub name: String,
    /// Might be empty.
    pub view_transform: String,
    /// The color space, or the display color space when a view transform is used.
    pub colorspace: String,
    /// Might be empty.
    pub looks: String,
    /// Might be empty.
    pub rule: String,
    /// Might be empty.
    pub description: String,
}

impl View {
    /// Build a view.
    pub fn new(
        name: &str,
        view_transform: &str,
        colorspace: &str,
        looks: &str,
        rule: &str,
        description: &str,
    ) -> Self {
        Self {
            name: name.to_string(),
            view_transform: view_transform.to_string(),
            colorspace: colorspace.to_string(),
            looks: looks.to_string(),
            rule: rule.to_string(),
            description: description.to_string(),
        }
    }

    /// True if `csname` is `<USE_DISPLAY_NAME>` (case insensitive).
    pub fn use_display_name(csname: &str) -> bool {
        compare(csname, OCIO_VIEW_USE_DISPLAY_NAME)
    }

    /// True if the color space is `<USE_DISPLAY_NAME>`.
    pub fn use_display_name_for_colorspace(&self) -> bool {
        Self::use_display_name(&self.colorspace)
    }
}

/// Find a view by name (case insensitive).
pub fn find_view(views: &[View], name: &str) -> Option<usize> {
    views.iter().position(|v| compare(&v.name, name))
}

/// Add a view or update the existing view with the same name.
pub fn add_view(
    views: &mut Vec<View>,
    name: &str,
    view_transform: &str,
    display_color_space: &str,
    looks: &str,
    rule: &str,
    description: &str,
) {
    let cs = if View::use_display_name(display_color_space) {
        OCIO_VIEW_USE_DISPLAY_NAME
    } else {
        display_color_space
    };
    match find_view(views, name) {
        None => views.push(View::new(
            name,
            view_transform,
            cs,
            looks,
            rule,
            description,
        )),
        Some(i) => {
            let v = &mut views[i];
            v.view_transform = view_transform.to_string();
            v.colorspace = cs.to_string();
            v.looks = looks.to_string();
            v.rule = rule.to_string();
            v.description = description.to_string();
        }
    }
}

/// A display: its own views and references to shared views.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct Display {
    /// Displays instantiated from the virtual display are not saved.
    pub temporary: bool,
    /// Views defined by the display.
    pub views: Vec<View>,
    /// Names of the config shared views used by the display.
    pub shared_views: Vec<String>,
}

/// Ordered list of (display name, display).
pub type DisplayMap = Vec<(String, Display)>;

/// Find a display by name (case insensitive).
pub fn find_display(displays: &DisplayMap, name: &str) -> Option<usize> {
    displays.iter().position(|(n, _)| compare(n, name))
}

/// Compute the list of active displays (`ComputeDisplays`).
pub fn compute_displays(
    displays: &DisplayMap,
    active: &[String],
    active_env_override: &[String],
) -> Vec<String> {
    let master: Vec<String> = displays.iter().map(|(n, _)| n.clone()).collect();
    if !active_env_override.is_empty() {
        let r = intersect_case_ignore(active_env_override, &master);
        if !r.is_empty() {
            return r;
        }
    } else if !active.is_empty() {
        let r = intersect_case_ignore(active, &master);
        if !r.is_empty() {
            return r;
        }
    }
    master
}