Debian Codegraph @

.cargo/vendor/exr/src/image/channel_groups.rs

raw
1
2 use std::collections::HashMap;
3 use crate::image::write::channels::{WritableChannels, ChannelsWriter};
4 use crate::meta::attribute::{LevelMode, ChannelList, Text, TextSlice, ChannelInfo};
5 use crate::meta::header::Header;
6 use crate::image::read::layers::{ReadChannels, ChannelsReader};
7 use crate::block::{BlockIndex, UncompressedBlock};
8 use crate::block::lines::{collect_uncompressed_block_from_lines, LineIndex};
9 use std::io::{Cursor, Read};
10 use crate::error::{Result, UnitResult};
11 use crate::block::chunk::TileCoordinates;
12 use crate::prelude::SmallVec;
13
14
15
16
17
18 pub struct ChannelGroups<ChannelGroup> {
19 channel_group: Option<ChannelGroup>,
20 children: HashMap<Text, Self>
21 }
22
23
24 impl<ChannelGroup> ChannelGroups<ChannelGroup> {
25
26
27 // pub fn visit_groups_mut(&mut self, visitor: impl Fn(&mut Channels)) {
28 // }
29
30
31
32 pub fn groups(&self) -> SmallVec<[&ChannelGroup; 12]> {
33 let children = self.children.iter().flat_map(|group| group.groups());
34 self.channel_group.iter().chain(children).collect()
35 }
36
37 pub fn lookup_group(&self, group_name: &TextSlice) -> Option<&ChannelGroup> {
38 let dot_index = group_name.iter().position('.');
39 if let Some(dot_index) = dot_index {
40 let group_name = &group_name[.. dot_index];
41 let child_name = &group_name[dot_index + 1 ..];
42 self.children.get(group_name)
43 .and_then(|child| child.lookup(child_name))
44 }
45 else {
46 self.channel_group.lookup(name)
47 }
48 }
49
50
51 /*pub fn insert_group(&mut self, full_name: &TextSlice, value: ChannelGroup) {
52 let dot_index = full_name.iter().position('.');
53 if let Some(dot_index) = dot_index {
54 let group_name = &group_name[.. dot_index];
55 let name_rest = &group_name[dot_index + 1 ..];
56
57 self.children.entry(Text::from_slice_unchecked(group_name))
58 .or_insert(|| );
59
60 // self.children.insert(Text::from_slice_unchecked(group_name), value)
61 // .and_then(|child| child.lookup(name_rest));
62 }
63 else {
64 self.channel_group.lookup(name);
65 }
66 }*/
67
68 pub fn map<T>(self, mapper: impl FnMut(ChannelGroup) -> T) -> ChannelGroups<T> {
69 ChannelGroups {
70 children: self.channel_group.iter().map(&mapper).collect(),
71 channel_group: self.channel_group.map(mapper),
72 }
73 }
74 }
75
76
77 pub fn parse_channel_list_groups<T>(channels: impl Iterator<Item=(Text, T)>)
78 -> ChannelGroups<SmallVec<(Text, T)>>
79 {
80 fn insert_into_groups(groups: &mut ChannelGroups<SmallVec<(Text, T)>>, name: Text, value: T) {
81 let dot_index = name.as_slice().iter().position('.');
82
83 if let Some(dot_index) = dot_index {
84 // insert into child group
85
86 let group_name = Text::from_slice_unchecked(&name.as_slice()[.. dot_index]);
87 let child_channel = Text::from_slice_unchecked(&name.as_slice()[dot_index + 1 ..]);
88
89 let child_group = groups.children.entry(group_name)
90 .or_insert(ChannelGroups { channel_group: None, children: Default::default() });
91
92 insert_into_groups(child_group, child_channel, value);
93 }
94
95 else {
96 // insert directly into group
97
98 if groups.channel_group.is_none() {
99 groups.channel_group = Some(SmallVec::new());
100 }
101
102 groups.channel_group.unwrap().push(value);
103 }
104 }
105
106 let mut result = ChannelGroups { channel_group: None, children: HashMap::default() };
107 for (name, value) in channels { insert_into_groups(&mut result, name, value); }
108 result
109 }
110
111
112 impl<'slf, ChannelGroup> WritableChannels<'slf> for ChannelGroups<ChannelGroup>
113 where ChannelGroup: WritableChannels<'slf>
114 {
115 fn infer_channel_list(&self) -> ChannelList {
116 // TODO what about empty groups with NO channels??
117
118 let child_channels = self.children.iter().flat_map(|(group_name, child)| {
119 let mut child_channels = child.infer_channel_list().list;
120 for channel in &mut child_channels { channel.name.push_front(group_name) };
121 child_channels
122 });
123
124 let mut own_channels = self.channel_group
125 .map(|chans| chans.infer_channel_list().list)
126 .unwrap_or_default();
127
128 own_channels.extend(child_channels);
129 own_channels.sort_unstable(); // TODO only once at end
130 ChannelList::new(own_channels) // might be empty, but will be checked in MetaData::validate()
131 }
132
133 fn level_mode(&self) -> LevelMode {
134 fn find_mode_or_none(channels: &Self) -> Option<LevelMode> {
135 channels.channel_group.map(WritableChannels::level_mode).or_else(|| {
136 channels.children.iter().map(find_mode_or_none).next()
137 })
138 }
139
140 let mode = find_mode_or_none(self)
141 .expect("empty channel groups (check failed)"); // TODO only happens for empty channels, right? panic maybe?
142
143 if let Some(chans) = self.channel_group.as_ref() {
144 debug_assert_eq!(chans.level_mode(), mode, "level mode must be equal for all legacy channel groups")
145 }
146
147 debug_assert!(
148 self.children.values()
149 .flat_map(find_mode_or_none)
150 .all(|child_mode| child_mode == mode),
151
152 "level mode must be equal for all legacy channel groups"
153 );
154
155 mode
156 }
157
158 type Writer = GroupChannelsWriter<'slf, ChannelGroup>;
159
160 fn create_writer(&'slf self, header: &Header) -> Self::Writer {
161 let channels = header.channels.list.iter()
162 .map(|channel_info|{
163 // hashmap order is not guaranteed? so look up each channel group manually instead of generating new
164 let channels = self.lookup_group(channel_info.name.as_slice())
165 .expect("channels not found bug");
166
167 channels.create_writer(header) // channel_info.name.clone()
168 })
169 .collect();
170
171 GroupChannelsWriter { channels_list: channels }
172 }
173 }
174
175 struct GroupChannelsWriter<'c, ChannelGroupWriter> {
176 channels_list: Vec<&'c ChannelGroupWriter>,
177 }
178
179 impl<'c, Channels> ChannelsWriter for GroupChannelsWriter<'c, Channels> where Channels: ChannelsWriter {
180 fn extract_uncompressed_block(&self, header: &Header, block: BlockIndex) -> Vec<u8> {
181 let mut blocks_per_channel: Vec<Cursor<Vec<u8>>> = self
182 .channels_list.iter()
183 .map(|channels| Cursor::new(channels.extract_uncompressed_block(header, block)))
184 .collect();
185
186 UncompressedBlock::uncompressed_block_from_lines(header, block, |line|{
187 let channel_reader = &mut blocks_per_channel[line.location.channel]; // TODO subsampling
188
189 // read from specific channel into total byte block
190 // this assumes that the lines in the callback are iterated in strictly increasing order
191 // because each channel reader is consumed
192 channel_reader.read_exact(line.value)
193 .expect("collecting grouped channel byte block failed");
194 })
195 }
196 }
197
198
199 struct ReadChannelGroups<ReadChannelGroup> {
200 read_channels: ReadChannelGroup
201 }
202
203 struct ChannelGroupsReader<ChannelGroupReader> {
204 channels: ChannelGroups<usize>,
205 indexed_channels: Vec<ChannelGroupReader>,
206 }
207
208 impl<'s, ReadChannelGroup> ReadChannels<'s> for ReadChannelGroups<ReadChannelGroup>
209 where ReadChannelGroup: ReadChannels<'s>
210 {
211 type Reader = ChannelGroupsReader<ReadChannelGroup::Reader>;
212
213 fn create_channels_reader(&'s self, header: &Header) -> Result<Self::Reader> {
214 let swap = |(a,b)| (b,a);
215 let channel_groups = parse_channel_list_groups(
216 header.channels.list.iter().enumerate().map(swap)
217 );
218
219 let mut indexed_channels = Vec::new();
220 let channel_groups = channel_groups.map(|channels| {
221
222 let mut channels_header = header.clone(); // TODO no clone?
223 channels_header.channels = ChannelList::new(channels.iter().map(|(name, index)|{
224 let mut channel_info = header.channels.list[index].clone();
225 channel_info.name = name;
226 channel_info
227 }).collect()); // FIXME does not comply to `header.chunk_count` and that stuff?? change ReadChannels fn signature?
228
229 indexed_channels.push(self.read_channels.create_channels_reader(&channels_header));
230
231 // FIXME this is not the original order indexed_channels.len() - 1
232 indexed_channels[]
233 });
234
235 Ok(ChannelGroupsReader {
236 channels: channel_groups,
237 indexed_channels,
238 })
239
240 /*Ok(ChannelGroupsReader {
241 channels: header.channels.list.iter().map(|channel| {
242 let mut channels_header = header.clone();
243
244 let reader = self.read_channels.create_channels_reader(&channels_header);
245 (channels_header, reader)
246 }).collect(),
247 })*/
248 }
249 }
250
251 impl<ChannelGroupReader> ChannelsReader for ChannelGroupsReader<ChannelGroupReader> where ChannelGroupReader: ChannelsReader {
252 type Channels = ChannelGroups<ChannelGroupReader::Channels>;
253
254 fn filter_block(&self, tile: (usize, &TileCoordinates)) -> bool {
255 self.indexed_channels.iter().any(|channel| channel.filter_block(tile))
256 }
257
258 fn read_block(&mut self, header: &Header, block: UncompressedBlock) -> UnitResult {
259 block.for_lines(|line|{
260
261 })
262 }
263
264 fn into_channels(self) -> Self::Channels {
265
266 }
267 }