Struct dicom_json::DicomJson

pub struct DicomJson<T>(/* private fields */);

A wrapper type for DICOM JSON serialization using Serde.

Serializing this type will yield JSON data according to the standard. Deserialization from this type will interpret the input data as standard DICOM JSON deserialization.

Serialization

Convert a DICOM data type such as a file, object, or data element into a DicomJson value using From or Into, then use a JSON serializer such as the one in serde_json to serialize it to the intended type. A reference may be used as well, so as to not consume the DICOM data.

DicomJson can serialize:

• InMemDicomObject as a standard DICOM JSON data set;
• InMemElement by writing the VR and value in a single object (note that the tag will not be serialized);
• &[InMemDicomObject] and Vec<InMemDicomObject>, resulting in a JSON array of DICOM JSON data sets;
• DefaultDicomObject, which will also include the attributes from the file meta group. Note however, that this is not conforming to the standard. Obtain the inner data set through Deref (&*obj) if you do not wish to include file meta group data.
• Tag: values are written as a single string in the expected DICOM JSON format "GGGGEEEE" where GGGG and EEEE are the group/element parts in uppercase hexadecimal.

Example

use dicom_json::DicomJson;

// creating a DICOM object with a single attribute
let obj = InMemDicomObject::from_element_iter([
    DataElement::new(
        Tag(0x0010, 0x0020),
        VR::LO,
        PrimitiveValue::from("ID0001"),
    )
]);
// wrap it with DicomJson
let json_obj = DicomJson::from(&obj);
// serialize it to a JSON Value
let serialized = serde_json::to_value(&json_obj)?;
assert_eq!(
  serialized,
  serde_json::json!({
      "00100020": {
          "vr": "LO",
          "Value": [ "ID0001" ]
      }
  })
);

Deserialization

Specify the concrete DICOM data type to deserialize to, place it as the type parameter T of DicomJson<T>, then request to deserialize it.

DicomJson can deserialize:

• InMemDicomObject, expecting a JSON object indexed by tags;
• Tag, a string formatted as a DICOM tag;
• VR, a 2-character string with one of the supported value representation identifiers.

Example

use dicom_json::DicomJson;

// given this JSON data
let json_data = r#"{
    "00100020": {
        "vr": "LO",
        "Value": [ "ID0001" ]
    }
}"#;
// deserialize to DicomJson, then unwrap it
let deserialized: DicomJson<InMemDicomObject> = serde_json::from_str(json_data)?;
let obj = deserialized.into_inner();
assert_eq!(
  obj,
  InMemDicomObject::from_element_iter([
      DataElement::new(Tag(0x0010, 0x0020), VR::LO, "ID0001"),
  ]),
);

Implementations

impl<T> DicomJson<T>

pub fn into_inner(self) -> T

Unwrap the DICOM JSON wrapper, returning the underlying value.

pub fn inner(&self) -> &T

Obtain a reference to the underlying value.

Trait Implementations

impl<T: Clone> Clone for DicomJson<T>

fn clone(&self) -> DicomJson<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for DicomJson<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de, I> Deserialize<'de> for DicomJson<InMemDicomObject<I>>

where I: Default + Clone + DataDictionary,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'de> Deserialize<'de> for DicomJson<Tag>

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a, D> From<&'a [InMemDicomObject<D>]> for DicomJson<&'a [InMemDicomObject<D>]>

fn from(value: &'a [InMemDicomObject<D>]) -> Self

Converts to this type from the input type.

impl<'a, D> From<&'a DataElement<InMemDicomObject<D>>> for DicomJson<&'a InMemElement<D>>

fn from(value: &'a InMemElement<D>) -> Self

Converts to this type from the input type.

impl<'a, D> From<&'a FileDicomObject<InMemDicomObject<D>>> for DicomJson<&'a DefaultDicomObject<D>>

fn from(value: &'a DefaultDicomObject<D>) -> Self

Converts to this type from the input type.

impl<'a, D> From<&'a InMemDicomObject<D>> for DicomJson<&'a InMemDicomObject<D>>

fn from(value: &'a InMemDicomObject<D>) -> Self

Converts to this type from the input type.

impl<D> From<DataElement<InMemDicomObject<D>>> for DicomJson<InMemElement<D>>

fn from(value: InMemElement<D>) -> Self

Converts to this type from the input type.

impl<D> From<FileDicomObject<InMemDicomObject<D>>> for DicomJson<DefaultDicomObject<D>>

fn from(value: DefaultDicomObject<D>) -> Self

Converts to this type from the input type.

impl<D> From<InMemDicomObject<D>> for DicomJson<InMemDicomObject<D>>

fn from(value: InMemDicomObject<D>) -> Self

Converts to this type from the input type.

impl From<Tag> for DicomJson<Tag>

fn from(value: Tag) -> Self

Converts to this type from the input type.

impl<D> From<Vec<InMemDicomObject<D>>> for DicomJson<Vec<InMemDicomObject<D>>>

fn from(value: Vec<InMemDicomObject<D>>) -> Self

Converts to this type from the input type.

impl<T: PartialEq> PartialEq for DicomJson<T>

fn eq(&self, other: &DicomJson<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, D> Serialize for DicomJson<&'a [InMemDicomObject<D>]>

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serializes the sequence of DICOM objects into a JSON array.

impl<D> Serialize for DicomJson<&InMemElement<D>>

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serializes the data element as a single JSON map.

The fields present will be:

• "vr", containing the value representation;
• Either "Value" (as an array of values) or "InlineBinary" (binary data in base64), if the value is not empty.

The DICOM tag is not encoded, as it is typically serialized as the entry key within a data set.

impl<'a, D> Serialize for DicomJson<&'a DefaultDicomObject<D>>

where D: 'a,

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serializes the DICOM file as a JSON map containing one entry per data element (indexed by tag), plus the data elements described by its file meta table.

To exclude the file meta group data instead, dereference the value into the underlying DICOM object first (e.g. via &*obj).

impl<'a, D> Serialize for DicomJson<&'a InMemDicomObject<D>>

where D: 'a,

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serializes the DICOM object as a JSON map containing one entry per data element, indexed by tag.

impl<D> Serialize for DicomJson<InMemElement<D>>

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<D> Serialize for DicomJson<DefaultDicomObject<D>>

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serializes the DICOM file as a JSON map containing one entry per data element (indexed by tag), plus the data elements described by its file meta table.

To exclude the file meta group data instead, dereference the value into the underlying DICOM object first (e.g. via &*obj).

impl<D> Serialize for DicomJson<InMemDicomObject<D>>

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Serialize for DicomJson<Tag>

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serializes the DICOM tag as a single string in uppercase hexadecimal, with no separators or delimiters ("GGGGEEEE").

impl<D> Serialize for DicomJson<Vec<InMemDicomObject<D>>>

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serializes the sequence of DICOM objects into a JSON array.

impl<T> StructuralPartialEq for DicomJson<T>