def test_matrix(self):
original = np.array([[(255, 255, 255), (48, 113, 219), (0, 0, 0)],
[(0, 0, 0), (48, 113, 219), (255, 255, 255)],
[(48, 113, 219), (0, 0, 0), (0, 0, 0)],
[(255, 255, 255), (48, 113, 219),
(255, 255, 255)]])
expected = np.array([[(255, 128, 128), (137, 186, 78), (0, 128, 128)],
[(0, 128, 128), (137, 186, 78), (255, 128, 128)],
[(137, 186, 78), (0, 128, 128), (0, 128, 128)],
[(255, 128, 128), (137, 186, 78),
(255, 128, 128)]])
actual = imagetools.bgr_to_ycrcb(original)
np.testing.assert_array_equal(
expected, actual,
"The original pixel- {} converted to {} and not to {} that expected"
.format(original, actual, expected))
dest=os.path.join(src_dir,
mode + '_channel_c.png'))
print('Downsampling ' + mode)
img_channel_b = encode.upsample(encode.downsample(img_channel_b))
img_channel_c = encode.upsample(encode.downsample(img_channel_c))
imagetools.save_matrix(encode.concatenate_three_colors(
img_channel_a, img_channel_b, img_channel_c),
mode=mode,
dest=os.path.join(src_dir,
mode + '_downsapling.png'))
split_and_downsample(img, 'BGR')
print("bgr_to_ycrcb")
img = imagetools.bgr_to_ycrcb(img)
split_and_downsample(img, 'YCrCb')
def local_dct(matrix, dst, size=8):
y, cr, cb = encode.split_to_three_colors(matrix)
y_shape = encode.shape_for_contacting(y.shape, size)
cb_shape = encode.shape_for_contacting(cb.shape, size)
cr_shape = encode.shape_for_contacting(cr.shape, size)
print("Split and padding to submatrices")
y = [
matrix
for matrix in encode.split_matrix_into_sub_matrices(y, size)
]
cr = [
def compress_image(src_path, dest_path, entropy=False, size=8) -> bool:
print("Reading file")
bitmap = imagetools.get_bitmap_from_bmp(src_path)
if entropy:
print("Bitmap entropy: " + str(ent.entropy(bitmap)))
print("Crop image")
bitmap = crop_bitmap(bitmap)
print("Converting to YCrCb")
bitmap = imagetools.bgr_to_ycrcb(bitmap)
print("Separating bitmap to Y, Cb, Cr matrices")
y, cb, cr = split_to_three_colors(bitmap)
print("Downsampling")
cr = downsample(cr)
cb = downsample(cb)
y_shape = shape_for_contacting(y.shape, size)
cr_shape = shape_for_contacting(cr.shape, size)
cb_shape = shape_for_contacting(cb.shape, size)
print("Splitting to {0}x{0} sub-matrices".format(size))
y = split_matrix_into_sub_matrices(y, size)
cr = split_matrix_into_sub_matrices(cr, size)
cb = split_matrix_into_sub_matrices(cb, size)
print("dct")
y = [dct.dct(sub_matrix) for sub_matrix in y]
cr = [dct.dct(sub_matrix) for sub_matrix in cr]
cb = [dct.dct(sub_matrix) for sub_matrix in cb]
print("Quantization")
y = [dct.quantization(submatrix) for submatrix in y]
cr = [dct.quantization(submatrix) for submatrix in cr]
cb = [dct.quantization(submatrix) for submatrix in cb]
if entropy:
print("Compressed entropy: " + str(
ent.entropy(np.dstack([np.dstack(
y), np.dstack(cr), np.dstack(cb)]))))
print("UnQuantization")
y = [dct.un_quantization(submatrix) for submatrix in y]
cr = [dct.un_quantization(submatrix) for submatrix in cr]
cb = [dct.un_quantization(submatrix) for submatrix in cb]
print("Invert dct")
y = [dct.inverse_dct(matrix) for matrix in y]
cr = [dct.inverse_dct(matrix) for matrix in cr]
cb = [dct.inverse_dct(matrix) for matrix in cb]
print("Concatenate")
y = concatenate_sub_matrices_to_big_matrix(y, y_shape)
cr = concatenate_sub_matrices_to_big_matrix(cr, cb_shape)
cb = concatenate_sub_matrices_to_big_matrix(cb, cr_shape)
print("upsample")
cr = upsample(cr)
cb = upsample(cb)
print("concatenate")
concatenate_three_colors(y, cr, cb, bitmap)
# print("ycrcb_to_bgr")
# bitmap = imagetools.ycrcb_to_bgr(bitmap)
print("save_matrix")
imagetools.save_matrix(bitmap, mode='YCrCb', dest=dest_path + '.png')
def compress_image(src_path, dest_path, entropy=False,
size=8): # pragma: no cover
print("Reading file")
bitmap = imagetools.get_bitmap_from_bmp(src_path)
if entropy:
print("Bitmap entropy: " + str(ent.entropy(bitmap)))
print("Crop image")
ycrcb_crop = crop_bitmap(bitmap)
print("Converting to YCrCb")
ycrcb_bitmap = imagetools.bgr_to_ycrcb(ycrcb_crop)
print("Separating bitmap to Y, Cb, Cr matrices")
y, cb, cr = split_to_three_colors(ycrcb_bitmap)
print("Downsampling")
cb_downsample = downsample(cb)
cr_downsample = downsample(cr)
y_shape = shape_for_contacting(y.shape, size)
cb_shape = shape_for_contacting(cb_downsample.shape, size)
cr_shape = shape_for_contacting(cr_downsample.shape, size)
print("Splitting to 8x8 sub-matrices")
y_split = split_matrix_into_sub_matrices(y)
cb_split = split_matrix_into_sub_matrices(cb_downsample)
cr_split = split_matrix_into_sub_matrices(cr_downsample)
print("DCT")
y_dct = [dct.DCT(sub_matrix) for sub_matrix in y_split]
cb_dct = [dct.DCT(sub_matrix) for sub_matrix in cb_split]
cr_dct = [dct.DCT(sub_matrix) for sub_matrix in cr_split]
print("Quantization")
y_quantization = [dct.quantization(submatrix) for submatrix in y_dct]
cb_quantization = [dct.quantization(submatrix) for submatrix in cb_dct]
cr_quantization = [dct.quantization(submatrix) for submatrix in cr_dct]
if entropy:
print("Compressed entropy: " + str(
ent.entropy(
np.array([y_quantization, cb_quantization, cr_quantization]))))
print("UnQuantization")
y_un_quantization = [
dct.un_quantization(submatrix) for submatrix in y_quantization
]
cb_un_quantization = [
dct.un_quantization(submatrix) for submatrix in cb_quantization
]
cr_un_quantization = [
dct.un_quantization(submatrix) for submatrix in cr_quantization
]
print("Invert DCT")
y_invert_dct = [dct.inverse_DCT(matrix) for matrix in y_un_quantization]
cb_invert_dct = [dct.inverse_DCT(matrix) for matrix in cb_un_quantization]
cr_invert_dct = [dct.inverse_DCT(matrix) for matrix in cr_un_quantization]
print("Concatenate")
y_big = concatenate_sub_matrices_to_big_matrix(y_invert_dct, y_shape)
cb_big = concatenate_sub_matrices_to_big_matrix(cb_invert_dct, cb_shape)
cr_big = concatenate_sub_matrices_to_big_matrix(cr_invert_dct, cr_shape)
print("upsample")
cb_upsample = upsample(cb_big)
cr_upsample = upsample(cr_big)
new_image = concatenate_three_colors(y_big, cb_upsample, cr_upsample)
imagetools.save_matrix(new_image, mode='YCrCb', dest=dest_path + '.png')
def test_vs_cv2(self):
im = cv2.imread(os.path.join(src, "colored.bmp"))
expected = cv2.cvtColor(im, cv2.COLOR_BGR2YCrCb)
actual = imagetools.bgr_to_ycrcb(im)
different = np.count_nonzero(actual - expected) / np.prod(im.shape)
self.assertLessEqual(different, 1 / 100)