Update app.py

app.py

@@ -2,16 +2,14 @@ from PIL import Image
 import numpy as np
 import streamlit as st
 import io
+import random
 
 # Resize image to prevent memory issues with large images
 def resize_image(img, max_size=(3000, 3000)):
     """
     Resize image to fit within max_size while maintaining aspect ratio.
-    :param img: PIL Image object
-    :param max_size: Maximum dimensions (width, height)
-    :return: Resized PIL Image object
     """
-    img.thumbnail(max_size, Image.Resampling.LANCZOS)  # Use LANCZOS for high-quality downscaling
+    img.thumbnail(max_size, Image.Resampling.LANCZOS)
     return img
 
 # Logistic map function
@@ -27,19 +25,53 @@ def generate_key(seed, n):
         key.append(int(x * 255) % 256)  # Map to 0-255
     return np.array(key, dtype=np.uint8)
 
-# Encrypt the image using chaotic logistic map
+# Shuffle pixels using a chaotic sequence
+def shuffle_pixels(img_array, seed):
+    h, w, c = img_array.shape
+    num_pixels = h * w
+    flattened = img_array.reshape(-1, c)
+    indices = np.arange(num_pixels)
+    
+    random.seed(seed)
+    random.shuffle(indices)  # Shuffle indices
+    
+    shuffled = flattened[indices]
+    return shuffled.reshape(h, w, c), indices
+
+# Unshuffle pixels (for decryption, if needed)
+def unshuffle_pixels(shuffled_array, indices, original_shape):
+    flattened = shuffled_array.reshape(-1, shuffled_array.shape[-1])
+    unshuffled = np.zeros_like(flattened)
+    unshuffled[indices] = flattened
+    return unshuffled.reshape(original_shape)
+
+# Multi-layer encryption using logistic map and pixel shuffling
 def encrypt_image(img_array, seed):
     h, w, c = img_array.shape
     flat_image = img_array.flatten()
+
+    # Generate chaotic key
     chaotic_key = generate_key(seed, len(flat_image))
+    
+    # XOR-based encryption
     encrypted_flat = [pixel ^ chaotic_key[i] for i, pixel in enumerate(flat_image)]
     encrypted_array = np.array(encrypted_flat, dtype=np.uint8).reshape(h, w, c)
-    return encrypted_array
+
+    # Pixel shuffling
+    shuffled_array, indices = shuffle_pixels(encrypted_array, seed)
+
+    # Second layer of logistic map encryption
+    chaotic_key_2 = generate_key(seed * 1.1, len(flat_image))
+    shuffled_flat = shuffled_array.flatten()
+    doubly_encrypted_flat = [pixel ^ chaotic_key_2[i] for i, pixel in enumerate(shuffled_flat)]
+    doubly_encrypted_array = np.array(doubly_encrypted_flat, dtype=np.uint8).reshape(h, w, c)
+
+    return doubly_encrypted_array
 
 # Streamlit App
 def main():
-    st.title("Chaotic Logistic Map Image Encryption")
-    st.write("Upload an image to encrypt using a chaotic logistic map.")
+    st.title("Enhanced Chaotic Logistic Map Image Encryption")
+    st.write("Upload an image to encrypt using advanced chaotic logistic map methods.")
 
     uploaded_file = st.file_uploader("Upload an image", type=["jpg", "jpeg", "png"])
     if uploaded_file is not None: