Upload 6 files

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,12 +1,102 @@
----
-title: SafeLicensing
-emoji: 📊
-colorFrom: blue
-colorTo: pink
-sdk: streamlit
-sdk_version: 1.42.2
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 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: [![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.
+
+## 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,6 @@
+libglib2.0-0
+libsm6
+libxrender1
+libxext6
+libfontconfig1
+libgl1-mesa-glx

requirements.txt

@@ -0,0 +1,12 @@
+streamlit
+torch
+torchvision
+pillow
+opencv-python
+numpy
+requests
+ultralytics
+omegaconf
+opencv-python-headless
+moviepy==1.0.3
+imageio-ffmpeg