qualia_core_db/medical/dicom_dataset/
query.rs1use super::{DatasetError, Element, ElementId, ElementKind, ItemId, Part10Dataset, TransferSyntax};
2#[derive(Clone, Copy, Debug)]
3pub struct WorkBudget {
4 remaining: usize,
5}
6impl WorkBudget {
7 pub fn new(steps: usize) -> Self {
8 Self { remaining: steps }
9 }
10 pub fn remaining(&self) -> usize {
11 self.remaining
12 }
13 pub fn charge(&mut self, n: usize) -> Result<(), DatasetError> {
14 self.remaining = self
15 .remaining
16 .checked_sub(n)
17 .ok_or(DatasetError::WorkLimit)?;
18 Ok(())
19 }
20}
21pub(crate) fn uid(value: &[u8], tag: u32) -> Result<&str, DatasetError> {
22 let value = value.strip_suffix(&[0]).unwrap_or(value);
23 let s = std::str::from_utf8(value).map_err(|_| DatasetError::Invalid(tag))?;
24 if s.is_empty()
25 || s.len() > 64
26 || !s.bytes().all(|b| b.is_ascii_digit() || b == b'.')
27 || s.split('.')
28 .any(|p| p.is_empty() || (p.len() > 1 && p.starts_with('0')))
29 {
30 return Err(DatasetError::Invalid(tag));
31 }
32 Ok(s)
33}
34impl<'a> Part10Dataset<'a> {
35 pub fn original_bytes(&self) -> &'a [u8] {
36 self.source
37 }
38 pub fn source_blake3(&self) -> [u8; 32] {
39 self.digest
40 }
41 pub fn transfer_syntax(&self) -> TransferSyntax {
42 self.syntax
43 }
44 pub fn transfer_syntax_uid(&self) -> &'a str {
45 self.transfer_uid
46 }
47 pub fn media_sop_class_uid(&self) -> Option<&'a str> {
48 self.media_class
49 }
50 pub fn media_sop_instance_uid(&self) -> Option<&'a str> {
51 self.media_instance
52 }
53 pub fn element_count(&self) -> usize {
54 self.elements.len()
55 }
56 pub fn item_count(&self) -> usize {
57 self.items.len()
58 }
59 pub fn element(&self, id: ElementId) -> Result<&Element, DatasetError> {
60 self.elements.get(id.0).ok_or(DatasetError::InvalidId)
61 }
62 pub fn value(&self, id: ElementId) -> Result<&'a [u8], DatasetError> {
63 let e = self.element(id)?;
64 self.source
65 .get(e.value.clone())
66 .ok_or(DatasetError::Boundary)
67 }
68 pub fn find(
69 &self,
70 scope: Option<ItemId>,
71 tag: u32,
72 work: &mut WorkBudget,
73 ) -> Result<Option<ElementId>, DatasetError> {
74 if scope.is_some_and(|i| i.0 >= self.items.len()) {
75 return Err(DatasetError::InvalidId);
76 }
77 work.charge(
78 self.elements
79 .len()
80 .checked_add(1)
81 .ok_or(DatasetError::Overflow)?,
82 )?;
83 Ok(self
84 .elements
85 .iter()
86 .position(|e| e.scope == scope && e.tag == tag)
87 .map(ElementId))
88 }
89 pub fn children<'b>(
90 &'b self,
91 scope: Option<ItemId>,
92 work: &mut WorkBudget,
93 ) -> Result<impl Iterator<Item = ElementId> + 'b, DatasetError> {
94 if scope.is_some_and(|i| i.0 >= self.items.len()) {
95 return Err(DatasetError::InvalidId);
96 }
97 work.charge(self.elements.len())?;
98 Ok(self
99 .elements
100 .iter()
101 .enumerate()
102 .filter(move |(_, e)| e.scope == scope)
103 .map(|(i, _)| ElementId(i)))
104 }
105 pub fn sequence_items<'b>(
106 &'b self,
107 id: ElementId,
108 work: &mut WorkBudget,
109 ) -> Result<impl Iterator<Item = ItemId> + 'b, DatasetError> {
110 if self.element(id)?.kind == ElementKind::Value {
111 return Err(DatasetError::NotSequence);
112 }
113 work.charge(self.items.len())?;
114 Ok(self
115 .items
116 .iter()
117 .enumerate()
118 .filter(move |(_, item)| item.sequence == id)
119 .map(|(i, _)| ItemId(i)))
120 }
121 pub fn item_bytes(&self, id: ItemId) -> Result<&'a [u8], DatasetError> {
122 let i = self.items.get(id.0).ok_or(DatasetError::InvalidId)?;
123 self.source
124 .get(i.value.clone())
125 .ok_or(DatasetError::Boundary)
126 }
127 pub fn expected_value(
128 &self,
129 scope: Option<ItemId>,
130 tag: u32,
131 vr: [u8; 2],
132 work: &mut WorkBudget,
133 ) -> Result<Option<&'a [u8]>, DatasetError> {
134 let Some(id) = self.find(scope, tag, work)? else {
135 return Ok(None);
136 };
137 let e = self.element(id)?;
138 if e.kind != ElementKind::Value || e.vr.is_some_and(|v| v != vr) {
139 return Err(DatasetError::Invalid(tag));
140 }
141 Ok(Some(self.value(id)?))
142 }
143 pub fn uid(
144 &self,
145 scope: Option<ItemId>,
146 tag: u32,
147 work: &mut WorkBudget,
148 ) -> Result<Option<&'a str>, DatasetError> {
149 self.expected_value(scope, tag, *b"UI", work)?
150 .map(|v| uid(v, tag))
151 .transpose()
152 }
153 pub fn text(
154 &self,
155 scope: Option<ItemId>,
156 tag: u32,
157 vr: [u8; 2],
158 work: &mut WorkBudget,
159 ) -> Result<Option<&'a str>, DatasetError> {
160 self.expected_value(scope, tag, vr, work)?
161 .map(|v| {
162 let s = std::str::from_utf8(v)
163 .map_err(|_| DatasetError::Invalid(tag))?
164 .trim_matches(' ');
165 if s.is_empty() || s.bytes().any(|b| b < 32 || b == 127) {
166 Err(DatasetError::Invalid(tag))
167 } else {
168 Ok(s)
169 }
170 })
171 .transpose()
172 }
173 pub fn unsigned_short(
174 &self,
175 tag: u32,
176 work: &mut WorkBudget,
177 ) -> Result<Option<u16>, DatasetError> {
178 self.expected_value(None, tag, *b"US", work)?
179 .map(|v| {
180 if v.len() != 2 {
181 return Err(DatasetError::Invalid(tag));
182 }
183 Ok(u16::from_le_bytes([v[0], v[1]]))
184 })
185 .transpose()
186 }
187 pub fn frame_count(&self, work: &mut WorkBudget) -> Result<u32, DatasetError> {
188 match self.text(None, 0x00280008, *b"IS", work)? {
189 None => Ok(1),
190 Some(text) => {
191 if text.len() > 12 || !text.bytes().all(|b| b.is_ascii_digit()) {
192 return Err(DatasetError::Invalid(0x00280008));
193 }
194 let n = text
195 .parse::<u32>()
196 .map_err(|_| DatasetError::Invalid(0x00280008))?;
197 if n == 0 {
198 return Err(DatasetError::Invalid(0x00280008));
199 }
200 Ok(n)
201 }
202 }
203 }
204}