dicomweb_util/decode.rs
1use super::DicomResponse;
2use dicom::core::chrono::FixedOffset;
3use dicom::core::dicom_value;
4use dicom::core::value::deserialize::{parse_date, parse_datetime, parse_time};
5use dicom::core::{DataElement, DicomValue, Length, Tag, VR};
6use dicom::object::mem::InMemDicomObject;
7use serde_json::Value;
8use std::i64;
9
10/// this function is adapted from a pull request https://github.com/Enet4/dicom-rs/pull/174
11/// thanks to https://github.com/charbeljc
12pub fn decode_response_item(item: &Value) -> DicomResponse {
13 let mut obj = InMemDicomObject::create_empty();
14 match item {
15 Value::Object(item) => {
16 item.into_iter().for_each(|(k, v)| {
17 let a = i64::from_str_radix(&k[..4], 16).unwrap() as u16;
18 let b = i64::from_str_radix(&k[4..], 16).unwrap() as u16;
19 let tag: Tag = (a, b).into();
20 if let Value::String(raw_vr) = &v["vr"] {
21 let vr = raw_vr.parse::<VR>().unwrap();
22 let value = &v["Value"];
23 match vr {
24 // VR::AE => {
25 // todo!()
26 // }
27 VR::AT => {
28 todo!()
29 }
30 VR::AS
31 | VR::AE
32 | VR::CS
33 | VR::LO
34 | VR::SH
35 | VR::UI
36 | VR::UR
37 | VR::OW
38 | VR::ST
39 | VR::UN
40 | VR::LT
41 | VR::OB => match value {
42 Value::Array(_) => {
43 let v: Vec<String> =
44 serde_json::from_value(value.to_owned()).unwrap();
45 let vv = &v[0];
46 let elt = DataElement::new(tag, vr, dicom_value!(Str, vv));
47 obj.put(elt);
48 }
49 Value::Null => {
50 let elt = DataElement::new(tag, vr, dicom_value!());
51 obj.put(elt);
52 }
53 other => {
54 eprintln!("{:?} unexpected value: {:?}", vr, other);
55 }
56 },
57 VR::DA => match value {
58 Value::Array(_) => {
59 let v: Vec<String> =
60 serde_json::from_value(value.to_owned()).unwrap();
61 let vv = &v[0];
62 let (date, _bytes) = parse_date(vv.as_bytes()).unwrap();
63 let elt = DataElement::new(tag, vr, dicom_value!(date));
64 obj.put(elt);
65 }
66 Value::Null => {
67 let elt = DataElement::new(tag, vr, dicom_value!());
68 obj.put(elt);
69 }
70 other => {
71 eprintln!("{:?} unexpected value: {:?}", vr, other);
72 }
73 },
74 VR::DS => match value {
75 Value::Array(_) => {
76 let v: Vec<f64> = serde_json::from_value(value.to_owned()).unwrap();
77 let vv = v[0];
78 let elt = DataElement::new(tag, vr, dicom_value!(F64, vv));
79 obj.put(elt);
80 }
81 other => {
82 eprintln!("{:?} unexpected value: {:?}", vr, other);
83 }
84 },
85 VR::DT => match value {
86 Value::Array(_) => {
87 let v: Vec<String> =
88 serde_json::from_value(value.to_owned()).unwrap();
89 let vv = &v[0];
90 let default_offset = FixedOffset::east(0);
91 eprintln!("VR:DT: {:?}", v);
92 let datetime =
93 parse_datetime(vv.as_bytes(), default_offset).unwrap();
94 let elt = DataElement::new(tag, vr, dicom_value!(datetime));
95 obj.put(elt);
96 }
97 Value::Null => {
98 let elt = DataElement::new(tag, vr, dicom_value!());
99 obj.put(elt);
100 }
101 other => {
102 eprintln!("{:?} unexpected value: {:?}", vr, other);
103 }
104 },
105 VR::FL => match value {
106 Value::Array(_) => {
107 let v: Vec<f32> = serde_json::from_value(value.to_owned()).unwrap();
108 let vv = v[0];
109 let elt = DataElement::new(tag, vr, dicom_value!(F32, vv));
110 obj.put(elt);
111 }
112 Value::Null => {
113 let elt = DataElement::new(tag, vr, dicom_value!());
114 obj.put(elt);
115 }
116 other => {
117 eprintln!("{:?} unexpected value: {:?}", vr, other);
118 } /* todo!(VR::DS) */
119 },
120 VR::FD => {
121 /* todo!("VR::FD") */
122 eprintln!("TODO: VR::FD");
123 }
124 VR::IS => match value {
125 Value::Array(_) => {
126 let v: Result<Vec<i16>, serde_json::Error> =
127 serde_json::from_value(value.to_owned());
128 if let Ok(v) = v {
129 let vv = &v[0];
130 let elt = DataElement::new(
131 tag,
132 vr,
133 dicom_value!(Str, vv.to_string()),
134 );
135 obj.put(elt);
136 } else {
137 // DCM4CHEE encodes IS as JSON strings
138 let v: Vec<String> =
139 serde_json::from_value(value.to_owned()).unwrap();
140 let vv = &v[0];
141 let elt = DataElement::new(tag, vr, dicom_value!(Str, vv));
142 obj.put(elt);
143 }
144 }
145 Value::Null => {
146 let elt = DataElement::new(tag, vr, dicom_value!());
147 obj.put(elt);
148 }
149 other => {
150 eprintln!("{:?} unexpected value: {:?}", vr, other);
151 }
152 },
153 VR::OD => {
154 todo!()
155 }
156 VR::OF => {
157 todo!()
158 }
159 VR::OL => {
160 todo!()
161 }
162 VR::OV => {
163 todo!()
164 }
165 VR::PN => match value {
166 Value::Array(array) => {
167 let v = &array[0];
168 let name = match v {
169 Value::Object(hm) => {
170 if let Some(name) =
171 hm.get("Alphabetic").and_then(|v| v.as_str())
172 {
173 name
174 } else {
175 ""
176 }
177 }
178 _other => "",
179 };
180 let elt = DataElement::new(tag, vr, dicom_value!(Str, name));
181 obj.put(elt);
182 }
183 Value::Null => {
184 let elt = DataElement::new(tag, vr, dicom_value!());
185 obj.put(elt);
186 }
187 other => {
188 eprintln!("VR:PN unexpected value: {:?}", other);
189 }
190 },
191 VR::SL => {
192 eprintln!("TODO: VR::SL");
193 }
194 VR::SQ => match value {
195 Value::Array(array) => {
196 // eprintln!("TODO: VR::SQ: {:?}", array);
197 let value = DicomValue::new_sequence(
198 array
199 .iter()
200 .map(|v| decode_response_item(v))
201 .collect::<Vec<_>>(),
202 Length::UNDEFINED,
203 );
204 // let value: Vec<_> = array.iter().map(|v| {
205 // decode_response_item(v)
206 // }).collect();
207 let elt = DataElement::new(tag, VR::SQ, value);
208 // eprintln!("Check: SEQ: {:#?}", elt);
209
210 // FIXME: don't work check dcmdump side
211 // note: expected struct `dicom::dicom_core::DataElement<_, std::vec::Vec<u8>>`
212 // found struct `dicom::dicom_core::DataElement<_, [u8; 0]>`
213 // obj.put(elt);
214 // let _ = dump_element(&mut std::io::stderr(), &elt, 120, 0, true);
215 }
216 Value::Null => {
217 let elt = DataElement::new(tag, VR::SQ, dicom_value!());
218 obj.put(elt);
219 }
220 other => {
221 eprintln!("VR::SEQ unexpected value: {:?}", other);
222 }
223 },
224 VR::SS => {
225 todo!()
226 }
227 VR::SV => {
228 todo!()
229 }
230 VR::TM => {
231 /* todo!() */
232 match value {
233 Value::Array(_) => {
234 let v: Vec<String> =
235 serde_json::from_value(value.to_owned()).unwrap();
236 let vv = &v[0];
237 let (time, _bytes) = parse_time(vv.as_bytes()).unwrap();
238 let elt = DataElement::new(tag, vr, dicom_value!(time));
239 obj.put(elt);
240 }
241 Value::Null => {
242 let elt = DataElement::new(tag, vr, dicom_value!());
243 obj.put(elt);
244 }
245 other => {
246 eprintln!("{:?} unexpected value: {:?}", vr, other);
247 }
248 }
249 }
250 VR::UC => {
251 todo!()
252 }
253 VR::UL => {
254 todo!()
255 }
256 VR::US => match value {
257 Value::Array(_) => {
258 let v: Vec<u16> = serde_json::from_value(value.to_owned()).unwrap();
259 let vv = v[0];
260 let elt = DataElement::new(tag, vr, dicom_value!(vv));
261 obj.put(elt);
262 }
263 Value::Null => {
264 let elt = DataElement::new(tag, vr, dicom_value!());
265 obj.put(elt);
266 }
267 other => {
268 eprintln!("{:?} unexpected value: {:?}", vr, other);
269 }
270 },
271 VR::UT => {
272 todo!()
273 }
274 VR::UV => {
275 todo!()
276 }
277 }
278 } else {
279 eprintln!("error, invalid VR: {:?}", v["vr"]);
280 }
281 })
282 }
283 other => {
284 println!("Unexpected: {:?}", other);
285 }
286 }
287 obj
288}