Skip to main content

qualia_core_db/medical/dicom_dataset/
query.rs

1use 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}