[WIP] PS3.5 H3.2 compliant

Author: 9enki

Cargo.lock

@@ -18,3 +18,4 @@ dicom-dictionary-std = { path = "../dictionary-std/", version = "0.6.1" }
 smallvec = "1.6.1"
 snafu = "0.7.3"
 tracing = "0.1.34"
+encoding_rs = "0.8.33"

parser/Cargo.toml

@@ -439,6 +439,68 @@ where
         Ok(PrimitiveValue::Strs(parts?))
     }
 
+    fn read_value_pn(
+        &mut self,
+        header: &DataElementHeader,
+        specific_char_set: &SpecificCharacterSet,
+    ) -> Result<PrimitiveValue> {
+        match self.read_value_pns(header, specific_char_set) {
+            Ok(PrimitiveValue::Strs(parts)) => Ok(PrimitiveValue::Str(parts.join("="))),
+            Ok(_) => {
+                panic!("wron impl: read_value_pns should always return Strs")
+            }
+            Err(e) => Err(e),
+        }
+    }
+
+    fn read_value_pns(
+        &mut self,
+        header: &DataElementHeader,
+        specific_char_set: &SpecificCharacterSet,
+    ) -> Result<PrimitiveValue> {
+        let len = self.require_known_length(header)?;
+        self.buffer.resize_with(len, Default::default);
+        self.from
+            .read_exact(&mut self.buffer)
+            .context(ReadValueDataSnafu {
+                position: self.position,
+            })?;
+
+        let equal_positions: Vec<_> = self
+            .buffer
+            .iter()
+            .enumerate()
+            .filter(|&(_, &b)| b == b'=')
+            .map(|(i, _)| i)
+            .collect();
+
+        if equal_positions.len() == 0 {
+            return self.read_value_str(header);
+        }
+
+        let mut binary_data = Vec::new();
+        let mut equal_position = 0;
+        for &index in &equal_positions {
+            binary_data.push(&self.buffer[equal_position..index]);
+            equal_position = index + 1;
+        }
+        binary_data.push(&self.buffer[equal_position..]);
+
+        let mut decoded_parts = Vec::new();
+        for (i, part) in binary_data.iter().enumerate() {
+            let charset = match i {
+                0 => specific_char_set,
+                _ => &SpecificCharacterSet::IsoIr87,
+            };
+            let decoded = charset.decode(part).context(DecodeTextSnafu {
+                position: self.position,
+            })?;
+            decoded_parts.push(decoded);
+        }
+
+        Ok(PrimitiveValue::Strs(decoded_parts.into()))
+    }
+
     fn read_value_str(&mut self, header: &DataElementHeader) -> Result<PrimitiveValue> {
         let len = self.require_known_length(header)?;
 
@@ -920,9 +982,8 @@ where
                 .fail()
             }
             VR::AT => self.read_value_tag(header),
-            VR::AE | VR::AS | VR::PN | VR::SH | VR::LO | VR::UC | VR::UI => {
-                self.read_value_strs(header)
-            }
+            VR::AE | VR::AS | VR::SH | VR::LO | VR::UC | VR::UI => self.read_value_strs(header),
+            VR::PN => self.read_value_pns(header, &self.text.clone()),
             VR::CS => self.read_value_cs(header),
             VR::UT | VR::ST | VR::UR | VR::LT => self.read_value_str(header),
             VR::UN | VR::OB => self.read_value_ob(header),
@@ -958,7 +1019,6 @@ where
             VR::AT => self.read_value_tag(header),
             VR::AE
             | VR::AS
-            | VR::PN
             | VR::SH
             | VR::LO
             | VR::UC
@@ -968,6 +1028,7 @@ where
             | VR::DA
             | VR::TM
             | VR::DT => self.read_value_strs(header),
+            VR::PN => self.read_value_pn(header, &self.text.clone()),
             VR::CS => self.read_value_cs(header),
             VR::UT | VR::ST | VR::UR | VR::LT => self.read_value_str(header),
             VR::UN | VR::OB => self.read_value_ob(header),
@@ -1065,13 +1126,16 @@ fn trim_trail_empty_bytes(mut x: &[u8]) -> &[u8] {
 mod tests {
     use super::{StatefulDecode, StatefulDecoder};
     use dicom_core::header::{DataElementHeader, HasLength, Header, Length, SequenceItemHeader};
-    use dicom_core::{Tag, VR};
+    use dicom_core::{PrimitiveValue, Tag, VR};
     use dicom_encoding::decode::basic::LittleEndianBasicDecoder;
     use dicom_encoding::decode::{
         explicit_le::ExplicitVRLittleEndianDecoder, implicit_le::ImplicitVRLittleEndianDecoder,
     };
     use dicom_encoding::text::{SpecificCharacterSet, TextCodec};
+    use encoding_rs::{ISO_2022_JP, SHIFT_JIS};
+    use smallvec::SmallVec;
     use std::io::{Cursor, Seek, SeekFrom};
+    use std::str;
 
     // manually crafting some DICOM data elements
     //  Tag: (0002,0002) Media Storage SOP Class UID
@@ -1479,4 +1543,85 @@ mod tests {
 
         assert_eq!(decoder.position(), 138);
     }
+
+    #[test]
+    fn test_read_value_pn() {
+        let yamada_taro_sjis = SHIFT_JIS.encode("ﾔﾏﾀﾞ^ﾀﾛｳ").0;
+        let equal_ascii = b"=";
+        let yamada_taro_iso2022jp = ISO_2022_JP.encode("山田^太郎").0;
+        let equal_ascii_2 = b"=";
+        let yamada_taro_kana_iso2022jp = ISO_2022_JP.encode("ヤマダ^タロウ").0;
+
+        let mut combined = Vec::new();
+        combined.extend_from_slice(&yamada_taro_sjis);
+        combined.extend_from_slice(equal_ascii);
+        combined.extend_from_slice(&yamada_taro_iso2022jp);
+        combined.extend_from_slice(equal_ascii_2);
+        combined.extend_from_slice(&yamada_taro_kana_iso2022jp);
+
+        let mut cursor = Cursor::new(&combined);
+
+        let mut decoder = StatefulDecoder::new(
+            &mut cursor,
+            ImplicitVRLittleEndianDecoder::default(),
+            LittleEndianBasicDecoder,
+            SpecificCharacterSet::IsoIr13,
+        );
+
+        let header =
+            DataElementHeader::new(Tag(0x0010, 0x0010), VR::PN, Length(combined.len() as u32));
+
+        let result = decoder.read_value(&header);
+        assert!(result.is_ok());
+
+        let value = result.unwrap();
+        let expected: SmallVec<[&str; 3]> =
+            vec!["ﾔﾏﾀ\u{ff9e}^ﾀﾛｳ", "山田^太郎", "ヤマダ^タロウ"].into();
+        match value {
+            PrimitiveValue::Strs(s) => {
+                assert_eq!(s, expected);
+            }
+            _ => panic!("Unexpected value type"),
+        }
+    }
+
+    #[test]
+    fn test_read_value_pns() {
+        let yamada_taro_sjis = SHIFT_JIS.encode("ﾔﾏﾀﾞ^ﾀﾛｳ").0;
+        let equal_ascii = b"=";
+        let yamada_taro_iso2022jp = ISO_2022_JP.encode("山田^太郎").0;
+        let equal_ascii_2 = b"=";
+        let yamada_taro_kana_iso2022jp = ISO_2022_JP.encode("ヤマダ^タロウ").0;
+
+        let mut combined = Vec::new();
+        combined.extend_from_slice(&yamada_taro_sjis);
+        combined.extend_from_slice(equal_ascii);
+        combined.extend_from_slice(&yamada_taro_iso2022jp);
+        combined.extend_from_slice(equal_ascii_2);
+        combined.extend_from_slice(&yamada_taro_kana_iso2022jp);
+
+        let mut cursor = Cursor::new(&combined);
+
+        let mut decoder = StatefulDecoder::new(
+            &mut cursor,
+            ImplicitVRLittleEndianDecoder::default(),
+            LittleEndianBasicDecoder,
+            SpecificCharacterSet::IsoIr13,
+        );
+
+        let header =
+            DataElementHeader::new(Tag(0x0010, 0x0010), VR::PN, Length(combined.len() as u32));
+
+        let result = decoder.read_value_preserved(&header);
+        assert!(result.is_ok());
+
+        let value = result.unwrap();
+        let expected = "ﾔﾏﾀ\u{ff9e}^ﾀﾛｳ=山田^太郎=ヤマダ^タロウ";
+        match value {
+            PrimitiveValue::Str(s) => {
+                assert_eq!(s, expected);
+            }
+            _ => panic!("Unexpected value type"),
+        }
+    }
 }