Upload 6 files

overlay.py

@@ -0,0 +1,104 @@
+import cv2
+from PIL import ImageFont, ImageDraw, Image
+
+def process(img,font_text,font_fac,font_x,font_y,font_col,font_op):
+    img.save('tmp.png')
+
+    img = Image.open('tmp.png').convert("RGBA") 
+    im=img
+    #im=Image.open(img)  
+    txt = Image.new('RGBA', im.size, (255,255,255,0))
+
+    w, h = im.size
+    print (f'FONT COLOR: {font_col}')
+    #t_fill = ("#"+"E6"+f"{font_col.strip('#')}")
+    
+    #t_fill = (font_col)
+    h1 = font_col.strip("#")
+    rgb_tup = tuple(int(h1[i:i+2], 16) for i in (0, 2, 4))
+    print (rgb_tup)
+    a,b,c = rgb_tup
+    t_fill = (a,b,c,font_op)
+    
+    print (f'FONT COLOR: {t_fill}')
+    
+    #x = int(w-font_x)
+    #y = int(h-font_y)
+    x = int(font_x)
+    y = int(font_y)
+    draw = ImageDraw.Draw(txt)
+    text = f'{font_text}'
+    font_size=font_fac
+    font = ImageFont.truetype("./fonts/SansitaOne.ttf", int(font_size))
+    size = font.getsize(text)
+    draw.text((x-size[0]/2, y),text, font = font, fill=t_fill)
+    
+    #txt.putalpha(128)
+
+    combined = Image.alpha_composite(im, txt)    
+    return combined
+    
+def textover(im,txt1="",txt2=""):
+    #im.save('tmp.png')
+
+    im = Image.open(im)
+    inp=1
+    hh=0
+    hhh=25
+    #cnt = len(inp)
+    cnt = inp
+    font_a = 30
+    font_b = 10
+    if cnt >0:
+        font_a = font_a + (cnt * 2)
+        font_b = font_b + (cnt * 2)
+        #hh = hh-int(cnt/2)
+        hhh = hhh+int(cnt/2)
+    w,h = im.size
+    print (w)
+    print (h)
+    font_x = (w/2)
+    font_y = h-hhh
+    out = process(im,txt1,font_fac=font_a,font_x=font_x,font_y=hh,font_col="#000000",font_op=255)
+    out = process(out,txt2,font_fac=font_b,font_x=font_x,font_y=font_y,font_col="#000000",font_op=255)
+    #out.save("out.png")
+
+    return out
+
+def background_image():
+    img_b = np.zeros([512,512,3],dtype=np.uint8)
+    img_b.fill(255)
+    img_b.save("background.png")
+    
+def custom_overlay(txt=None):
+    background_image()
+    background = Image.open("background.png")
+    x,y = background.size
+    if x > y:
+        aa=y
+    if y > x: 
+        aa=x
+    if x==y:
+        aa=x
+    out = f'{txt}'
+    print (f'txt {out}')
+    qrm = qr.QRCode(box_size=10,error_correction=qr.constants.ERROR_CORRECT_H)
+    qrm.add_data(out)
+    qrm.make(fit=True)
+    img1 = qrm.make_image(fill_color=fill, back_color="white")
+    img1 = img1.resize((aa,aa))
+    img1.save("im2.png")
+    
+    image_bgr = cv2.imread('im2.png')
+
+    h, w, c = image_bgr.shape
+    image_bgra = np.concatenate([image_bgr, np.full((h, w, 1), 255, dtype=np.uint8)], axis=-1)
+    white = np.all(image_bgr == [255, 255, 255], axis=-1)
+    image_bgra[white, -1] = 0
+    cv2.imwrite('result.png', image_bgra)
+
+    
+    over_im = Image.open("result.png")
+    background.paste(over_im, (0, 0), over_im)
+    background.save("out_im.png")
+    return "out_im.png"       

qr.py

@@ -0,0 +1,83 @@
+import qrcode as qr
+import base64
+import cv2
+import os
+from PIL import Image
+
+def make_qr(txt=None,data=None,im_size=None,color_f=None,color_b=None):
+        
+    qrm = qr.QRCode(box_size=10,error_correction=qr.constants.ERROR_CORRECT_H)
+    if color_f == None:
+        color_f = "#000"
+    if color_b == None:
+        color_b = "#fff"
+    if txt != None and txt != "" and data != None:
+        f = Image.open(f'{data}')
+        f.thumbnail((im_size,im_size))
+        f.save("tmp.jpg")
+        imr = open(f'tmp.jpg','rb')
+        out = f'{txt}+++{base64.b64encode(imr.read())}'
+        print (f'txt+data {out}')
+        qrm.add_data(out)
+        qrm.make(fit=True)
+        img1 = qrm.make_image(fill_color=color_f, back_color=color_b)
+        img1.save("im.png")
+        return "im.png"
+    if txt == None or txt == "" and data != None:
+        f = Image.open(f'{data}')
+        f.thumbnail((im_size,im_size))
+        f.save("tmp1.jpg")
+        imr = open(f'tmp1.jpg','rb')
+        out = f'+++{base64.b64encode(imr.read())}'
+        print (f'data {out}')
+        qrm.add_data(out)
+        qrm.make(fit=True)
+        img1 = qrm.make_image(fill_color=color_f, back_color=color_b)
+        img1.save("im1.png")
+        return "im1.png"
+        
+    if txt != None and txt != "" and data == None:
+        out = f'{txt}'
+        print (f'txt {out}')
+        qrm.add_data(out)
+        qrm.make(fit=True)
+        img1 = qrm.make_image(fill_color=color_f, back_color=color_b)
+        img1.save("im2.png")
+        return "im2.png"    
+
+def cnt_im_bytes(im,txt_cnt,im_size):
+    f = Image.open(f'{im}')
+    f.thumbnail((im_size,im_size))
+    f.save("tmp11.jpg")
+    im_cnt=os.stat('tmp11.jpg').st_size
+    print(im_cnt)
+    tot_cnt=im_cnt+int(txt_cnt)
+    return im_cnt,tot_cnt  
+
+def cnt_bytes(txt,im_cnt):
+    txt_cnt = (len(txt.encode('utf-8')))
+    tot_cnt = txt_cnt + int(im_cnt)
+    return txt_cnt, tot_cnt
+
+
+def decode(im):
+    
+    image = cv2.imread(f'{im}')
+    qrCodeDetector = cv2.QRCodeDetector()
+    decodedText, points, _ = qrCodeDetector.detectAndDecode(image)
+    if points is not None:
+        text = decodedText
+    else:
+        text = "No QR Code Found"
+    return text
+def make_im(tx_str):
+    out = tx_str.split("+++b",1)[1]
+    out.replace("'","")
+    print(out)
+    decoded_data=base64.b64decode((out))
+    
+    #write the decoded data back to original format in  file
+    img_file = open('image.jpeg', 'wb')
+    img_file.write(decoded_data)
+    img_file.close()
+    return ('image.jpeg')

stegan.py

@@ -0,0 +1,108 @@
+import base64
+import cv2
+import numpy as np
+#import pandas as pd
+from PIL import Image
+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)   
+    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
+    this = decoded_data[:-5].split("#####",1)[0]
+    this = eval(this)
+    enc_in=this
+    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)
+    secret_data1=secret_data
+    #secret_data1=f'{secret_data}#{resultp}'
+    
+    while True:
+        if len(secret_data1)+5 < (n_bytes):
+            secret_data1 = f'{secret_data1}#####'
+        elif len(secret_data1)+5 >= (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(im,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 = im
+    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)
+    if data_pad > imgw or data_pad > imgh :
+        
+        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

stegan2.py

@@ -0,0 +1,106 @@
+import base64
+import cv2
+import numpy as np
+#import pandas as pd
+from PIL import Image
+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)   
+    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
+    this = decoded_data[:-5].split("#####",1)[0]
+    this = eval(this)
+    enc_in=this
+    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)
+    secret_data1=secret_data
+    #secret_data1=f'{secret_data}#{resultp}'
+    
+    while True:
+        if len(secret_data1)+5 < (n_bytes):
+            secret_data1 = f'{secret_data1}#####'
+        elif len(secret_data1)+5 >= (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