Spaces:
Sleeping
Sleeping
| import base64 | |
| import gradio as gr | |
| import cv2 | |
| import numpy as np | |
| import pandas as pd | |
| from PIL import Image | |
| import hashlib | |
| import os | |
| import uuid as uniq | |
| from qr import make_qr | |
| import math | |
| def to_bin(data): | |
| """Convert `data` to binary format as string""" | |
| if isinstance(data, str): | |
| return ''.join([ format(ord(i), "08b") for i in data ]) | |
| elif isinstance(data, bytes): | |
| return ''.join([ format(i, "08b") for i in data ]) | |
| elif isinstance(data, np.ndarray): | |
| return [ format(i, "08b") for i in data ] | |
| elif isinstance(data, int) or isinstance(data, np.uint8): | |
| return format(data, "08b") | |
| else: | |
| raise TypeError("Type not supported.") | |
| def decode(image_name,txt=None): | |
| BGRimage = cv2.imread(image_name) | |
| image = cv2.cvtColor(BGRimage, cv2.COLOR_BGR2RGB) | |
| #resultd = hashlib.sha256(txt.encode('utf-8')).hexdigest() | |
| binary_data = "" | |
| for row in image: | |
| for pixel in row: | |
| r, g, b = to_bin(pixel) | |
| binary_data += r[-1] | |
| binary_data += g[-1] | |
| binary_data += b[-1] | |
| all_bytes = [ binary_data[i: i+8] for i in range(0, len(binary_data), 8) ] | |
| decoded_data = "" | |
| for byte in all_bytes: | |
| decoded_data += chr(int(byte, 2)) | |
| if decoded_data[-5:] == "=====": | |
| break | |
| p = decoded_data[:-5].split("#",1)[1].split("#",1)[0] | |
| #if p == resultd: | |
| this = decoded_data[:-5].split("#",1)[0].split("'",1)[1] | |
| #base = bytes(this, 'utf-8') | |
| #with open(f"finished_im{uniqnum}.png", "wb") as fh: | |
| # fh.write(base64.decodebytes(bytes(this, 'utf-8'))) | |
| #fh.close | |
| #return f"finished_im{uniqnum}.png" | |
| return this | |
| def encode(image_name, secret_data,txt=None): | |
| BGRimage = cv2.imread(image_name) | |
| image = cv2.cvtColor(BGRimage, cv2.COLOR_BGR2RGB) | |
| n_bytes = image.shape[0] * image.shape[1] * 3 // 8 | |
| print("[*] Maximum bytes to encode:", n_bytes) | |
| #resultp = hashlib.sha256(txt.encode('utf-8')).hexdigest() | |
| secret_data1=secret_data | |
| #secret_data1=f'{secret_data}#{resultp}' | |
| while True: | |
| if len(secret_data1) < (n_bytes): | |
| secret_data1 = f'{secret_data1}#' | |
| elif len(secret_data1) >= (n_bytes): | |
| break | |
| secret_data = secret_data1 | |
| if len(secret_data) > n_bytes: | |
| return image_name, gr.Markdown.update("""<center><h3>Input image is too large""") | |
| secret_data += "=====" | |
| data_index = 0 | |
| binary_secret_data = to_bin(secret_data) | |
| data_len = len(binary_secret_data) | |
| for row in image: | |
| for pixel in row: | |
| r, g, b = to_bin(pixel) | |
| if data_index < data_len: | |
| pixel[0] = int(r[:-1] + binary_secret_data[data_index], 2) | |
| data_index += 1 | |
| if data_index < data_len: | |
| pixel[1] = int(g[:-1] + binary_secret_data[data_index], 2) | |
| data_index += 1 | |
| if data_index < data_len: | |
| pixel[2] = int(b[:-1] + binary_secret_data[data_index], 2) | |
| data_index += 1 | |
| if data_index >= data_len: | |
| break | |
| return image | |
| def conv_im(qr_link,data): | |
| uniqnum = uniq.uuid4() | |
| byte_size = len(data) | |
| print (f'bytes:{byte_size}') | |
| data_pixels = byte_size*4 | |
| print (f'pixels:{data_pixels}') | |
| #data_sq=data_pixels/2 | |
| data_sq = int(math.sqrt(data_pixels)) | |
| data_pad = data_sq+100 | |
| print (f'square image:{data_pad}x{data_pad}') | |
| qr_im = make_qr(txt=qr_link) | |
| img1 = Image.open(qr_im) | |
| imgw = img1.size[0] | |
| imgh = img1.size[1] | |
| print (f'qr Size:{img1.size}') | |
| #img1.thumbnail((imgw*4,imgh*4), Image.Resampling.LANCZOS) | |
| img1 = img1.resize((int(data_pad),int(data_pad)), Image.Resampling.LANCZOS) | |
| print (img1.size) | |
| img1.save(f'tmpim{uniqnum}.png') | |
| with open(f'tmpim{uniqnum}.png', "rb") as image_file: | |
| encoded_string = base64.b64encode(image_file.read()) | |
| image_file.close() | |
| im_out = encode(f'tmpim{uniqnum}.png',data) | |
| return im_out |