Add support for non-finite float handling in DICOM JSON

json/src/de/mod.rs

@@ -422,6 +422,17 @@ mod tests {
     use super::from_str;
     use dicom_core::{dicom_value, DataElement, Tag, VR};
     use dicom_object::InMemDicomObject;
+    use num_traits::Float;
+
+    /// This asserts that two float slices are equal in size and content.
+    /// It needs a special comparison for NAN values since assert_eq will not match.
+    fn assert_float_slice_eq<T: Float>(actual: &[T], expected: &[T]) {
+        assert_eq!(actual.len(), expected.len());
+        assert!(actual
+            .iter()
+            .zip(actual.iter())
+            .all(|(&a, &b)| (a == b) || (a.is_nan() && b.is_nan())));
+    }
 
     #[test]
     fn can_parse_tags() {
@@ -535,4 +546,48 @@ mod tests {
 
         assert!(super::from_value::<InMemDicomObject>(serialized).is_ok());
     }
+
+    #[test]
+    fn can_resolve_nan_and_inf_float() {
+        let serialized = serde_json::json!({
+            "0018605A": {
+                "vr": "FL",
+                "Value": [
+                    5492.8545,
+                    5462.5205,
+                    "NaN",
+                    "-inf",
+                    "inf"
+                ]
+            }
+        });
+
+        let obj: InMemDicomObject = super::from_value(serialized).unwrap();
+        let tag = Tag(0x0018, 0x605A);
+        let element = obj.get(tag).unwrap();
+
+        // verify NAN, INFINITY, and NEG_INFINITY are correctly deserialized to f32::NAN, f32::INFINITY, and f32::NEG_INFINITY
+        let actual_values = element.float32_slice().unwrap();
+        let expected_values = &[
+            5492.8545,
+            5462.5205,
+            f32::NAN,
+            f32::NEG_INFINITY,
+            f32::INFINITY,
+        ];
+
+        assert_float_slice_eq(&actual_values, expected_values);
+
+        // validate upcasting to float 64, additional precision (5492.8544921875) is expected beyond original (5492.8545) due to upcasting
+        let actual_values_multifloat_64 = element.to_multi_float64().unwrap();
+        let expected_values_multifloat_64 = &[
+            5492.8544921875,
+            5462.5205078125,
+            f64::NAN,
+            f64::NEG_INFINITY,
+            f64::INFINITY,
+        ];
+
+        assert_float_slice_eq(&actual_values_multifloat_64, expected_values_multifloat_64);
+    }
 }

json/src/lib.rs

@@ -83,6 +83,13 @@ mod ser;
 pub use crate::de::{from_reader, from_slice, from_str, from_value};
 pub use crate::ser::{to_string, to_string_pretty, to_value, to_vec, to_writer};
 
+/// Represents the serialized representation of "NaN" (Not a Number) for 32-bit float (FL) and 64-bit float (FD) in DICOM JSON.
+pub const NAN: &str = "NaN";
+/// Represents the serialized representation of "inf" (positive infinity) for 32-bit float (FL) and 64-bit float (FD) in DICOM JSON.
+pub const INFINITY: &str = "inf";
+/// Represents the serialized representation of "-inf" (negative infinity) for 32-bit float (FL) and 64-bit float (FD) in DICOM JSON.
+pub const NEG_INFINITY: &str = "-inf";
+
 /// A wrapper type for DICOM JSON serialization using [Serde](serde).
 ///
 /// Serializing this type will yield JSON data according to the standard.

json/src/ser/value.rs

@@ -1,8 +1,11 @@
 //! DICOM value serialization
+
 use dicom_core::PrimitiveValue;
 use serde::ser::SerializeSeq;
 use serde::Serialize;
 
+use crate::{INFINITY, NAN, NEG_INFINITY};
+
 /// Wrapper type for [primitive values][1]
 /// which should always be encoded as strings.
 ///
@@ -102,6 +105,12 @@ impl Serialize for AsNumbers<'_> {
                 for number in numbers {
                     if number.is_finite() {
                         ser.serialize_element(&number)?;
+                    } else if number.is_nan() {
+                        ser.serialize_element(NAN)?;
+                    } else if number.is_infinite() && number.is_sign_positive() {
+                        ser.serialize_element(INFINITY)?;
+                    } else if number.is_infinite() && number.is_sign_negative() {
+                        ser.serialize_element(NEG_INFINITY)?;
                     } else {
                         ser.serialize_element(&Option::<()>::None)?;
                     }
@@ -113,6 +122,12 @@ impl Serialize for AsNumbers<'_> {
                 for number in numbers {
                     if number.is_finite() {
                         ser.serialize_element(&number)?;
+                    } else if number.is_nan() {
+                        ser.serialize_element(NAN)?;
+                    } else if number.is_infinite() && number.is_sign_positive() {
+                        ser.serialize_element(INFINITY)?;
+                    } else if number.is_infinite() && number.is_sign_negative() {
+                        ser.serialize_element(NEG_INFINITY)?;
                     } else {
                         ser.serialize_element(&Option::<()>::None)?;
                     }
@@ -235,6 +250,14 @@ mod tests {
         let json = serde_json::to_value(&AsNumbers(&v)).unwrap();
         assert_eq!(json, json!([23.5]),);
 
+        let v = PrimitiveValue::from([f64::NAN, f64::INFINITY, f64::NEG_INFINITY]);
+        let json = serde_json::to_value(&AsNumbers(&v)).unwrap();
+        assert_eq!(json, json!(["NaN", "inf", "-inf"]),);
+
+        let v = PrimitiveValue::from([f32::NAN, f32::INFINITY, f32::NEG_INFINITY]);
+        let json = serde_json::to_value(&AsNumbers(&v)).unwrap();
+        assert_eq!(json, json!(["NaN", "inf", "-inf"]),);
+
         let v = PrimitiveValue::Empty;
         let json = serde_json::to_value(&AsNumbers(&v)).unwrap();
         assert_eq!(json, json!([]));