WIP2

Author: scaramallion

rle/tests/test_decode.py

@@ -69,19 +69,19 @@ def as_bytes(self, offsets):
 
     def test_bits_allocated_zero_raises(self):
         """Test exception raised for BitsAllocated 0."""
-        msg = r"The \(0028,0100\) 'Bits Allocated' value must be 8, 16, 32 or 64"
+        msg = r"The \(0028,0100\) 'Bits Allocated' value must be 1, 8, 16, 32 or 64"
         with pytest.raises(ValueError, match=msg):
             decode_frame(b"\x00\x00\x00\x00", 1, 0, "<")
 
     def test_bits_allocated_not_octal_raises(self):
-        """Test exception raised for BitsAllocated not a multiple of 8."""
-        msg = r"The \(0028,0100\) 'Bits Allocated' value must be 8, 16, 32 or 64"
+        """Test exception raised for BitsAllocated not 1 or a multiple of 8."""
+        msg = r"The \(0028,0100\) 'Bits Allocated' value must be 1, 8, 16, 32 or 64"
         with pytest.raises(ValueError, match=msg):
             decode_frame(b"\x00\x00\x00\x00", 1, 12, "<")
 
     def test_bits_allocated_large_raises(self):
         """Test exception raised for BitsAllocated greater than 64."""
-        msg = r"The \(0028,0100\) 'Bits Allocated' value must be 8, 16, 32 or 64"
+        msg = r"The \(0028,0100\) 'Bits Allocated' value must be 1, 8, 16, 32 or 64"
         with pytest.raises(ValueError, match=msg):
             decode_frame(b"\x00\x00\x00\x00", 1, 72, "<")
 
@@ -357,6 +357,114 @@ def test_u32_3s(self):
         assert [4294967295, 16777216, 65536, 256, 1, 0] == arr[6:12].tolist()
         assert [1, 16777216, 65536, 256, 1, 4294967294] == arr[12:].tolist()
 
+    def test_u8_1s_bs1(self):
+        """Test decoding bit packed 1 sample/px."""
+        header = b"\x01\x00\x00\x00\x40\x00\x00\x00"
+        header += (64 - len(header)) * b"\x00"
+        # 0, 64, 128, 160, 192, 255
+        data = b"\x05\x00\x40\x80\xA0\xC0\xFF"
+        # Big endian
+        # 48 px - byte aligned in 6 bytes
+        decoded = decode_frame(header + data, 6 * 8, 1, ">")
+        arr = np.frombuffer(decoded, np.dtype("uint8"))
+        assert [0, 64, 128, 160, 192, 255] == arr.tolist()
+
+        # 37 px -> 5 bytes
+        decoded = decode_frame(header + data, 4 * 8 + 5, 1, ">")
+        arr = np.frombuffer(decoded, np.dtype("uint8"))
+        assert [0, 64, 128, 160, 192] == arr.tolist()
+
+        # 2 px -> 1 byte
+        decoded = decode_frame(header + data, 2, 1, ">")
+        arr = np.frombuffer(decoded, np.dtype("uint8"))
+        assert [0] == arr.tolist()
+
+        # Little-endian
+        decoded = decode_frame(header + data, 6 * 8, 1, "<")
+        arr = np.frombuffer(decoded, np.dtype("uint8"))
+        assert [0, 64, 128, 160, 192, 255] == arr.tolist()
+
+        decoded = decode_frame(header + data, 4 * 8 + 5, 1, "<")
+        arr = np.frombuffer(decoded, np.dtype("uint8"))
+        assert [0, 64, 128, 160, 192] == arr.tolist()
+
+        decoded = decode_frame(header + data, 2, 1, "<")
+        arr = np.frombuffer(decoded, np.dtype("uint8"))
+        assert [0] == arr.tolist()
+
+    def test_u8_3s_bs1(self):
+        """Test decoding bit packed 3 sample/px."""
+        header = (
+            b"\x03\x00\x00\x00"  # 3 segments
+            b"\x40\x00\x00\x00"  # 64
+            b"\x47\x00\x00\x00"  # 71
+            b"\x4E\x00\x00\x00"  # 78
+        )
+        header += (64 - len(header)) * b"\x00"
+        # 0, 64, 128, 160, 192, 255
+        data = (
+            b"\x05\x00\x40\x80\xA0\xC0\xFF"  # R
+            b"\x05\x7F\xC0\x80\x40\x00\xFF"  # B
+            b"\x05\x01\x40\x80\xA0\xC0\xFE"  # G
+        )
+        # 48 px - byte aligned in 18 bytes
+        decoded = decode_frame(header + data, 6 * 8, 1, "<")
+        arr = np.frombuffer(decoded, np.dtype("uint8"))
+        # Ordered all R, all G, all B
+        assert [0, 64, 128, 160, 192, 255] == arr[:6].tolist()
+        assert [127, 192, 128, 64, 0, 255] == arr[6:12].tolist()
+        assert [1, 64, 128, 160, 192, 254] == arr[12:].tolist()
+
+        # 47 px - non-byte aligned in 18 bytes
+        decoded = decode_frame(header + data, 6 * 8 - 1, 1, "<")
+        arr = np.frombuffer(decoded, np.dtype("uint8"))
+        # Boundaries are 47 | 94 | 141
+        #                       v removed
+        # 255 | 127: 0b[1111_111x 0b0]111_1111 -> 0b1111_1110
+        assert [0, 64, 128, 160, 192, 254] == arr[:6].tolist()
+        # Left shift values by 1 bit
+        # 127 | 192: 0b0[111_1111 0b1]100_0000 -> 0b1111_1111
+        # 192 | 128: 0b1[100_0000 0b1]000_0000 -> 0b1000_0001
+        # 128 |  64: 0b1[000_0000 0b0]100_0000 -> 0b0000_0000
+        #  64 |   0: 0b0[100_0000 0b0]000_0000 -> 0b1000_0000
+        #   0 | 255: 0b0[000_0000 0b1]111_1111 -> 0b0000_0001
+        #                       v removed
+        # 255 |   1: 0b1[111_111x 0b00]00_0001 -> 0b1111_1100
+        assert [255, 129, 0, 128, 1, 252] == arr[6:12].tolist()
+        # Left shift values by 2 bits
+        #   1 |  64: 0b00[00_0001 0b01]00_0000 -> 0b0000_0101
+        #  64 | 128: 0b01[00_0000 0b10]00_0000 -> 0b0000_0010
+        # 128 | 160: 0b10[00_0000 0b10]10_0000 -> 0b0000_0010
+        # 160 | 192: 0b10[10_0000 0b11]00_0000 -> 0b1000_0011
+        # 192 | 254: 0b11[00_0000 0b11]11_1110 -> 0b0000_0011
+        #                       v removed
+        # 254 |   x: 0b11[11_111x             -> 0b1111_1000
+        assert [5, 2, 2, 131, 3, 248] == arr[12:].tolist()
+
+        # 41 px - non-byte aligned in 16 bytes
+        decoded = decode_frame(header + data, 5 * 8 + 1, 1, "<")
+        arr = np.frombuffer(decoded, np.dtype("uint8"))
+        # Boundaries are 48 | 96 | 144 -> 41 | 82 | 123
+        #                vvv vvvv removed
+        # 255 | 255: 0b[1xxx_xxxx 0b0111_111]1 -> 0b1011_1111
+        assert [0, 64, 128, 160, 192, 191] == arr[:6].tolist()
+        # Left shift values by 7 bits
+        # 255 | 192: 0b1111_111[1 0b1100_000]0 -> 0b1110_0000
+        # 192 | 128: 0b1100_000[0 0b1000_000]0 -> 0b0100_0000
+        # 128 |  64: 0b1000_000[0 0b0100_000]0 -> 0b0010_0000
+        #  64 |   0: 0b0100_000[0 0b0000_000]0 -> 0b0000_0000
+        #                                  vvv vvvv removed
+        #   0 | 255 |   1: 0b0000_000[0 0b1xxx_xxxx 0b0000_00]01 -> 0b0100_0000
+        assert [224, 64, 32, 0, 64] == arr[6:11].tolist()
+        # Left shift values by 14 bits
+        #   1 |  64: 0b0000_00[01 0b0100_00]00 -> 0b0101_0000
+        #  64 | 128: 0b0100_00[00 0b1000_00]00 -> 0b0010_0000
+        # 128 | 160: 0b1000_00[00 0b1010_00]00 -> 0b0010_1000
+        # 160 | 192: 0b1010_00[00 0b1100_00]00 -> 0b0011_0000
+        #                           vvv vvvv removed
+        # 192 | 254: 0b1100_[00 0b1]xxx_xxxx   -> 0b0010_0000
+        assert [80, 32, 40, 48, 32] == arr[11:].tolist()
+
 
 @pytest.mark.skipif(not HAVE_PYDICOM, reason="No pydicom")
 class TestDecodeFrame_Datasets:

rle/tests/test_utils.py

@@ -199,7 +199,7 @@ def test_bad_bits_allocated_raises(self):
             "byteorder": "<",
         }
 
-        msg = r"'bits_allocated' must be 8, 16, 32 or 64"
+        msg = r"'bits_allocated' must be 1, 8, 16, 32 or 64"
         with pytest.raises(ValueError, match=msg):
             encode_pixel_data(b"", **kwargs)