Update app.py

app.py

@@ -1,61 +1,66 @@
+Certainly! Below is the complete Streamlit app code that combines both basic image transformations and a simulation of latent space augmentation to generate synthetic images. This version doesn't require training a model and instead uses traditional image processing techniques along with simulated noise addition to create augmented images. Users can upload 1 to 10 images, specify the desired number of augmented samples per original image, and download a ZIP file containing all the generated synthetic images.
+
+### Complete Streamlit App Code
+
+```python
 import streamlit as st
-from PIL import Image
+from PIL import Image, ImageEnhance, ImageOps
 import numpy as np
 import io
 import zipfile
 
-def mock_encoder(image):
-    """Simulates encoding an image into a latent representation."""
-    # This is a placeholder. In practice, this would be your trained encoder's output.
-    return np.random.normal(0, 1, (1, 100)), np.random.normal(0, 1, (1, 100)), np.random.normal(0, 1, (1, 100))
+def apply_basic_augmentations(image):
+    """Applies basic augmentations such as rotation and color jitter."""
+    image = image.rotate(np.random.uniform(-30, 30))
+    enhancer = ImageEnhance.Color(image)
+    image = enhancer.enhance(np.random.uniform(0.75, 1.25))
+    if np.random.rand() > 0.5:
+        image = ImageOps.mirror(image)
+    return image
 
-def mock_decoder(latent_representation):
-    """Simulates decoding a latent representation back into an image."""
-    # Returns a random image for demonstration
-    return np.random.rand(28, 28, 1) * 255
+def simulate_latent_space_noising(image, noise_scale=25):
+    """Simulates latent space manipulation by adding noise."""
+    image_array = np.array(image)
+    noise = np.random.normal(0, noise_scale, image_array.shape)
+    noised_image_array = np.clip(image_array + noise, 0, 255).astype(np.uint8)
+    return Image.fromarray(noised_image_array)
 
-def latent_space_augmentation(image, encoder, decoder, noise_scale=0.1):
-    """Performs latent space augmentation by adding noise to the latent representation."""
-    z_mean, z_log_var, _ = encoder(image)
-    epsilon = np.random.normal(size=z_mean.shape)
-    z_augmented = z_mean + np.exp(0.5 * z_log_var) * epsilon * noise_scale
-    augmented_image = decoder(z_augmented)
-    return np.squeeze(augmented_image)
+def augment_image(image, augmentations_count):
+    """Generates augmented versions of a single image."""
+    augmented_images = []
+    for _ in range(augmentations_count):
+        augmented_image = apply_basic_augmentations(image)
+        augmented_image = simulate_latent_space_noising(augmented_image)
+        augmented_images.append(augmented_image)
+    return augmented_images
 
 def create_downloadable_zip(augmented_images):
     """Creates a ZIP file in memory for downloading."""
     zip_buffer = io.BytesIO()
     with zipfile.ZipFile(zip_buffer, "a", zipfile.ZIP_DEFLATED, False) as zip_file:
-        for idx, image_data in enumerate(augmented_images):
-            img_byte_arr = io.BytesIO(image_data)
-            zip_file.writestr(f"augmented_image_{idx+1}.jpeg", img_byte_arr.getvalue())
+        for idx, image in enumerate(augmented_images):
+            img_byte_arr = io.BytesIO()
+            image.save(img_byte_arr, format="JPEG")
+            zip_file.writestr(f"augmented_image_{idx+1}.jpg", img_byte_arr.getvalue())
     zip_buffer.seek(0)
     return zip_buffer
 
-st.title("Batch Image Augmentation with Latent Space Manipulation")
+st.title("Batch Image Augmentation for Dataset Creation")
 
 uploaded_files = st.file_uploader("Choose images (1-10)", accept_multiple_files=True, type=["jpg", "jpeg", "png"])
 augmentations_count = st.number_input("Number of augmented samples per image", min_value=1, max_value=10, value=3)
 
-if uploaded_files and st.button("Generate Augmented Images"):
+if uploaded_files:
     all_augmented_images = []
     for uploaded_file in uploaded_files:
         image = Image.open(uploaded_file).convert("RGB")
-        image = image.resize((28, 28))  # Resize for simplicity with the mock decoder
-
-        # Convert to numpy for processing
-        image_np = np.array(image) / 255.0  # Normalize
-        for _ in range(augmentations_count):
-            augmented_image_np = latent_space_augmentation(image_np, mock_encoder, mock_decoder)
-            augmented_image = (augmented_image_np * 255).astype(np.uint8)  # Denormalize
-            augmented_images_io = io.BytesIO()
-            Image.fromarray(augmented_image).save(augmented_images_io, format="JPEG")
-            all_augmented_images.append(augmented_images_io.getvalue())
-
-    if all_augmented_images:
+        augmented_images = augment_image(image, augmentations_count)
+        all_augmented_images.extend(augmented_images)
+
+    if st.button("Download Augmented Dataset") and all_augmented_images:
         zip_buffer = create_downloadable_zip(all_augmented_images)
         st.download_button(
-            label="Download Augmented Dataset",
+            label="Download ZIP",
             data=zip_buffer,
             file_name="augmented_images.zip",
             mime="application/zip"