Spaces:
Running
Running
| title: SafeLicensing | |
| emoji: 🛡️ | |
| colorFrom: indigo | |
| colorTo: blue | |
| sdk: streamlit | |
| sdk_version: 1.38.0 | |
| app_file: app.py | |
| pinned: false | |
| license: mit | |
| # SafeLicensing | |
| 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. | |
| >[!TIP] | |
| > You can directly test the application on the web using the following link: [](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 | |
|  | |
| ### Encrypted Image | |
|  | |
| ## 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) | |