Configure for Hugging Face Spaces

.devcontainer/devcontainer.json

@@ -0,0 +1,33 @@
+{
+  "name": "Python 3",
+  // Or use a Dockerfile or Docker Compose file. More info: https://containers.dev/guide/dockerfile
+  "image": "mcr.microsoft.com/devcontainers/python:1-3.11-bullseye",
+  "customizations": {
+    "codespaces": {
+      "openFiles": [
+        "README.md",
+        "app.py"
+      ]
+    },
+    "vscode": {
+      "settings": {},
+      "extensions": [
+        "ms-python.python",
+        "ms-python.vscode-pylance"
+      ]
+    }
+  },
+  "updateContentCommand": "[ -f packages.txt ] && sudo apt update && sudo apt upgrade -y && sudo xargs apt install -y <packages.txt; [ -f requirements.txt ] && pip3 install --user -r requirements.txt; pip3 install --user streamlit; echo '✅ Packages installed and Requirements met'",
+  "postAttachCommand": {
+    "server": "streamlit run app.py --server.enableCORS false --server.enableXsrfProtection false"
+  },
+  "portsAttributes": {
+    "8501": {
+      "label": "Application",
+      "onAutoForward": "openPreview"
+    }
+  },
+  "forwardPorts": [
+    8501
+  ]
+}

.gitattributes

@@ -1,35 +1,3 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
 *.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,171 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# PyPI configuration file
+.pypirc

Dockerfile

@@ -1,20 +1,35 @@
-FROM python:3.13.5-slim
+# Use an official Python runtime as a parent image
+FROM python:3.9-slim
 
-WORKDIR /app
+# Set environment variables
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1
 
+# Install system dependencies
 RUN apt-get update && apt-get install -y \
-    build-essential \
     curl \
-    git \
+    libglib2.0-0 \
+    libsm6 \
+    libxrender1 \
+    libxext6 \
+    libfontconfig1 \
+    libgl1-mesa-glx \
     && rm -rf /var/lib/apt/lists/*
 
-COPY requirements.txt ./
-COPY src/ ./src/
+# Set the working directory in the container
+WORKDIR /app
+
+# Copy the current directory contents into the container at /app
+COPY . /app
 
-RUN pip3 install -r requirements.txt
+# Install any needed packages specified in requirements.txt
+RUN pip install --no-cache-dir -r requirements.txt
 
+# Make port 8501 available to the world outside this container
 EXPOSE 8501
 
-HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
+# Healthcheck to verify the application is running
+HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health || exit 1
 
-ENTRYPOINT ["streamlit", "run", "src/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]
+# Run app.py when the container launches
+CMD ["streamlit", "run", "--server.address", "0.0.0.0", "app.py"]

Dockerfile.gpu

@@ -0,0 +1,41 @@
+# Use NVIDIA CUDA base image
+FROM nvidia/cuda:11.6.2-cudnn8-runtime-ubuntu20.04
+
+# Set environment variables
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    DEBIAN_FRONTEND=noninteractive
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    python3-pip \
+    python3-dev \
+    curl \
+    libglib2.0-0 \
+    libsm6 \
+    libxrender1 \
+    libxext6 \
+    libfontconfig1 \
+    libgl1-mesa-glx \
+    && rm -rf /var/lib/apt/lists/*
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Copy the current directory contents into the container at /app
+COPY . /app
+
+# Install any needed packages specified in requirements.txt
+RUN pip3 install --no-cache-dir -r requirements.txt
+
+# Install PyTorch with CUDA support
+RUN pip3 install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu116
+
+# Make port 8501 available to the world outside this container
+EXPOSE 8501
+
+# Healthcheck to verify the application is running
+HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health || exit 1
+
+# Run app.py when the container launches
+CMD ["streamlit", "run", "--server.address", "0.0.0.0", "app.py"]

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -1,20 +1,171 @@
 ---
 title: SafeLicensing
-emoji: 🚀
-colorFrom: red
-colorTo: red
-sdk: docker
-app_port: 8501
-tags:
-- streamlit
+emoji: 🛡️
+colorFrom: indigo
+colorTo: blue
+sdk: streamlit
+sdk_version: 1.31.0
+app_file: app.py
 pinned: false
-short_description: Streamlit template space
 license: apache-2.0
 ---
 
-# Welcome to Streamlit!
+# SafeLicensing
 
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
+This project demonstrates a pipeline for detecting license plates in images using YOLOv8 and encrypting the detected regions with a Chaotic Logistic Map encryption algorithm. It provides a user-friendly interface built with Streamlit.
 
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+>[!TIP]
+> You can directly test the application on the web using the following link: [![Open in Streamlit](https://static.streamlit.io/badges/streamlit_badge_black_white.svg)](https://share.streamlit.io/fahimfba/safelicensing/main/app.py)
+
+## Features
+
+- **License Plate Detection**: Uses the YOLOv8 model to detect license plates in uploaded images.
+- **Chaotic Encryption**: Encrypts the detected license plate regions using a two-layer XOR-based chaotic logistic map algorithm.
+- **Streamlit Web App**: A simple interface to upload images, detect license plates, encrypt them, and download the results.
+
+## Installation
+
+1. Clone the repository:
+   ```bash
+   git clone https://github.com/FahimFBA/SafeLicensing.git
+   cd SafeLicensing
+   ```
+
+2. Install `ffmpeg` for video processing (Linux):
+   ```bash
+   sudo apt-get install ffmpeg
+   ```
+
+   or, for macOS:
+   ```bash
+   brew install ffmpeg
+   ```
+
+3. Install the required dependencies:
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+4. Download the YOLOv8 weights file (`best.pt`) and place it in the root directory of the project. You can train your own model or use a pre-trained one. This repository already have our model from [SEncrypt](https://github.com/IsratIJK/SEncrypt) located in [best.pt](./best.pt) file.
+
+## Usage
+
+1. Run the Streamlit app:
+   ```bash
+   streamlit run app.py
+   ```
+
+2. Open the app in your browser (typically at `http://localhost:8501`).
+
+3. Follow the steps:
+   - Upload an image or provide a URL.
+   - Adjust the encryption key seed using the slider.
+   - Click the "Detect & Encrypt" button to process the image.
+
+4. Download the encrypted image directly from the app.
+
+## Docker Usage
+
+You can run this application using Docker. There are two options: CPU-only and GPU-enabled.
+
+### CPU Version
+
+1. Build the Docker image:
+   ```bash
+   docker build -t safelicensing .
+   ```
+
+2. Run the Docker container:
+   ```bash
+   docker run -d -p 8501:8501 --name safelicensing_container safelicensing
+   ```
+
+### GPU Version (for NVIDIA GPU users)
+
+1. Ensure you have the NVIDIA Container Toolkit installed. If not, follow the [official installation guide](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/install-guide.html).
+
+2. Build the GPU-enabled Docker image:
+   ```bash
+   docker build -f Dockerfile.gpu -t safelicensing-gpu .
+   ```
+
+3. Run the GPU-enabled Docker container:
+   ```bash
+   docker run -d -p 8501:8501 --gpus all --name safelicensing_gpu_container safelicensing-gpu
+   ```
+
+### Common Steps
+
+4. Check if the container is running:
+   ```bash
+   docker ps
+   ```
+   You should see a container named `safelicensing_container` or `safelicensing_gpu_container` in the list.
+
+5. View the container logs:
+   ```bash
+   docker logs safelicensing_container  # or safelicensing_gpu_container for GPU version
+   ```
+   This will show you the Streamlit startup logs and any errors if they occur.
+
+6. Open the app in your browser by navigating to `http://localhost:8501`.
+
+If you encounter any issues:
+- Ensure that port 8501 is not being used by another application.
+- Check the container logs for any error messages.
+- If needed, you can stop and remove the container using:
+  ```bash
+  docker stop safelicensing_container  # or safelicensing_gpu_container
+  docker rm safelicensing_container  # or safelicensing_gpu_container
+  ```
+  Then, try running the container again.
+
+Note: The GPU version requires an NVIDIA GPU and proper drivers. If you don't have a compatible GPU, use the CPU version instead.
+
+## Workflow
+
+1. **License Plate Detection**:
+   - The YOLOv8 model is used to detect license plates in the input image. The model has been taken from [SEncrypt](https://github.com/IsratIJK/SEncrypt).
+   - Detected regions are highlighted with bounding boxes.
+
+2. **Chaotic Logistic Map Encryption**:
+   - A chaotic logistic map generates two XOR-based encryption keys.
+   - Pixels in the license plate regions are shuffled and encrypted in two stages.
+   - The encrypted region replaces the original plate in the image.
+
+3. **Visualization and Download**:
+   - The original, detected, and encrypted images are displayed in the app.
+   - Encrypted images can be downloaded as PNG files.
+
+## Files
+
+- `app.py`: The main Streamlit app file.
+- `requirements.txt`: Python dependencies for the project.
+- `best.pt`: YOLOv8 weights file (not included, add your own).
+
+## Key Parameters
+
+- **Encryption Key Seed**: A slider in the app adjusts the seed value for the chaotic logistic map, affecting the encryption's randomness.
+
+## Example Screenshots
+
+### Original Image
+
+![Original Image](./img/lpr-tesla-license-plate-recognition-1910x1000.jpg)
+
+### Encrypted Image
+
+![Encrypted Image](./img/encrypted_plate.png)
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for more details.
+
+## Contact
+
+For any queries, feel free to reach out:
+
+- **Author**: Md. Fahim Bin Amin
+- **GitHub**: [FahimFBA](https://github.com/FahimFBA)
+
+- **Other Authors**: [Rafid Mehda](https://github.com/rafid29mehda), [Israt Jahan Khan](https://github.com/IsratIJK)

app.py

@@ -0,0 +1,293 @@
+import streamlit as st
+import os
+import requests
+import numpy as np
+from PIL import Image, ImageDraw
+import io
+import random
+from ultralytics import YOLO
+import time
+import cv2
+from moviepy.editor import VideoFileClip, ImageSequenceClip
+
+###############################################################################
+# 1. Chaotic Logistic Map Encryption Functions
+###############################################################################
+
+def logistic_map(r, x):
+    return r * x * (1 - x)
+
+def generate_key(seed, n):
+    """
+    Generate a chaotic key (array of size n) using a logistic map and the given seed.
+    """
+    key = []
+    x = seed
+    for _ in range(n):
+        x = logistic_map(3.9, x)
+        key.append(int(x * 255) % 256)  # map float to 0-255
+    return np.array(key, dtype=np.uint8)
+
+def shuffle_pixels(img_array, seed):
+    """
+    Shuffle the pixels in img_array based on a random sequence seeded by '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)
+    shuffled = flattened[indices]
+    return shuffled.reshape(h, w, c), indices
+
+def encrypt_image(img_array, seed):
+    """
+    Encrypt the given image array using a two-layer XOR + pixel shuffling approach.
+    """
+    h, w, c = img_array.shape
+    flat_image = img_array.flatten()
+    # First chaotic key
+    chaotic_key_1 = generate_key(seed, len(flat_image))
+    # XOR-based encryption (first layer)
+    encrypted_flat_1 = [p ^ chaotic_key_1[i] for i, p in enumerate(flat_image)]
+    encrypted_array_1 = np.array(
+        encrypted_flat_1, dtype=np.uint8).reshape(h, w, c)
+    # Shuffle
+    shuffled_array, _ = shuffle_pixels(encrypted_array_1, seed)
+    # Second chaotic key
+    chaotic_key_2 = generate_key(seed * 1.1, len(flat_image))
+    shuffled_flat = shuffled_array.flatten()
+    encrypted_flat_2 = [p ^ chaotic_key_2[i]
+                        for i, p in enumerate(shuffled_flat)]
+    doubly_encrypted_array = np.array(
+        encrypted_flat_2, dtype=np.uint8).reshape(h, w, c)
+    return doubly_encrypted_array
+
+###############################################################################
+# 2. YOLOv8 License Plate Detection
+###############################################################################
+
+@st.cache_resource(show_spinner=False)
+def load_model(weights_path: str):
+    """
+    Loads the YOLOv8 model from local .pt weights.
+    """
+    model = YOLO(weights_path)
+    return model
+
+def detect_license_plates(model, pil_image):
+    """
+    Runs YOLOv8 detection on the PIL image.
+    Returns:
+      - image_with_boxes: PIL image with bounding boxes drawn
+      - bboxes: list of (x1, y1, x2, y2) for detected license plates
+    """
+    np_image = np.array(pil_image)
+    results = model.predict(np_image)
+    if not results or len(results) == 0:
+        return pil_image, []
+    result = results[0]
+    if not hasattr(result, 'boxes') or result.boxes is None or len(result.boxes) == 0:
+        return pil_image, []
+    bboxes = []
+    draw = ImageDraw.Draw(pil_image)
+    for box in result.boxes:
+        coords = box.xyxy[0].tolist()  # [x1, y1, x2, y2]
+        cls_id = int(box.cls[0].item())
+        cls_name = model.names.get(cls_id, "Unknown")
+        if cls_name.lower() == "licenseplate" or cls_id == 0:
+            x1, y1, x2, y2 = map(int, coords)
+            bboxes.append((x1, y1, x2, y2))
+            draw.rectangle([x1, y1, x2, y2], outline="red", width=2)
+    return pil_image, bboxes
+
+###############################################################################
+# 3. Video Processing Functions
+###############################################################################
+
+def process_video(video_path, model, key_seed):
+    """
+    Process video frame by frame, detect license plates, and encrypt them.
+    """
+    cap = cv2.VideoCapture(video_path)
+    fps = cap.get(cv2.CAP_PROP_FPS)
+    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    
+    processed_frames = []
+    
+    while cap.isOpened():
+        ret, frame = cap.read()
+        if not ret:
+            break
+        
+        pil_image = Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
+        _, bboxes = detect_license_plates(model, pil_image)
+        
+        if bboxes:
+            for (x1, y1, x2, y2) in bboxes:
+                plate_region = frame[y1:y2, x1:x2]
+                encrypted_region = encrypt_image(plate_region, key_seed)
+                frame[y1:y2, x1:x2] = encrypted_region
+        
+        processed_frames.append(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
+    
+    cap.release()
+    return processed_frames, fps, (width, height)
+
+def create_video_from_frames(frames, fps, size, output_path, audio_path=None):
+    """
+    Create a video from processed frames and optionally add audio.
+    """
+    clip = ImageSequenceClip(frames, fps=fps)
+    
+    if audio_path:
+        audio = VideoFileClip(audio_path).audio
+        clip = clip.set_audio(audio)
+    
+    clip.write_videofile(output_path, codec='libx264')
+
+###############################################################################
+# 4. Streamlit App
+###############################################################################
+
+def main():
+    st.title("YOLOv8 + Chaotic Encryption for Images and Videos")
+    st.write(
+        """
+        **Instructions**:
+        1. Provide an image or video (URL or file upload).
+        2. If a license plate is detected, only that region will be **encrypted** using Chaotic Logistic Map.
+        3. Download the final result (image or video).
+        """
+    )
+    default_model_path = "best.pt"
+    model_path = st.sidebar.text_input(
+        "YOLOv8 Weights (.pt)", value=default_model_path)
+    if not os.path.isfile(model_path):
+        st.warning(
+            f"Model file '{model_path}' not found. Please upload or provide a correct path.")
+        st.stop()
+    with st.spinner("Loading YOLOv8 model..."):
+        model = load_model(model_path)
+    st.success("Model loaded successfully!")
+    
+    st.subheader("Input")
+    input_type = st.radio("Select input type", ["Image", "Video"])
+    
+    if input_type == "Image":
+        image_url = st.text_input("Image URL (optional)")
+        uploaded_file = st.file_uploader("Or upload an image file", type=["jpg", "jpeg", "png"])
+    else:
+        video_url = st.text_input("Video URL (optional)")
+        uploaded_file = st.file_uploader("Or upload a video file", type=["mp4", "avi", "mov"])
+    
+    key_seed = st.slider("Encryption Key Seed (0 < seed < 1)", 0.001, 0.999, 0.5, step=0.001)
+    
+    if st.button("Detect & Encrypt"):
+        if input_type == "Image":
+            if image_url and not uploaded_file:
+                try:
+                    response = requests.get(image_url, timeout=10)
+                    response.raise_for_status()
+                    image_bytes = io.BytesIO(response.content)
+                    pil_image = Image.open(image_bytes).convert("RGB")
+                except Exception as e:
+                    st.error(f"Failed to load image from URL. Error: {str(e)}")
+                    return
+            elif uploaded_file:
+                try:
+                    pil_image = Image.open(uploaded_file).convert("RGB")
+                except Exception as e:
+                    st.error(f"Failed to open uploaded image. Error: {str(e)}")
+                    return
+            else:
+                st.warning("Please either paste a valid URL or upload an image.")
+                return
+            
+            st.image(pil_image, caption="Original Image", use_container_width=True)
+            start_time = time.time()
+            
+            with st.spinner("Detecting license plates..."):
+                image_with_boxes, bboxes = detect_license_plates(model, pil_image.copy())
+            
+            st.image(image_with_boxes, caption="Detected Plate(s)", use_container_width=True)
+            
+            if not bboxes:
+                st.warning("No license plates detected.")
+                return
+            
+            with st.spinner("Encrypting license plates..."):
+                np_img = np.array(pil_image)
+                encrypted_np = np_img.copy()
+                for (x1, y1, x2, y2) in bboxes:
+                    x1 = max(x1, 0)
+                    y1 = max(y1, 0)
+                    x2 = min(x2, encrypted_np.shape[1])
+                    y2 = min(y2, encrypted_np.shape[0])
+                    plate_region = encrypted_np[y1:y2, x1:x2]
+                    if plate_region.size == 0:
+                        st.warning(f"Detected plate region ({x1}, {y1}, {x2}, {y2}) is invalid or empty.")
+                        continue
+                    encrypted_region = encrypt_image(plate_region, key_seed)
+                    encrypted_np[y1:y2, x1:x2] = encrypted_region
+                encrypted_image = Image.fromarray(encrypted_np)
+            
+            elapsed_time = time.time() - start_time
+            st.write(f"Total time taken for detection and encryption: **{elapsed_time:.2f} seconds**")
+            st.image(encrypted_image, caption="Encrypted Image", use_container_width=True)
+            
+            buf = io.BytesIO()
+            encrypted_image.save(buf, format="PNG")
+            buf.seek(0)
+            st.download_button(
+                label="Download Encrypted Image",
+                data=buf,
+                file_name="encrypted_plate.png",
+                mime="image/png"
+            )
+        
+        else:  # Video processing
+            if video_url and not uploaded_file:
+                try:
+                    response = requests.get(video_url, timeout=10)
+                    response.raise_for_status()
+                    video_bytes = io.BytesIO(response.content)
+                    with open("temp_video.mp4", "wb") as f:
+                        f.write(video_bytes.getvalue())
+                    video_path = "temp_video.mp4"
+                except Exception as e:
+                    st.error(f"Failed to load video from URL. Error: {str(e)}")
+                    return
+            elif uploaded_file:
+                video_path = "temp_video.mp4"
+                with open(video_path, "wb") as f:
+                    f.write(uploaded_file.getvalue())
+            else:
+                st.warning("Please either paste a valid video URL or upload a video file.")
+                return
+            
+            with st.spinner("Processing video..."):
+                start_time = time.time()
+                processed_frames, fps, size = process_video(video_path, model, key_seed)
+                create_video_from_frames(processed_frames, fps, size, "encrypted_video.mp4", video_path)
+                elapsed_time = time.time() - start_time
+            
+            st.write(f"Total time taken for video processing: **{elapsed_time:.2f} seconds**")
+            st.video("encrypted_video.mp4")
+            
+            with open("encrypted_video.mp4", "rb") as f:
+                st.download_button(
+                    label="Download Encrypted Video",
+                    data=f,
+                    file_name="encrypted_video.mp4",
+                    mime="video/mp4"
+                )
+            
+            # Clean up temporary files
+            os.remove("temp_video.mp4")
+            os.remove("encrypted_video.mp4")
+
+if __name__ == "__main__":
+    main()

best.pt

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

packages.txt

@@ -0,0 +1,7 @@
+libglib2.0-0
+libsm6
+libxrender1
+libxext6
+libfontconfig1
+libgl1-mesa-glx
+ffmpeg

requirements.txt

@@ -1,3 +1,11 @@
-altair
-pandas
-streamlit
+streamlit
+torch
+torchvision
+pillow
+opencv-python-headless
+numpy
+requests
+ultralytics
+omegaconf
+moviepy==1.0.3
+imageio-ffmpeg