def _ehead(self, data: bytes):
header = b'FsTeg\x01\x02\x03'
ee = pad(data, self.block_size)
ll = struct.pack('i', 1 + len(ee) // self.block_size)
_rrs1 = RSCodec()
_rrs2 = RSCodec(_check)
return _rrs1.encode(pad(header + ll, _header_size - 10)) + _rrs2.encode(pad(data, _rsc_block))
def reed_solomon_encode(txt: typing.Union[bytes, str, bytearray],
number_repair_symbols: int = 2) -> bytes:
global rscodec, number_r_symbols
if rscodec is None or number_r_symbols != number_repair_symbols:
rscodec = RSCodec(number_repair_symbols)
number_r_symbols = number_repair_symbols
return bytes(rscodec.encode(txt))
def test_prim_fcr_basic(self):
nn = 30
kk = 18
tt = nn - kk
rs = RSCodec(tt, fcr=120, prim=0x187)
hexencmsg = '00faa123555555c000000354064432c02800fe97c434e1ff5365' \
'cf8fafe4'
strf = str if sys.version_info[0] >= 3 else unicode
encmsg = bytearray.fromhex(strf(hexencmsg))
decmsg = encmsg[:kk]
tem = rs.encode(decmsg)
self.assertEqual(encmsg, tem, msg="encoded does not match expected")
tdm = rs.decode(tem)
self.assertEqual(tdm, decmsg, msg="decoded does not match original")
tem1 = bytearray(tem) # clone a copy
# encoding and decoding intact message seem OK, so test errors
numerrs = tt >> 1 # inject tt/2 errors (expected to recover fully)
for i in sample(range(nn), numerrs): # inject errors in random places
tem1[i] ^= 0xff # flip all 8 bits
tdm = rs.decode(tem1)
self.assertEqual(tdm, decmsg,
msg="decoded with errors does not match original")
tem1 = bytearray(tem) # clone another copy
numerrs += 1 # inject tt/2 + 1 errors (expected to fail and detect it)
for i in sample(range(nn), numerrs): # inject errors in random places
tem1[i] ^= 0xff # flip all 8 bits
# if this fails, it means excessive errors not detected
self.assertRaises(ReedSolomonError, rs.decode, tem1)
class TMEncoder:
def __init__(self):
self.rsc = RSCodec(ECC)
def encode_tc_datalink_packets(self, datalink_packets) -> bytes:
bytestream = b''
for packet in datalink_packets:
bytestream += self.encode_bytes(packet.to_bytes())
return bytestream
def encode_bytes(self, data):
frames = []
for i in range(0, len(data), FRAME_LENGTH):
frame = data[i:i + FRAME_LENGTH]
encoded_data = self.rsc.encode(frame)
sync_frame = ASM + encoded_data
frames.append(sync_frame)
return b''.join(frames)
def convolve_code(self, data):
bits = bytes_2_bits(data)
state = collections.deque([0, 0, 0, 0, 0, 0], 6)
c_bits = []
for bit in bits:
c1 = bit ^ state[0] ^ state[1] ^ state[2] ^ state[5]
c2 = bit ^ state[1] ^ state[2] ^ state[4] ^ state[5]
state.appendleft(bit)
c_bits.append(c1)
c_bits.append(abs(c2 - 1))
return bits_2_bytes(c_bits)
def test_prim_fcr_long(self):
nn = 48
kk = 34
tt = nn - kk
rs = RSCodec(tt, fcr=120, prim=0x187)
hexencmsg = '08faa123555555c000000354064432c0280e1b4d090cfc04887400' \
'000003500000000e1985ff9c6b33066ca9f43d12e8'
strf = str if sys.version_info[0] >= 3 else unicode
encmsg = bytearray.fromhex(strf(hexencmsg))
decmsg = encmsg[:kk]
tem = rs.encode(decmsg)
self.assertEqual(encmsg, tem, msg="encoded does not match expected")
tdm = rs.decode(tem)
self.assertEqual(tdm, decmsg,
msg="decoded does not match original")
tem1 = bytearray(tem)
numerrs = tt >> 1
for i in sample(range(nn), numerrs):
tem1[i] ^= 0xff
tdm = rs.decode(tem1)
self.assertEqual(tdm, decmsg,
msg="decoded with errors does not match original")
tem1 = bytearray(tem)
numerrs += 1
for i in sample(range(nn), numerrs):
tem1[i] ^= 0xff
self.assertRaises(ReedSolomonError, rs.decode, tem1)
def generate(n, k=12, mnemonic=Mnemonic("english")):
"""Generate a mnemonic phrase with the specified level of error correction.
Phrases include t=(n-k) "error correcting" words, allowing the correction of up to t invalid
words in a phrase, and up to floor(t/2) words that are wrong, but still valid BIP-39 words.
Arguments:
n (int): Total number of words in the phrase.
k (int): Number of words chosen at random.
mnemonic (Mnemonic): Instance of Mnemonic to use.
"""
ok, error = validate_n_k(n, k)
if not ok:
raise ValueError(error)
coder = RSCodec(nsize=n, nsym=(n-k), c_exp=BIP39_SYMBOL_SIZE)
for i in itertools.count():
bits = random_bits(k*BIP39_SYMBOL_SIZE)
symbols = bits_to_symbols(bits, BIP39_SYMBOL_SIZE)
coded = coder.encode(symbols)
phrase = symbols_to_mnemonic(coded, mnemonic)
if not mnemonic.check(phrase):
continue
return phrase
def recover(phrase, k=12, mnemonic=Mnemonic("english")):
"""Attempts to recover the original mnemonic phrase from a mnemonic phrase with errors.
Infers the value of n from the number of words in the phrase. If words are missing or unknown,
include an arbitrary character in its place. (e.g. '_')
Arguments:
phrase (str): Mnemonic phrase with errors to fix.
k (int): Number of words chosen at random.
mnemonic (Mnemonic): Instance of Mnemonic to use.
"""
symbols = mnemonic_to_symbols(phrase, mnemonic)
ok, error = validate_n_k(len(symbols), k)
if not ok:
raise ValueError(error)
coder = RSCodec(nsize=len(symbols), nsym=(len(symbols)-k), c_exp=BIP39_SYMBOL_SIZE)
erasures = [i for i, s in enumerate(symbols) if s < 0]
recovered, _, _ = coder.decode(symbols, erase_pos=erasures)
coded = coder.encode(recovered)
phrase = symbols_to_mnemonic(coded, mnemonic)
if not mnemonic.check(phrase):
raise ValueError("error-corrected phrase does not have a valid checksum")
return phrase
def encodeWithReedSolo(bytedata, length=0):
if len(bytedata) > 182 or length > 256:
return b''
ecc_len = 0
if length == 0:
# if len(bytedata) > 182:
# c = math.ceil(len(bytedata) / 2)
# if c > 182:
# c = 182
# return encodeWithReedSolo(bytedata[:c]) + encodeWithReedSolo(bytedata[c:])
ecc_len = math.ceil(len(bytedata) * errorPercent)
else:
# if length > 255:
# c = math.ceil(length / 2)
# print(c)
# if c > 255:
# c = 255
# return encodeWithReedSolo(bytedata[:c]) + encodeWithReedSolo(bytedata[c:])
print('use length ' + str(length))
ecc_len = math.ceil(int(length) / (1 + errorPercent) * errorPercent)
bytedata += os.urandom(math.floor(length - ecc_len - len(bytedata)))
print('error: ' + str(ecc_len))
print('random: ' + str(math.floor(length - ecc_len - len(bytedata))))
print('data: ' + str(len(bytedata)))
rsc = RSCodec(ecc_len)
encodedata = rsc.encode(bytedata)
print('ENCODED')
print(len(encodedata))
return encodedata
class CCSDS_Chunk_Packet(CCSDS_Packet):
def __init__(self, packet_seq_num, telemetry_packet_type,
current_batch_num, current_chunk_num, chunk):
self.rsc = RSCodec(16) # 16 ecc symbols
self.chunk = chunk
packet_data = self._create_chunk_packet_data(telemetry_packet_type,
current_batch_num,
current_chunk_num, chunk)
super().__init__(packet_seq_num, packet_data)
def __str__(self):
return f"chunk|seqnum:{self.packet_seq_num}|len:{len(self.get_tx_packet())}"
def get_tx_packet(self):
return self.header + self.packet_data
def _create_chunk_packet_data(self, telemetry_packet_type,
current_batch_num, current_chunk_num, chunk):
TELEMETRY_TYPE_LENGTH = 1
CURRENT_CHUNKS_LENGTH = 3 # bytes
CURRENT_BATCH_LENGTH = 3
data = bytearray(0)
data = telemetry_packet_type.to_bytes(TELEMETRY_TYPE_LENGTH, 'big')
data = data + current_batch_num.to_bytes(CURRENT_BATCH_LENGTH, 'big')
data = data + current_chunk_num.to_bytes(CURRENT_CHUNKS_LENGTH, 'big')
data += self.rsc.encode(chunk)
return data
def listen_linux(frame_rate=44100, interval=0.1):
mic = alsaaudio.PCM(alsaaudio.PCM_CAPTURE,
alsaaudio.PCM_NORMAL,
device="default")
mic.setchannels(1)
mic.setrate(44100)
mic.setformat(alsaaudio.PCM_FORMAT_S16_LE)
num_frames = int(round((interval / 2) * frame_rate))
mic.setperiodsize(num_frames)
print("start...")
in_packet = False
packet = []
while True:
l, data = mic.read()
if not l:
continue
chunk = np.fromstring(data, dtype=np.int16)
dom = dominant(frame_rate, chunk)
#print(dom)
if in_packet and match(dom, HANDSHAKE_END_HZ):
byte_stream = extract_packet(packet)
try:
byte_stream = RSCodec(FEC_BYTES).decode(byte_stream)
byte_stream = byte_stream.decode("utf-8")
#print(byte_stream) #이 부분을 찍어보면 최종 문자열을 확인가능
if "201502127" in byte_stream: # in 키워드를 이용하면 문자열이 있는지를 찾을 수 있다.
ID_count = byte_stream.count(
"201502127") #201502127이 몇번 출현하는지 찾는다.
byte_stream = extract_Data(byte_stream, ID_count)
display(byte_stream)
try:
byte_stream = RSCodec(FEC_BYTES).encode(
byte_stream.encode("utf-8")
) # 필요한 데이터 뒤에 오류 코드까지 아스키 코드(1byte)로 인코딩 되어 나온다.
#print(byte_stream[0:4]) #byteArray가 된 " hel"이 출력됨.
sound(bytes_to_freq(byte_stream))
except ReedSolomonError as e:
pass
#print("{}: {}".format(e, byte_stream))
except ReedSolomonError as e:
pass
#print("{}: {}".format(e, byte_stream))
packet = []
in_packet = False
elif in_packet:
packet.append(dom)
elif match(dom, HANDSHAKE_START_HZ):
in_packet = True
def main():
for i in range(0, 256):
postit = np.tile(np.uint8([255]), (postit_height, postit_width, 1))
#draw location dot
for count in range(0, 8):
location_dot_array = [1] + [
0 for j in range(0, location_dot_num - 1)
]
for j in range(0, len(location_dot_array) - 2):
if count & 2**j != 0:
location_dot_array[j + 1] = 1
if count < 3:
draw_location_dot(postit, location_dot_array,
horizon_x_buffer + count * horizon_space,
horizon_y_buffer, True)
elif count < 6:
draw_location_dot(
postit, location_dot_array,
horizon_x_buffer + (count - 3) * horizon_space,
postit_height - horizon_y_buffer - location_height, True)
elif count == 6:
draw_location_dot(postit, location_dot_array, horizon_y_buffer,
postit_height / 2 - location_width / 2,
False)
elif count == 7:
draw_location_dot(
postit, location_dot_array,
postit_width - horizon_y_buffer - location_height,
postit_height / 2 - location_width / 2, False)
#need reed solomon
rs = RSCodec(14)
rs_result = rs.encode([i])
#make bit array
bit_array_all = []
for number in rs_result:
#print number
bit_array = [0 for j in range(0, bit_num)]
for j in range(0, bit_num - 1):
if number & 2**j != 0:
bit_array[j] = 1
bit_array[bit_num - 1] = bit_array[0]
bit_array_all.append(bit_array)
#draw bit array
draw_all_bit(bit_array_all, postit)
#outer rectangle
cv2.rectangle(postit, (0, 0), (postit_width - 1, postit_height - 1), 0,
1)
#cv2.imshow("result", postit)
#cv2.waitKey(0)
filename = "./datas/postit/postit" + str(i) + ".jpg"
cv2.imwrite(filename, postit)
def encode(string, coding):
#encode the text in bytes
in_bytes = string.encode("utf-8")
#compress the bytes
compressed = zlib.compress(in_bytes, 9)
# if coding!=0, add error correcting code
if(coding):
rs = RSCodec(coding)
compressed = rs.encode(compressed)
return compressed
def test_long(self):
rs = RSCodec(10)
msg = bytearray("a" * 10000, "utf8")
enc = rs.encode(msg)
dec = rs.decode(enc)
self.assertEqual(dec, msg)
enc[177] = 99
enc[2212] = 88
dec2 = rs.decode(enc)
self.assertEqual(dec2, msg)
def test_correction(self):
rs = RSCodec(10)
msg = bytearray("hello world " * 10, "utf8")
enc = rs.encode(msg)
self.assertEqual(rs.decode(enc), msg)
for i in [27, -3, -9, 7, 0]:
enc[i] = 99
self.assertEqual(rs.decode(enc), msg)
enc[82] = 99
self.assertRaises(ReedSolomonError, rs.decode, enc)
def test_long(self):
rs = RSCodec(10)
msg = bytearray("a" * 10000, "utf8")
enc = rs.encode(msg)
dec = rs.decode(enc)
self.assertEqual(dec, msg)
enc[177] = 99
enc[2212] = 88
dec2 = rs.decode(enc)
self.assertEqual(dec2, msg)
def test_correction(self):
rs = RSCodec(10)
msg = bytearray("hello world " * 10, "utf8")
enc = rs.encode(msg)
self.assertEqual(rs.decode(enc), msg)
for i in [27, -3, -9, 7, 0]:
enc[i] = 99
self.assertEqual(rs.decode(enc), msg)
enc[82] = 99
self.assertRaises(ReedSolomonError, rs.decode, enc)
def listen_linux(frame_rate=44100, interval=0.1):
mic = alsaaudio.PCM(alsaaudio.PCM_CAPTURE,
alsaaudio.PCM_NORMAL,
device="default")
mic.setchannels(1)
mic.setrate(44100)
mic.setformat(alsaaudio.PCM_FORMAT_S16_LE)
num_frames = int(round((interval / 2) * frame_rate))
mic.setperiodsize(num_frames)
print("start...")
in_packet = False
packet = []
while True:
l, data = mic.read()
if not l:
continue
chunk = np.fromstring(data, dtype=np.int16)
dom = dominant(frame_rate,
chunk) #소리를 주파수로 변환하는 함수(dominant), 소리에 맞게 주파수를 분리
if in_packet and match(dom, HANDSHAKE_END_HZ): #끝 주파수를 수신함
byte_stream = extract_packet(
packet) #주파수의 묶음을 데이터로 바꿔줌(extract packet)
try:
byte_stream = RSCodec(FEC_BYTES).decode(
byte_stream) #RSCodec 함수로 FEC_BYTES 디코딩
byte_stream = byte_stream.decode("utf-8") #문자값으로로 디코딩
#print(byte_stream)
if byte_stream[:9] == number: #학번이 입력되면
#print(byte_stream[:9])
display(byte_stream[9:]) #학번 이후부터 결과출력
byte_stream = byte_stream[9:]
# print(byte_stream[9:])
byte_stream = byte_stream.encode("utf-8") #아스키코드값으로 인코딩
byte_stream = RSCodec(FEC_BYTES).encode(
byte_stream) #RSCodec 함수로 FEC_BYTES 인코딩
make_sound(byte_stream) #make_sound함수 호출
except ReedSolomonError as e:
pass
#print("{}: {}".format(e, byte_stream))
packet = []
in_packet = False
elif in_packet:
packet.append(dom) #주파수를 받음
elif match(dom, HANDSHAKE_START_HZ):
in_packet = True
class RSCode:
""" Reed-Solomon encoder and decoder """
def __init__(self, num_ec=None):
""" Create R.S. Code with given number of EC symbols. corrects num_ec / 2 errors. """
self.num_ec = num_ec or config.RS_NUM_EC
self.coder = RSCodec(self.num_ec)
def encode(self, bitarr):
output = []
bitarr_bytes = _bitarr2bytes(bitarr, 8, 8)
encoded = self.coder.encode(bitarr_bytes)
output = _bytes2bitarr(encoded)
return output
def decode(self, bitarr, starts_to_try=10):
if not bitarr:
print('warning: empty block received')
return
# sometimes we have extra bytes at the beginning, fix that by bruteforcing
for offs in range(starts_to_try):
try:
if len(bitarr) % 8:
# cut off unaligned
bitarr_trim = bitarr[:-len(bitarr) % 8]
else:
bitarr_trim = bitarr
if config.DEBUG:
import os.path
decoded = bitarr_trim[:]
if os.path.exists('_actual_message.npy'):
if offs:
print('reed-solomon offset =', offs)
actual = np.load('_actual_message.npy')
while len(decoded) > len(actual):
decoded.pop()
while len(decoded) < len(actual):
decoded.append(0)
Y = np.array(decoded)
X = np.array(actual)
bitwise_errs = np.sum(np.abs(Y - X))
X = X.reshape(-1, 8)
Y = Y.reshape(-1, 8)
errs = np.sum(np.any(X != Y, axis=1))
#print(X)
#print(Y)
print('bit errors', bitwise_errs, '=', bitwise_errs / len(decoded))
print('byte errors', errs, '=', errs / (len(decoded) // 8))
bitarr_bytes = _bitarr2bytes(bitarr_trim, None)
decoded = self.coder.decode(bitarr_bytes)[0]
output = _bytes2bitarr(decoded)
return _unpad(output, 8)
except:
bitarr = bitarr[8:]
raise Exception('FATAL: reed-solomon decoding failed')
def listen_linux(frame_rate=44100, interval=0.1):
mic = alsaaudio.PCM(alsaaudio.PCM_CAPTURE, alsaaudio.PCM_NORMAL)
mic.setchannels(1)
mic.setrate(44100)
mic.setformat(alsaaudio.PCM_FORMAT_S16_LE)
num_frames = int(round((interval / 2) * frame_rate))
mic.setperiodsize(num_frames)
print("start...")
in_packet = False
packet = []
while True:
l, data = mic.read()
if not l:
continue
chunk = np.fromstring(data, dtype=np.int16)
dom = dominant(frame_rate, chunk)
if in_packet and match(dom, HANDSHAKE_END_HZ):
byte_stream = extract_packet(packet)
print("original code", byte_stream)
if match_num(byte_stream) == False:
break
try:
byte_stream = RSCodec(FEC_BYTES).decode(byte_stream)
byte_stream = byte_stream.decode("utf-8")
print(byte_stream)
byte_stream = byte_stream.replace("201702087", "")
display(byte_stream)
display("")
sin_freq = []
byte_stream = byte_stream.encode("utf-8")
byte_stream = RSCodec(FEC_BYTES).encode(byte_stream)
sin_freq = make_freq(byte_stream, sin_freq)
print(sin_freq)
make_sound(sin_freq)
except ReedSolomonError as e:
print("{}: {}".format(e, byte_stream))
packet = []
in_packet = False
elif in_packet:
packet.append(dom)
elif match(dom, HANDSHAKE_START_HZ):
in_packet = True
class PublicCode:
def __init__(self):
self.n = 78 * 768
self.inner_code = RSCodec(78 - 32)
self.outer_code = ReedMuller(6)
def encode(self, msg):
return self.outer_code.encode(self.inner_code.encode(msg))
def decode(self, msg):
return self.inner_code.decode(self.outer_code.decode(msg))
def _genErrorCorrection(self, codewords):
""" Turn codewords into error-corrected data groups """
# Get EC info
block_info = QRCode.BLOCK_LIST[self.version - 1][self.ecc]
# Split into groups of blocks
groups = ([], [])
first_block_size = block_info[2]
for block in range(block_info[1]):
groups[0].append(codewords[first_block_size *
block:first_block_size * (block + 1)])
# Same for second group
if len(
block_info
) == 5: # There will be 5 elements in the info tuple if there are 2 groups
offset = first_block_size * block_info[1]
second_block_size = block_info[4]
for block in range(block_info[3]):
groups[1].append(
codewords[offset + second_block_size * block:offset +
second_block_size * (block + 1)])
# Do first group's error correction
ec_groups = ([], [])
ecc_codewords = block_info[0]
rscodec = RSCodec(ecc_codewords)
for b in range(len(groups[0])):
# Get full error corrected (EC) codewords as bytes and extract only EC bytes
ecBytes = rscodec.encode(groups[0][b])[block_info[2]:]
# Append to list of EC codewords
ec_groups[0].append(ecBytes)
# Do second group's error correction
if len(block_info) == 5:
for b in range(len(groups[1])):
# Same thing as for first group
ecBytes = rscodec.encode(groups[1][b])[block_info[4]:]
ec_groups[1].append(ecBytes)
return groups, ec_groups
class Sender:
def __init__(self, msg, encode_method, bits_per_packet):
self.msg = msg
self.encode_method = encode_method
self.bits_per_packet = bits_per_packet
self.counter = 0
self.rsc = RSCodec(SALOMON_DEPTH)
def get_encoded_msg(self):
while len(self.msg) >= (self.counter + 1) * self.bits_per_packet:
if self.encode_method == TRIPLE:
yield self._get_triple_packet()
elif self.encode_method == HAMMING:
yield self._get_hamming_packet()
elif self.encode_method == SALOMON:
yield self._get_salomon_packet()
else:
raise
def _get_triple_packet(self):
packet_start = self.counter * self.bits_per_packet
packet_end = (self.counter + 1) * self.bits_per_packet
packet = self.msg[packet_start:packet_end]
encoded_packet = []
for bit in packet:
for i in range(MULTIPLIER):
encoded_packet.append(bit)
self.counter += 1
return encoded_packet
def _get_hamming_packet(self):
packet_start = self.counter * self.bits_per_packet
packet_end = (self.counter + 1) * self.bits_per_packet
packet = self.msg[packet_start:packet_end]
number = ImageBitParser.bit_array_to_number(packet)
encoded_packet = [
int(bit)
for bit in hamming_codec.encode(number, self.bits_per_packet)
]
self.counter += 1
return encoded_packet
def _get_salomon_packet(self):
packet_start = self.counter * self.bits_per_packet
packet_end = (self.counter + 1) * self.bits_per_packet
packet = self.msg[packet_start:packet_end]
encoded_value = self.rsc.encode(packet)
for number in encoded_value[self.bits_per_packet:]:
packet += ImageBitParser.number_to_bit_array(number, 8)
self.counter += 1
return packet
def trame(data, conf):
out = bytearray([conf["trame"]["startbyte"]])
for i, val in enumerate(data): # Concaténation des valeurs des capteurs
out += struct.pack(str("!"+ conf["sensors"][i]), *val)
out += bytearray([functools.reduce(operator.xor, out)])
rs = RSCodec(conf["trame"]["ecc"]["length"])
out = rs.encode(out)
return out
def dna_reed_solomon_encode(txt: typing.Union[bytes, str, bytearray],
number_repair_symbols: int = 2,
c_exp: int = 2,
prim_poly: int = 7) -> bytes:
"""
Warning: dna_reed_solomon_* requires a custom RSCodec version with support for custom c_exp and nsize.
"""
tmp_rscodec = RSCodec(number_repair_symbols,
c_exp=c_exp,
prim=prim_poly,
nsize=2**c_exp - 1)
dec_list = bits_to_dec(txt)
return bytes(tmp_rscodec.encode(dec_list))
def listen_linux(frame_rate=44100, interval=0.1):
mic = alsaaudio.PCM(alsaaudio.PCM_CAPTURE,
alsaaudio.PCM_NORMAL,
device="default")
mic.setchannels(1)
mic.setrate(44100)
mic.setformat(alsaaudio.PCM_FORMAT_S16_LE)
num_frames = int(round((interval / 2) * frame_rate))
mic.setperiodsize(num_frames)
print("start...")
in_packet = False
packet = []
while True:
l, data = mic.read()
if not l:
continue
chunk = np.fromstring(data, dtype=np.int16)
dom = dominant(frame_rate, chunk)
if in_packet and match(dom, HANDSHAKE_END_HZ):
byte_stream = extract_packet(packet)
try:
byte_stream = RSCodec(FEC_BYTES).decode(byte_stream)
byte_stream = byte_stream.decode("utf-8")
if ID in byte_stream:
global result_stream
#print(byte_stream)
result_stream = byte_stream.replace(ID, '')
result_stream = result_stream.strip()
rs = RSCodec(4)
result_stream = rs.encode(result_stream)
print(result_stream)
play_linux()
display(byte_stream)
except ReedSolomonError as e:
pass
#print("{}: {}".format(e, byte_stream))
packet = []
in_packet = False
elif in_packet:
packet.append(dom)
elif match(dom, HANDSHAKE_START_HZ):
in_packet = True
class ReedSolomon(AbstractErrorCorrectionCode):
def __init__(self, check_size=3, need_logs=False):
self.check_size = check_size
self.tool = RSCodec(check_size)
super().__init__(need_logs)
def insert_one(self, input_list):
if len(input_list) % 8 != 0:
raise ValueError("The length of inputted binary segment must be divided by 8!")
byte_list = []
for index in range(0, len(input_list), 8):
byte_list.append(int(str("".join(list(map(str, input_list[index: index + 8])))), 2))
output_list = []
for one_byte in list(self.tool.encode(byte_list)):
temp_bits = list(map(int, list(bin(one_byte))[2:]))
temp_bits = [0 for _ in range(8 - len(temp_bits))] + temp_bits
output_list += temp_bits
return output_list
def remove_one(self, input_list):
original_input_list = copy.deepcopy(input_list)
byte_list = []
for index in range(0, len(input_list), 8):
byte_list.append(int(str("".join(list(map(str, input_list[index: index + 8])))), 2))
try:
decode_byte_list = list(self.tool.decode(byte_list))
# fix error in Linux or Mac OS, TypeError: 'bytearray' object cannot be interpreted as an integer
if type(decode_byte_list[0]) is not int:
decode_byte_list = list(decode_byte_list[0])
output_list = []
for one_byte in list(decode_byte_list):
temp_bits = list(map(int, list(bin(one_byte))[2:]))
temp_bits = [0 for _ in range(8 - len(temp_bits))] + temp_bits
output_list += temp_bits
except ReedSolomonError:
# Irreparable
return {"data": original_input_list, "type": False}
except IndexError:
# No data acquisition
return {"data": original_input_list, "type": False}
return {"data": output_list, "type": True}
def rsencode(msg):
'''
msg: 二进制流
'''
# msg = '00110001001100100011001100110100001101010011011000110111'
# return msg
while len(msg) % 7:
msg += '0'
temp = ''
for i in range(0, len(msg), 7):
temp += chr(int(msg[i:i + 7], 2))
ecc = RSCodec(96)
byte_msg = ecc.encode(temp)
rscode = byte_msg[len(temp):]
binary_code = ''.join(format(x, '08b') for x in rscode)
return msg + binary_code
def distrupt_message(message):
"""Distrupt a given message."""
length = len(message)
rsc = RSCodec(length)
b = bytearray()
b.extend(map(ord, message))
b_arr = rsc.encode(b)
disrupted_arr = bytearray()
count = 0
for a in b_arr:
if count < length and count % 3 == 0:
a = 88
disrupted_arr.append(a)
count += 1
disrupted_string = disrupted_arr[0:length].decode("utf-8")
return (disrupted_string, disrupted_arr, length)
class reed_solomon_stream:
def __init__(self, f, ec=30, chunk_size=155, mode='read', on_failure=None):
if mode not in ['read', 'write']:
raise Exception('bad bit_file mode. Try "read" or "write"')
self.mode = mode
self.rsc = RSCodec(ec, nsize=chunk_size, fcr=1, prim=0x187)
self.chunk_size = chunk_size
self.empty_chunk = b'\0' * (chunk_size -
ec) if on_failure is None else on_failure
if isinstance(f, str):
fmode = 'wb' if mode == 'write' else 'rb'
self.f = open(f, fmode)
else:
self.f = f
@property
def closed(self):
return self.f.closed
def __enter__(self):
return self
def __exit__(self, type, value, traceback):
if not self.f.closed:
with self.f: # close file
pass
def write(self, buffer):
i = 0
while i < len(buffer):
bu = buffer[i:i + self.chunk_size]
try:
decoded = bytes(self.rsc.decode(bu)[0])
self.f.write(decoded)
except:
print(f'failed decode at {i}')
self.f.write(self.empty_chunk)
i += self.chunk_size
def read(self, max_bytes):
raw = self.f.read(max_bytes)
return self.rsc.encode(raw)
def generateWave(data):
deleteOldWavs()
recordStartChar()
rs = RSCodec(10)
dataHex = data.encode("ascii")
dataHex = rs.encode(dataHex)
dataHex = hexlify(dataHex)
index = 1
for c in dataHex:
if index is ((len(data)+1)*2):
recordSineWave(index, DELIMITER_FREQUENCY, DATA_PERIOD_MS)
index = index + 1
recordSineWave(index, NOTES[c], DATA_PERIOD_MS)
index = index + 1
recordStopChar(index)
combineWavs(index+1)
def code(data):
data = bytes(data, encoding='utf8')
rsc = RSCodec(10)
coded_data = rsc.encode(data)
binary_coded_data = ''
for byte in coded_data:
binary = bin(byte)[2::]
binary = '0' * (8 - len(binary)) + binary
binary_coded_data += binary
quart_coded_data = '0123'
for i in range(0, len(binary_coded_data), 2):
byte_pair = binary_coded_data[i] + binary_coded_data[i + 1]
if byte_pair == '00':
quart_coded_data += '0'
elif byte_pair == '01':
quart_coded_data += '1'
elif byte_pair == '10':
quart_coded_data += '2'
elif byte_pair == '11':
quart_coded_data += '3'
else:
raise ValueError
quart_coded_data += '3333'
return quart_coded_data
class Packetizer():
def __init__(self, callsign):
self.sequenceId = 0
callsignLen = 6 if len(callsign) > 6 else len(callsign)
self.callsign = bytes(
callsign[:callsignLen].upper() + ' ' * (6 - len(callsign)),
'utf-8')
self.rs = RSCodec(16)
def createPacket(self, data=b''):
packet = bytearray()
# Header (1 byte - added after padding)
# Callsign (6 bytes)
packet += self.callsign
# Length (2 bytes)
dataLen = len(data)
packet += bytes([(dataLen & 0xFF00) >> 8, dataLen & 0xFF])
# Sequence ID (2 bytes)
packet += bytes([(self.sequenceId & 0xFF00) >> 8,
self.sequenceId & 0xFF])
self.sequenceId = (self.sequenceId + 1) & 0xFFFF
# payload (unknown length)
packet += data
# CRC and footer (CRC MSB, CRC LSB) (2 bytes)
crcCalculator = CRC16()
crc = crcCalculator.calculate(bytes(packet))
packet += bytes([(crc & 0xFF00) >> 8, crc & 0xFF])
cobs_packet = cobs.encode(packet)
encoded_packet = self.rs.encode(cobs_packet)
return bytes([0]) + encoded_packet + bytes([0])
class Watermarker(object):
EPSILON = 0.001
def __init__(self, max_payload, ec_bytes, seed=1910819922, mother="haar"):
self.mother = mother
self.rscodec = RSCodec(ec_bytes)
self.max_payload = max_payload
self.total_bits = (max_payload + ec_bytes) * 8
rand = Random(seed)
chunk_size = 3000
while True:
self.seq0 = numpy.array(
[int(rand.random() > 0.8) for _ in range(chunk_size)])
self.seq1 = numpy.array(
[int(rand.random() > 0.75) for _ in range(chunk_size)])
corr, _ = pearsonr(self.seq0, self.seq1)
if corr < self.EPSILON:
break
def _embed(self, img, payload, k):
cA, (cH, cV, cD) = dwt2(img, self.mother)
target = cD.reshape(cD.size)
chunk_size = target.size // self.total_bits
sequence_of = (self.seq0[:chunk_size], self.seq1[:chunk_size])
for i, bit in enumerate(iterbits(payload)):
seq = sequence_of[bit]
#chunk = target[i::self.total_bits][:seq.size]
chunk = target[i * chunk_size:i * chunk_size + seq.size]
chunk += k * seq
return idwt2((cA, (cH, cV, target.reshape(cH.shape))),
self.mother)[:img.shape[0], :img.shape[1]]
def embed(self, img, payload, k):
if len(payload) > self.max_payload:
raise ValueError("payload too long")
payload = bytearray(payload) + "\x00" * (self.max_payload -
len(payload))
encoded = self.rscodec.encode(payload)
if len(img.shape) == 2:
return self._embed(img, encoded, k)
elif len(img.shape) == 3:
output = numpy.zeros(img.shape)
for i in range(img.shape[2]):
output[:, :, i] = self._embed(img[:, :, i], encoded, k)
return output
else:
raise TypeError("img must be a 2d or 3d array")
def _extract(self, img):
cA, (cH, cV, cD) = dwt2(img, self.mother)
target = cD.reshape(cD.size)
chunk_size = target.size // self.total_bits
seq0 = self.seq0[:chunk_size]
seq1 = self.seq1[:chunk_size]
byte = 0
output = bytearray()
for i in range(self.total_bits):
chunk = target[i * chunk_size:(i * chunk_size) + seq0.size]
#chunk = target[i::self.total_bits][:seq0.size]
#if not all(chunk[i] == chunk[i+1] for i in range(chunk.size-1)):
corr0, _ = pearsonr(chunk, seq0)
corr1, _ = pearsonr(chunk, seq1)
bit = int(corr1 > corr0)
#else:
# bit = 0
byte = (byte << 1) | bit
if i % 8 == 7:
output.append(byte)
byte = 0
print repr(output)
return output
def extract(self, img):
if len(img.shape) == 2:
return self.rscodec.decode(self._extract(img))
elif len(img.shape) == 3:
for i in range(img.shape[2]):
try:
return self.rscodec.decode(self._extract(img[:, :, i]))
except ReedSolomonError:
pass
return self.rscodec.decode(self._extract(mean(img, 2)))
else:
raise TypeError("img must be a 2d or 3d array")
def test_simple(self):
rs = RSCodec(10)
msg = bytearray("hello world " * 10, "utf8")
enc = rs.encode(msg)
dec = rs.decode(enc)
self.assertEqual(dec, msg)
def decode_rs(fragments):
fragment_lengths = ", ".join(["{}:{}".format(i, len(f)) for i,f in enumerate(fragments)])
p.pr("RS decode {} fragments of length {}".format(
len(fragments), fragment_lengths))
#for f in fragments:
# p.hexpr(" ZE FRAGMENT", f);
# Transpose fragments to get an RS block
rs_block = "".join("".join(f) for f in zip(*fragments))
# chunks before protection have size chunk_size
# protection adds 48 bytes
# The tuples here are (data, parity)
#p.hexpr(" ZE RS BLOCK", "".join(rs_block))
num_chunks = len(rs_block) / chunk_size
data_size = chunk_size + 48
af_packet_size = num_chunks * chunk_size
p.pr("AF Packet size {}".format(af_packet_size))
# Cut the block into list of (data, protection) tuples
rs_chunks = [ (rs_block[i*data_size:i*data_size + chunk_size],
rs_block[i*data_size + chunk_size:(i+1)*data_size])
for i in range(num_chunks)]
chunk_lengths = ", ".join(["{}:{}+{}".format(i, len(c[0]), len(c[1])) for i,c in enumerate(rs_chunks)])
p.pr("{} chunks of length {}".format(num_chunks, chunk_lengths))
#for c in rs_chunks:
# p.hexpr(" ZE CHUNK DATA", c[0]);
# p.hexpr(" ZE CHUNK PROT", c[1]);
if verify_protection:
rs_codec = RSCodec(48, fcr=1)
protection_ok = True
for chunk, protection in rs_chunks:
#p.pr(" Protection")
#p.hexpr(" OF ZE CHUNK DATA", chunk);
bchunk = bytearray(chunk)
padbytes = 255-(48 + len(chunk))
bchunk = bchunk + bytearray(0 for i in range(padbytes))
recalc_protection = rs_codec.encode(bchunk)[-48:]
if protection != recalc_protection:
p.pr(" PROTECTION ERROR")
p.hexpr(" data", chunk)
p.hexpr(" orig", protection)
p.hexpr(" calc", recalc_protection)
protection_ok = False
else:
p.pr(" PROTECTION OK")
if protection_ok:
p.pr("Protection check: OK")
afpacket = "".join(data for (data, protection) in rs_chunks)
#p.hexpr(" ZE AF PACKET", afpacket)
if zeropad:
return decode_af(afpacket[0:-zeropad])
else:
return decode_af(afpacket)
class Watermarker(object):
def __init__(self, max_payload, ec_bytes, seed = 1895746671, mother = "bior3.1", sparsity = 0.7):
self.mother = mother
self.sparsity = sparsity
self.rscodec = RSCodec(ec_bytes)
self.max_payload = max_payload
self.total_bits = (max_payload + ec_bytes) * 8
self.seed = seed
'''
def _interleave(self, cH, cV, cD):
vec = numpy.zeros(cH.size + cV.size + cD.size)
rcH = cH.ravel()
lH = cH.size
rcV = cV.ravel()
lV = cH.size + cV.size
rcD = cD.ravel()
rand = Random(self.seed)
indexes = range(vec.size)
rand.shuffle(indexes)
for i, j in enumerate(indexes):
vec[i] = rcD[j - lV] if j >= lV else (rcV[j - lH] if j >= lH else rcH[j])
return vec
def _deinterleave(self, vec, cH, cV, cD):
cH2 = numpy.zeros(cH.shape)
rcH = cH2.ravel()
lH = cH.size
cV2 = numpy.zeros(cV.shape)
rcV = cV2.ravel()
lV = cH.size + cV.size
cD2 = numpy.zeros(cD.shape)
rcD = cD2.ravel()
rand = Random(self.seed)
indexes = range(vec.size)
rand.shuffle(indexes)
for i, v in enumerate(vec):
j = indexes[i]
if j >= lV:
rcD[j -lV] = v
elif j >= lH:
rcV[j - lH] = v
else:
rcH[j] = v
return cH2, cV2, cD2
'''
@classmethod
def _interleave(cls, cH, cV, cD):
vec = numpy.zeros(cH.size + cV.size + cD.size, dtype = float)
vec[0::3] = cH.ravel()
vec[1::3] = cV.ravel()
vec[2::3] = cD.ravel()
return vec
@classmethod
def _deinterleave(cls, vec, cH, cV, cD):
return vec[0::3].reshape(cH.shape), vec[1::3].reshape(cV.shape), vec[2::3].reshape(cD.shape)
def _generate_sequences(self, chunk_size):
rand = Random(self.seed)
seq0 = numpy.array([int(rand.random() >= self.sparsity) for _ in range(chunk_size)])
seq1 = seq0[::-1]
return seq0, seq1
def _embed(self, img, payload, k):
cA, (cH, cV, cD) = dwt2(img.astype(float), self.mother)
vec = self._interleave(cH, cV, cD)
chunk_size = vec.size // self.total_bits
sequences = self._generate_sequences(chunk_size)
for i, bit in enumerate(iterbits(payload)):
offset = i * chunk_size
vec[offset : offset + chunk_size] += k * sequences[bit]
#vec[i:self.total_bits*chunk_size:self.total_bits] += k * sequences[bit]
w, h = img.shape
cH2, cV2, cD2 = self._deinterleave(vec, cH, cV, cD)
return idwt2((cA, (cH2, cV2, cD2)), self.mother)[:w,:h]
def embed(self, img, payload, k = 6, tv_denoising_weight = 4, rescale = True):
if len(payload) > self.max_payload:
raise ValueError("payload too long")
padded = bytearray(payload) + b"\x00" * (self.max_payload - len(payload))
encoded = self.rscodec.encode(padded)
if img.ndim == 2:
output = self._embed(img, encoded, k)
elif img.ndim == 3:
output = numpy.zeros(img.shape, dtype=float)
for i in range(img.shape[2]):
output[:,:,i] = self._embed(img[:,:,i], encoded, k)
#y, cb, cr = rgb_to_ycbcr(img)
#y2 = self._embed(y, encoded, k)
#cb = self._embed(cb, encoded, k)
#cr = self._embed(cr, encoded, k)
#y2 = rescale_intensity(y2, out_range = (numpy.min(y), numpy.max(y)))
#Cb2 = rescale_intensity(Cb2, out_range = (numpy.min(Cb), numpy.max(Cb)))
#Cr2 = rescale_intensity(Cr2, out_range = (numpy.min(Cr), numpy.max(Cr)))
#output = ycbcr_to_rgb(y2, cb, cr)
else:
raise TypeError("img must be a 2d or 3d array")
#if tv_denoising_weight > 0:
# output = tv_denoise(output, tv_denoising_weight)
if rescale:
output = rescale_intensity(output, out_range = (numpy.min(img), numpy.max(img)))
#return toimage(output,cmin=0,cmax=255)
return output
def _extract(self, img):
cA, (cH, cV, cD) = dwt2(img.astype(float), self.mother)
vec = self._interleave(cH, cV, cD)
chunk_size = vec.size // self.total_bits
seq0, seq1 = self._generate_sequences(chunk_size)
byte = 0
output = bytearray()
for i in range(self.total_bits):
offset = i * chunk_size
chunk = vec[offset: offset + chunk_size]
#chunk = vec[i:self.total_bits*chunk_size:self.total_bits]
corr0, _ = pearsonr(chunk, seq0)
corr1, _ = pearsonr(chunk, seq1)
bit = int(corr1 > corr0)
byte = (byte << 1) | bit
if i % 8 == 7:
output.append(byte)
byte = 0
return output
def _try_decode(self, payload):
try:
return self.rscodec.decode(payload)
except ReedSolomonError:
rpayload = bytearray(b ^ 255 for b in payload)
return self.rscodec.decode(rpayload)
def extract(self, img):
if img.ndim == 2:
return self._try_decode(self._extract(img))
elif img.ndim == 3:
for i in range(img.shape[2]):
try:
return self._try_decode(self._extract(img[:,:,i]))
except ReedSolomonError:
pass
return self._try_decode(self._extract(mean(img, 2)))
else:
raise TypeError("img must be a 2d or 3d array")
class Watermarker(object):
EPSILON = 0.001
def __init__(self, max_payload, ec_bytes, seed = 1910819922, mother = "haar"):
self.mother = mother
self.rscodec = RSCodec(ec_bytes)
self.max_payload = max_payload
self.total_bits = (max_payload + ec_bytes) * 8
rand = Random(seed)
chunk_size = 50000
self.seq0 = numpy.array([int(rand.random() > 0.7) for _ in range(chunk_size)])
self.seq1 = numpy.array(self.seq0[::-1])
def _interleave(self, cH, cV, cD):
arr = numpy.zeros(cH.size + cV.size + cD.size)
sources = [cH.reshape(cH.size), cV.reshape(cV.size), cD.reshape(cD.size)]
for i in range(arr.size):
src = sources[i % 3]
j = i // 3
if j >= src.size:
arr = arr[:i]
break
arr[i] = src[j]
return arr
def _deinterleave(self, arr, cH, cV, cD):
cH2 = numpy.zeros(cH.size)
cV2 = numpy.zeros(cV.size)
cD2 = numpy.zeros(cD.size)
destinations = [cH2, cV2, cD2]
for i in range(arr.size):
destinations[i % 3][i // 3] = arr[i]
return cH2.reshape(cH.shape), cV2.reshape(cV.shape), cD2.reshape(cD.shape)
def _embed(self, img, payload, k):
cA, (cH, cV, cD) = dwt2(img, self.mother)
arr = self._interleave(cH, cV, cD)
chunk_size = arr.size // self.total_bits
sequence_of = (self.seq0[:chunk_size], self.seq1[:chunk_size])
for i, bit in enumerate(iterbits(payload)):
seq = sequence_of[bit]
arr[i * chunk_size: i * chunk_size + seq.size] += k * seq
w, h = img.shape
cH2, cV2, cD2 = self._deinterleave(arr, cH, cV, cD)
return idwt2((cA, (cH2, cV2, cD2)), self.mother)[:w,:h]
def embed(self, img, payload, k):
if len(payload) > self.max_payload:
raise ValueError("payload too long")
padded = bytearray(payload) + b"\x00" * (self.max_payload - len(payload))
encoded = self.rscodec.encode(padded)
if img.ndim == 2:
return self._embed(img, encoded, k)
elif img.ndim == 3:
output = numpy.zeros(img.shape)
for i in range(img.shape[2]):
output[:,:,i] = self._embed(img[:,:,i], encoded, k)
return output
else:
raise TypeError("img must be a 2d or 3d array")
def _extract(self, img):
cA, (cH, cV, cD) = dwt2(img, self.mother)
arr = self._interleave(cH, cV, cD)
chunk_size = arr.size // self.total_bits
seq0 = self.seq0[:chunk_size]
seq1 = self.seq1[:chunk_size]
byte = 0
output = bytearray()
for i in range(self.total_bits):
chunk = arr[i * chunk_size: i * chunk_size + seq0.size]
corr0, _ = pearsonr(chunk, seq0)
corr1, _ = pearsonr(chunk, seq1)
bit = int(corr1 > corr0)
byte = (byte << 1) | bit
if i % 8 == 7:
output.append(byte)
byte = 0
return output
def _try_decode(self, payload):
try:
out = self.rscodec.decode(payload)
except ReedSolomonError:
#print "!!", repr(payload)
try:
rpayload = bytearray(b ^ 255 for b in payload)
out = self.rscodec.decode(rpayload)
except ReedSolomonError:
#print "!!", repr(rpayload)
out = None
return out
def extract(self, img):
if img.ndim == 2:
return self._try_decode(self._extract(img))
elif img.ndim == 3:
for i in range(img.shape[2]):
out = self._try_decode(self._extract(img[:,:,i]))
if out is not None:
return out
return self._try_decode(self._extract(mean(img, 2)))
else:
raise TypeError("img must be a 2d or 3d array")
def main():
# read input args
if len(sys.argv) != 3:
print "usage: " + sys.argv[0] + " outer_size fps"
return -1
outer_size = int(sys.argv[1])
fps = int(sys.argv[2])
# delete old postit image
old_postit_image = os.listdir('./datas/postit_saved/')
for old_postit in old_postit_image:
os.remove('./datas/postit_saved/' + old_postit)
# memory save
gc.enable()
# set parameter
analyse_config = yaml.load(open("./config/analyse_config.yaml", "r"))
dist_thre = analyse_config["dist_thre"]
angle_thre = analyse_config["angle_thre"]
time_thre = analyse_config["time_thre"]
video_save = False
skip_mode = True
# read movie file list
movie_id = 0
movie_files = os.listdir('./datas/movie/')
if len(movie_files) == 0:
print "no movie"
return -1
else:
print "movie files:"
for movie_file_each in movie_files:
print movie_file_each
# video reader and writer
cap = cv2.VideoCapture('./datas/movie/' + movie_files[0])
if video_save:
writer = cv2.VideoWriter("./datas/movie/OUT.avi",
cv2.cv.CV_FOURCC('M', 'J', 'P', 'G'), fps,
(3840, 2160))
# csv_file
csv_every_second = open("./datas/csv/every_second.csv", "w")
csv_final = open("./datas/csv/final.csv", "w")
# reed solomon
rs = RSCodec(14)
# first select the desk area
ret, frame = cap.read()
window_name = "SELECT DESK"
frame_for_select = cv2.resize(
frame, (int(frame.shape[1] * 0.2), int(frame.shape[0] * 0.2)))
print "Please select left-top and right-down"
cv2.imshow(window_name, frame_for_select)
desk_area = []
cv2.setMouseCallback(window_name, mouse_callback, desk_area)
cv2.waitKey(0)
cv2.destroyWindow(window_name)
desk_area = np.array(desk_area) * 5
# select the mask area
window_name = "SELECT left-top, right-top, right-down"
print "Please select left-top and right-down"
cv2.imshow(
window_name, frame[desk_area[0][1]:desk_area[1][1],
desk_area[0][0]:desk_area[1][0]])
postit_area = []
cv2.setMouseCallback(window_name, mouse_callback, postit_area)
cv2.waitKey(0)
cv2.destroyWindow(window_name)
postit_area_width = np.linalg.norm(
np.array(postit_area[0]) - np.array(postit_area[1]))
postit_area_height = np.linalg.norm(
np.array(postit_area[1]) - np.array(postit_area[2]))
# result file
experiment_result = open("./datas/csv/resolution_result.csv", "w")
experiment_result.write(str(desk_area) + "\n")
# set desk by myself
# desk_area = np.array([[1615, 890], [2110, 1285]])
for movie_id in range(len(movie_files)):
for resolution in range(0, 100):
resolution = float(resolution) * 0.01
print "pattern:" + str(resolution)
time = 0
success_count = 0
postit_saved = {}
cap = cv2.VideoCapture('./datas/movie/' + movie_files[movie_id])
while (1):
# read frame
# print "progress: " + str(time)
ret, frame = cap.read()
if ret == False:
break
# movie_id += 1
# if movie_id < len(movie_files):
# cap = cv2.VideoCapture('./movie/' + movie_files[movie_id])
# ret, frame = cap.read()
# else:
# break
# save frame for final
frame_for_final = np.copy(frame)
# extract only desk area
frame = frame[desk_area[0][1]:desk_area[1][1],
desk_area[0][0]:desk_area[1][0]]
# change resolution
frame = cv2.resize(frame,
(int(frame.shape[1] * (1 - resolution)),
int(frame.shape[0] * (1 - resolution))))
frame_for_save = np.copy(frame)
outer_size_resized = outer_size * ((1 - resolution)**2)
# get postit
getPostits = post_util.getPostits(frame, outer_size_resized)
# postit_image_analyzing = getPostits.postit_image_analyzing
postit_points = getPostits.postit_points
recognized_location_rectangle = getPostits.recognized_location_rectangle
# add buffer
for i in range(0, len(postit_points)):
for j in range(0, len(postit_points[i])):
postit_points[i][j] += desk_area[0]
# read postit's id and save
postit_ids = []
bit_array_list = []
for i in range(0, len(postit_points)):
# postit_image_analyzing = cv2.imread("./postit_tmp_analyzing/" + str(i) + ".jpg")
postit_image_analyzing = np.load(
"./tmp_datas/postit_tmp_analyzing/" + str(i) + ".npy")
bit_array = post_util.readDots(
postit_image_analyzing).bit_array
bit_array_answer = []
for num in rs.encode([62]):
bit_array_answer.append(num)
bit_array_list.append(bit_array)
result_num = -1
try:
result_num = rs.decode(bit_array)[0]
except:
result_num = -1
# success check
# if (recognized_location_rectangle == 8) and bit_array_answer == bit_array:
# success_count += 1
recognized_id_rectangle = 0
for each_bit in zip(bit_array_answer, bit_array):
if each_bit[0] == each_bit[1]:
recognized_id_rectangle += 1
success_count += recognized_id_rectangle + recognized_location_rectangle
postit_ids.append(result_num)
# save postit image
if result_num != -1:
# already exist
if postit_saved.has_key(result_num):
# judge move and rotate
# calc dist
dist = np.linalg.norm(
np.mean(postit_saved[result_num]
["points_saved"],
axis=0) -
np.mean(postit_points[i], axis=0))
# calc angle(degree)
angle_vec_before = np.array(
postit_saved[result_num]["points_saved"][0]
) - np.array(
postit_saved[result_num]["points_saved"][1])
angle_vec_after = np.array(
postit_points[i][0]) - np.array(
postit_points[i][1])
vec_cos = np.dot(
angle_vec_before, angle_vec_after) / (
np.linalg.norm(angle_vec_before) *
np.linalg.norm(angle_vec_after))
angle = np.arccos(vec_cos) * 180 / np.pi
# add information
if dist > dist_thre:
if len(postit_saved[result_num]["move"]) == 0:
postit_saved[result_num]["move"].append(
time / fps)
elif (time / fps -
postit_saved[result_num]["move"][-1]
) > 5:
postit_saved[result_num]["move"].append(
time / fps)
elif angle > angle_thre:
if len(postit_saved[result_num]
["rotate"]) == 0:
postit_saved[result_num]["rotate"].append(
time / fps)
elif (time / fps -
postit_saved[result_num]["rotate"][-1]
) > 5:
postit_saved[result_num]["rotate"].append(
time / fps)
# renew
postit_saved[result_num]["points"] = postit_points[
i]
postit_saved[result_num][
"points_saved"] = postit_points[i]
postit_saved[result_num]["last_time"] = time / fps
# first appear
else:
postit_saved[result_num] = {
"points": postit_points[i],
"points_saved": postit_points[i],
"first_time": time / fps,
"last_time": time / fps,
"move": [],
"rotate": []
}
postit_image_for_save = cv2.imread(
"./tmp_datas/postit_tmp/" + str(i) + ".jpg")
cv2.imwrite(
"./datas/postit_saved/" + str(result_num) +
".jpg", postit_image_for_save)
# delete old postit(long time no see)
for id, val in postit_saved.items():
if (time / fps - val["last_time"]) > time_thre:
postit_saved[id]["points"] = [[-5, 0], [0, 0], [0, -5],
[-5, -5]]
# write csv
csv_util.write_every_second(postit_saved, csv_every_second)
# memory save
del getPostits
gc.collect()
# key waiting
key = cv2.waitKey(1)
if key == 27:
break
# when drawing dict info
for key in postit_saved:
cv2.drawContours(
frame_for_final,
[np.array(postit_saved[key]["points"]).astype(np.int)],
0, (0, 0, 220), 2)
cv2.putText(frame_for_final, str(key),
(np.mean(postit_saved[key]["points"],
axis=0).astype(np.int)[0] - 40,
np.mean(postit_saved[key]["points"],
axis=0).astype(np.int)[1]),
cv2.FONT_HERSHEY_PLAIN, 5.0, (0, 140, 0), 5)
show_img_final = cv2.resize(
frame_for_final, (int(frame_for_final.shape[1] * 0.3),
int(frame_for_final.shape[0] * 0.3)))
cv2.imshow("show2", show_img_final)
# add time
time += 1
if time > 23:
break
# final save
csv_util.write_final(postit_saved, csv_final)
# print success rate
experiment_result.write(
str(int(postit_area_height * (1 - resolution))) + "," +
str(int(postit_area_width * (1 - resolution))) + "," +
str(time) + "," + str(success_count) + "," +
str(float(success_count) / time) + "\n")
cv2.imwrite("./datas/postit_saved/frame.jpg", frame_for_save)
print "-----success result------"
print "resolution:" + str(
int(postit_area_height * (1 - resolution))) + "," + str(
int(postit_area_width * (1 - resolution)))
print "success count: " + str(success_count)
print "time:" + str(time)
print "success rate: " + str(float(success_count) / time)
class Watermarker(object):
def __init__(self, max_payload, ec_bytes, seed = 1895746671, mother = "bior3.1", sparsity = 0.7):
self.mother = mother
self.sparsity = sparsity
self.rscodec = RSCodec(ec_bytes)
self.max_payload = max_payload
self.total_bits = (max_payload + ec_bytes) * 8
self.seed = seed
@classmethod
def _interleave(cls, cH, cV, cD):
vec = numpy.zeros(cH.size + cV.size + cD.size, dtype = float)
vec[0::3] = cH.ravel()
vec[1::3] = cV.ravel()
vec[2::3] = cD.ravel()
return vec
@classmethod
def _deinterleave(cls, vec, cH, cV, cD):
return vec[0::3].reshape(cH.shape), vec[1::3].reshape(cV.shape), vec[2::3].reshape(cD.shape)
def _generate_sequences(self, chunk_size):
rand = Random(self.seed)
seq0 = numpy.array([int(rand.random() >= self.sparsity) for _ in range(chunk_size)])
seq1 = seq0[::-1]
return seq0, seq1
def _embed(self, img, payload, k):
cA, (cH, cV, cD) = dwt2(img.astype(float), self.mother)
vec = self._interleave(cH, cV, cD)
chunk_size = vec.size // self.total_bits
sequences = self._generate_sequences(chunk_size)
for i, bit in enumerate(iterbits(payload)):
offset = i * chunk_size
vec[offset : offset + chunk_size] += k * sequences[bit]
#vec[i : self.total_bits*chunk_size : self.total_bits] += k * sequences[bit]
w, h = img.shape
cH2, cV2, cD2 = self._deinterleave(vec, cH, cV, cD)
return idwt2((cA, (cH2, cV2, cD2)), self.mother)[:w,:h]
def embed(self, img, payload, k = 4, rescale_color = True):
if len(payload) > self.max_payload:
raise ValueError("payload too long")
padded = bytearray(payload) + b"\x00" * (self.max_payload - len(payload))
encoded = self.rscodec.encode(padded)
if img.ndim == 2:
output = self._embed(img, encoded, k)
elif img.ndim == 3:
output = numpy.zeros(img.shape, dtype=float)
for i in range(img.shape[2]):
output[:,:,i] = self._embed(img[:,:,i], encoded, k)
else:
raise TypeError("img must be a 2d or 3d array")
if rescale_color:
output = rescale_intensity(output, out_range = (numpy.min(img), numpy.max(img)))
return output
def _extract(self, img):
cA, (cH, cV, cD) = dwt2(img.astype(float), self.mother)
vec = self._interleave(cH, cV, cD)
chunk_size = vec.size // self.total_bits
seq0, seq1 = self._generate_sequences(chunk_size)
byte = 0
output = bytearray()
for i in range(self.total_bits):
offset = i * chunk_size
chunk = vec[offset: offset + chunk_size]
#chunk = vec[i:self.total_bits*chunk_size:self.total_bits]
corr0, _ = pearsonr(chunk, seq0)
corr1, _ = pearsonr(chunk, seq1)
bit = int(corr1 > corr0)
byte = (byte << 1) | bit
if i % 8 == 7:
output.append(byte)
byte = 0
return output
def _try_decode(self, payload):
try:
return self.rscodec.decode(payload)
except ReedSolomonError:
rpayload = bytearray(b ^ 255 for b in payload)
return self.rscodec.decode(rpayload)
def extract(self, img):
if img.ndim == 2:
return self._try_decode(self._extract(img))
elif img.ndim == 3:
for i in range(img.shape[2]):
try:
return self._try_decode(self._extract(img[:,:,i]))
except ReedSolomonError:
pass
return self._try_decode(self._extract(mean(img, 2)))
else:
raise TypeError("img must be a 2d or 3d array")
class Watermarker(object):
EPSILON = 0.001
def __init__(self, max_payload, ec_bytes, seed = 1910819922, mother = "haar"):
self.mother = mother
self.rscodec = RSCodec(ec_bytes)
self.max_payload = max_payload
self.total_bits = (max_payload + ec_bytes) * 8
rand = Random(seed)
chunk_size = 50000
self.seq0 = numpy.array([int(rand.random() > 0.7) for _ in range(chunk_size)])
self.seq1 = numpy.array(self.seq0[::-1])
#while True:
# self.seq0 = numpy.array([int(rand.random() > 0.8) for _ in range(chunk_size)])
# self.seq1 = numpy.array([int(rand.random() > 0.75) for _ in range(chunk_size)])
# corr, _ = pearsonr(self.seq0, self.seq1)
# if corr < self.EPSILON:
# break
def _embed(self, img, payload, k):
cA, (cH, cV, cD) = dwt2(img, self.mother)
cH2 = cH.reshape(cH.size)
cV2 = cV.reshape(cV.size)
cD2 = cD.reshape(cD.size)
assert cH2.shape == cV2.shape == cD2.shape
chunk_size = (cH2.size * 3) // (self.total_bits)
sequence_of = (self.seq0[:chunk_size], self.seq1[:chunk_size])
buffers = (cH2, cV2, cD2)
for i, bit in enumerate(iterbits(payload)):
seq = sequence_of[bit]
target = buffers[i % 3]
offset = (i//3) * chunk_size
target[offset:offset + seq.size] += k * seq
w, h = img.shape
return idwt2((cA, (cH2.reshape(cH.shape), cV2.reshape(cV.shape), cD2.reshape(cD.shape))), self.mother)[:w,:h]
def embed(self, img, payload, k):
if len(payload) > self.max_payload:
raise ValueError("payload too long")
padded = bytearray(payload) + b"\x00" * (self.max_payload - len(payload))
encoded = self.rscodec.encode(padded)
if len(img.shape) == 2:
return self._embed(img, encoded, k)
elif len(img.shape) == 3:
output = numpy.zeros(img.shape)
for i in range(img.shape[2]):
output[:,:,i] = self._embed(img[:,:,i], encoded, k)
return output
else:
raise TypeError("img must be a 2d or 3d array")
def _extract(self, img):
cA, (cH, cV, cD) = dwt2(img, self.mother)
cH2 = cH.reshape(cH.size)
cV2 = cV.reshape(cV.size)
cD2 = cD.reshape(cD.size)
assert cH2.shape == cV2.shape == cD2.shape
buffers = (cH2, cV2, cD2)
chunk_size = (cH2.size * 3) // (self.total_bits)
seq0 = self.seq0[:chunk_size]
seq1 = self.seq1[:chunk_size]
byte = 0
output = bytearray()
for i in range(self.total_bits):
target = buffers[i % 3]
offset = (i//3) * chunk_size
chunk = target[offset : offset + seq0.size]
corr0, _ = pearsonr(chunk, seq0)
corr1, _ = pearsonr(chunk, seq1)
bit = int(corr1 > corr0)
byte = (byte << 1) | bit
if i % 8 == 7:
output.append(byte)
byte = 0
#print repr(output)
return output
def extract(self, img):
if len(img.shape) == 2:
return self.rscodec.decode(self._extract(img))
elif len(img.shape) == 3:
for i in range(img.shape[2]):
try:
return self.rscodec.decode(self._extract(img[:,:,i]))
except ReedSolomonError:
pass
return self.rscodec.decode(self._extract(mean(img, 2)))
else:
raise TypeError("img must be a 2d or 3d array")
class Watermarker(object):
def __init__(self, msg_bytes, ec_bytes, seed, mother = "haar"):
self.mother = mother
self.rscodec = RSCodec(ec_bytes)
self.msg_bytes = msg_bytes
self.total_bits = (msg_bytes + ec_bytes) * 8
rand = Random(seed)
#self.mask = [rand.randint(0,255) for _ in range(msg_bytes + ec_bytes)]
self.mask = [0] * (msg_bytes + ec_bytes)
chunk_size = 256*512 // self.total_bits
espilon = 0.0001
while True:
self.seq0 = numpy.array([int(rand.random() > 0.75) for _ in range(chunk_size)])
self.seq1 = numpy.array([int(rand.random() > 0.7) for _ in range(chunk_size)])
corr, _ = pearsonr(self.seq0, self.seq1)
if abs(corr) < espilon:
break
def _embed(self, img, payload, k):
cA, (cH, cV, cD) = dwt2(img, self.mother)
w, h = cH.shape
cH2 = cH.reshape(cH.size)
cV2 = cV.reshape(cV.size)
chunk_size = cH2.size // (self.total_bits // 2)
assert chunk_size >= self.seq0.size
for i, bit in enumerate(iterbits(payload)):
dst = (cH2, cV2)[i % 2]
seq = (self.seq0, self.seq1)[bit]
dst[(i//2)*chunk_size:(i//2)*chunk_size + seq.size] += k * seq
return idwt2((cA, (cH2.reshape(w, h), cV2.reshape(w, h), cD)), self.mother)[:img.shape[0],:img.shape[1]]
def embed(self, img, payload, k = 10):
if len(payload) > self.msg_bytes:
raise ValueError("payload too long")
if isinstance(payload, str):
payload = bytearray(payload)
payload.extend([0] * (self.msg_bytes - len(payload)))
encoded = self.rscodec.encode(payload)
masked = [v ^ m for v, m in zip(encoded, self.mask)]
if len(img.shape) == 2:
return self._embed(img, masked, k)
elif len(img.shape) == 3:
res = numpy.zeros(img.shape)
for i in range(img.shape[2]):
layer = self._embed(img[:,:,i], masked, k)
res[:,:,i] = layer
return res
else:
raise TypeError("image must be a 2d or 3d array")
def _extract(self, img):
cA, (cH, cV, cD) = dwt2(img, self.mother)
w, h = cH.shape
cH2 = cH.reshape(cH.size)
cV2 = cV.reshape(cV.size)
chunk_size = cH2.size // (self.total_bits // 2)
maskiter = iter(self.mask)
payload = bytearray()
byte = 0
for i in range(self.total_bits):
src = (cH2, cV2)[i % 2]
chunk = src[(i//2)*chunk_size:(i//2)*chunk_size + self.seq0.size]
corr0, _ = pearsonr(chunk, self.seq0)
corr1, _ = pearsonr(chunk, self.seq1)
bit = int(corr1 > corr0)
byte = bit | (byte << 1)
if i % 8 == 7:
payload.append(byte ^ maskiter.next())
byte = 0
print repr(payload)
return self.rscodec.decode(payload)
def extract(self, img):
if len(img.shape) == 2:
return self._extract(img)
elif len(img.shape) == 3:
for i in range(img.shape[2]):
try:
return self._extract(img[:,:,i])
except ReedSolomonError:
pass
return self._extract(mean(img, 2))
else:
raise TypeError("image must be a 2d or 3d array")
def test_simple(self):
rs = RSCodec(10)
msg = bytearray("hello world " * 10, "utf8")
enc = rs.encode(msg)
dec = rs.decode(enc)
self.assertEqual(dec, msg)
class Watermarker(object):
EPSILON = 0.001
def __init__(self, max_payload, ec_bytes, seed = 1910819922, mother = "haar"):
self.mother = mother
self.rscodec = RSCodec(ec_bytes)
self.max_payload = max_payload
self.total_bits = (max_payload + ec_bytes) * 8
self.seed = seed
def _embed(self, img, payload, k):
rand = Random(self.seed)
cA, (cH, cV, cD) = dwt2(img, self.mother)
cD2 = cD.reshape(cD.size)
for bit in iterbits(payload):
seq = numpy.array([int(rand.random() > 0.95) for _ in range(cD2.size)])
if bit:
cD2 += k * seq
return idwt2((cA, (cH, cV, cD2.reshape(cD.shape))), self.mother)[:img.shape[0],:img.shape[1]]
def embed(self, img, payload, k):
if len(payload) > self.max_payload:
raise ValueError("payload too long")
payload = bytearray(payload) + "\x00" * (self.max_payload - len(payload))
encoded = self.rscodec.encode(payload)
if len(img.shape) == 2:
return self._embed(img, encoded, k)
elif len(img.shape) == 3:
output = numpy.zeros(img.shape)
for i in range(img.shape[2]):
output[:,:,i] = self._embed(img[:,:,i], encoded, k)
return output
else:
raise TypeError("img must be a 2d or 3d array")
def _extract(self, img):
rand = Random(self.seed)
cA, (cH, cV, cD) = dwt2(img, self.mother)
cD2 = cD.reshape(cD.size)
byte = 0
output = bytearray()
for i in range(self.total_bits):
seq = numpy.array([int(rand.random() > 0.95) for _ in range(cD2.size)])
corr, _ = pearsonr(cD2, seq)
bit = int(corr > 0.1)
byte = (byte << 1) | bit
if i % 8 == 7:
output.append(byte)
byte = 0
print repr(output)
return output
def extract(self, img):
if len(img.shape) == 2:
return self.rscodec.decode(self._extract(img))
elif len(img.shape) == 3:
for i in range(img.shape[2]):
try:
return self.rscodec.decode(self._extract(img[:,:,i]))
except ReedSolomonError:
pass
return self.rscodec.decode(self._extract(mean(img, 2)))
else:
raise TypeError("img must be a 2d or 3d array")
class Watermarker(object):
EPSILON = 0.001
def __init__(self, max_payload, ec_bytes, seed = 1910819922, mother = "haar"):
self.mother = mother
self.rscodec = RSCodec(ec_bytes)
self.max_payload = max_payload
self.total_bits = (max_payload + ec_bytes) * 8
rand = Random(seed)
chunk_size = 3000
while True:
self.seq0 = numpy.array([int(rand.random() > 0.8) for _ in range(chunk_size)])
self.seq1 = numpy.array([int(rand.random() > 0.75) for _ in range(chunk_size)])
corr, _ = pearsonr(self.seq0, self.seq1)
if corr < self.EPSILON:
break
def _embed(self, img, payload, k):
cA, (cH, cV, cD) = dwt2(img, self.mother)
target = cD.reshape(cD.size)
chunk_size = target.size // self.total_bits
sequence_of = (self.seq0[:chunk_size], self.seq1[:chunk_size])
for i, bit in enumerate(iterbits(payload)):
seq = sequence_of[bit]
#chunk = target[i::self.total_bits][:seq.size]
chunk = target[i * chunk_size:i * chunk_size + seq.size]
chunk += k * seq
return idwt2((cA, (cH, cV, target.reshape(cH.shape))), self.mother)[:img.shape[0],:img.shape[1]]
def embed(self, img, payload, k):
if len(payload) > self.max_payload:
raise ValueError("payload too long")
payload = bytearray(payload) + "\x00" * (self.max_payload - len(payload))
encoded = self.rscodec.encode(payload)
if len(img.shape) == 2:
return self._embed(img, encoded, k)
elif len(img.shape) == 3:
hsv = rgb2hsv(img)
i = 0
hsv[:,:,i] = self._embed(hsv[:,:,i], encoded, k)
return hsv2rgb(hsv)
else:
raise TypeError("img must be a 2d or 3d array")
def _extract(self, img):
cA, (cH, cV, cD) = dwt2(img, self.mother)
target = cD.reshape(cD.size)
chunk_size = target.size // self.total_bits
seq0 = self.seq0[:chunk_size]
seq1 = self.seq1[:chunk_size]
byte = 0
output = bytearray()
for i in range(self.total_bits):
chunk = target[i * chunk_size : (i * chunk_size) + seq0.size]
#chunk = target[i::self.total_bits][:seq0.size]
#if not all(chunk[i] == chunk[i+1] for i in range(chunk.size-1)):
corr0, _ = pearsonr(chunk, seq0)
corr1, _ = pearsonr(chunk, seq1)
bit = int(corr1 > corr0)
#else:
# bit = 0
byte = (byte << 1) | bit
if i % 8 == 7:
output.append(byte)
byte = 0
print repr(output)
return output
def extract(self, img):
if len(img.shape) == 2:
return self.rscodec.decode(self._extract(img))
elif len(img.shape) == 3:
hsv = rgb2hsv(img)
return self.rscodec.decode(self._extract(hsv[:,:,0]))
else:
raise TypeError("img must be a 2d or 3d array")
