Created a test suite for image encoder.

Author: MillionIntegrals

.gitignore

@@ -6,3 +6,4 @@ __pycache__/
 .DS_Store
 
 output/
+/my_scripts/

encoder/algorithms/xor_encoding.py

@@ -2,25 +2,24 @@
 
 import numpy as np
 
-from encoder.bit_density import pad_bit_array, truncate_bit_array, convert_to_bit_density, convert_from_bit_density
+from encoder.bit_density import pad_bit_array, convert_to_bit_density, convert_from_bit_density
+from encoder.constants import BITS_PER_BYTE, BYTES_PER_UINT64
 from encoder.utilities import add_length_info, strip_length_info
 
 
 class XorEncoding:
-    BITS_PER_BYTE = 8
-    BYTES_PER_UINT64 = 8
 
     def __init__(self, block_size, intensity):
-        self.block_size = block_size
+        self.bits_per_block = block_size
+        self.block_size = 2 ** self.bits_per_block
         self.intensity = intensity
-        self.bits_per_block = int(np.log2(self.block_size))
         self.block_template = np.arange(self.block_size, dtype=np.uint64)
 
     def data_capacity(self, img_size):
-        """ Return data capacity for given algorithm and image """
+        """ Return data capacity for given algorithm and image -- in bytes """
         bits_in_image = img_size[0] * img_size[1] * img_size[2] * self.intensity
         number_of_blocks = bits_in_image // self.block_size
-        return number_of_blocks * self.bits_per_block // self.BITS_PER_BYTE - self.BYTES_PER_UINT64
+        return number_of_blocks * self.bits_per_block // BITS_PER_BYTE - BYTES_PER_UINT64
 
     def _pack_data(self, data):
         """ 
@@ -86,7 +85,7 @@ def encode(self, img_data, payload):
         initial_img_length = shape[0] * shape[1] * shape[2]
 
         raw_data = img_data.flatten()
-        raw_bits = np.unpackbits(raw_data).reshape(initial_img_length, self.BITS_PER_BYTE)
+        raw_bits = np.unpackbits(raw_data).reshape(initial_img_length, BITS_PER_BYTE)
 
         selected_raw_bits = raw_bits[:, -self.intensity:].flatten()
 
@@ -109,7 +108,7 @@ def decode(self, img_data):
         initial_img_length = shape[0] * shape[1] * shape[2]
 
         raw_data = img_data.flatten()
-        raw_bits = np.unpackbits(raw_data).reshape(initial_img_length, self.BITS_PER_BYTE)
+        raw_bits = np.unpackbits(raw_data).reshape(initial_img_length, BITS_PER_BYTE)
 
         selected_raw_bits = raw_bits[:, -self.intensity:].flatten()
 

encoder/bit_density.py

@@ -2,9 +2,11 @@
 
 import numpy as np
 
+from encoder.constants import BITS_PER_BYTE
+
 
 def truncate_bit_array(bit_array, bit_length):
-    """ Truncate given bit-array (uint8), so that the length can be divided by bit_length """
+    """ Truncate given bit-array (uint8), so that the length can be divided by bit_length without a remainder """
     overflow = bit_array.shape[0] % bit_length
 
     if overflow > 0:
@@ -14,7 +16,7 @@ def truncate_bit_array(bit_array, bit_length):
 
 
 def pad_bit_array(bit_array, bit_length):
-    """ Pad given bit-array (uint8) with zeros, so that the length can be divided by bit_length """
+    """ Pad given bit-array (uint8) with zeros, so that the length can be divided by bit_length without a remainder """
     missing_bits = (bit_length - (bit_array.shape[0] % bit_length)) % bit_length
 
     # PAD BITS IF NEEDED
@@ -40,28 +42,12 @@ def convert_to_bit_density(input_data, result_density):
 
 
 def convert_from_bit_density(input_data, result_density):
-    """ Convert from given density to uint8 """
+    """ Convert from given density (uint64) to uint8 """
     input_shape = input_data.shape[0]
     raw_bits = np.unpackbits(input_data.astype(np.dtype('>u8')).view(np.uint8)).reshape(input_shape, 64)
     truncated_bits = raw_bits[:, -result_density:]
     truncated_bits = truncated_bits.reshape(truncated_bits.shape[0] * truncated_bits.shape[1])
 
-    TARGET_DENSITY = 8
-
-    truncated_bits = pad_bit_array(truncated_bits, TARGET_DENSITY)
+    truncated_bits = pad_bit_array(truncated_bits, BITS_PER_BYTE)
 
     return np.packbits(truncated_bits)
-
-
-def main():
-    input = np.array([0, 1, 255], dtype=np.uint8)
-    converted = convert_to_bit_density(input, 12)
-    and_back = convert_from_bit_density(converted, 12)
-
-    print('Input =', input)
-    print('Converted =', converted)
-    print('And back =', and_back)
-
-
-if __name__ == '__main__':
-    main()

encoder/constants.py

@@ -0,0 +1,4 @@
+__author__ = 'jrx'
+
+BITS_PER_BYTE = 8
+BYTES_PER_UINT64 = 8

encoder/main.py

@@ -27,11 +27,12 @@ def info_action(args):
     assert im.mode == 'RGB', 'Only RGB mode images are supported!'
     rgb_data = np.array(im)
 
-
     capacity = algorithm.data_capacity(rgb_data.shape)
-    print(capacity)
 
-    # print('Data capacity {:.2f} b/{:.2f} kb/{:.2f} mb'.format(capacity, capacity / 1024, capacity / 1024 / 1024))
+    if args.verbose:
+        print('Data capacity {:.2f} b/{:.2f} kb/{:.2f} mb'.format(capacity, capacity / 1024, capacity / 1024 / 1024))
+    else:
+        print(capacity)
 
 
 def encode_action(args):
@@ -86,6 +87,7 @@ def main():
     parser.add_argument('-o', '--outfile', help='Specify output file', default='')
     parser.add_argument('-a', '--algorithm', help='Choose your algorithm', default='xor_encoding')
     parser.add_argument('-d', '--datafile', help='Specify data file', default='')
+    parser.add_argument('-v', '--verbose', help='Make program more verbose', default='')
 
     group = parser.add_argument_group('Algorithm parameters')
 

scripts/demo.sh

@@ -5,13 +5,13 @@ if ! [ -d output ]; then
 fi
 
 echo "Encoding marocco..."
-python3 -m encoder.main encode -i data/marocco.jpg -o output/marocco_encoded.png -d data/ALICE_IN_WONDERLAND --intensity=2 --block_size=64 
+python3 -m encoder.main encode -i data/marocco.jpg -o output/marocco_encoded.png -d data/ALICE_IN_WONDERLAND --intensity=2 --block_size=6
 echo "Decoding marocco..."
-python3 -m encoder.main decode -i output/marocco_encoded.png -o output/marocco_decoded.txt --intensity=2 --block_size=64 
+python3 -m encoder.main decode -i output/marocco_encoded.png -o output/marocco_decoded.txt --intensity=2 --block_size=6
 
 echo "Encoding dragon..."
-python3 -m encoder.main encode -i data/dragon.jpg -o output/dragon_encoded.png -d data/ALICE_IN_WONDERLAND --intensity=4 --block_size=8 
+python3 -m encoder.main encode -i data/dragon.jpg -o output/dragon_encoded.png -d data/ALICE_IN_WONDERLAND --intensity=4 --block_size=3
 echo "Decoding dragon..."
-python3 -m encoder.main decode -i output/dragon_encoded.png -o output/dragon_decoded.txt --intensity=4 --block_size=8 
+python3 -m encoder.main decode -i output/dragon_encoded.png -o output/dragon_decoded.txt --intensity=4 --block_size=3
 
 echo "Done"

tests/__init__.py

@@ -0,0 +1 @@
+__author__ = 'jrx'

tests/test_bit_density.py

@@ -0,0 +1,40 @@
+__author__ = 'jrx'
+
+
+import numpy as np
+
+from numpy.testing import assert_array_equal
+from nose.tools import assert_equal
+
+
+from encoder.bit_density import convert_from_bit_density, convert_to_bit_density
+
+
+def test_small_input():
+    initial = np.array([0, 1, 255], dtype=np.uint8)
+    converted = convert_to_bit_density(initial, 12)
+    and_back = convert_from_bit_density(converted, 12)
+
+    assert_array_equal(initial, and_back)
+
+
+def test_random_input():
+    for i in range(10):
+        random_input = np.random.random_integers(0, 255, np.random.randint(10, 100)).astype(np.uint8)
+        random_bit_density = np.random.randint(2, 20)
+
+        converted = convert_to_bit_density(random_input, random_bit_density)
+        and_back = convert_from_bit_density(converted, random_bit_density)
+
+        assert_equal(converted.dtype, np.uint64)
+        assert_equal(and_back.dtype, np.uint8)
+
+        assert_array_equal(random_input, and_back[:len(random_input)])
+
+
+def test_fixed_cases():
+    initial = np.array([0, 1, 255], dtype=np.uint8)
+    converted = convert_to_bit_density(initial, 12)
+    assert_array_equal(converted, np.array([0, 511], dtype=np.uint64))
+
+

tests/test_utilities.py

@@ -0,0 +1,24 @@
+__author__ = 'jrx'
+
+import numpy as np
+
+from numpy.testing import assert_array_equal
+from nose.tools import assert_equal
+
+
+from encoder.bit_density import convert_from_bit_density, convert_to_bit_density
+from encoder.utilities import add_length_info, strip_length_info
+
+
+def test_random_input_density_conversion():
+    for i in range(10):
+        random_input = np.random.random_integers(0, 255, np.random.randint(10, 100)).astype(np.uint8)
+        random_bit_density = np.random.randint(2, 20)
+
+        converted = convert_to_bit_density(add_length_info(random_input), random_bit_density)
+        and_back = strip_length_info(convert_from_bit_density(converted, random_bit_density))
+
+        assert_equal(converted.dtype, np.uint64)
+        assert_equal(and_back.dtype, np.uint8)
+
+        assert_array_equal(random_input, and_back)

tests/test_xor_encoder.py

@@ -0,0 +1,87 @@
+__author__ = 'jrx'
+
+
+import numpy as np
+
+from numpy.testing import assert_array_equal
+from nose.tools import assert_greater, assert_equal
+
+
+from encoder.algorithms.xor_encoding import XorEncoding
+
+
+def test_capacity_monotonic():
+    shape = (640, 480, 3)
+
+    base = XorEncoding(block_size=6, intensity=4)
+    low_block = XorEncoding(block_size=5, intensity=4)
+    high_intensity = XorEncoding(block_size=5, intensity=8)
+
+    assert_greater(low_block.data_capacity(shape), base.data_capacity(shape))
+    assert_greater(high_intensity.data_capacity(shape), base.data_capacity(shape))
+
+    assert_equal(base.data_capacity(shape), 43192)
+    assert_equal(low_block.data_capacity(shape), 71992)
+    assert_equal(high_intensity.data_capacity(shape), 143992)
+
+
+def test_base():
+    image = np.random.randint(0, 256, (640, 480, 3)).astype(np.uint8)
+    encoding = XorEncoding(block_size=6, intensity=4)
+    max_size = encoding.data_capacity(image.shape)
+
+    data = np.random.randint(0, 256, max_size).astype(np.uint8)
+
+    encoded = encoding.encode(image, data)
+
+    assert_equal(encoded.dtype, np.uint8)
+    assert_equal(encoded.shape, image.shape)
+
+    decoded = encoding.decode(encoded)
+
+    assert_equal(decoded.dtype, np.uint8)
+    assert_equal(decoded.shape, data.shape)
+
+    assert_array_equal(data, decoded)
+
+
+def test_high_intensity():
+    image = np.random.randint(0, 256, (640, 480, 3)).astype(np.uint8)
+    encoding = XorEncoding(block_size=6, intensity=8)
+    max_size = encoding.data_capacity(image.shape)
+
+    data = np.random.randint(0, 256, max_size).astype(np.uint8)
+
+    encoded = encoding.encode(image, data)
+
+    assert_equal(encoded.dtype, np.uint8)
+    assert_equal(encoded.shape, image.shape)
+
+    decoded = encoding.decode(encoded)
+
+    assert_equal(decoded.dtype, np.uint8)
+    assert_equal(decoded.shape, data.shape)
+
+    assert_array_equal(data, decoded)
+
+
+def test_low_block():
+    image = np.random.randint(0, 256, (640, 480, 3)).astype(np.uint8)
+    encoding = XorEncoding(block_size=1, intensity=1)
+    max_size = encoding.data_capacity(image.shape)
+
+    data = np.random.randint(0, 256, max_size).astype(np.uint8)
+
+    encoded = encoding.encode(image, data)
+
+    assert_equal(encoded.dtype, np.uint8)
+    assert_equal(encoded.shape, image.shape)
+
+    decoded = encoding.decode(encoded)
+
+    assert_equal(decoded.dtype, np.uint8)
+    assert_equal(decoded.shape, data.shape)
+
+    assert_array_equal(data, decoded)
+
+