Initial commit — StegNet

.gitattributes

@@ -0,0 +1,10 @@
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.hdf5 filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+app/ui/assets/components_backgrounds/main_window_welcome_bg.png filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.ico filter=lfs diff=lfs merge=lfs -text
+*.json filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1 @@
+.idea/

README.md

@@ -0,0 +1,100 @@
+<h1 align="center">
+  InvisiCipher : Deep Learning-Based image Steganography with Chaotic Encryption and
+Enhanced Super Resolution
+</h1>
+
+<p align="center">
+  <img src="app/ui/logo.png" alt="Project Logo" width="100">
+</p>
+
+<p align="center">
+  <strong>Hide secrets, enhance images!</strong>
+</p>
+
+## Overview
+
+Welcome to our Steganography and Super Resolution project! This project combines the power of steganography techniques and super-resolution using deep learning models. Our goal is to hide a secret image within a cover image using advanced convolutional neural networks (CNNs) and then enhance the quality of the hidden image using an Enhanced Super Resolution Generative Adversarial Network (ESRGAN). We also provide an option to encrypt the steg image using various chaos encryption algorithms for added security.
+
+## Features
+
+✨ **Interactive Hiding**: Utilize our intuitive hide network powered by CNNs to embed secret images within cover images effortlessly.
+
+🔒 **Secure Encryption**: Choose from multiple chaos encryption algorithms such as AES, Blowfish to encrypt your steg image and protect your secrets.
+
+🌟 **Enhanced Super Resolution**: Witness the magic of our ESRGAN model as it enhances the resolution and quality of the hidden image, revealing every detail.
+
+🎨 **Easy-to-Use**: Our project provides a user-friendly interface and simple scripts to perform hiding, encryption, decryption, and image enhancement with just a few lines of code.
+
+## Project Architecture
+
+The project architecture consists of the following components:
+
+1. **Prepare Network**: A CNN-based network that prepares the secret image for hiding by extracting essential features and encoding it.
+
+2. **Hide Network**: Another CNN-based network that embeds the prepared secret image within the cover image, producing the steg image.
+
+3. **Chaos Encryption**: Choose between AES encryption, Blowfish encryption to secure your steg image.
+
+4. **Chaos Decryption**: Decrypt the encrypted steg image using the corresponding decryption algorithm to retrieve the steg image.
+
+5. **Reveal Network**: A CNN-based network that extracts the secret image from the steg image by decoding the hidden information.
+
+6. **ESRGAN**: Our Enhanced Super Resolution Generative Adversarial Network (ESRGAN) model enhances the quality and resolution of the extracted secret image.
+
+## Getting Started
+
+To get started with our project, follow these steps:
+
+1. **Clone the Repository**: `git clone https://github.com/Asirwad/InvisiCipher.git`
+
+2. **Install Dependencies**: Install the required dependencies by running `pip install -r requirements.txt`.
+
+3. **Prepare Your Dataset**: Organize your cover and secret images dataset and place them in the appropriate directories.
+
+4. **Customize Configuration**: Modify the configuration files to set the desired parameters for the models and encryption algorithms.
+
+5. **Train the Models**: Run the training script to train the CNN models and ESRGAN: `python train.py`.
+
+6. **Explore the Scripts**: Utilize the provided scripts to hide, encrypt, reveal, and enhance images based on your specific requirements.
+
+## Welcome screen
+
+<p align="center">
+  <img src="app/ui/assets/readme_assets/main_window.png" alt="Welcome" width="1000">
+</p>
+
+## Image hide
+
+<p align="center">
+  <img src="app/ui/assets/readme_assets/hide.png" alt="Image hide" width="1000">
+</p>
+
+## Image reveal
+
+<p align="center">
+  <img src="app/ui/assets/readme_assets/reveal.png" alt="Image reveal" width="1000">
+</p>
+
+## Super resolution
+
+<p align="center">
+  <img src="app/ui/assets/readme_assets/superres.png" alt="Super resolution" width="1000">
+</p>
+
+## Contributing
+
+We welcome contributions from the open source community. If you find any issues or have suggestions for improvements, please feel free to open an issue or submit a pull request.
+
+## Acknowledgements
+
+We would like to acknowledge the following resources and libraries used in this project:
+
+- <img src="https://upload.wikimedia.org/wikipedia/commons/thumb/2/2d/Tensorflow_logo.svg/1915px-Tensorflow_logo.svg.png" alt="TensorFlow" width="26" align="center"> TensorFlow: [↗️](https://www.tensorflow.org/)
+- <img src="https://upload.wikimedia.org/wikipedia/commons/thumb/1/10/PyTorch_logo_icon.svg/1200px-PyTorch_logo_icon.svg.png"
+ alt="PyTorch" width="25" align="center"> PyTorch: [↗️](https://pytorch.org/)
+- <img src="https://upload.wikimedia.org/wikipedia/commons/thumb/e/e6/Python_and_Qt.svg/800px-Python_and_Qt.svg.png"
+ alt="PyQt" width="25" align="center"> PyQt: [↗️](https://www.qt.io/qt-for-python)
+
+## Contact
+
+For any questions or inquiries, please contact us at [asirwadsali@gmail.com](mailto:asirwadsali@gmail.com).

app.py

@@ -0,0 +1,197 @@
+"""
+StegNet — Gradio web interface.
+
+Entry point for HuggingFace Spaces (or any Gradio-compatible host).
+Set the HF_API_KEY environment variable (Spaces secret) to enable
+the "Generate Image" tab.
+
+Run locally:
+    python app.py
+"""
+
+import os
+import sys
+
+# Make sure the package root is on the path when run directly
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+import gradio as gr
+
+from app.models.DEEP_STEGO.hide_image import hide_image
+from app.models.DEEP_STEGO.reveal_image import reveal_image
+from app.models.ESRGAN.upscale_image import upscale_image
+from app.models.encryption import aes, blowfish
+from app.models.StableDiffusionAPI.StableDiffusionV2 import generate
+
+
+# ---------------------------------------------------------------------------
+# Handler functions
+# ---------------------------------------------------------------------------
+
+def hide_fn(cover, secret):
+    if cover is None or secret is None:
+        return None, "Please upload both a cover image and a secret image."
+    try:
+        output_path = hide_image(cover, secret)
+        return output_path, "Secret image hidden successfully!"
+    except Exception as e:
+        return None, f"Error: {e}"
+
+
+def reveal_fn(steg):
+    if steg is None:
+        return None, "Please upload a steg image."
+    try:
+        output_path = reveal_image(steg)
+        return output_path, "Secret image revealed successfully!"
+    except Exception as e:
+        return None, f"Error: {e}"
+
+
+def encrypt_fn(image, key, algo):
+    if image is None:
+        return None, "Please upload an image."
+    if not key:
+        return None, "Please enter a secret key."
+    try:
+        if algo == "AES":
+            aes.encrypt(image, key)
+        else:
+            blowfish.encrypt(image, key)
+        enc_path = image + ".enc"
+        return enc_path, f"Image encrypted with {algo}. Download the file below."
+    except Exception as e:
+        return None, f"Error: {e}"
+
+
+def decrypt_fn(enc_file, key, algo):
+    if enc_file is None:
+        return None, "Please upload an encrypted .enc file."
+    if not key:
+        return None, "Please enter the secret key."
+    try:
+        if algo == "AES":
+            code, filename = aes.decrypt(enc_file, key)
+        else:
+            code, filename = blowfish.decrypt(enc_file, key)
+        if code == -1:
+            return None, "Decryption failed — wrong key."
+        return filename, "Image decrypted successfully!"
+    except Exception as e:
+        return None, f"Error: {e}"
+
+
+def upscale_fn(image):
+    if image is None:
+        return None, "Please upload a low-resolution image."
+    try:
+        output_path = upscale_image(image)
+        return output_path, "Image upscaled 4× successfully!"
+    except Exception as e:
+        return None, f"Error: {e}"
+
+
+def generate_fn(prompt):
+    if not prompt or not prompt.strip():
+        return None, "Please enter a text prompt."
+    if not os.environ.get("HF_API_KEY"):
+        return None, "HF_API_KEY is not set. Add it as a Space secret to enable image generation."
+    try:
+        img = generate(prompt.strip())
+        return img, "Image generated successfully!"
+    except Exception as e:
+        return None, f"Error: {e}"
+
+
+# ---------------------------------------------------------------------------
+# Gradio UI
+# ---------------------------------------------------------------------------
+
+DESCRIPTION = """
+# StegNet
+### AI-Based Secure Image Steganography Platform
+
+Hide secret images inside cover images using deep learning, encrypt the result,
+reveal hidden images, enhance resolution with ESRGAN, or generate new images
+with Stable Diffusion — all in one place.
+"""
+
+with gr.Blocks(title="StegNet", theme=gr.themes.Soft()) as demo:
+    gr.Markdown(DESCRIPTION)
+
+    # ── Tab 1: Hide Image ──────────────────────────────────────────────────
+    with gr.Tab("🔒 Hide Image"):
+        gr.Markdown("Upload a **cover image** and a **secret image**. The model embeds the secret inside the cover.")
+        with gr.Row():
+            cover_input = gr.Image(type="filepath", label="Cover Image")
+            secret_input = gr.Image(type="filepath", label="Secret Image")
+        hide_btn = gr.Button("Hide Secret", variant="primary")
+        with gr.Row():
+            steg_output = gr.Image(label="Steg Image (download me)")
+            hide_status = gr.Textbox(label="Status", interactive=False, lines=2)
+        hide_btn.click(hide_fn, inputs=[cover_input, secret_input], outputs=[steg_output, hide_status])
+
+    # ── Tab 2: Reveal Image ────────────────────────────────────────────────
+    with gr.Tab("🔍 Reveal Image"):
+        gr.Markdown("Upload a **steg image** to extract the hidden secret image.")
+        steg_input = gr.Image(type="filepath", label="Steg Image")
+        reveal_btn = gr.Button("Reveal Secret", variant="primary")
+        with gr.Row():
+            revealed_output = gr.Image(label="Revealed Secret Image")
+            reveal_status = gr.Textbox(label="Status", interactive=False, lines=2)
+        reveal_btn.click(reveal_fn, inputs=[steg_input], outputs=[revealed_output, reveal_status])
+
+    # ── Tab 3: Encrypt Image ───────────────────────────────────────────────
+    with gr.Tab("🛡️ Encrypt Image"):
+        gr.Markdown("Encrypt any image file (e.g. your steg image) with AES or Blowfish.")
+        enc_image_input = gr.Image(type="filepath", label="Image to Encrypt")
+        with gr.Row():
+            enc_key_input = gr.Textbox(label="Secret Key", type="password", placeholder="Enter a strong key…")
+            enc_algo = gr.Radio(["AES", "Blowfish"], value="AES", label="Algorithm")
+        enc_btn = gr.Button("Encrypt", variant="primary")
+        with gr.Row():
+            enc_file_output = gr.File(label="Encrypted File (.enc) — Download")
+            enc_status = gr.Textbox(label="Status", interactive=False, lines=2)
+        enc_btn.click(encrypt_fn, inputs=[enc_image_input, enc_key_input, enc_algo], outputs=[enc_file_output, enc_status])
+
+    # ── Tab 4: Decrypt Image ───────────────────────────────────────────────
+    with gr.Tab("🔓 Decrypt Image"):
+        gr.Markdown("Upload an encrypted **.enc** file and the correct key to recover the image.")
+        dec_file_input = gr.File(label="Encrypted File (.enc)", type="filepath")
+        with gr.Row():
+            dec_key_input = gr.Textbox(label="Secret Key", type="password", placeholder="Enter the key used for encryption…")
+            dec_algo = gr.Radio(["AES", "Blowfish"], value="AES", label="Algorithm")
+        dec_btn = gr.Button("Decrypt", variant="primary")
+        with gr.Row():
+            dec_image_output = gr.Image(label="Decrypted Image")
+            dec_status = gr.Textbox(label="Status", interactive=False, lines=2)
+        dec_btn.click(decrypt_fn, inputs=[dec_file_input, dec_key_input, dec_algo], outputs=[dec_image_output, dec_status])
+
+    # ── Tab 5: Super Resolution ────────────────────────────────────────────
+    with gr.Tab("✨ Super Resolution"):
+        gr.Markdown("Upscale any image **4×** using ESRGAN.")
+        lr_input = gr.Image(type="filepath", label="Low-Resolution Image")
+        upscale_btn = gr.Button("Upscale 4×", variant="primary")
+        with gr.Row():
+            hr_output = gr.Image(label="High-Resolution Output")
+            upscale_status = gr.Textbox(label="Status", interactive=False, lines=2)
+        upscale_btn.click(upscale_fn, inputs=[lr_input], outputs=[hr_output, upscale_status])
+
+    # ── Tab 6: Generate Image ──────────────────────────────────────────────
+    with gr.Tab("🎨 Generate Image"):
+        gr.Markdown(
+            "Generate an image from a text prompt using Stable Diffusion 2.1.  \n"
+            "*(Requires `HF_API_KEY` set as a Space secret.)*"
+        )
+        prompt_input = gr.Textbox(
+            label="Text Prompt",
+            placeholder="A futuristic city at sunset, digital art…",
+            lines=2,
+        )
+        gen_btn = gr.Button("Generate", variant="primary")
+        with gr.Row():
+            gen_output = gr.Image(label="Generated Image")
+            gen_status = gr.Textbox(label="Status", interactive=False, lines=2)
+        gen_btn.click(generate_fn, inputs=[prompt_input], outputs=[gen_output, gen_status])
+
+demo.launch()

app/main_CLI_v1.py

@@ -0,0 +1,75 @@
+from tkinter import filedialog
+
+from app.models.encryption import blowfish
+from app.models.DEEP_STEGO.hide_image import hide_image
+from app.models.DEEP_STEGO.reveal_image import reveal_image
+from app.models.ESRGAN.upscale_image import upscale_image
+from app.models.encryption import aes as aes_chaos
+
+print("StegNet CLI")
+
+""" DEEP STEGANO """
+print("Image hiding")
+print("input the cover image filename")
+cover_filename = filedialog.askopenfilename(title="Select Image", filetypes=(
+("PNG files", "*.png"), ("JPEG files", "*.jpg;*.jpeg"), ("All files", "*.*")))
+print("input the secret image filename")
+secret_filename = filedialog.askopenfilename(title="Select Image", filetypes=(
+("PNG files", "*.png"), ("JPEG files", "*.jpg;*.jpeg"), ("All files", "*.*")))
+hide_image(cover_filename, secret_filename)
+
+print("image hidden successfully\n\n")
+
+
+print("1. AES")
+print("2. Blowfish")
+enc_choice = int(input("What type of encryption do you want? :"))
+print("Your choice is : ", enc_choice)
+
+if enc_choice == 1:
+    # AES Encryption
+    filename = filedialog.askopenfilename(title="Select Image", filetypes=(
+    ("PNG files", "*.png"), ("JPEG files", "*.jpg;*.jpeg"), ("All files", "*.*")))
+    key = input("Enter your secret key : ")
+    aes_chaos.encrypt(filename, key)
+
+    # AES Decryption
+    print("AES Decryption")
+    key = input("Enter your secret key : ")
+    filename = filedialog.askopenfilename(title="Select Image", filetypes=(
+    ("All files", "*.*"), ("JPEG files", "*.jpg;*.jpeg"), ("PNG files", "*.png")))
+    aes_chaos.decrypt(filename, key)
+
+
+elif enc_choice == 2:
+    print("Blowfish Encryption")
+    # Blowfish Encryption
+    key = input("Enter your secret key : ")
+    filename = filedialog.askopenfilename(title="Select Image", filetypes=(
+    ("PNG files", "*.png"), ("JPEG files", "*.jpg;*.jpeg"), ("All files", "*.*")))
+    blowfish.encrypt(filename, key)
+    print("Encrypted output saved to output_encrypted.png")
+
+    # Blowfish Decryption
+    filename = filedialog.askopenfilename(title="Select Image", filetypes=(
+    ("PNG files", "*.png"), ("JPEG files", "*.jpg;*.jpeg"), ("All files", "*.*")))
+    key = input("Enter your secret key : ")
+    blowfish.decrypt(filename, key)
+
+else:
+    print('Invalid choice')
+
+print("input the steg image filename")
+steg_filename = filedialog.askopenfilename(title="Select Image", filetypes=(
+    ("PNG files", "*.png"), ("JPEG files", "*.jpg;*.jpeg"), ("All files", "*.*")))
+reveal_image(steg_filename)
+
+""" UP-SCALING """
+print("UP-SCALING")
+print("input the low res image filename")
+low_res_filename = filedialog.askopenfilename(title="Select Image", filetypes=(
+    ("PNG files", "*.png"), ("JPEG files", "*.jpg;*.jpeg"), ("All files", "*.*")))
+upscale_image(low_res_filename)
+
+
+

app/models/DEEP_STEGO/Utils/customLossWeight.py

@@ -0,0 +1,14 @@
+from tensorflow.keras.losses import mean_squared_error
+
+
+# Loss functions
+def custom_loss_1(secret, secret_pred):
+    # Compute L2 loss(MSE) for secret image
+    secret_mse = mean_squared_error(secret, secret_pred)
+    return secret_mse
+
+
+def custom_loss_2(cover, cover_predict):
+    # Compute L2 loss(MSE) for cover image
+    cover_mse = mean_squared_error(cover, cover_predict)
+    return cover_mse

app/models/DEEP_STEGO/Utils/enhance.py

@@ -0,0 +1,70 @@
+import numpy as np
+import argparse
+import sys
+import math
+from PIL import ImageFilter, Image
+import cv2
+
+'''
+Enhance video by applying denoise and sharpen filters
+'''
+
+# Construct argument parser
+parser = argparse.ArgumentParser(description='Use block shuffle')
+parser.add_argument('--denoise', action='store_true', default=False)
+parser.add_argument('--sharpen', action='store_true', default=False)
+parser.add_argument("--input_video", required=True, help="path to input video")
+args = vars(parser.parse_args())
+
+# Start video enhancement
+print('\nEnhancing video ...\n')
+
+
+# Update progress bar
+def update_progress(current_frame, total_frames):
+    progress = math.ceil((current_frame / total_frames) * 100)
+    sys.stdout.write('\rProgress: [{0}] {1}%'.format('>' * math.ceil(progress / 10), progress))
+
+
+# Open the input video
+vid_cap = cv2.VideoCapture(args['input_video'])
+
+# Total input video frames
+num_frames = int(vid_cap.get(cv2.CAP_PROP_FRAME_COUNT))
+print("Total frames in input video:", num_frames)
+
+# Initialize the video writer
+enhanced_video = cv2.VideoWriter('results/enhanced_secret_300.avi', cv2.VideoWriter_fourcc('M', 'J', 'P', 'G'), 15,
+                                 (300, 300))
+
+# Initialize the frame buffer
+frames = []
+
+# Load the frames to buffer
+while vid_cap.isOpened():
+    success, image = vid_cap.read()
+    if success:
+        frames.append(image)
+    else:
+        break
+
+# Set up the start frame index
+start_frame = 5
+
+# Enhance and save video frame-by-frame
+for i in range(start_frame, len(frames) - (start_frame + 1)):
+    output = frames[i]
+    if args["denoise"]:
+        output = cv2.fastNlMeansDenoisingColoredMulti(frames, i, 11)
+    if args["sharpen"]:
+        output = np.array(Image.fromarray(output).filter(ImageFilter.DETAIL))
+    enhanced_video.write(output)
+    update_progress(i, num_frames - (start_frame + 1))
+
+# Finish video enhancement
+print('\n\nSuccessfully enhanced video !!!\n')
+
+'''
+Sample run:-
+python enhance.py --input_video results/secret_outvid_300.avi --denoise --sharpen
+'''

app/models/DEEP_STEGO/Utils/eval.py

@@ -0,0 +1,135 @@
+import numpy as np
+import random
+import glob
+import sys
+import os
+from PIL import Image
+import matplotlib.pyplot as plt
+from tensorflow.keras.losses import mean_squared_error
+from tensorflow.keras.preprocessing.image import ImageDataGenerator
+from tensorflow.keras.models import load_model
+from pathlib import Path
+
+'''
+Evaluates the trained model on a new dataset
+Uses Mean Square Error as evaluation metric
+'''
+
+# Path for evaluation dataset
+EVAL_PATH = Path(sys.argv[1]).resolve()
+BATCH_SIZE = 1
+TEST_NUM = len(glob.glob(str(EVAL_PATH)))
+
+
+# Normalize input for evaluation
+def normalize_batch(imgs):
+    return (imgs - np.array([0.485, 0.456, 0.406])) / np.array([0.229, 0.224, 0.225])
+
+
+# Denormalize output for prediction
+def denormalize_batch(imgs, should_clip=True):
+    imgs = (imgs * np.array([0.229, 0.224, 0.225])) + np.array([0.485, 0.456, 0.406])
+
+    if should_clip:
+        imgs = np.clip(imgs, 0, 1)
+    return imgs
+
+
+# Create a data generator for evaluation
+test_imgen = ImageDataGenerator(rescale=1. / 255)
+
+
+# Compute L2 loss(MSE) for secret image
+def custom_loss_1(secret, secret_pred):
+    secret_mse = mean_squared_error(secret, secret_pred)
+    return secret_mse
+
+
+# Compute L2 loss(MSE) for cover image
+def custom_loss_2(cover, cover_pred):
+    cover_mse = mean_squared_error(cover, cover_pred)
+    return cover_mse
+
+
+# Load the trained model
+model = load_model(sys.argv[2], custom_objects={'custom_loss_1': custom_loss_1, 'custom_loss_2': custom_loss_2})
+
+
+# Custom data generator
+def generate_generator_multiple(generator, direc):
+    genX1 = generator.flow_from_directory(direc, target_size=(224, 224), batch_size=12, shuffle=True, seed=3,
+                                          class_mode=None)
+    genX2 = generator.flow_from_directory(direc, target_size=(224, 224), batch_size=12, shuffle=True, seed=8,
+                                          class_mode=None)
+
+    while True:
+        X1i = normalize_batch(genX1.next())
+        X2i = normalize_batch(genX2.next())
+
+        yield ({'secret': X1i, 'cover': X2i},
+               {'hide_conv_f': X2i, 'revl_conv_f': X1i})  # Yield both images and their mutual label
+
+
+# Load data using generator
+testgenerator = generate_generator_multiple(test_imgen, direc=str(EVAL_PATH.parent))
+
+# Evaluates the model using data generator
+score = model.evaluate(testgenerator, steps=TEST_NUM / BATCH_SIZE, verbose=0)
+
+# Print mean square error
+print('Mean square error:', score[0])
+
+'''
+Test the model on a  random pair of images (test)
+Plots the input and output for verification
+'''
+
+
+# Perform prediction for single input
+def predict(source, cover):
+    # Normalize inputs
+    secret = np.array(source / 255.0)
+    cover = np.array(cover / 255.0)
+
+    # Predict output
+    coverout, secretout = model.predict(
+        [normalize_batch(np.reshape(secret, (1, 224, 224, 3))), normalize_batch(np.reshape(cover, (1, 224, 224, 3)))])
+
+    # Postprocess output cover image
+    coverout = denormalize_batch(coverout)
+    coverout = np.squeeze(coverout) * 255.0
+    coverout = np.uint8(coverout)
+
+    # Postprocess output secret image
+    secretout = denormalize_batch(secretout)
+    secretout = np.squeeze(secretout) * 255.0
+    secretout = np.uint8(secretout)
+
+    # Plot output images
+    fig_out, ax_out = plt.subplots(1, 2, figsize=(10, 10))
+    fig_out.suptitle('Outputs')
+    ax_out[0].title.set_text("Secret output")
+    ax_out[0].imshow(secretout)
+    ax_out[1].title.set_text("Cover output")
+    ax_out[1].imshow(coverout)
+    print("Prediction Completed!")
+
+
+# Load random test image pairs
+sec, cov = random.sample(os.listdir(str(EVAL_PATH)), k=2)
+
+source = np.array(Image.open(str(EVAL_PATH) + '/' + sec))
+cover = np.array(Image.open(str(EVAL_PATH) + '/' + cov))
+
+# Plot input images
+fig_in, ax_in = plt.subplots(1, 2, figsize=(10, 10))
+fig_in.suptitle('Inputs')
+ax_in[0].title.set_text("Secret input")
+ax_in[0].imshow(source)
+ax_in[1].title.set_text("Cover input")
+ax_in[1].imshow(cover)
+
+# Perform prediction
+predict(source, cover)
+
+# Sample run: python eval.py dataset/eval_data checkpoints/steg_model-06-0.03.hdf5

app/models/DEEP_STEGO/Utils/preprocessing.py

@@ -0,0 +1,18 @@
+import numpy as np
+
+
+# Preprocessing functions
+def normalize_batch(images):
+    """Performs channel-wise z-score normalization"""
+
+    return (images - np.array([0.485, 0.456, 0.406])) / np.array([0.229, 0.224, 0.225])
+
+
+def denormalize_batch(images, should_clip=True):
+    """Denormalize the images for prediction"""
+
+    images = (images * np.array([0.229, 0.224, 0.225])) + np.array([0.485, 0.456, 0.406])
+
+    if should_clip:
+        images = np.clip(images, 0, 1)
+    return images

app/models/DEEP_STEGO/Utils/progressbarCL_animation.py

@@ -0,0 +1,7 @@
+import math
+import sys
+
+
+def update_progress(current_frame, total_frames):
+    progress = math.ceil((current_frame/total_frames)*100)
+    sys.stdout.write('\rProgress: [{0}] {1}%'.format('>'*math.ceil(progress/10), progress))

app/models/DEEP_STEGO/Utils/test.py

@@ -0,0 +1,80 @@
+import numpy as np
+import sys
+from tensorflow.keras.models import Model
+from tensorflow.keras.utils import plot_model
+from tensorflow.keras.models import load_model
+from PIL import Image
+import matplotlib.pyplot as plt
+from random import randint
+import imageio
+from skimage.util.shape import view_as_blocks
+
+'''
+Test the model on sample images (unseen)
+Plot the input and output images
+'''
+
+# Load test images
+test_images = np.load(sys.argv[1])
+
+# Load model
+model = load_model(sys.argv[2], compile=False)
+
+
+# Normalize inputs
+def normalize_batch(imgs):
+    """ Performs channel-wise z-score normalization """
+
+    return (imgs - np.array([0.485, 0.456, 0.406])) / np.array([0.229, 0.224, 0.225])
+
+
+# Denormalize outputs
+def denormalize_batch(imgs, should_clip=True):
+    imgs = (imgs * np.array([0.229, 0.224, 0.225])) + np.array([0.485, 0.456, 0.406])
+
+    if should_clip:
+        imgs = np.clip(imgs, 0, 1)
+    return imgs
+
+
+# Load images as batch (batch size -4)
+secretin = test_images[np.random.choice(len(test_images), size=4, replace=False)]
+coverin = test_images[np.random.choice(len(test_images), size=4, replace=False)]
+
+# Perform batch prediction
+coverout, secretout = model.predict([normalize_batch(secretin), normalize_batch(coverin)])
+
+# Postprocess cover output
+coverout = denormalize_batch(coverout)
+coverout = np.squeeze(coverout) * 255.0
+coverout = np.uint8(coverout)
+
+# Postprocess secret output
+secretout = denormalize_batch(secretout)
+secretout = np.squeeze(secretout) * 255.0
+secretout = np.uint8(secretout)
+
+# Convert images to UINT8 format (0-255)
+coverin = np.uint8(np.squeeze(coverin * 255.0))
+secretin = np.uint8(np.squeeze(secretin * 255.0))
+
+
+# Plot the images
+def plot(im, title):
+    fig = plt.figure(figsize=(20, 20))
+
+    for i in range(4):
+        sub = fig.add_subplot(1, 4, i + 1)
+        sub.title.set_text(title + " " + str(i + 1))
+        sub.imshow(im[i, :, :, :])
+
+
+# Plot secret input and output
+plot(secretin, "Secret Input")
+plot(secretout, "Secret Output")
+
+# Plot cover input and output
+plot(coverin, "Cover Input")
+plot(coverout, "Cover Output")
+
+# Sample run: python test.py test/testdata.npy checkpoints/steg_model-06-0.03.hdf5

app/models/DEEP_STEGO/checkpoints/steg_model-06-0.03.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d2567ad658864875aba9f3c51fde8e2b032d4964b1382298e2d36c62708adceb
+size 32115520

app/models/DEEP_STEGO/hide_image.py

@@ -0,0 +1,46 @@
+import os
+import tempfile
+import numpy as np
+from tensorflow.keras.models import load_model
+from PIL import Image
+import imageio
+from app.models.DEEP_STEGO.Utils.preprocessing import normalize_batch, denormalize_batch
+
+_MODEL_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'models', 'hide.h5')
+_model = None
+
+
+def _get_model():
+    global _model
+    if _model is None:
+        _model = load_model(_MODEL_PATH)
+    return _model
+
+
+def hide_image(cover_image_filepath, secret_image_filepath):
+    model = _get_model()
+
+    secret_image_in = Image.open(secret_image_filepath).convert('RGB')
+    cover_image_in = Image.open(cover_image_filepath).convert('RGB')
+
+    if secret_image_in.size != (224, 224):
+        secret_image_in = secret_image_in.resize((224, 224))
+    if cover_image_in.size != (224, 224):
+        cover_image_in = cover_image_in.resize((224, 224))
+
+    secret_image_in = np.array(secret_image_in).reshape(1, 224, 224, 3) / 255.0
+    cover_image_in = np.array(cover_image_in).reshape(1, 224, 224, 3) / 255.0
+
+    steg_image_out = model.predict([normalize_batch(secret_image_in), normalize_batch(cover_image_in)])
+
+    steg_image_out = denormalize_batch(steg_image_out)
+    steg_image_out = np.squeeze(steg_image_out) * 255.0
+    steg_image_out = np.uint8(steg_image_out)
+
+    _, output_path = tempfile.mkstemp(suffix='.png')
+    imageio.imsave(output_path, steg_image_out)
+    print("Saved steg image to", output_path)
+
+    return output_path
+
+

app/models/DEEP_STEGO/models/hide.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d134911e755c063b31d1f2f76678a2b690c5952536bb7c01981cdf6d68e3724b
+size 7692752

app/models/DEEP_STEGO/models/reveal.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f60e937b2957601be10e58df12aaa27b51763449a7883baaf50613500c2dfb32
+size 3102992

app/models/DEEP_STEGO/reveal_image.py

@@ -0,0 +1,45 @@
+import os
+import tempfile
+import numpy as np
+from tensorflow.keras.models import load_model
+from PIL import Image
+import imageio
+from app.models.DEEP_STEGO.Utils.preprocessing import normalize_batch, denormalize_batch
+
+_MODEL_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'models', 'reveal.h5')
+_model = None
+
+
+def _get_model():
+    global _model
+    if _model is None:
+        _model = load_model(_MODEL_PATH, compile=False)
+    return _model
+
+
+def reveal_image(stego_image_filepath):
+    model = _get_model()
+
+    stego_image = Image.open(stego_image_filepath).convert('RGB')
+
+    if stego_image.size != (224, 224):
+        stego_image = stego_image.resize((224, 224))
+
+    stego_image = np.array(stego_image).reshape(1, 224, 224, 3) / 255.0
+
+    secret_image_out = model.predict([normalize_batch(stego_image)])
+
+    secret_image_out = denormalize_batch(secret_image_out)
+    secret_image_out = np.squeeze(secret_image_out) * 255.0
+    secret_image_out = np.uint8(secret_image_out)
+
+    _, output_path = tempfile.mkstemp(suffix='.png')
+    imageio.imsave(output_path, secret_image_out)
+    print("Saved revealed image to", output_path)
+
+    return output_path
+
+
+
+
+