| import struct
|
| import uuid
|
| import copy
|
| import base64
|
| import cv2
|
| import numpy as np
|
| from .maxDct import EmbedMaxDct
|
| from .dwtDctSvd import EmbedDwtDctSvd
|
| from .rivaGan import RivaWatermark
|
| import pprint
|
|
|
| pp = pprint.PrettyPrinter(indent=2)
|
|
|
| class WatermarkEncoder(object):
|
| def __init__(self, content=b''):
|
| seq = np.array([n for n in content], dtype=np.uint8)
|
| self._watermarks = list(np.unpackbits(seq))
|
| self._wmLen = len(self._watermarks)
|
| self._wmType = 'bytes'
|
|
|
| def set_by_ipv4(self, addr):
|
| bits = []
|
| ips = addr.split('.')
|
| for ip in ips:
|
| bits += list(np.unpackbits(np.array([ip % 255], dtype=np.uint8)))
|
| self._watermarks = bits
|
| self._wmLen = len(self._watermarks)
|
| self._wmType = 'ipv4'
|
| assert self._wmLen == 32
|
|
|
| def set_by_uuid(self, uid):
|
| u = uuid.UUID(uid)
|
| self._wmType = 'uuid'
|
| seq = np.array([n for n in u.bytes], dtype=np.uint8)
|
| self._watermarks = list(np.unpackbits(seq))
|
| self._wmLen = len(self._watermarks)
|
|
|
| def set_by_bytes(self, content):
|
| self._wmType = 'bytes'
|
| seq = np.array([n for n in content], dtype=np.uint8)
|
| self._watermarks = list(np.unpackbits(seq))
|
| self._wmLen = len(self._watermarks)
|
|
|
| def set_by_b16(self, b16):
|
| content = base64.b16decode(b16)
|
| self.set_by_bytes(content)
|
| self._wmType = 'b16'
|
|
|
| def set_by_bits(self, bits=[]):
|
| self._watermarks = [int(bit) % 2 for bit in bits]
|
| self._wmLen = len(self._watermarks)
|
| self._wmType = 'bits'
|
|
|
| def set_watermark(self, wmType='bytes', content=''):
|
| if wmType == 'ipv4':
|
| self.set_by_ipv4(content)
|
| elif wmType == 'uuid':
|
| self.set_by_uuid(content)
|
| elif wmType == 'bits':
|
| self.set_by_bits(content)
|
| elif wmType == 'bytes':
|
| self.set_by_bytes(content)
|
| elif wmType == 'b16':
|
| self.set_by_b16(content)
|
| else:
|
| raise NameError('%s is not supported' % wmType)
|
|
|
| def get_length(self):
|
| return self._wmLen
|
|
|
| @classmethod
|
| def loadModel(cls):
|
| RivaWatermark.loadModel()
|
|
|
| def encode(self, cv2Image, method='dwtDct', **configs):
|
| (r, c, channels) = cv2Image.shape
|
| if r*c < 256*256:
|
| raise RuntimeError('image too small, should be larger than 256x256')
|
|
|
| if method == 'dwtDct':
|
| embed = EmbedMaxDct(self._watermarks, wmLen=self._wmLen, **configs)
|
| return embed.encode(cv2Image)
|
| elif method == 'dwtDctSvd':
|
| embed = EmbedDwtDctSvd(self._watermarks, wmLen=self._wmLen, **configs)
|
| return embed.encode(cv2Image)
|
| elif method == 'rivaGan':
|
| embed = RivaWatermark(self._watermarks, self._wmLen)
|
| return embed.encode(cv2Image)
|
| else:
|
| raise NameError('%s is not supported' % method)
|
|
|
| class WatermarkDecoder(object):
|
| def __init__(self, wm_type='bytes', length=0):
|
| self._wmType = wm_type
|
| if wm_type == 'ipv4':
|
| self._wmLen = 32
|
| elif wm_type == 'uuid':
|
| self._wmLen = 128
|
| elif wm_type == 'bytes':
|
| self._wmLen = length
|
| elif wm_type == 'bits':
|
| self._wmLen = length
|
| elif wm_type == 'b16':
|
| self._wmLen = length
|
| else:
|
| raise NameError('%s is unsupported' % wm_type)
|
|
|
| def reconstruct_ipv4(self, bits):
|
| ips = [str(ip) for ip in list(np.packbits(bits))]
|
| return '.'.join(ips)
|
|
|
| def reconstruct_uuid(self, bits):
|
| nums = np.packbits(bits)
|
| bstr = b''
|
| for i in range(16):
|
| bstr += struct.pack('>B', nums[i])
|
|
|
| return str(uuid.UUID(bytes=bstr))
|
|
|
| def reconstruct_bits(self, bits):
|
|
|
| return bits
|
|
|
| def reconstruct_b16(self, bits):
|
| bstr = self.reconstruct_bytes(bits)
|
| return base64.b16encode(bstr)
|
|
|
| def reconstruct_bytes(self, bits):
|
| nums = np.packbits(bits)
|
| bstr = b''
|
| for i in range(self._wmLen//8):
|
| bstr += struct.pack('>B', nums[i])
|
| return bstr
|
|
|
| def reconstruct(self, bits):
|
| if len(bits) != self._wmLen:
|
| raise RuntimeError('bits are not matched with watermark length')
|
|
|
| if self._wmType == 'ipv4':
|
| return self.reconstruct_ipv4(bits)
|
| elif self._wmType == 'uuid':
|
| return self.reconstruct_uuid(bits)
|
| elif self._wmType == 'bits':
|
| return self.reconstruct_bits(bits)
|
| elif self._wmType == 'b16':
|
| return self.reconstruct_b16(bits)
|
| else:
|
| return self.reconstruct_bytes(bits)
|
|
|
| def decode(self, cv2Image, method='dwtDct', **configs):
|
| (r, c, channels) = cv2Image.shape
|
| if r*c < 256*256:
|
| raise RuntimeError('image too small, should be larger than 256x256')
|
|
|
| bits = []
|
| if method == 'dwtDct':
|
| embed = EmbedMaxDct(watermarks=[], wmLen=self._wmLen, **configs)
|
| bits = embed.decode(cv2Image)
|
| elif method == 'dwtDctSvd':
|
| embed = EmbedDwtDctSvd(watermarks=[], wmLen=self._wmLen, **configs)
|
| bits = embed.decode(cv2Image)
|
| elif method == 'rivaGan':
|
| embed = RivaWatermark(watermarks=[], wmLen=self._wmLen, **configs)
|
| bits = embed.decode(cv2Image)
|
| else:
|
| raise NameError('%s is not supported' % method)
|
| return self.reconstruct(bits)
|
|
|
| @classmethod
|
| def loadModel(cls):
|
| RivaWatermark.loadModel()
|
|
|
