bbox threshodl increase

api/detection.py

@@ -10,7 +10,7 @@ from .utils import (
     save_image,
     load_json,
     save_json,
-    validate_user_and_camera
+    validate_user_and_camera,extract_metadata
 )
 
 router = APIRouter()
@@ -29,6 +29,7 @@ async def predict(
     new_results = []
     for file in images:
         raw = await file.read()
+        metadata = extract_metadata(raw)
         nparr = np.frombuffer(raw, np.uint8)
         img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
         if img is None:
@@ -38,7 +39,8 @@ async def predict(
         record = {
             "filename": file.filename,
             "image_url": url,
-            "detections": detections
+            "detections": detections,
+            "metadata": metadata   
         }
         data.append(record)
         new_results.append(record)

api/utils.py

@@ -4,7 +4,9 @@ from pathlib import Path
 from fastapi import HTTPException
 import cv2
 import numpy as np
-
+from datetime import datetime
+from exif import Image as ExifImage
+from io import BytesIO
 # ---------------- CONFIG IMPORTS ----------------
 from .config import (
     DETECT_MODEL,
@@ -24,70 +26,107 @@ from .config import (
 def validate_form(user_id, camera_name, images):
     if not user_id or not user_id.strip():
         raise HTTPException(400, "user_id is required")
-
     if not camera_name or not camera_name.strip():
         raise HTTPException(400, "camera_name is required")
-
     if not images or len(images) == 0:
         raise HTTPException(400, "At least one image is required")
-
     images = [f for f in images if f.filename and f.filename.strip()]
-
     if len(images) < MIN_IMAGES:
         raise HTTPException(400, f"At least {MIN_IMAGES} image(s) required")
-
     if len(images) > MAX_IMAGES:
         raise HTTPException(400, f"Maximum {MAX_IMAGES} images allowed")
-
     for f in images:
         if "." not in f.filename:
             raise HTTPException(400, f"Invalid file: {f.filename}")
-
         ext = f.filename.rsplit(".", 1)[1].lower()
         if ext not in ALLOWED_EXTENSIONS:
             raise HTTPException(400, f"Invalid file type: {f.filename}")
-
     return images
 
+
+
+def make_json_safe(value):
+    """Convert EXIF values to JSON-serializable types"""
+    if hasattr(value, "name"):
+        return value.name
+    if isinstance(value, (bytes, bytearray)):
+        return value.decode(errors="ignore")
+    if isinstance(value, (tuple, list)):
+        return [make_json_safe(v) for v in value]
+    if not isinstance(value, (str, int, float, bool, type(None))):
+        return str(value)
+    return value
+
+
+def extract_metadata(image_bytes):
+    metadata = {
+        "upload_datetime": datetime.utcnow().isoformat() + "Z"
+    }
+    try:
+        exif_img = ExifImage(BytesIO(image_bytes))
+        if not exif_img.has_exif:
+            return metadata
+        exif_dict = {}
+        for tag in exif_img.list_all():
+            try:
+                value = getattr(exif_img, tag)
+                value = make_json_safe(value)
+                if value not in ("", None, [], {}):
+                    exif_dict[tag] = value
+            except Exception:
+                continue
+        if exif_dict:
+            metadata["exif"] = exif_dict
+    except Exception:
+        pass
+    return metadata
+
+
 # ---------------- IMAGE PROCESSING ----------------
 def process_image(image):
-    """Run detection and classification on an image"""
+    """Run 3-stage detection and classification with dynamic confidence"""
     detections = []
-    results = DETECT_MODEL(image)
-
+    results = DETECT_MODEL(image,conf=0.8 ,iou=0.7,agnostic_nms=True)  # Stage 1: Deer detection
     for r in results:
         for box in r.boxes:
             x1, y1, x2, y2 = map(int, box.xyxy[0])
             crop = image[y1:y2, x1:x2]
             if crop.size == 0:
                 continue
-
-            buck_res = BUCK_DOE_MODEL(crop)
-            buck_name = buck_res[0].names[buck_res[0].probs.top1]
-
+            # ---------------- Stage 2: Buck/Doe ----------------
+            buck_res = BUCK_DOE_MODEL(crop,conf=0.85, iou=0.40,agnostic_nms=True) 
+            buck_probs = buck_res[0].probs
+            top1_idx = buck_probs.top1
+            buck_name = buck_res[0].names[top1_idx]
+            buck_conf = float(buck_probs.top1conf)
             if buck_name.lower() == "buck":
+                # ---------------- Stage 3: Buck Type ----------------
                 type_res = BUCK_TYPE_MODEL(crop)
-                type_name = type_res[0].names[type_res[0].probs.top1]
-                label = f"Deer | Buck | {type_name}"
+                type_probs = type_res[0].probs
+                top1_type_idx = type_probs.top1
+                type_name = type_res[0].names[top1_type_idx]
+                type_conf = float(type_probs.top1conf)
+                label = f"Deer | Buck | {type_name} | {type_conf:.2f}"
+                final_conf = type_conf
             else:
-                label = "Deer | Doe"
-
+                # Doe: use stage 2 confidence
+                label = f"Deer | Doe | {buck_conf:.2f}"
+                final_conf = buck_conf
             detections.append({
                 "label": label,
-                "bbox": [x1, y1, x2, y2]
+                "bbox": [x1, y1, x2, y2],
+                "confidence": final_conf
             })
-
     return detections
 
 
 
+
 # ---------------- CAMERA VALIDATION ----------------
 def validate_user_and_camera(user_id: str, camera_name: str):
     if not user_exists(user_id):
         raise HTTPException(404, "User not found")
-
     cameras = load_cameras(user_id)
-
     if not any(c["camera_name"] == camera_name for c in cameras):
         raise HTTPException(404, "Camera not registered")
 
@@ -96,16 +135,13 @@ def validate_user_and_camera(user_id: str, camera_name: str):
 def save_image(user_id, camera_name, filename, data):
     path = BASE_DIR / user_id / camera_name / "raw"
     path.mkdir(parents=True, exist_ok=True)
-
     local_path = path / filename
     with open(local_path, "wb") as f:
         f.write(data)
-
     if STORAGE_BACKEND == "gcs" and gcs_bucket:
         blob = gcs_bucket.blob(f"{GCS_UPLOAD_DIR}{user_id}/{camera_name}/{filename}")
         blob.upload_from_filename(local_path)
         return blob.public_url
-
     return f"/user_data/{user_id}/{camera_name}/raw/{filename}"
 
 
@@ -137,10 +173,8 @@ def user_exists(user_id: str) -> bool:
 
 def load_cameras(user_id: str) -> list:
     path = get_user_file(user_id)
-
     if not path.exists():
         return []
-
     try:
         with open(path, "r") as f:
             return json.load(f)
@@ -151,7 +185,6 @@ def save_cameras(user_id: str, cameras: list):
     # Folder only created when we are saving ( Add Camera)
     folder = get_user_folder(user_id)
     folder.mkdir(exist_ok=True)
-
     with open(folder / "cameras.json", "w") as f:
         json.dump(cameras, f, indent=2)
 
@@ -162,32 +195,25 @@ def get_user_dashboard(user_id: str, camera_name: str = None) -> dict:
     """Return analytics for a user or a specific camera"""
     user_folder = Path(UPLOAD_DIR) / user_id
     cameras_file = user_folder / "cameras.json"
-
     if not cameras_file.exists():
         raise HTTPException(404, f"User {user_id} not found")
-
     try:
         with open(cameras_file, "r") as f:
             cameras = json.load(f)
     except json.JSONDecodeError:
         cameras = []
-
     total_cameras = len(cameras)
     total_images = 0
     total_detections = 0
     buck_type_distribution = {}
     buck_doe_distribution = {"Buck": 0, "Doe": 0}
-
     for cam in cameras:
         cam_name = cam["camera_name"]
-
         # Skip cameras if a specific one is selected
         if camera_name and cam_name != camera_name:
             continue
-
         raw_folder = user_folder / cam_name / "raw"
         detections_file = user_folder / cam_name / f"{cam_name}_detections.json"
-
         # Count images
         if raw_folder.exists():
             total_images += len(list(raw_folder.glob("*.*")))

app.py

@@ -1,2 +1,29 @@
 # app.py
 from api.main import app
+
+import warnings
+warnings.filterwarnings("ignore", message="Corrupt JPEG data")
+
+import os
+from dotenv import load_dotenv
+from pyngrok import ngrok
+import uvicorn
+
+load_dotenv()
+NGROK_AUTH_TOKEN = os.getenv("NGROK_AUTH_TOKEN")
+
+if NGROK_AUTH_TOKEN:
+    ngrok.set_auth_token(NGROK_AUTH_TOKEN)
+
+
+
+if __name__ == "__main__":
+
+    #     # Run FastAPI
+    uvicorn.run(
+        "api.main:app",
+        host="0.0.0.0",
+        port=8080,
+        reload=True,
+        log_level="info"
+    )

requirements.txt

@@ -9,4 +9,10 @@ gunicorn
 waitress
 fastapi
 uvicorn
-python-multipart
+python-multipart
+huggingface_hub
+gradio_client
+pyarrow
+gradio
+PyExifTool
+exif