Add support for non-finite float handling in DICOM JSON

json/src/de/mod.rs

@@ -535,4 +535,41 @@ mod tests {
 
         assert!(super::from_value::<InMemDicomObject>(serialized).is_ok());
     }
+
+    #[test]
+    fn can_resolve_nan_and_inf_float() {
+        let serialized = serde_json::json!({
+            "00020011": {
+                "vr": "FL",
+                "Value": [
+                    5492.8545,
+                    5462.5205,
+                    "NaN",
+                    "-inf",
+                    "inf"
+                ]
+            }
+        });
+
+        let obj: InMemDicomObject = super::from_value(serialized).unwrap();
+        let tag = Tag(0x0002, 0x0011);
+        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,
+        ];
+
+        // need special comparison for NAN values since assert_eq will not match
+        assert_eq!(actual_values.len(), expected_values.len());
+        assert!(actual_values
+            .iter()
+            .zip(expected_values.iter())
+            .all(|(&a, &b)| (a == b) || (a.is_nan() && b.is_nan())));
+    }
 }

json/src/ser/value.rs

@@ -1,4 +1,6 @@
 //! DICOM value serialization
+use core::f32;
+
 use dicom_core::PrimitiveValue;
 use serde::ser::SerializeSeq;
 use serde::Serialize;
@@ -102,6 +104,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(&f32::NAN.to_string())?;
+                    } else if number.is_infinite() && number.is_sign_positive() {
+                        ser.serialize_element(&f32::INFINITY.to_string())?;
+                    } else if number.is_infinite() && number.is_sign_negative() {
+                        ser.serialize_element(&f32::NEG_INFINITY.to_string())?;
                     } else {
                         ser.serialize_element(&Option::<()>::None)?;
                     }
@@ -113,6 +121,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(&f64::NAN.to_string())?;
+                    } else if number.is_infinite() && number.is_sign_positive() {
+                        ser.serialize_element(&f64::INFINITY.to_string())?;
+                    } else if number.is_infinite() && number.is_sign_negative() {
+                        ser.serialize_element(&f64::NEG_INFINITY.to_string())?;
                     } else {
                         ser.serialize_element(&Option::<()>::None)?;
                     }
@@ -235,6 +249,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!([]));