WIP

Author: gaganmanku96

README.md

@@ -26,117 +26,44 @@ The objective of this project is to help Police and higher authorities to track
 In such cases, the ideal approach is to go through CCTV footages and evidences. Again, this can be very time consuming and given the number of people that go missing everyday, it can be a challanage to keep up with it.<br>
 
 ## Solution (Project's Implementation)
-### 1. Registering New Cases
-The first step is to register a new case. The GUI application is built using <b>PyQT5</b> that allows you to collect all relevant information and store it in database <b>Postgres</b>.
-> Please ignore the SRK's image. It is just for the sake of project :)
-
-![New Case Window](resources/new_case.PNG)
-
-### 2. Waiting for Users to submit images
-So far we have only talked about 'how new cases will be registered', the next thing we have to do is to match these registered cases but who do we match it with? This is where ours Users come in. These users are common people like you and me who wants to make a change in the society.<br>
-The common people will use an application on their mobile to submit photos of people who they think have lost or found begging while keeping them their identity anonymous. The anonymous part is very important because they fear of local <i>Gundas</i> that might create trouble for them.<br>
-> Mobile Application
-![Mobile Application](resources/mobile_application.PNG)
-
-> An android Application can also be build and used but I have very little experience in it.
-### 3. Matching Cases
-The next step is to match the case images and user submitted images. To match <b>KNN Algorithm </b> is used.
-![Main Application](resources/app_window.PNG)
-
-## How to run
-#### 1. With Docker (Easy)
-Prerequisites
-```
-Docker (docker-compose as well)
-```
-```
-$ git clone https://github.com/gaganmanku96/Finding-missing-person-using-AI
-$ cd Finding-missing-person-using-AI
-$ docker-compose up --build
-$ cd app
-$ pip install -r requirements.txt --no-cache-dir
-$ python login_window.py
-```
-At this point you'll see a window like this
-![Login Window](resources/login_screen.PNG)
-
-> Default username: admin
-> Default password: admin
-> 
-> Login window makes sure that only authenticated can view the registered cases. Each user can only view the cases submitted by him.
-> NOTE: There is no concpet of superuser.
-
-After logging in you'll see the main screen through which you'll be able to submit cases.
-
-##### To run the mobile application:
-```
-$ cd mobile_app
-```
-or (if you are inside app dir) 
-```
-$ ../mobile_app
-```
-```
-$ python ui.py
-```
-After that you'll see a window like this<br>
-![mobile application](resources/mobile_application.PNG)
-
-You can this to submit user images or you can create your own mobile app.
-
-Once done you'll have to <b>Click on Refresh</b> button on train KNN Model and then on <b>Match</b> to start Matching Images.
-
-#### 2. Without Docker (Intermediate)
-Here are the step you have to do
-1. Install Postgres Database and replace the username and password in config/.env.file
-2. The next step is to run database and make sure it is working.
-```
-$ cd database
-$ pip install -r requirements.txt
-$ uvicorn main:app --port 8002
-```
-3. Next, the face encoding api
-```
-$ cd face_encoding
-$ pip install -r requirements.txt
-$ uvicorn main:app --port 8000
-```
-> If you are using non-conda environment like venv then it might give error while installing dlib library.
-4. Running  the application
-```
-$ cd app
-$ pip install -r requirements.txt
-$ python login.py
-```
-At this point you'll see a window like this
-![Login Window](resources/login_screen.PNG)
-
-> Default username: admin
-> Default password: admin
-> 
-> Login window makes sure that only authenticated can view the registered cases. Each user can only view the cases submitted by him.
-> NOTE: There is no concpet of superuser.
-
-After logging in you'll see the main screen through which you'll be able to submit cases.
-
-##### To run the mobile application:
-```
-$ cd mobile_app
-```
-or (if you are inside app dir) 
-```
-$ ../mobile_app
-```
-```
-$ python ui.py
-```
-After that you'll see a window like this<br>
-![mobile application](resources/mobile_application.PNG)
-
-You can this to submit user images or you can create your own mobile app.
-
-Once done you'll have to <b>Click on Refresh</b> button on train KNN Model and then on <b>Match</b> to start Matching Images.
 
+### 2025 Major Update: Migration to MediaPipe Face Mesh
+- The project has migrated from dlib-based facial landmark/encoding to **MediaPipe Face Mesh** for all facial feature extraction and matching.
+- All code and database logic now use MediaPipe landmarks, making the app easier to run and maintain (no dlib dependency).
+- Registration and matching flows are updated to use face mesh data (stored as JSON in the database).
+- All legacy dlib/face_encoding code and dependencies have been removed.
+- The database schema now expects a `face_mesh` column (string/JSON) for facial features.
+- The app is compatible with Python 3.12+ and the latest Streamlit.
+
+### Features
+- User authentication (with hashed passwords, Streamlit Authenticator)
+- Register new missing person cases (with image upload and face mesh extraction)
+- Public/mobile submission of potential matches
+- Case matching using face mesh features
+- Admin/user dashboard for case management
+
+
+## How to Run
+
+1. Clone the repository and install dependencies:
+   ```bash
+   git clone https://github.com/gaganmanku96/Finding-missing-person-using-AI.git
+   cd Finding-missing-person-using-AI
+   pip install -r requirements.txt
+   ```
+2. Run the main web app:
+   ```bash
+   streamlit run Home.py
+   ```
+3. To use the mobile/public submission app:
+   ```bash
+   streamlit run mobile_app.py
+   ```
+
+- The database will auto-create on first run (SQLite, file: `sqlite_database.db`).
+- Images are stored in the `resources/` folder.
+
+> **Note:** If you previously used the dlib version, delete any old database files and images, as the schema and features have changed.
 
 ## What is left?
  - [x] Login (Authentication)
@@ -155,3 +82,4 @@ Once done you'll have to <b>Click on Refresh</b> button on train KNN Model and t
 ## Vote of Thanks
 - Thanks to [Davis King](https://github.com/davisking) for creating dlib and for providing the trained facial feature
   detection and face encoding models used in this project.
+- Thanks to the [MediaPipe](https://mediapipe.dev/) team for their open-source face mesh solution, now powering this project!

classifier.pkl

@@ -1,30 +1,53 @@
 import streamlit as st
+import uuid
 from pages.helper import db_queries, match_algo, train_model
 from pages.helper.streamlit_helpers import require_login
 
 
 def case_viewer(registered_case_id, public_case_id):
-    case_details = db_queries.get_registered_case_detail(registered_case_id)[0]
-    data_col, image_col = st.columns(2)
-    for text, value in zip(
-        ["Name", "Mobile", "Age", "Last Seen", "Birth marks"], case_details
-    ):
-        data_col.write(f"{text}: {value}")
     try:
+        # Convert string IDs to UUID objects
+        try:
+            # Try to convert to UUID - this handles both string and UUID inputs
+            registered_uuid = uuid.UUID(str(registered_case_id))
+            public_uuid = uuid.UUID(str(public_case_id))
+
+            # Convert back to string in the correct format for the database
+            registered_case_id = str(registered_uuid)
+            public_case_id = str(public_uuid)
+        except ValueError as e:
+            st.error(f"Invalid UUID format: {str(e)}")
+            return
+
+        # Get case details using the properly formatted UUID
+        case_details = db_queries.get_registered_case_detail(registered_case_id)[0]
+        data_col, image_col = st.columns(2)
+        for text, value in zip(
+            ["Name", "Mobile", "Age", "Last Seen", "Birth marks"], case_details
+        ):
+            data_col.write(f"{text}: {value}")
+
+        # Update status with properly formatted UUIDs
         db_queries.update_found_status(registered_case_id, public_case_id)
         st.success(
             "Status Changed. Next time it will be only visible in confirmed cases page"
         )
-        image_col.image(
-            "./resources/" + str(registered_case_id) + ".jpg",
-            width=80,
-            use_container_width=False,
-        )
+
+        # Display image
+        try:
+            image_col.image(
+                "./resources/" + registered_case_id + ".jpg",
+                width=80,
+                use_container_width=False,
+            )
+        except Exception as img_err:
+            st.warning(f"Could not load image: {str(img_err)}")
+
     except Exception as e:
         import traceback
 
         traceback.print_exc()
-        st.error("Something went wrong. Please check logs")
+        st.error(f"Something went wrong: {str(e)}. Please check logs")
 
 
 if "login_status" not in st.session_state:
@@ -47,9 +70,12 @@ def case_viewer(registered_case_id, public_case_id):
             matched_ids = match_algo.match()
 
             if matched_ids["status"]:
-                for matched_id, submitted_case_id in matched_ids["result"].items():
-                    case_viewer(matched_id, submitted_case_id[0])
-                    st.write("---")
+                if not matched_ids["result"]:
+                    st.info("No match found")
+                else:
+                    for matched_id, submitted_case_id in matched_ids["result"].items():
+                        case_viewer(matched_id, submitted_case_id[0])
+                        st.write("---")
             else:
                 st.info("No match found")
 

pages/4_Match Cases.py

@@ -108,6 +108,7 @@ def get_public_case_detail(case_id: str):
 
 
 def get_registered_case_detail(case_id: str):
+    print(case_id)
     with Session(engine) as session:
         result = session.exec(
             select(

pages/helper/__pycache__/db_queries.cpython-312.pyc

@@ -7,9 +7,9 @@
 
 import pandas as pd
 import numpy as np
-from sklearn.exceptions import DataConversionWarning
 
-warnings.filterwarnings(action="ignore", category=DataConversionWarning)
+
+warnings.filterwarnings(action="ignore")
 
 
 from pages.helper import db_queries
@@ -24,38 +24,100 @@ def get_public_cases_data(status="NF"):
             columns=lambda x: "fm_{}".format(x + 1)
         )
         df = d1.join(d2)
+        # Ensure all columns except label are float
+        for col in df.columns:
+            if col != "label":
+                df[col] = pd.to_numeric(df[col], errors="coerce")
         return df
 
     except Exception as e:
         traceback.print_exc()
         return None
 
 
-def match(threshold=0.1):
-    from scipy.spatial.distance import euclidean
+def get_registered_cases_data(status="NF"):
+    try:
+        from pages.helper.db_queries import engine, RegisteredCases
+        import pandas as pd
+        import json
+        from sqlmodel import Session, select
+
+        with Session(engine) as session:
+            result = session.exec(
+                select(
+                    RegisteredCases.id,
+                    RegisteredCases.face_mesh,
+                    RegisteredCases.status,
+                )
+            ).all()
+            d1 = pd.DataFrame(result, columns=["label", "face_mesh", "status"])
+            if status:
+                d1 = d1[d1["status"] == status]
+            d1["face_mesh"] = d1["face_mesh"].apply(lambda x: json.loads(x))
+            d2 = pd.DataFrame(
+                d1.pop("face_mesh").values.tolist(), index=d1.index
+            ).rename(columns=lambda x: "fm_{}".format(x + 1))
+            df = d1.join(d2)
+            # Ensure all columns except label and status are float
+            for col in df.columns:
+                if col not in ["label", "status"]:
+                    df[col] = pd.to_numeric(df[col], errors="coerce")
+            return df
+    except Exception as e:
+        traceback.print_exc()
+        return None
 
+
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.preprocessing import LabelEncoder
+
+
+def match(distance_threshold=3):
     matched_images = defaultdict(list)
-    user_submissions_df = get_public_cases_data()
+    public_cases_df = get_public_cases_data()
+    registered_cases_df = get_registered_cases_data()
 
-    if user_submissions_df is None:
+    if public_cases_df is None or registered_cases_df is None:
         return {"status": False, "message": "Couldn't connect to database"}
-
-    if len(user_submissions_df) == 0:
-        return {"status": False, "message": "No submissions found"}
-
-    # Compare each pair (brute force, can optimize)
-    for i, row1 in user_submissions_df.iterrows():
-        label1 = row1[0]
-        mesh1 = np.array(row1[1:]).astype(float)
-        for j, row2 in user_submissions_df.iterrows():
-            if i >= j:
-                continue
-            label2 = row2[0]
-            mesh2 = np.array(row2[1:]).astype(float)
-            dist = euclidean(mesh1, mesh2)
-            if dist < threshold:
-                matched_images[label1].append(label2)
-                matched_images[label2].append(label1)
+    if len(public_cases_df) == 0 or len(registered_cases_df) == 0:
+        return {"status": False, "message": "No public or registered cases found"}
+
+    # Store original labels before encoding
+    original_reg_labels = registered_cases_df.iloc[:, 0].tolist()
+    original_pub_labels = public_cases_df.iloc[:, 0].tolist()
+
+    # Prepare training data - use index positions as labels for the classifier
+    reg_features = registered_cases_df.iloc[:, 2:].values.astype(float)
+
+    # Create simple numeric labels for KNN (0, 1, 2, ...)
+    numeric_labels = list(range(len(reg_features)))
+
+    # Train KNN classifier with numeric labels
+    knn = KNeighborsClassifier(n_neighbors=1, algorithm="ball_tree", weights="distance")
+    knn.fit(reg_features, numeric_labels)
+
+    # For each public submission, find the closest registered case
+    for i, row in public_cases_df.iterrows():
+        pub_label = original_pub_labels[i]  # Original public case ID
+        face_encoding = np.array(row[1:]).astype(float)
+
+        try:
+            # Get distances to nearest neighbors
+            closest_distances = knn.kneighbors([face_encoding])[0][0]
+            closest_distance = np.min(closest_distances)
+            print(f"Distance for case {pub_label}: {closest_distance}")
+
+            # Check if distance meets threshold criteria
+            if closest_distance >= distance_threshold:  # Lower distance = better match
+                # Get the index of the predicted registered case
+                predicted_idx = knn.predict([face_encoding])[0]
+                # Get the original UUID of the registered case
+                reg_label = original_reg_labels[predicted_idx]
+                # Store the match
+                matched_images[reg_label].append(pub_label)
+        except Exception as e:
+            print(f"Error processing public case {pub_label}: {str(e)}")
+            continue
 
     return {"status": True, "result": matched_images}