def pnsr_ber_index(
hider_factory, cover_work, data,
index, step, *args, attacks=None, reference_psnr=44, **kwargs):
def get_extractor(extractor, index):
def wrapper(ws_work):
return extractor(ws_work, index=index)
return wrapper
index = int(round(index))
step = int(round(step))
data = utils.char2bin(data)
hider = hider_factory.build(step, *args, **kwargs)
ws_work = hider.insert(cover_work, data, index=index)
psnr = imperceptibility.psnr(cover_work, ws_work)
watermark = hider.extract(ws_work, index=index)
if attacks:
extract = get_extractor(hider.extract, index)
ber = ber_mean(extract, ws_work, watermark, attacks)
else:
ber = robustness.ber(watermark, data)
return psnr, ber
def insert(self, cover_array, msg=None):
'''
obj.insert(cover_array, msg) => (np.numpy): Return a watermarked
work (stego work) with specified message.
'''
# Initial Values
count = 0
# Binary message
bin_msg = utils.char2bin(msg)
# Creating copy
watermarked_array = np.copy(cover_array)
# Depth of the image
if len(watermarked_array.shape) == 2:
red_watermarked_array = watermarked_array
else:
# Red component
red_watermarked_array = watermarked_array[:, :, 0]
# Instance
block_instace_8x8 = BlocksImage(red_watermarked_array)
# Increasing the hash function
# self.hashf = increase(self.hashf, block_instace_8x8.max_num_blocks())
# Checking the embedding capacity
embd_cap = block_instace_8x8.max_num_blocks() * 8
if len(bin_msg) > embd_cap:
raise ExceededCapacity
for i in range(block_instace_8x8.max_num_blocks()):
block8x8 = block_instace_8x8[i]
block_transf8x8 = self.ortho_matrix.direct(block8x8)
vac = utils.vzig_zag_scan(block_transf8x8)
for k in range(1, 9):
# TODO: l deleted
# vac[k] = np.sign(vac[k]) * utils.replace(
# abs(round(vac[k])), bin_msg[i % (len(bin_msg))]
# )
if count < len(bin_msg):
vac[k] = np.sign(vac[k]) * utils.replace(
abs(round(vac[k])), bin_msg[count])
count += 1
block_transf8x8 = utils.mzig_zag_scan(vac)
block_instace_8x8[i] = self.ortho_matrix.inverse(block_transf8x8)
return watermarked_array
def insert(self, cover_array, msg, coeficient_index):
# Binary data
bin_msg = utils.char2bin(msg)
# Cover copy and block generation
watermarked_array = np.copy(cover_array)
block_instance_8x8 = BlocksImage(watermarked_array)
# Checking the embedding capacity
embd_cap = block_instance_8x8.max_num_blocks()
self.validate_capacity(bin_msg, embd_cap)
# insertion process
for index, bit in enumerate(bin_msg):
block8x8 = block_instance_8x8.get_block(index)
block_transf8x8 = self.__insert__(bit, block8x8, coeficient_index)
block_instance_8x8.set_block(
self.ortho_matrix.inverse(block_transf8x8), index)
return watermarked_array
def test_utf8(self):
msg = 'díaz núñez'
self.assertEqual(utils.bin2char(utils.char2bin(msg)), msg)
def test_ascii(self):
msg = 'hello world'
self.assertEqual(utils.bin2char(utils.char2bin(msg)), msg)
def test_empty_string(self):
self.assertEqual(utils.bin2char(utils.char2bin('')), '')