dicomweb-util 0.1.0

A pure Rust implementation of the DICOMweb standard
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

use std::collections::{BTreeMap, HashMap};

use dicom::core::VR::*;
use dicom::object::InMemDicomObject;
use serde_json::{json, Value};

pub type DICOMJsonObject = BTreeMap<String, HashMap<String, Value>>;

// http://dicom.nema.org/medical/dicom/current/output/chtml/part18/sect_F.2.3.html#table_F.2.3-1
pub fn encode_dicom_to_json(dicom: InMemDicomObject) -> DICOMJsonObject {
    dicom
        .into_iter()
        .map(|elt| {
            let mut eltmap = HashMap::new();
            eltmap.insert("vr".to_string(), json!(elt.header().vr().to_string()));
            eltmap.insert("Value".to_string(), {
                match elt.header().vr() {
                    AE | AS | AT | CS | DA | DS | DT | IS | LO | LT | SH | ST | SV | TM | UC
                    | UI | UR | UT | UV => match elt.value().multiplicity() {
                        0 => json!([]),
                        1 => json!([elt.value().to_clean_str().unwrap()]),
                        _ => json!(elt.value().to_multi_str().unwrap()),
                    },
                    FL => {
                        json!([elt.value().to_float32().unwrap()])
                    }
                    FD => {
                        json!([elt.value().to_float64().unwrap()])
                    }
                    OB | OD | OF | OL | OV | OW | UN => {
                        let bytes = elt.value().to_bytes().unwrap();
                        json!(base64::encode(bytes))
                    }
                    PN => {
                        json!([{ "Alphabetic": elt.value().to_clean_str().unwrap() }])
                    }
                    SL => {
                        json!([elt.value().to_int::<i64>().unwrap()])
                    }
                    SQ => match elt.value() {
                        dicom::core::DicomValue::Sequence { items, size } => {
                            let v: Vec<DICOMJsonObject> = items
                                .into_iter()
                                .map(|i| encode_dicom_to_json(i.clone()))
                                .collect();
                            json!(v)
                        }
                        _ => panic!(),
                    },
                    SS => {
                        json!([elt.value().to_int::<i32>().unwrap()])
                    }
                    UL => {
                        json!([elt.value().to_int::<u64>().unwrap()])
                    }
                    US => {
                        json!([elt.value().to_int::<u32>().unwrap()])
                    }
                }
            });
            (
                format!(
                    "{:04X}{:04X}",
                    elt.header().tag.group(),
                    elt.header().tag.element()
                ),
                eltmap,
            )
        })
        .collect()
}