feat: update model and convert images to RGB for prediction display

This commit includes the update of the model used for predictions. Additionally, it introduces a change to convert images to RGB format for better prediction display.

.gitignore

@@ -158,6 +158,5 @@ cython_debug/
 #  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/
-resources
-images
+
 

Dockerfile

@@ -0,0 +1,17 @@
+# base image
+FROM python:3.10
+
+# working directory
+WORKDIR /app
+
+# Copy the current directory contents into the container at /app
+COPY . .
+
+# Install any needed packages specified in requirements.txt
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Expose the port the app runs in (streamlit default port)
+EXPOSE 8000
+
+# Run app.py when the container launches
+CMD ["streamlit", "run", "app.py"]

README.md

@@ -1,95 +1,98 @@
----
-
-title: Weapon Detection
-emoji: 🐢
-colorFrom: green
-colorTo: green
-sdk: streamlit
-python_version: 3.10
-sdk_version: 1.32.2
-app_file: app.py
-pinned: false
-
----
-
 # weapon-detection-alert-location-share
 
 This project focuses on enhancing the security of different places, like public areas and banks, by implementing a
-robust gun detection and location-sharing system. The system is designed to capture images from an IP camera
-strategically placed within the bank premises. When a captured image contains an identifiable gun, the system takes
-appropriate actions, such as sending alerts or sharing the location of the detected firearm.
+robust gun detection and alert system. The system is designed to capture images from an IP camera strategically placed.
+within the bank's premises. When a captured image contains an identifiable gun, the system takes
+appropriate actions, such as playing alerts or sharing the location of the detected weapons, including knife and guns.
 
 1. **Image Capture:**
 
-   Utilizes an IP camera to continuously capture images in real-time within the camera range.Images are processed and
+   Utilizes an IP camera to continuously capture images in real-time within the camera range. Images are processed and
    analyzed for potential gun presence.
 
 2. **Gun Detection:**
 
    Employs advanced computer vision algorithms for accurate gun detection in captured images.
    The system recognizes various types of firearms and distinguishes them from other objects.
+
 3. Alert Systems:
 
    When a gun is detected, the system triggers immediate alerts.
    Alerts can be configured to notify security personnel, law enforcement, and relevant authorities.
-4. Location Sharing:
 
-   If a gun is detected, the system captures the location of the incident.
-   The location information is shared in real-time with designated security personnel and law enforcement agencies.
+# 🚀 Technologies
 
-## File Structure
+- **Python**
+- **FastAPI**
+- **Streamlit**
+- **YOLO**
+- **OpenCV**
+- **Docker**
 
-File structure of the project
+# File Structure
 
-```commandline
+File structure of the project
 
+```angular2html
+.
 ├── config
-│   ├── config.ini
-│   └── config.yaml
-├── examples
-│   ├── start_cap.py
-│   └── stop_cap.py
+│   └── config.ini
 ├── images
-│   ├── cam_images
-│   └── detected_image
-│       ├── img_1.png
-│       └── img.png
+│   └── cam_images
+│       └── th-3711382641.jpg
 ├── logs
-│   └── gun_det.log
+│   ├── gun_det.log
+│   └── ipcam.log
 ├── resources
+│   ├── alert
+│   │   └── alert.mp3
+│   ├── flag_load_image
+│   ├── image_capturing
 │   └── models
-│       └── yolov7.pt
-├── services
-│   ├── entity
-│   │   └── __init__.py
-│   ├── gun_det_service
-│   │   ├── detection_example_cam.py
-│   │   └── __init__.py
-│   ├── image_capture
-│   │   ├── capture_main.py
-│   │   ├── __init__.py
-│   │   ├── main_start_stop.py
-│   │   └── yolov7_detection_example.py
-│   ├── image_load
+│       ├── best.pt
+│       ├── v1
+│       │   └── best.pt
+├── src
+│   ├── api
+│   │   ├── fast_api.py
 │   │   ├── __init__.py
-│   │   ├── main_load.py
-│   │   ├── main_start_stop.py
-│   │   ├── start_load.py
-│   │   └── stop_load.py
 │   ├── __init__.py
-│   └── location_share
-│       └── __init__.py
-├── utils
+│   ├── services
+│   │   ├── alert_service
+│   │   │   ├── alert_service.py
+│   │   │   ├── __init__.py
+│   │   │   └── __pycache__
+│   │   ├── entity
+│   │   │   ├── entity_config.py
+│   │   │   └── __init__.py
+│   │   ├── image_capture_service
+│   │   │   ├── capture_main.py
+│   │   │   ├── image_load_main.py
+│   │   │   ├── __init__.py
+│   │   ├── __init__.py
+│   │   └── weapon_det_service
+│   │       ├── __init__.py
+│   │       └── weapon_detection_service.py
+│   └── utils
+│       ├── __init__.py
+│       ├── __pycache__
+│       └── settings.py
+├── demos
+│   ├── alert_service_example.py
+│   ├── cam_service_example
+│   │   ├── start_frame_capturing.py
+│   │   └── stop_frame_capturing.py
+│   ├── image_load_service_example
+│   │   ├── start_image_load_example.py
+│   │   └── stop_image_load_example.py
 │   ├─��� __init__.py
-│   ├── __pycache__
-│   │   ├── __init__.cpython-310.pyc
-│   │   └── settings.cpython-310.pyc
-│   └── settings.py
+│   └── single_image_inference.py
 ├── Dockerfiles
+├── app.py
 ├── main.py
 ├── README.md
 ├── requirements.txt
-└── visualization
+└── streamlit_app.py
 
 
 ```
@@ -115,26 +118,56 @@ File structure of the project
 
 4. **Perform Inference/Prediction:**
     ```bash
-    python3 main.py
     streamlit run streamlit_app.py
     ```
 
     - We have to run both programs for inference. py for fastapi post request and streamlit for UI for the prediction.
+5. **Perform Single Image Inference:**
+    ```bash
+    streamlit run app.py
+    ```
 
 ### Docker
 
 ```commandline
+docker build -t myapp .
+```
+
+Then run the docker container
+
+```commandline
+docker myapp
 ```
 
 # 🔥Features
 
+- **Real-time Gun Detection:** The system can detect guns in real-time images captured by an IP camera.
+- **Alert System:** The system can send alerts to security personnel and law enforcement when a gun is detected.
+
 # ⚠️ Limitations
 
+- The system may not be able to detect guns in low-light conditions or when the weapon is partially obscured.
+- Accuracy may vary based on the quality of the images captured by the IP camera.
+
 # Future Work
 
+- One of the future work is to train the model on diverse datasets to improve the model's performance and accuracy.
+- Implement and test the system in real-world scenarios using raspberry pi or other edge devices.
+- Develop a feature to share the location of detected with the authorities.
+
 # Demo
 
+For single image inference i have used huggingface here you can try it
+out [here](https://huggingface.co/spaces/ishworrsubedii/weapon-detection)
+
+![img.png](img.png)
+
 # Recommendations
 
 Your recommendations are highly valuable, and I highly value your insights and suggestions to enhance this project! Feel
-free to propose new features, report bugs, or suggest improvements.
+free to propose new features, report bugs, or suggest improvements.
+
+# Contributors
+
+Contributions are always welcome! If you'd like to contribute to this project or have any suggestions, please feel free
+to reach out or submit a pull request.

app.py

@@ -4,16 +4,14 @@ Date: 2024-04-04
 """
 import streamlit as st
 from PIL import Image
+import cv2
 
 from demos.single_image_inference import single_image_inference
 
-# Constants
 MAX_FILE_SIZE = 5 * 1024 * 1024  # 5MB
 
-# Configure Streamlit
 st.set_page_config(layout="wide", page_title="Weapon Detection")
 
-# Write to Streamlit
 st.write("## Weapon Detection")
 st.write(
     "This app uses a custom trained yolov8 model to detect weapons in images. Upload an image to see the detection results."
@@ -33,6 +31,7 @@ def process_image(upload):
 
         processed_image = single_image_inference(image)
         col2.write("Predicted Image")
+        processed_image = cv2.cvtColor(processed_image, cv2.COLOR_BGR2RGB)
         col2.image(processed_image)
         st.sidebar.markdown("\n")
     except Exception as e:

demos/alert_service_example.py

@@ -2,7 +2,7 @@
 Created By: ishwor subedi
 Date: 2023-12-30
 """
-from services.alert_service.alert_service import AlertService
+from src.services.alert_service.alert_service import AlertService
 
 if __name__ == '__main__':
     alert_service = AlertService("resources/alert/alert.mp3")

demos/cam_service_example/start_frame_capturing.py

@@ -1,6 +1,6 @@
 import os
 import time
-from services.image_capture_service.capture_main import FrameSaver
+from src.services.image_capture_service.capture_main import FrameSaver
 
 
 class ImageCaptureService:

demos/cam_service_example/stop_frame_capturing.py

@@ -6,6 +6,10 @@ class StopImageCaptureServiceExample:
         self.stop_flag_path = stop_flag_path
 
     def stop_example_ipcam_webcam(self):
+        """
+        Stop the image capturing service
+        :return:
+        """
         try:
             with open(self.stop_flag_path, 'w') as flag_file:
                 flag_file.write("True")

demos/image_load_service_example/start_image_load_example.py

@@ -1,8 +1,7 @@
 import os
-import sys
 import time
-import threading
-from services.image_capture_service.image_load_main import ImageLoad
+
+from src.services.image_capture_service.image_load_main import ImageLoad
 
 
 class StartImageLoadExample:
@@ -14,6 +13,10 @@ class StartImageLoadExample:
         self.running = False
 
     def create_stop_flag(self):
+        """
+        Create a stop flag file
+        :return:
+        """
         try:
             with open(self.flag_path, 'w') as flag_file:
                 flag_file.write('False')
@@ -21,6 +24,10 @@ class StartImageLoadExample:
             print(f"Error creating stop flag: {e}")
 
     def check_stop_flag(self):
+        """
+        Check the stop flag
+        :return:
+        """
         try:
             if os.path.exists(self.flag_path):
                 with open(self.flag_path, 'r') as flag_file:
@@ -33,6 +40,11 @@ class StartImageLoadExample:
             return False
 
     def update_stop_flag(self, value):
+        """
+        Update the stop flag
+        :param value: value to update the stop flag
+        :return:
+        """
         try:
             with open(self.flag_path, 'w') as flag_file:
                 flag_file.write(str(value))
@@ -40,6 +52,10 @@ class StartImageLoadExample:
             print(f"Error updating stop flag: {e}")
 
     def start_service(self):
+        """
+        Start the image loading service
+        :return:
+        """
         try:
             self.running = True
             start_load = ImageLoad(self.image_dir, self.model_path)
@@ -70,6 +86,10 @@ class StartImageLoadExample:
                         "Issue encountered while stopping image loading services_trinetra in finally block.")
 
     def stop_service(self):
+        """
+        Stop the image loading service
+        :return:
+        """
         self.update_stop_flag("True")
 
 

demos/image_load_service_example/stop_image_load_example.py

@@ -3,9 +3,7 @@ Created By: ishwor subedi
 Date: 2023-12-28
 """
 
-import os
-import os
-from services import ipcam_logger
+from src.services import ipcam_logger
 
 
 class StopImageLoadServiceExample:
@@ -14,6 +12,10 @@ class StopImageLoadServiceExample:
         self.logger = ipcam_logger()
 
     def stop_service(self):
+        """
+        Stop the image loading service
+        :return:
+        """
         try:
             with open(self.stop_flag_path, 'w') as flag_file:
                 flag_file.write("True")

demos/single_image_inference.py

@@ -2,18 +2,24 @@
 Created By: ishwor subedi
 Date: 2024-04-04
 """
-from services.weapon_det_service.weapon_detection_service import DetectionService
 import cv2 as cv
 
+from src.services.weapon_det_service.weapon_detection_service import DetectionService
+
 
 def single_image_inference(image_path):
+    """
+    This function is used to detect the weapon in the image and save the image with bounding box
+    :param image_path:  image path to detect the weapon
+    :return: image vector with bounding box
+    """
     detection_service = DetectionService(
-        model_path='resources/models/v1/best.pt',
+        model_path='resources/models/v2/best.pt',
 
     )
     results = detection_service.image_det_save(
         image_path=image_path,
-        thresh=0.5
+        thresh=0.4
     )
     for result in results:
         original_image = result.orig_img

main.py

@@ -4,7 +4,7 @@ Date: 2024-01-02
 """
 import uvicorn
 
-from services.api.fast_api import app
+from src.api.fast_api import app
 
 if __name__ == "__main__":
     uvicorn.run(app, host="localhost", port=8000)

requirements.txt

@@ -1,13 +1,12 @@
-ensure==1.0.4
 fastapi==0.110.1
-imagehash==4.3.1
-opencv_python==4.9.0.80
+ImageHash==4.3.1
+opencv_contrib_python==4.6.0.66
+opencv_python==4.8.1.78
+opencv_python_headless==4.8.0.74
 pandas==2.2.1
 Pillow==10.3.0
 pygame==2.5.2
-PyYAML==6.0.1
-PyYAML==6.0.1
 Requests==2.31.0
-streamlit==1.32.2
-ultralytics==8.1.42
+streamlit==1.29.0
+ultralytics==8.0.230
 uvicorn==0.29.0

resources/models/v2/best.pt

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

src/__init__.py

@@ -0,0 +1,4 @@
+"""
+Created By: ishwor subedi
+Date: 2024-04-04
+"""

src/api/__init__.py

@@ -0,0 +1,4 @@
+"""
+Created By: ishwor subedi
+Date: 2023-12-28
+"""

src/api/fast_api.py

@@ -0,0 +1,86 @@
+from fastapi import FastAPI
+from fastapi.responses import JSONResponse
+from fastapi import HTTPException
+import uvicorn
+from demos.cam_service_example.start_frame_capturing import ImageCaptureService
+from demos.cam_service_example.stop_frame_capturing import StopImageCaptureServiceExample
+from demos.image_load_service_example.start_image_load_example import StartImageLoadExample
+from demos.image_load_service_example.stop_image_load_example import StopImageLoadServiceExample
+
+app = FastAPI()
+
+
+def start_ipcam():
+    flag_path = "resources/flag"
+
+    source = 'rtsp://ishwor:subedi@192.168.1.106:5555/h264_opus.sdp'
+
+    image_path_to_save = "images/cam_images"
+    image_hash_threshold = 5
+    image_capture_start_example = ImageCaptureService(flag_path, source, image_path_to_save,
+                                                      image_hash_threshold)
+    image_capture_start_example.start_service()
+
+
+def stop_ipcam():
+    flag_path = "resources/flag"
+
+    image_capture_stop_example = StopImageCaptureServiceExample(flag_path)
+    image_capture_stop_example.stop_load_image_example()
+
+
+def start_detection():
+    flag_path = "resources/flag_load_image"
+
+    image_dir_path = "images/cam_images"
+
+    start_load_image_example = StartImageLoadExample(flag_path, image_dir_path, model_path="resources/model/v1/best.pt")
+    start_load_image_example.start_service()
+
+
+def stop_detection():
+    flag_path = "resources/flag_load_image"
+
+    stop_load_image_example = StopImageLoadServiceExample(flag_path)
+    stop_load_image_example.stop_service()
+
+
+# FastAPI Endpoints
+@app.post("/start_ipcam_server")
+def start_ipcam_server_api():
+    try:
+        start_ipcam()
+        return JSONResponse(content={"message": "IP Cam Server started!"}, status_code=200)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/stop_ipcam_server")
+def stop_ipcam_server_api():
+    try:
+        stop_ipcam()
+        return JSONResponse(content={"message": "IP Cam Server stopped!"}, status_code=200)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/start_detection_service")
+def start_detection_service_api():
+    try:
+        start_detection()
+        return JSONResponse(content={"message": "Image loading Server started!"}, status_code=200)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/stop_detection_service")
+def stop_detection_service_api():
+    try:
+        stop_detection()
+        return JSONResponse(content={"message": "Image loading Server stopped!"}, status_code=200)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="localhost", port=8001)

src/services/__init__.py

@@ -0,0 +1,64 @@
+import os
+import sys
+import logging
+
+
+def configure_logger(logger_name, log_filename, log_dir="logs"):
+    """
+    Configures a logger with specified parameters.
+
+    :param logger_name: Name of the logger.
+    :param log_filename: Name of the log file.
+    :param log_dir: Directory where logs will be stored. Defaults to "logs".
+    :return: Configured logger.
+    """
+    logging_str = "[%(asctime)s:%(levelname)s:%(module)s:%(message)s]"
+
+    log_path = os.path.join(log_dir, log_filename)
+    os.makedirs(log_dir, exist_ok=True)
+
+    logger = logging.getLogger(logger_name)
+    logger.setLevel(logging.INFO)
+
+    formatter = logging.Formatter(logging_str)
+
+    file_handler = logging.FileHandler(log_path)
+    file_handler.setFormatter(formatter)
+
+    stream_handler = logging.StreamHandler(sys.stdout)
+    stream_handler.setFormatter(formatter)
+
+    logger.addHandler(file_handler)
+    logger.addHandler(stream_handler)
+
+    return logger
+
+
+def main_sys_logger(log_dir="logs"):
+    """
+    Configures and returns the main system logger.
+
+    :param log_dir: Directory where logs will be stored. Defaults to "logs".
+    :return: Main system logger.
+    """
+    return configure_logger("main_sys_logger", "gun_det.log", log_dir)
+
+
+def ipcam_logger(log_dir="logs"):
+    """
+    Configures and returns the IP camera logger.
+
+    :param log_dir: Directory where logs will be stored. Defaults to "logs".
+    :return: IP camera logger.
+    """
+    return configure_logger("ipcam_logger", "ipcam.log", log_dir)
+
+
+def detection_logger(log_dir="logs"):
+    """
+    Configures and returns the detection logger.
+
+    :param log_dir: Directory where logs will be stored. Defaults to "logs".
+    :return: Detection logger.
+    """
+    return configure_logger("detection_logger", "detection.log", log_dir)

src/services/alert_service/__init__.py

@@ -0,0 +1,4 @@
+"""
+Created By: ishwor subedi
+Date: 2023-12-29
+"""

src/services/alert_service/alert_service.py

@@ -0,0 +1,30 @@
+"""
+Created By: ishwor subedi
+Date: 2023-12-30
+"""
+
+import pygame
+
+
+class AlertService:
+    def __init__(self, alert_sound_path):
+        self.alert_sound_path = alert_sound_path
+        pygame.init()
+
+    def play_alert(self):
+        """
+        This function help us to play the alert sound
+        :return:
+        """
+        try:
+            pygame.mixer.init()
+            alert_sound = pygame.mixer.Sound(self.alert_sound_path)
+            alert_sound.play()
+            pygame.time.wait(int(alert_sound.get_length() * 1000))  # Wait for the sound to finish playing
+        except pygame.error as e:
+            print(f"Error playing alert sound: {e}")
+
+
+if __name__ == '__main__':
+    alert_service = AlertService("resources/alert/alert.mp3")
+    alert_service.play_alert()

src/services/entity/entity_config.py

@@ -0,0 +1,7 @@
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass(frozen=True)
+class StreamLitConfig:
+    pass

src/services/image_capture_service/capture_main.py

@@ -0,0 +1,95 @@
+"""
+Author: ishwor subedi
+Date: 2023-12-28
+Project Name:gun-detection
+
+"""
+import os
+from PIL import Image
+from datetime import datetime
+import threading
+import imagehash
+import cv2 as cv
+from src.utils.settings import get_frame_save_dir
+
+
+class FrameSaver:
+    def __init__(self, source, image_path_to_save, image_hash_threshold):
+        self.source = source
+        self.image_path_to_save = image_path_to_save
+        if self.image_path_to_save is None or not os.path.exists(self.image_path_to_save):
+            self.image_path_to_save = get_frame_save_dir()
+        self.thread_running = False
+        self.frame_save_thread = None
+        self.cap = cv.VideoCapture(self.source)
+        self.image_hash_threshold = image_hash_threshold
+
+    def start_stream(self):
+        """
+        Start the video stream
+        :return:
+        """
+        self.frame_save_thread = threading.Thread(target=self.video_webcam_frame_extraction)
+        self.frame_save_thread.start()
+        self.thread_running = True
+
+    def stop_stream(self):
+        """
+        Stop the video stream
+        :return:
+        """
+        if self.thread_running:
+            self.thread_running = False
+            self.frame_save_thread.join()
+        self.cap.release()
+
+    def hashing_diff(self, prev_frame, current_frame):
+        """
+        This function is used to calculate the hash difference between the previous frame and the current frame
+        :param prev_frame: previous frame
+        :param current_frame: current frame
+        :return:
+        """
+        if prev_frame is None:
+            return None
+        else:
+            hash1 = imagehash.average_hash(Image.fromarray(prev_frame))
+            hash2 = imagehash.average_hash(Image.fromarray(current_frame))
+            return hash2 - hash1
+
+    def video_webcam_frame_extraction(self):
+        """
+        This function is used to extract the frame from the video stream and save the image if the hash difference is greater than the threshold value.
+        :return:
+        """
+
+        try:
+
+            previous_frame = None
+            while self.cap.isOpened():
+                success, frame = self.cap.read()
+                if success:
+                    hash_diff = self.hashing_diff(previous_frame, frame)
+                    if hash_diff is None or hash_diff > self.image_hash_threshold:
+                        current_time = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+                        name = os.path.join(self.image_path_to_save, f"{current_time}.jpg")
+                        success = cv.imwrite(name, frame)
+                        if success:
+                            print(f"Saved {name}...")
+                        else:
+                            print(f"Failed to save image: {name}")
+                    previous_frame = frame
+        except Exception as e:
+            print(f"Exception occurred: {e}")
+            try:
+                self.stop_stream()
+            except Exception as e:
+                print(f"Failed to stop stream: {e}")
+
+
+if __name__ == '__main__':
+    source = 'rtsp://ishwor:subedi@192.168.1.106:5555/h264_opus.sdp'
+    image_path_to_save = "images/cam_images"
+    image_hash_threshold = 5
+    image_capture_service = FrameSaver(source, image_path_to_save, image_hash_threshold)
+    image_capture_service.video_webcam_frame_extraction()

src/services/image_capture_service/image_load_main.py

@@ -0,0 +1,87 @@
+import os
+import time
+import threading
+from src.services.weapon_det_service.weapon_detection_service import DetectionService
+import cv2
+
+
+class ImageLoad:
+    def __init__(self, image_dir, model_path, ):
+        self.flag = False
+        self.thread_running = False
+        self.image_load = None
+        self.image_path_img = image_dir
+        self.latest_image_path = None
+        self.detection_service = DetectionService(
+            model_path=model_path,
+        )
+        self.filename = None
+        self.display = True
+
+        self.image_info_save = None
+        self.original_image = None
+        self.bbox = None
+        self.image_display_thread = None
+
+    def start_load_image(self):
+        """
+        Start the image loading thread
+        :return:
+        """
+        self.image_load = threading.Thread(target=self.image_list)
+
+        self.image_load.start()
+
+        self.thread_running = True
+
+    def stop_load_image(self):
+        """
+        Stop the image loading thread
+        :return:
+        """
+        if self.thread_running:
+            self.thread_running = False
+
+            self.image_load.join()
+            print("Stopping the image loading thread...")
+
+    def image_list(self):
+        """
+        This function is used to load the image from the image directory
+        :return: None
+        """
+        time.sleep(0.1)
+        while self.thread_running:
+            files = sorted(os.listdir(self.image_path_img))
+            for self.filename in files:
+                if not self.thread_running:
+                    break
+
+                image_path = os.path.join(self.image_path_img, self.filename)
+
+                self.latest_image_path = image_path
+                print("Processing:", self.latest_image_path)
+
+                rd = cv2.imread(self.latest_image_path)
+                time.sleep(0.5)
+                if rd is not None:
+                    results = self.detection_service.image_det_save(image_path=self.latest_image_path,
+                                                                    thresh=0.5,
+                                                                    )
+                    cv2.waitKey(3)
+                    print('done')
+                    os.remove(self.latest_image_path)
+                else:
+                    print('Image Loading Failed .......')
+
+
+if __name__ == '__main__':
+    image_load = ImageLoad(
+        image_dir='images/cam_images',
+        model_path='resources/models/v1/best.pt',
+    )
+
+    image_load.start_load_image()
+    # time.sleep(10)
+    # image_load.stop_load_image()
+    # print("Exiting the program...")

src/services/weapon_det_service/weapon_detection_service.py

@@ -0,0 +1,35 @@
+from pathlib import Path
+from ultralytics import YOLO
+
+
+class DetectionService:
+    def __init__(self, model_path):
+        self.model_path = model_path
+
+    def image_det_save(self, image_path, thresh=0.2):
+        """
+         This function is used to detect the weapon in the image and save the image with bounding box
+        :param image_path: image path to detect the weapon
+        :param thresh: threshold value for detection
+        :return:
+        """
+
+        detector = YOLO(self.model_path)
+        results = detector.predict(image_path, conf=thresh, show=False)
+
+        return results
+
+
+if __name__ == "__main__":
+    detection_service = DetectionService(
+        model_path='resources/models/v1/best.pt',
+
+    )
+    input_image_path = Path(
+        "/home/ishwor/Downloads/PY-4856_Crosman-Bushmaster-MPW-Full_1558033480-458822316.jpg")
+
+    detection_service.image_det_save(
+        image_path=str(input_image_path),
+
+        thresh=0.2
+    )

src/utils/settings.py

@@ -0,0 +1,60 @@
+"""
+Author: ishwor subedi
+Date: 2023-12-27
+
+"""
+import os
+
+from src.services import main_sys_logger
+import cv2 as cv
+
+main_sys_logger = main_sys_logger()
+
+
+def get_frame_save_dir():
+    """
+    Create a directory for saving images from a video.
+
+    :return:
+    str: The path of the created or existing directory.
+    """
+    root_dir = 'images/cam_images'
+
+    frame_dir = os.path.join(root_dir)
+    if not os.path.exists(frame_dir):
+        main_sys_logger.info(f"<<<<<<<<<<<<<<<<<< Folder created {frame_dir} >>>>>>>>>>>>>>>>>>>>")
+        os.makedirs(frame_dir)
+    return frame_dir
+
+
+def imutil(image_path, output_path, new_size=None):
+    """
+    Resize an image using OpenCV.
+
+    :param image_path: str, path to the input image file.
+    :param output_path: str, path to save the resized image.
+    :param new_size: tuple, (width, height) of the desired size.
+    """
+    try:
+        image = cv.imread(image_path)
+
+        if new_size is not None:
+            image = cv.resize(image, new_size)
+
+        cv.imwrite(output_path, image)
+        main_sys_logger.info(f"Image saved to: {output_path}")
+    except Exception as e:
+        main_sys_logger.error(f"Error in imutil: {e}")
+
+
+# Example usage:
+if __name__ == "__main__":
+    # Get the directory for saving frames
+    frame_dir = get_frame_save_dir()
+
+    # Example image path and output path
+    input_image_path = 'path/to/your/input/image.jpg'
+    output_image_path = os.path.join(frame_dir, 'resized_image.jpg')
+
+    # Resize the image and save it
+    imutil(input_image_path, output_image_path, new_size=(800, 600))

streamlit_app.py

@@ -4,7 +4,7 @@ import streamlit as st
 import pandas as pd
 import uvicorn
 
-from services.api.fast_api import app
+from src.api.fast_api import app
 
 LOG_DIR = "logs"
 API_URL = "http://localhost:8000"
@@ -132,5 +132,4 @@ def main_streamlit():
 
 if __name__ == '__main__':
     uvicorn.run(app, host="localhost", port=8000)
-
     main_streamlit()