Upload pixel_char_bria.ipynb

pixel_char_bria.ipynb

@@ -0,0 +1,640 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "gpuType": "T4"
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    },
+    "accelerator": "GPU"
+  },
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "54eb8180"
+      },
+      "source": [
+        "### Hugging Face Login\n",
+        "\n",
+        "To access gated models like `briaai/RMBG-2.0`, you need to log in to Hugging Face. Make sure you have your Hugging Face API token stored in Colab secrets as `HF_TOKEN`. You can create a token [here](https://huggingface.co/settings/tokens)."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "69c32694",
+        "outputId": "4db31198-daed-450c-9fd4-8c84211935d3"
+      },
+      "source": [
+        "from google.colab import userdata\n",
+        "from huggingface_hub import login\n",
+        "\n",
+        "# Retrieve HF_TOKEN from Colab secrets\n",
+        "HF_TOKEN = userdata.get('HF_TOKEN')\n",
+        "\n",
+        "if HF_TOKEN:\n",
+        "    login(token=HF_TOKEN)\n",
+        "    print(\"Successfully logged into Hugging Face.\")\n",
+        "else:\n",
+        "    print(\"HF_TOKEN not found in Colab secrets. Please add it to proceed with gated models.\")"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Successfully logged into Hugging Face.\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!pip install -q \\\n",
+        "    transformers \\\n",
+        "    accelerate \\\n",
+        "    pillow \\\n",
+        "    tqdm \\\n",
+        "    safetensors \\\n",
+        "    kornia"
+      ],
+      "metadata": {
+        "id": "Y3HzjfqPsP45",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "d631aca6-59d8-4fba-969b-8c96168f2131"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "\u001b[?25l   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/1.2 MB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K   \u001b[91m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[91m╸\u001b[0m \u001b[32m1.2/1.2 MB\u001b[0m \u001b[31m35.4 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\r\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.2/1.2 MB\u001b[0m \u001b[31m23.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25h\u001b[?25l   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/3.7 MB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K   \u001b[91m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[91m╸\u001b[0m \u001b[32m3.7/3.7 MB\u001b[0m \u001b[31m130.8 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\r\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m3.7/3.7 MB\u001b[0m \u001b[31m66.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25h"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from google.colab import drive\n",
+        "drive.mount('/content/drive')"
+      ],
+      "metadata": {
+        "id": "WHDPLITy4Rh0"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "Note:  Bria AI remove background tool is a gated access model , meaning you will need a huggingface account , and you\n",
+        "will need to fetch your huggingface api token , the  agree to open source terms of usage on https://huggingface.co/briaai/RMBG-2.0  while logged into your huggingface account"
+      ],
+      "metadata": {
+        "id": "TT87LNT9uAWR"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import zipfile\n",
+        "import shutil\n",
+        "from pathlib import Path\n",
+        "\n",
+        "import torch\n",
+        "import numpy as np\n",
+        "\n",
+        "from PIL import Image\n",
+        "from tqdm import tqdm\n",
+        "\n",
+        "from transformers import AutoModelForImageSegmentation\n",
+        "\n",
+        "# =============================================================================\n",
+        "# SETTINGS: Find all 'animation' zip files in Google Drive\n",
+        "# =============================================================================\n",
+        "\n",
+        "drive_root = Path(\"/content/drive/MyDrive\")\n",
+        "animation_zip_files = []\n",
+        "print(f\"Searching for 'animation' zip files in {drive_root} recursively...\")\n",
+        "\n",
+        "# Use .rglob to find all .zip files recursively in MyDrive\n",
+        "for p in drive_root.rglob(\"*.zip\"):\n",
+        "    if \"animation\" in p.name.lower():\n",
+        "        animation_zip_files.append(p)\n",
+        "\n",
+        "if not animation_zip_files:\n",
+        "    raise FileNotFoundError(\n",
+        "        \"No ZIP files containing 'animation' found in Google Drive. \"\n",
+        "        \"Please upload your animation zip files to your Google Drive.\"\n",
+        "    )\n",
+        "else:\n",
+        "    print(f\"Found {len(animation_zip_files)} animation ZIP file(s):\")\n",
+        "    for i, zip_file in enumerate(animation_zip_files):\n",
+        "        print(f\"{i+1}. {zip_file.name}\")\n",
+        "\n",
+        "# =============================================================================\n",
+        "# DEVICE & MODEL LOADING (Load once for all ZIPs)\n",
+        "# =============================================================================\n",
+        "\n",
+        "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
+        "print(f\"Using device: {device}\")\n",
+        "\n",
+        "print(\"Loading BRIA RMBG 2.0...\")\n",
+        "model = AutoModelForImageSegmentation.from_pretrained(\n",
+        "    \"briaai/RMBG-2.0\",\n",
+        "    trust_remote_code=True\n",
+        ")\n",
+        "model.to(device)\n",
+        "model.eval()\n",
+        "print(\"Model loaded\")\n",
+        "\n",
+        "# =============================================================================\n",
+        "# IMAGE HELPERS\n",
+        "# =============================================================================\n",
+        "\n",
+        "MODEL_SIZE = 1024\n",
+        "\n",
+        "def preprocess_image(image):\n",
+        "    image = image.convert(\"RGB\")\n",
+        "    original_size = image.size\n",
+        "    resized = image.resize((MODEL_SIZE, MODEL_SIZE), Image.Resampling.LANCZOS)\n",
+        "    image_np = (np.array(resized).astype(np.float32) / 255.0)\n",
+        "    image_np = image_np.transpose(2, 0, 1)\n",
+        "    tensor = torch.from_numpy(image_np).unsqueeze(0)\n",
+        "    return tensor, original_size\n",
+        "\n",
+        "def postprocess_mask(mask, original_size):\n",
+        "    mask = mask.squeeze()\n",
+        "    mask = mask.cpu().numpy()\n",
+        "    mask = (\n",
+        "        mask * 255\n",
+        "    ).astype(np.uint8)\n",
+        "    mask_img = Image.fromarray(mask)\n",
+        "    mask_img = mask_img.resize(original_size, Image.Resampling.LANCZOS)\n",
+        "    return mask_img\n",
+        "\n",
+        "# =============================================================================\n",
+        "# PROCESS EACH ANIMATION ZIP FILE\n",
+        "# =============================================================================\n",
+        "\n",
+        "total_processed_images_across_all_zips = 0\n",
+        "processed_output_zip_paths = []\n",
+        "\n",
+        "for idx, zip_filepath in enumerate(animation_zip_files):\n",
+        "    print(f\"\\n{'='*10} Processing {zip_filepath.name} ({idx+1}/{len(animation_zip_files)}) {'='*10}\")\n",
+        "\n",
+        "    # Determine output ZIP filename\n",
+        "    output_zip_filename = f\"{zip_filepath.stem}_transparent.zip\"\n",
+        "\n",
+        "    # Define unique working directories for this specific ZIP file\n",
+        "    # Use the stem of the zip_filepath to create unique temporary directories\n",
+        "    current_zip_base_dir = Path(\"/content/bria_rmbg_temp\") / zip_filepath.stem\n",
+        "    input_dir = current_zip_base_dir / \"input\"\n",
+        "    output_dir = current_zip_base_dir / \"output\"\n",
+        "\n",
+        "    # Clean up previous run's temporary directories for this specific zip, if they exist\n",
+        "    if current_zip_base_dir.exists():\n",
+        "        shutil.rmtree(current_zip_base_dir)\n",
+        "\n",
+        "    input_dir.mkdir(parents=True, exist_ok=True)\n",
+        "    output_dir.mkdir(parents=True, exist_ok=True)\n",
+        "\n",
+        "    # EXTRACT ZIP\n",
+        "    print(f\"Extracting {zip_filepath.name} to {input_dir}...\")\n",
+        "    try:\n",
+        "        with zipfile.ZipFile(zip_filepath, \"r\") as z:\n",
+        "            z.extractall(input_dir)\n",
+        "        print(\"ZIP extracted successfully.\")\n",
+        "    except Exception as e:\n",
+        "        print(f\"Error extracting {zip_filepath.name}: {e}. Skipping this ZIP.\")\n",
+        "        shutil.rmtree(current_zip_base_dir, ignore_errors=True)\n",
+        "        continue\n",
+        "\n",
+        "    # REMOVE MACOS METADATA (e.g., __MACOSX, .DS_Store)\n",
+        "    print(\"Cleaning up macOS metadata...\")\n",
+        "    for macos_dir in input_dir.rglob(\"__MACOSX\"):\n",
+        "        if macos_dir.is_dir():\n",
+        "            try:\n",
+        "                shutil.rmtree(macos_dir, ignore_errors=True)\n",
+        "            except Exception as e:\n",
+        "                print(f\"Warning: Could not remove {macos_dir}: {e}\")\n",
+        "    for ds_store in input_dir.rglob(\".DS_Store\"):\n",
+        "        try:\n",
+        "            ds_store.unlink()\n",
+        "        except Exception as e:\n",
+        "            print(f\"Warning: Could not remove {ds_store}: {e}\")\n",
+        "\n",
+        "    # FIND IMAGES\n",
+        "    IMAGE_EXTENSIONS = {\".jpg\", \".jpeg\", \".png\", \".webp\", \".bmp\", \".tif\", \".tiff\"}\n",
+        "    image_files = []\n",
+        "    for p in input_dir.rglob(\"*\"):\n",
+        "        if not p.is_file():\n",
+        "            continue\n",
+        "        # Skip AppleDouble files (._filename.jpg)\n",
+        "        if p.name.startswith(\"._\"):\n",
+        "            continue\n",
+        "        if p.suffix.lower() in IMAGE_EXTENSIONS:\n",
+        "            image_files.append(p)\n",
+        "\n",
+        "    print(f\"Found {len(image_files)} image(s) in {zip_filepath.name} for processing.\")\n",
+        "\n",
+        "    if len(image_files) == 0:\n",
+        "        print(f\"No valid image files found in {zip_filepath.name}. Skipping background removal for this ZIP.\")\n",
+        "        shutil.rmtree(current_zip_base_dir, ignore_errors=True)\n",
+        "        continue\n",
+        "\n",
+        "    # PROCESS IMAGES (Remove Background)\n",
+        "    processed_images_in_current_zip = 0\n",
+        "    print(f\"Removing backgrounds for images in {zip_filepath.name}...\")\n",
+        "    for image_path in tqdm(image_files, desc=f\"Processing images in {zip_filepath.name}\"):\n",
+        "        try:\n",
+        "            image = Image.open(image_path).convert(\"RGB\")\n",
+        "            tensor, original_size = preprocess_image(image)\n",
+        "            tensor = tensor.to(device)\n",
+        "\n",
+        "            with torch.no_grad():\n",
+        "                prediction = model(tensor)\n",
+        "                if isinstance(prediction, (tuple, list)):\n",
+        "                    prediction = prediction[-1]\n",
+        "                prediction = torch.sigmoid(prediction)\n",
+        "\n",
+        "            mask = postprocess_mask(prediction[0][0], original_size)\n",
+        "            rgba = image.convert(\"RGBA\")\n",
+        "            rgba.putalpha(mask)\n",
+        "\n",
+        "            # Preserve original folder structure and filename, convert to PNG\n",
+        "            relative_path = image_path.relative_to(input_dir)\n",
+        "            output_image_path = output_dir / relative_path.with_suffix(\".png\")\n",
+        "\n",
+        "            output_image_path.parent.mkdir(parents=True, exist_ok=True)\n",
+        "            rgba.save(output_image_path, \"PNG\", optimize=True)\n",
+        "            processed_images_in_current_zip += 1\n",
+        "\n",
+        "        except Exception as e:\n",
+        "            print(f\"\\nFailed to process image: {image_path.name} from {zip_filepath.name}. Error: {e}\")\n",
+        "            # Continue to the next image even if one fails\n",
+        "\n",
+        "    total_processed_images_across_all_zips += processed_images_in_current_zip\n",
+        "    print(f\"Successfully processed {processed_images_in_current_zip} images for {zip_filepath.name}.\")\n",
+        "\n",
+        "    # CREATE OUTPUT ZIP for the current processed files\n",
+        "    print(f\"Creating output ZIP '{output_zip_filename}' for processed images...\")\n",
+        "    temp_output_zip_path = Path(\"/content\") / f\"{zip_filepath.stem}_transparent\" # Temporary zip without .zip suffix\n",
+        "\n",
+        "    # Ensure no old temporary zip file exists\n",
+        "    if temp_output_zip_path.with_suffix(\".zip\").exists():\n",
+        "        temp_output_zip_path.with_suffix(\".zip\").unlink()\n",
+        "\n",
+        "    shutil.make_archive(str(temp_output_zip_path), \"zip\", output_dir)\n",
+        "    print(\"Output ZIP created successfully.\")\n",
+        "\n",
+        "    # SAVE TO GOOGLE DRIVE\n",
+        "    final_destination_path = drive_root / output_zip_filename\n",
+        "    if final_destination_path.exists():\n",
+        "        final_destination_path.unlink() # Overwrite if it exists\n",
+        "\n",
+        "    shutil.move(str(temp_output_zip_path.with_suffix(\".zip\")), str(final_destination_path))\n",
+        "    processed_output_zip_paths.append(final_destination_path)\n",
+        "    print(f\"Processed output ZIP saved to Google Drive: {final_destination_path}\")\n",
+        "\n",
+        "    # Clean up temporary directories for the current ZIP\n",
+        "    shutil.rmtree(current_zip_base_dir, ignore_errors=True)\n",
+        "    print(f\"Cleaned up temporary working directory: {current_zip_base_dir}\")\n",
+        "\n",
+        "# =============================================================================\n",
+        "# FINAL SUMMARY\n",
+        "# =============================================================================\n",
+        "\n",
+        "print(\"\\n\" + \"=\" * 60)\n",
+        "print(\"ALL ANIMATION ZIP FILES PROCESSING COMPLETE\")\n",
+        "print(\"=\" * 60)\n",
+        "print(f\"Total 'animation' ZIP files found: {len(animation_zip_files)}\")\n",
+        "print(f\"Total images processed across all ZIPs: {total_processed_images_across_all_zips}\")\n",
+        "print(\"\\nGenerated output ZIP(s) saved to Google Drive:\")\n",
+        "if processed_output_zip_paths:\n",
+        "    for path in processed_output_zip_paths:\n",
+        "        print(f\"- {path}\")\n",
+        "else:\n",
+        "    print(\"- No output ZIPs were generated.\")\n",
+        "print(\"=\" * 60)"
+      ],
+      "metadata": {
+        "id": "HOMl19GZxBmh"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "58ad1230"
+      },
+      "source": [
+        "import zipfile\n",
+        "import shutil\n",
+        "from pathlib import Path\n",
+        "from PIL import Image\n",
+        "from tqdm import tqdm\n",
+        "\n",
+        "# =============================================================================\n",
+        "# SETTINGS\n",
+        "# =============================================================================\n",
+        "\n",
+        "input_zip_path = Path('/content/drive/MyDrive/running_animation_top_transparent.zip')\n",
+        "output_zip_filename = input_zip_path.name # Keep the same filename for the output zip\n",
+        "drive_root = Path(\"/content/drive/MyDrive\")\n",
+        "\n",
+        "# =============================================================================\n",
+        "# PREPARE WORKING DIRECTORIES\n",
+        "# =============================================================================\n",
+        "\n",
+        "base_dir_name = input_zip_path.stem.replace('_transparent', '_halved_top') # Unique base dir\n",
+        "base_dir = Path(\"/content\") / base_dir_name\n",
+        "\n",
+        "if base_dir.exists():\n",
+        "    shutil.rmtree(base_dir)\n",
+        "\n",
+        "input_extract_dir = base_dir / \"extracted_images\"\n",
+        "output_top_halves_dir = base_dir / \"top_halves\"\n",
+        "\n",
+        "input_extract_dir.mkdir(parents=True, exist_ok=True)\n",
+        "output_top_halves_dir.mkdir(parents=True, exist_ok=True)\n",
+        "\n",
+        "# =============================================================================\n",
+        "# EXTRACT ZIP\n",
+        "# =============================================================================\n",
+        "\n",
+        "print(f\"Extracting {input_zip_path.name} to {input_extract_dir}...\")\n",
+        "with zipfile.ZipFile(input_zip_path, \"r\") as z:\n",
+        "    z.extractall(input_extract_dir)\n",
+        "print(\"ZIP extracted successfully.\")\n",
+        "\n",
+        "# =============================================================================\n",
+        "# FIND IMAGES AND PROCESS\n",
+        "# =============================================================================\n",
+        "\n",
+        "IMAGE_EXTENSIONS = {\".jpg\", \".jpeg\", \".png\", \".webp\", \".bmp\", \".tif\", \".tiff\"}\n",
+        "image_files = []\n",
+        "for p in input_extract_dir.rglob(\"*\"):\n",
+        "    if p.is_file() and p.suffix.lower() in IMAGE_EXTENSIONS:\n",
+        "        image_files.append(p)\n",
+        "\n",
+        "if not image_files:\n",
+        "    raise FileNotFoundError(\"No images found in the extracted ZIP file.\")\n",
+        "\n",
+        "print(f\"Found {len(image_files)} images. Cutting them in half...\")\n",
+        "\n",
+        "processed_count = 0\n",
+        "for image_path in tqdm(image_files, desc=\"Processing images\"):\n",
+        "    try:\n",
+        "        img = Image.open(image_path).convert(\"RGBA\") # Keep alpha channel\n",
+        "        width, height = img.size\n",
+        "\n",
+        "        # Define the halfway point\n",
+        "        half_height = height // 2\n",
+        "\n",
+        "        # Crop the top half\n",
+        "        top_half = img.crop((0, 0, width, half_height))\n",
+        "\n",
+        "        # Save the top half to the output directory, preserving subfolder structure\n",
+        "        relative_path = image_path.relative_to(input_extract_dir)\n",
+        "        output_half_path = output_top_halves_dir / relative_path\n",
+        "\n",
+        "        output_half_path.parent.mkdir(parents=True, exist_ok=True)\n",
+        "        top_half.save(output_half_path, format=img.format) # Save in original format\n",
+        "        processed_count += 1\n",
+        "\n",
+        "    except Exception as e:\n",
+        "        print(f\"Error processing {image_path.name}: {e}\")\n",
+        "\n",
+        "print(f\"Processed {processed_count} images. Creating new ZIP file...\")\n",
+        "\n",
+        "# =============================================================================\n",
+        "# CREATE NEW ZIP WITH TOP HALVES\n",
+        "# =============================================================================\n",
+        "\n",
+        "output_zip_base_name = base_dir / input_zip_path.stem # e.g., /content/running_animation_top_transparent/running_animation_top_transparent\n",
+        "\n",
+        "# Ensure no old temporary zip file exists\n",
+        "if output_zip_base_name.with_suffix(\".zip\").exists():\n",
+        "    output_zip_base_name.with_suffix(\".zip\").unlink()\n",
+        "\n",
+        "shutil.make_archive(str(output_zip_base_name), \"zip\", output_top_halves_dir)\n",
+        "print(f\"New ZIP '{output_zip_filename}' created successfully.\")\n",
+        "\n",
+        "# =============================================================================\n",
+        "# SAVE TO GOOGLE DRIVE AND CLEAN UP\n",
+        "# =============================================================================\n",
+        "\n",
+        "final_destination_path = drive_root / output_zip_filename\n",
+        "\n",
+        "# Overwrite if exists\n",
+        "if final_destination_path.exists():\n",
+        "    final_destination_path.unlink()\n",
+        "\n",
+        "shutil.move(str(output_zip_base_name.with_suffix(\".zip\")), str(final_destination_path))\n",
+        "print(f\"New ZIP saved to Google Drive: {final_destination_path}\")\n",
+        "\n",
+        "shutil.rmtree(base_dir)\n",
+        "print(f\"Cleaned up temporary directory: {base_dir}\")\n",
+        "\n",
+        "print(\"\\nImage splitting and zipping complete!\")"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "5144d0e5"
+      },
+      "source": [
+        "import zipfile\n",
+        "import shutil\n",
+        "from pathlib import Path\n",
+        "from PIL import Image, ImageDraw\n",
+        "from tqdm import tqdm\n",
+        "\n",
+        "# =============================================================================\n",
+        "# SETTINGS\n",
+        "# =============================================================================\n",
+        "\n",
+        "drive_root = Path(\"/content/drive/MyDrive\")\n",
+        "showcase_output_filename = \"transparent_images_showcase.png\"\n",
+        "target_image_height = 256  # Fixed height for all images in the showcase\n",
+        "max_images_per_row = 30    # Maximum images from one zip before starting a new row\n",
+        "background_color = \"#181818\" # Dark gray background\n",
+        "\n",
+        "# =============================================================================\n",
+        "# FIND ALL 'TRANSPARENT' ZIP FILES\n",
+        "# =============================================================================\n",
+        "\n",
+        "transparent_zip_files = []\n",
+        "print(f\"Searching for 'transparent' zip files in {drive_root} (top-level only)...\")\n",
+        "\n",
+        "# Use .glob to find .zip files only in the top-level of MyDrive\n",
+        "for p in drive_root.glob(\"*.zip\"):\n",
+        "    if \"transparent\" in p.name.lower():\n",
+        "        transparent_zip_files.append(p)\n",
+        "\n",
+        "if not transparent_zip_files:\n",
+        "    raise FileNotFoundError(\n",
+        "        \"No ZIP files containing 'transparent' found in Google Drive (top-level). \"\n",
+        "        \"Please ensure you have processed transparent images and they are zipped.\"\n",
+        "    )\n",
+        "else:\n",
+        "    print(f\"Found {len(transparent_zip_files)} transparent ZIP file(s):\")\n",
+        "    for i, zip_file in enumerate(transparent_zip_files):\n",
+        "        print(f\"{i+1}. {zip_file.name}\")\n",
+        "\n",
+        "# =============================================================================\n",
+        "# PROCESS EACH ZIP AND COLLECT RESIZED IMAGES\n",
+        "# =============================================================================\n",
+        "\n",
+        "all_resized_images_by_zip = [] # Stores lists of (resized_img, original_zip_name) for each zip\n",
+        "\n",
+        "for idx, zip_filepath in enumerate(transparent_zip_files):\n",
+        "    print(f\"\\n{'='*10} Processing {zip_filepath.name} ({idx+1}/{len(transparent_zip_files)}) {'='*10}\")\n",
+        "\n",
+        "    current_zip_base_dir = Path(\"/content/showcase_temp\") / zip_filepath.stem\n",
+        "    input_dir = current_zip_base_dir / \"extracted_images\"\n",
+        "\n",
+        "    if current_zip_base_dir.exists():\n",
+        "        shutil.rmtree(current_zip_base_dir)\n",
+        "    input_dir.mkdir(parents=True, exist_ok=True)\n",
+        "\n",
+        "    print(f\"Extracting {zip_filepath.name} to {input_dir}...\")\n",
+        "    try:\n",
+        "        with zipfile.ZipFile(zip_filepath, \"r\") as z:\n",
+        "            z.extractall(input_dir)\n",
+        "        print(\"ZIP extracted successfully.\")\n",
+        "    except Exception as e:\n",
+        "        print(f\"Error extracting {zip_filepath.name}: {e}. Skipping this ZIP.\")\n",
+        "        shutil.rmtree(current_zip_base_dir, ignore_errors=True)\n",
+        "        continue\n",
+        "\n",
+        "    IMAGE_EXTENSIONS = {'.jpg', '.jpeg', '.png', '.webp', '.bmp', '.tif', '.tiff'}\n",
+        "    image_files = []\n",
+        "    for p in input_dir.rglob(\"*\"):\n",
+        "        if p.is_file() and p.suffix.lower() in IMAGE_EXTENSIONS:\n",
+        "            image_files.append(p)\n",
+        "\n",
+        "    if not image_files:\n",
+        "        print(f\"No valid image files found in {zip_filepath.name}. Skipping.\")\n",
+        "        shutil.rmtree(current_zip_base_dir, ignore_errors=True)\n",
+        "        continue\n",
+        "\n",
+        "    images_for_current_zip = []\n",
+        "    print(f\"Resizing {len(image_files)} images from {zip_filepath.name}...\")\n",
+        "    for image_path in tqdm(image_files, desc=f\"Resizing images from {zip_filepath.name}\"):\n",
+        "        try:\n",
+        "            img = Image.open(image_path).convert(\"RGBA\")\n",
+        "            width, height = img.size\n",
+        "            aspect_ratio = width / height\n",
+        "            new_width = int(target_image_height * aspect_ratio)\n",
+        "            resized_img = img.resize((new_width, target_image_height), Image.Resampling.LANCZOS)\n",
+        "            images_for_current_zip.append(resized_img)\n",
+        "        except Exception as e:\n",
+        "            print(f\"Error resizing {image_path.name}: {e}. Skipping.\")\n",
+        "\n",
+        "    # Split images from current zip into chunks for rows\n",
+        "    for i in range(0, len(images_for_current_zip), max_images_per_row):\n",
+        "        all_resized_images_by_zip.append(\n",
+        "            (images_for_current_zip[i:i + max_images_per_row], zip_filepath.name)\n",
+        "        )\n",
+        "\n",
+        "    shutil.rmtree(current_zip_base_dir, ignore_errors=True)\n",
+        "    print(f\"Cleaned up temporary directory: {current_zip_base_dir}\")\n",
+        "\n",
+        "# =============================================================================\n",
+        "# CREATE SHOWCASE IMAGE\n",
+        "# =============================================================================\n",
+        "\n",
+        "if not all_resized_images_by_zip:\n",
+        "    raise RuntimeError(\"No images were successfully processed for the showcase.\")\n",
+        "\n",
+        "print(\"\\nCreating showcase image...\")\n",
+        "\n",
+        "# Calculate dimensions for the showcase image\n",
+        "showcase_width = 0\n",
+        "showcase_height = len(all_resized_images_by_zip) * target_image_height\n",
+        "\n",
+        "for image_row_chunk, _ in all_resized_images_by_zip:\n",
+        "    current_row_width = sum(img.width for img in image_row_chunk)\n",
+        "    if current_row_width > showcase_width:\n",
+        "        showcase_width = current_row_width\n",
+        "\n",
+        "# Create the blank canvas\n",
+        "showcase_image = Image.new(\"RGBA\", (showcase_width, showcase_height), color=background_color)\n",
+        "\n",
+        "current_y_offset = 0\n",
+        "for image_row_chunk, original_zip_name in tqdm(all_resized_images_by_zip, desc=\"Compositing showcase\"):\n",
+        "    current_x_offset = 0\n",
+        "    for img in image_row_chunk:\n",
+        "        showcase_image.paste(img, (current_x_offset, current_y_offset), img)\n",
+        "        current_x_offset += img.width\n",
+        "    current_y_offset += target_image_height\n",
+        "\n",
+        "# =============================================================================\n",
+        "# SAVE SHOWCASE IMAGE TO GOOGLE DRIVE\n",
+        "# =============================================================================\n",
+        "\n",
+        "final_showcase_path = drive_root / showcase_output_filename\n",
+        "\n",
+        "if final_showcase_path.exists():\n",
+        "    final_showcase_path.unlink() # Overwrite if it exists\n",
+        "\n",
+        "showcase_image.save(final_showcase_path)\n",
+        "print(f\"\\nShowcase image saved to Google Drive: {final_showcase_path}\")\n",
+        "\n",
+        "print(\"\\nShowcase creation complete!\")"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "6973ff74"
+      },
+      "source": [
+        "### Disconnect Runtime"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "75027cc1"
+      },
+      "source": [
+        "#@title Auto Disconnect Runtime upon code completion\n",
+        "disconnect_runtime = True #@param {type:'boolean'}\n",
+        "\n",
+        "if disconnect_runtime:\n",
+        "  from google.colab import runtime\n",
+        "  runtime.unassign()"
+      ],
+      "execution_count": null,
+      "outputs": []
+    }
+  ]
+}