Criminal_Face_Detection_System.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyPXohOMFBhStLpP+KQEBuzi",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/mukul-mschauhan/Machine-Learning-Projects/blob/master/Criminal_Face_Detection_System.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4fbQjLUJxStq",
        "outputId": "de8ffc34-08e7-42c9-b6d7-b71d441c262a"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: opencv-python in /usr/local/lib/python3.10/dist-packages (4.10.0.84)\n",
            "Requirement already satisfied: numpy>=1.21.2 in /usr/local/lib/python3.10/dist-packages (from opencv-python) (1.26.4)\n",
            "Requirement already satisfied: dlib in /usr/local/lib/python3.10/dist-packages (19.24.2)\n",
            "Collecting face_recognition\n",
            "  Downloading face_recognition-1.3.0-py2.py3-none-any.whl.metadata (21 kB)\n",
            "Collecting face-recognition-models>=0.3.0 (from face_recognition)\n",
            "  Downloading face_recognition_models-0.3.0.tar.gz (100.1 MB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m100.1/100.1 MB\u001b[0m \u001b[31m7.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25h  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "Requirement already satisfied: Click>=6.0 in /usr/local/lib/python3.10/dist-packages (from face_recognition) (8.1.7)\n",
            "Requirement already satisfied: dlib>=19.7 in /usr/local/lib/python3.10/dist-packages (from face_recognition) (19.24.2)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (from face_recognition) (1.26.4)\n",
            "Requirement already satisfied: Pillow in /usr/local/lib/python3.10/dist-packages (from face_recognition) (10.4.0)\n",
            "Downloading face_recognition-1.3.0-py2.py3-none-any.whl (15 kB)\n",
            "Building wheels for collected packages: face-recognition-models\n",
            "  Building wheel for face-recognition-models (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for face-recognition-models: filename=face_recognition_models-0.3.0-py2.py3-none-any.whl size=100566164 sha256=b0777a95e3e61cca6da40a580a3fa9d6088daa99fa96d783e13bf04927cdfa3f\n",
            "  Stored in directory: /root/.cache/pip/wheels/7a/eb/cf/e9eced74122b679557f597bb7c8e4c739cfcac526db1fd523d\n",
            "Successfully built face-recognition-models\n",
            "Installing collected packages: face-recognition-models, face_recognition\n",
            "Successfully installed face-recognition-models-0.3.0 face_recognition-1.3.0\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (1.26.4)\n",
            "\u001b[31mERROR: Could not find a version that satisfies the requirement tkinter (from versions: none)\u001b[0m\u001b[31m\n",
            "\u001b[0m\u001b[31mERROR: No matching distribution found for tkinter\u001b[0m\u001b[31m\n",
            "\u001b[0m"
          ]
        }
      ],
      "source": [
        "!pip install opencv-python\n",
        "!pip install dlib\n",
        "!pip install face_recognition\n",
        "!pip install numpy\n",
        "!pip install tkinter"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Step 2: Face Detection with OpenCV\n",
        "\n",
        "To detect faces in an image or video stream, we will use OpenCV’s Haar Cascade Classifier. This classifier is pre-trained to detect faces and is widely used in computer vision tasks."
      ],
      "metadata": {
        "id": "YIdX70EVxliO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import cv2\n",
        "\n",
        "# Load the pre-trained face detection classifier\n",
        "face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')\n",
        "\n",
        "# Open the webcam or video file\n",
        "cap = cv2.VideoCapture(0)  # 0 for the default webcam\n",
        "\n",
        "while True:\n",
        "    # Read each frame from the webcam\n",
        "    ret, frame = cap.read()\n",
        "\n",
        "    # Convert to grayscale for detection\n",
        "    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\n",
        "\n",
        "    # Detect faces in the image\n",
        "    faces = face_cascade.detectMultiScale(gray, 1.1, 4)\n",
        "\n",
        "    # Draw rectangles around each face\n",
        "    for (x, y, w, h) in faces:\n",
        "        cv2.rectangle(frame, (x, y), (x+w, y+h), (255, 0, 0), 2)\n",
        "\n",
        "    # Display the output\n",
        "    cv2.imshow('Face Detection', frame)\n",
        "\n",
        "    # Break the loop on 'q' key press\n",
        "    if cv2.waitKey(1) & 0xFF == ord('q'):\n",
        "        break\n",
        "\n",
        "# Release the capture object and close all windows\n",
        "cap.release()\n",
        "cv2.destroyAllWindows()"
      ],
      "metadata": {
        "id": "d3z-hJI9xU_y"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Step 3: Face Recognition with face_recognition Library\n",
        "\n",
        "To recognize faces, we will use the face_recognition library, which provides a simple interface for facial recognition using deep learning models. It can compare faces against a database of known faces and identify if there’s a match."
      ],
      "metadata": {
        "id": "majTkugexdUm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import face_recognition\n",
        "import cv2\n",
        "import numpy as np\n",
        "\n",
        "# Load a criminal image from the database (known face)\n",
        "criminal_image = face_recognition.load_image_file(\"criminal.jpg\")\n",
        "criminal_face_encoding = face_recognition.face_encodings(criminal_image)[0]\n",
        "\n",
        "# Array of known face encodings (could be multiple criminals)\n",
        "known_face_encodings = [criminal_face_encoding]\n",
        "known_face_names = [\"John Doe\"]  # Criminal name for display\n",
        "\n",
        "# Initialize the webcam\n",
        "cap = cv2.VideoCapture(0)\n",
        "\n",
        "while True:\n",
        "    ret, frame = cap.read()\n",
        "\n",
        "    # Resize the frame for faster face recognition processing\n",
        "    small_frame = cv2.resize(frame, (0, 0), fx=0.25, fy=0.25)\n",
        "\n",
        "    # Convert to RGB since face_recognition uses RGB format\n",
        "    rgb_small_frame = small_frame[:, :, ::-1]\n",
        "\n",
        "    # Find all faces and their encodings in the current frame\n",
        "    face_locations = face_recognition.face_locations(rgb_small_frame)\n",
        "    face_encodings = face_recognition.face_encodings(rgb_small_frame, face_locations)\n",
        "\n",
        "    # Loop through each face found in the frame\n",
        "    for face_encoding in face_encodings:\n",
        "        # Compare the face to the known faces\n",
        "        matches = face_recognition.compare_faces(known_face_encodings, face_encoding)\n",
        "\n",
        "        name = \"Unknown\"\n",
        "\n",
        "        # If a match is found, display the criminal's name\n",
        "        if True in matches:\n",
        "            first_match_index = matches.index(True)\n",
        "            name = known_face_names[first_match_index]\n",
        "\n",
        "        # Display the name below the face\n",
        "        for (top, right, bottom, left) in face_locations:\n",
        "            top *= 4\n",
        "            right *= 4\n",
        "            bottom *= 4\n",
        "            left *= 4\n",
        "            cv2.rectangle(frame, (left, top), (right, bottom), (0, 255, 0), 2)\n",
        "            cv2.putText(frame, name, (left + 6, bottom - 6), cv2.FONT_HERSHEY_DUPLEX, 0.75, (255, 255, 255), 1)\n",
        "\n",
        "    # Display the resulting image\n",
        "    cv2.imshow('Criminal Face Recognition', frame)\n",
        "\n",
        "    # Break loop on 'q' key press\n",
        "    if cv2.waitKey(1) & 0xFF == ord('q'):\n",
        "        break\n",
        "\n",
        "# Release the webcam and close windows\n",
        "cap.release()\n",
        "cv2.destroyAllWindows()\n"
      ],
      "metadata": {
        "id": "0WnDXZGvxak_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "In this code:\n",
        "\n",
        "The criminal face encoding is compared with the detected faces.\n",
        "If a match is found, the name of the criminal is displayed on the screen."
      ],
      "metadata": {
        "id": "HN2FHFjfxxvq"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Step 4: Storing and Managing the Criminal Database\n",
        "We will use an SQLite database or a CSV file to store criminal face encodings along with metadata such as names, crimes, etc."
      ],
      "metadata": {
        "id": "GlZyDntCx1z3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import sqlite3\n",
        "import face_recognition\n",
        "\n",
        "# Connect to SQLite database (or create it)\n",
        "conn = sqlite3.connect('criminals.db')\n",
        "cursor = conn.cursor()\n",
        "\n",
        "# Create a table to store criminal face encodings\n",
        "cursor.execute('''\n",
        "CREATE TABLE IF NOT EXISTS Criminals (\n",
        "    id INTEGER PRIMARY KEY AUTOINCREMENT,\n",
        "    name TEXT NOT NULL,\n",
        "    face_encoding BLOB NOT NULL\n",
        ")\n",
        "''')\n",
        "\n",
        "# Insert a criminal's face encoding into the database\n",
        "def insert_criminal(name, image_path):\n",
        "    # Load image and encode the face\n",
        "    image = face_recognition.load_image_file(image_path)\n",
        "    face_encoding = face_recognition.face_encodings(image)[0]\n",
        "\n",
        "    # Store the face encoding as a binary string\n",
        "    cursor.execute(\"INSERT INTO Criminals (name, face_encoding) VALUES (?, ?)\", (name, face_encoding.tobytes()))\n",
        "    conn.commit()\n",
        "\n",
        "# Example: Add a new criminal to the database\n",
        "insert_criminal(\"John Doe\", \"criminal.jpg\")\n",
        "\n",
        "# Query criminal data from the database\n",
        "def get_criminals():\n",
        "    cursor.execute(\"SELECT * FROM Criminals\")\n",
        "    return cursor.fetchall()\n",
        "\n",
        "# Close the connection\n",
        "conn.close()\n"
      ],
      "metadata": {
        "id": "1E_2IESJxufu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Step 5: Implementing an Alert System\n",
        "When a match is found between the detected face and a known criminal, the system should generate an alert (e.g., print a message to the console or send an email)."
      ],
      "metadata": {
        "id": "GESP5LmHx639"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def alert_authorities(criminal_name):\n",
        "    print(f\"ALERT! Criminal {criminal_name} has been detected!\")\n"
      ],
      "metadata": {
        "id": "hckLUB2cx8Uz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Step 6: Building the GUI (Optional)\n",
        "You can use Tkinter to build a basic interface that allows users to upload a new criminal’s face, view the detection status, and manage the criminal database."
      ],
      "metadata": {
        "id": "VphdH3HHyB8K"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import tkinter as tk\n",
        "from tkinter import filedialog\n",
        "\n",
        "# Initialize Tkinter window\n",
        "root = tk.Tk()\n",
        "root.title(\"Criminal Face Detection System\")\n",
        "root.geometry(\"400x400\")\n",
        "\n",
        "# Function to upload a new criminal face\n",
        "def upload_new_criminal():\n",
        "    file_path = filedialog.askopenfilename()\n",
        "    name = input(\"Enter the criminal's name: \")\n",
        "    insert_criminal(name, file_path)\n",
        "\n",
        "# Button to upload new criminal\n",
        "upload_button = tk.Button(root, text=\"Upload New Criminal\", command=upload_new_criminal)\n",
        "upload_button.pack(pady=20)\n",
        "\n",
        "# Start Tkinter main loop\n",
        "root.mainloop()"
      ],
      "metadata": {
        "id": "yIJ0GDazx_Sh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 7. Full Prototype Structure\n",
        "This is the structure for the Criminal Face Detection System:\n",
        "\n",
        "Face Detection: Using OpenCV to detect faces in real-time.\n",
        "Face Recognition: Using the face_recognition library to match detected faces against a criminal database.\n",
        "Database: Storing criminal face encodings using SQLite for persistence.\n",
        "Alert System: Sending notifications or printing alerts when a match is found.\n",
        "GUI (Optional): Building a user-friendly interface for managing the system."
      ],
      "metadata": {
        "id": "G_mstC_wyK-v"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "3q-EvDwKyLyG"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}