Gsoc'25 Frontend Revamp

backend/app/config/settings.py

@@ -1,6 +1,9 @@
 # Model Exports Path
 MODEL_EXPORTS_PATH = "app/models/ONNX_Exports"
 
+# Microservice URLs
+SYNC_MICROSERVICE_URL = "http://localhost:8001/api/v1"
+
 # Object Detection Models:
 SMALL_OBJ_DETECTION_MODEL = f"{MODEL_EXPORTS_PATH}/YOLOv11_Small.onnx"
 NANO_OBJ_DETECTION_MODEL = f"{MODEL_EXPORTS_PATH}/YOLOv11_Nano.onnx"

backend/app/database/face_clusters.py

@@ -12,6 +12,7 @@ class ClusterData(TypedDict):
 
     cluster_id: ClusterId
     cluster_name: Optional[ClusterName]
+    face_image_base64: Optional[str]
 
 
 ClusterMap = Dict[ClusterId, ClusterData]
@@ -25,7 +26,8 @@ def db_create_clusters_table() -> None:
         """
         CREATE TABLE IF NOT EXISTS face_clusters (
             cluster_id TEXT PRIMARY KEY,
-            cluster_name TEXT
+            cluster_name TEXT,
+            face_image_base64 TEXT
         )
     """
     )
@@ -56,14 +58,15 @@ def db_insert_clusters_batch(clusters: List[ClusterData]) -> List[ClusterId]:
     for cluster in clusters:
         cluster_id = cluster.get("cluster_id")
         cluster_name = cluster.get("cluster_name")
+        face_image_base64 = cluster.get("face_image_base64")
 
-        insert_data.append((cluster_id, cluster_name))
+        insert_data.append((cluster_id, cluster_name, face_image_base64))
         cluster_ids.append(cluster_id)
 
     cursor.executemany(
         """
-        INSERT INTO face_clusters (cluster_id, cluster_name)
-        VALUES (?, ?)
+        INSERT INTO face_clusters (cluster_id, cluster_name, face_image_base64)
+        VALUES (?, ?, ?)
     """,
         insert_data,
     )
@@ -88,15 +91,17 @@ def db_get_cluster_by_id(cluster_id: ClusterId) -> Optional[ClusterData]:
     cursor = conn.cursor()
 
     cursor.execute(
-        "SELECT cluster_id, cluster_name FROM face_clusters WHERE cluster_id = ?",
+        "SELECT cluster_id, cluster_name, face_image_base64 FROM face_clusters WHERE cluster_id = ?",
         (cluster_id,),
     )
 
     row = cursor.fetchone()
     conn.close()
 
     if row:
-        return ClusterData(cluster_id=row[0], cluster_name=row[1])
+        return ClusterData(
+            cluster_id=row[0], cluster_name=row[1], face_image_base64=row[2]
+        )
     return None
 
 
@@ -111,15 +116,19 @@ def db_get_all_clusters() -> List[ClusterData]:
     cursor = conn.cursor()
 
     cursor.execute(
-        "SELECT cluster_id, cluster_name FROM face_clusters ORDER BY cluster_id"
+        "SELECT cluster_id, cluster_name, face_image_base64 FROM face_clusters ORDER BY cluster_id"
     )
 
     rows = cursor.fetchall()
     conn.close()
 
     clusters = []
     for row in rows:
-        clusters.append(ClusterData(cluster_id=row[0], cluster_name=row[1]))
+        clusters.append(
+            ClusterData(
+                cluster_id=row[0], cluster_name=row[1], face_image_base64=row[2]
+            )
+        )
 
     return clusters
 
@@ -190,20 +199,24 @@ def db_get_all_clusters_with_face_counts() -> List[
     Dict[str, Union[str, Optional[str], int]]
 ]:
     """
-    Retrieve all clusters with their face counts.
+    Retrieve all clusters with their face counts and stored face images.
 
     Returns:
-        List of dictionaries containing cluster_id, cluster_name, and face_count
+        List of dictionaries containing cluster_id, cluster_name, face_count, and face_image_base64
     """
     conn = sqlite3.connect(DATABASE_PATH)
     cursor = conn.cursor()
 
     cursor.execute(
         """
-        SELECT fc.cluster_id, fc.cluster_name, COUNT(f.face_id) as face_count
+        SELECT 
+            fc.cluster_id, 
+            fc.cluster_name, 
+            COUNT(f.face_id) as face_count,
+            fc.face_image_base64
         FROM face_clusters fc
         LEFT JOIN faces f ON fc.cluster_id = f.cluster_id
-        GROUP BY fc.cluster_id, fc.cluster_name
+        GROUP BY fc.cluster_id, fc.cluster_name, fc.face_image_base64
         ORDER BY fc.cluster_id
         """
     )
@@ -213,8 +226,84 @@ def db_get_all_clusters_with_face_counts() -> List[
 
     clusters = []
     for row in rows:
+        cluster_id, cluster_name, face_count, face_image_base64 = row
         clusters.append(
-            {"cluster_id": row[0], "cluster_name": row[1], "face_count": row[2]}
+            {
+                "cluster_id": cluster_id,
+                "cluster_name": cluster_name,
+                "face_count": face_count,
+                "face_image_base64": face_image_base64,
+            }
         )
 
     return clusters
+
+
+def db_get_images_by_cluster_id(
+    cluster_id: ClusterId,
+) -> List[Dict[str, Union[str, int]]]:
+    """
+    Get all images that contain faces belonging to a specific cluster.
+
+    Args:
+        cluster_id: The ID of the cluster to get images for
+
+    Returns:
+        List of dictionaries containing image data with face information
+    """
+    conn = sqlite3.connect(DATABASE_PATH)
+    cursor = conn.cursor()
+
+    cursor.execute(
+        """
+        SELECT DISTINCT 
+            i.id as image_id,
+            i.path as image_path,
+            i.thumbnailPath as thumbnail_path,
+            i.metadata,
+            f.face_id,
+            f.confidence,
+            f.bbox
+        FROM images i
+        INNER JOIN faces f ON i.id = f.image_id
+        WHERE f.cluster_id = ?
+        ORDER BY i.path
+        """,
+        (cluster_id,),
+    )
+
+    rows = cursor.fetchall()
+    conn.close()
+
+    images = []
+    for row in rows:
+        (
+            image_id,
+            image_path,
+            thumbnail_path,
+            metadata,
+            face_id,
+            confidence,
+            bbox_json,
+        ) = row
+
+        # Parse bbox JSON if it exists
+        bbox = None
+        if bbox_json:
+            import json
+
+            bbox = json.loads(bbox_json)
+
+        images.append(
+            {
+                "image_id": image_id,
+                "image_path": image_path,
+                "thumbnail_path": thumbnail_path,
+                "metadata": metadata,
+                "face_id": face_id,
+                "confidence": confidence,
+                "bbox": bbox,
+            }
+        )
+
+    return images

backend/app/database/folders.py

@@ -382,6 +382,30 @@ def db_get_folder_ids_by_paths(
         conn.close()
 
 
+def db_get_all_folder_details() -> List[
+    Tuple[str, str, Optional[str], int, bool, Optional[bool]]
+]:
+    """
+    Get all folder details including folder_id, folder_path, parent_folder_id,
+    last_modified_time, AI_Tagging, and taggingCompleted.
+    Returns list of tuples with all folder information.
+    """
+    conn = sqlite3.connect(DATABASE_PATH)
+    cursor = conn.cursor()
+
+    try:
+        cursor.execute(
+            """
+            SELECT folder_id, folder_path, parent_folder_id, last_modified_time, AI_Tagging, taggingCompleted 
+            FROM folders 
+            ORDER BY folder_path
+            """
+        )
+        return cursor.fetchall()
+    finally:
+        conn.close()
+
+
 def db_get_direct_child_folders(parent_folder_id: str) -> List[Tuple[str, str]]:
     """
     Get all direct child folders (not subfolders) for a given parent folder.

backend/app/database/images.py

@@ -90,6 +90,81 @@ def db_bulk_insert_images(image_records: List[ImageRecord]) -> bool:
         conn.close()
 
 
+def db_get_all_images() -> List[dict]:
+    """
+    Get all images from the database with their tags.
+
+    Returns:
+        List of dictionaries containing all image data including tags
+    """
+    conn = sqlite3.connect(DATABASE_PATH)
+    cursor = conn.cursor()
+
+    try:
+        cursor.execute(
+            """
+            SELECT 
+                i.id, 
+                i.path, 
+                i.folder_id, 
+                i.thumbnailPath, 
+                i.metadata, 
+                i.isTagged,
+                m.name as tag_name
+            FROM images i
+            LEFT JOIN image_classes ic ON i.id = ic.image_id
+            LEFT JOIN mappings m ON ic.class_id = m.class_id
+            ORDER BY i.path, m.name
+            """
+        )
+
+        results = cursor.fetchall()
+
+        # Group results by image ID
+        images_dict = {}
+        for (
+            image_id,
+            path,
+            folder_id,
+            thumbnail_path,
+            metadata,
+            is_tagged,
+            tag_name,
+        ) in results:
+            if image_id not in images_dict:
+                images_dict[image_id] = {
+                    "id": image_id,
+                    "path": path,
+                    "folder_id": folder_id,
+                    "thumbnailPath": thumbnail_path,
+                    "metadata": metadata,
+                    "isTagged": bool(is_tagged),
+                    "tags": [],
+                }
+
+            # Add tag if it exists
+            if tag_name:
+                images_dict[image_id]["tags"].append(tag_name)
+
+        # Convert to list and set tags to None if empty
+        images = []
+        for image_data in images_dict.values():
+            if not image_data["tags"]:
+                image_data["tags"] = None
+            images.append(image_data)
+
+        # Sort by path
+        images.sort(key=lambda x: x["path"])
+
+        return images
+
+    except Exception as e:
+        print(f"Error getting all images: {e}")
+        return []
+    finally:
+        conn.close()
+
+
 def db_get_untagged_images() -> List[ImageRecord]:
     """
     Find all images that need AI tagging.

backend/app/models/FaceDetector.py

@@ -26,13 +26,20 @@ def detect_faces(self, image_id: int, image_path: str):
             return None
 
         boxes, scores, class_ids = self.yolo_detector(img)
+        print(boxes)
         print(f"Detected {len(boxes)} faces in image {image_id}.")
 
-        processed_faces, embeddings = [], []
+        processed_faces, embeddings, bboxes, confidences = [], [], [], []
 
         for box, score in zip(boxes, scores):
             if score > self.yolo_detector.conf_threshold:
                 x1, y1, x2, y2 = map(int, box)
+
+                # Create bounding box dictionary in JSON format
+                bbox = {"x": x1, "y": y1, "width": x2 - x1, "height": y2 - y1}
+                bboxes.append(bbox)
+                confidences.append(float(score))
+
                 padding = 20
                 face_img = img[
                     max(0, y1 - padding) : min(img.shape[0], y2 + padding),
@@ -45,7 +52,9 @@ def detect_faces(self, image_id: int, image_path: str):
                 embeddings.append(embedding)
 
         if embeddings:
-            db_insert_face_embeddings_by_image_id(image_id, embeddings)
+            db_insert_face_embeddings_by_image_id(
+                image_id, embeddings, confidence=confidences, bbox=bboxes
+            )
 
         return {
             "ids": f"{class_ids}",