| | 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()
|
| |
|
