Update app.py

app.py

@@ -1,65 +1,76 @@
 import gradio as gr
-import numpy as np
-from PIL import Image
-from skimage.util import random_noise
-from skimage.restoration import denoise_nl_means, estimate_sigma
 import hashlib
-from skimage import img_as_float 
+import qrcode
+from PIL import Image, ImageDraw
+import os
 
-def hash_password(password):
-    """Hash the password to generate noise parameters."""
-    hash_object = hashlib.sha256(password.encode())
-    hex_dig = hash_object.hexdigest()
-    return int(hex_dig, 16)
+# Function to hash image data
+def hash_image(image):
+    image_data = image.tobytes()
+    image_hash = hashlib.sha256(image_data).hexdigest()
+    return image_hash
 
-def add_noise(image, password):
-    """Add Gaussian noise to the image based on the password."""
-    seed = hash_password(password) % (2**32)
-    np.random.seed(seed)
-    mean = np.random.uniform(-0.001, 0.1)  # Wider range for mean
-    var = np.random.uniform(0.0005, 0.1)   # Higher variance for stronger noise
-    noisy_image = random_noise(np.array(image), mode='gaussian', mean=mean, var=var, clip=True)
-    noisy_image = (255 * noisy_image).astype(np.uint8)  # Scale back to 0-255
-    return Image.fromarray(noisy_image)
+# Function to generate QR code
+def generate_qr_code(data):
+    qr = qrcode.QRCode(
+        version=1,
+        error_correction=qrcode.constants.ERROR_CORRECT_L,
+        box_size=10,
+        border=4,
+    )
+    qr.add_data(data)
+    qr.make(fit=True)
+    qr_img = qr.make_image(fill='black', back_color='white')
+    return qr_img
 
-def remove_noise(noisy_image, password):
-    """Attempt to remove noise from the image using the same password."""
-    if isinstance(noisy_image, np.ndarray):
-        noisy_image = Image.fromarray(noisy_image.astype('uint8'))
+# Function to embed QR code into image
+def embed_qr_code(image, qr_img):
+    image.paste(qr_img, (10, 10))  # Adjust position as needed
+    return image
 
-    seed = hash_password(password) % (2**32)
-    np.random.seed(seed)  # Reset the seed to generate the same noise parameters
-    image = np.array(noisy_image)
+# Function to save hash to file
+def save_hash(hash_code, description=""):
+    with open("hash.txt", "a") as file:
+        file.write(f"{hash_code}: {description}\n")
 
-    # Convert image to floating point type needed for denoise_nl_means
-    image_float = img_as_float(image)
+# Function to check image authenticity
+def check_authenticity(image):
+    hash_code = hash_image(image)
+    with open("hash.txt", "r") as file:
+        hashes = file.readlines()
+        for line in hashes:
+            saved_hash, description = line.strip().split(': ', 1)
+            if saved_hash == hash_code:
+                return f"Image is authentic. Description: {description}"
+    return "Image is new or modified."
 
-    sigma_est = np.mean(estimate_sigma(image_float, channel_axis=-1))  # Use channel_axis=-1 for color images
+# Main processing function
+def process_image(image, description):
+    hash_code1 = hash_image(image)
+    qr_img = generate_qr_code(hash_code1)
+    qr_img = qr_img.resize((100, 100))  # Resize QR code as needed
+    image_with_qr = embed_qr_code(image, qr_img)
+    save_hash(hash_code1, description)
+    hash_code2 = hash_image(image_with_qr)
+    save_hash(hash_code2)
+    return image_with_qr, "Image processed and hashes stored."
 
-    denoised_image = denoise_nl_means(image_float, h=1.15 * sigma_est, fast_mode=True,
-                                      patch_size=5, patch_distance=6, channel_axis=-1)
-
-    denoised_image = (255 * denoised_image).astype(np.uint8)  # Scale back to 0-255
-    return Image.fromarray(denoised_image)
-
-# Define Gradio interface with tabs for adding and removing noise
-with gr.Blocks() as interface:
-    gr.Markdown("### Image Noise Encryption and Decryption App")
-    with gr.Tab("Encrypt"):
+# Gradio interface setup
+with gr.Blocks() as app:
+    with gr.Tab("Upload and Process Image"):
         with gr.Row():
-            image_input = gr.Image(label="Original Image")
-            password_input = gr.Textbox(label="Password for Encryption", type="password")
-            encrypt_button = gr.Button("Encrypt Image")
-        image_output = gr.Image(label="Encrypted Image")
-        encrypt_button.click(add_noise, inputs=[image_input, password_input], outputs=image_output)
+            image_input = gr.Image(label="Upload Image")
+            description_input = gr.Textbox(label="Description")
+            submit_button = gr.Button("Process Image")
+        image_output = gr.Image(label="Processed Image")
+        submit_button.click(process_image, inputs=[image_input, description_input], outputs=image_output)
 
-    with gr.Tab("Decrypt"):
+    with gr.Tab("Check Image Authenticity"):
         with gr.Row():
-            image_input_decrypt = gr.Image(label="Encrypted Image")
-            password_input_decrypt = gr.Textbox(label="Password for Decryption", type="password")
-            decrypt_button = gr.Button("Decrypt Image")
-        image_output_decrypt = gr.Image(label="Decrypted Image")
-        decrypt_button.click(remove_noise, inputs=[image_input_decrypt, password_input_decrypt], outputs=image_output_decrypt)
+            image_check_input = gr.Image(label="Upload Image to Verify")
+            check_button = gr.Button("Check Authenticity")
+        authenticity_output = gr.Textbox(label="Result")
+        check_button.click(check_authenticity, inputs=[image_check_input], outputs=authenticity_output)
 
-# Launch the app
-interface.launch()
+# Launch the application
+app.launch()