Video processing added

app.py

@@ -4,7 +4,7 @@ import uuid
 from fractions import Fraction
 import exifread
 import uvicorn
-from fastapi import FastAPI, UploadFile, File, HTTPException, Form
+from fastapi import FastAPI, UploadFile, File, HTTPException, Form, BackgroundTasks
 from fastapi.middleware.cors import CORSMiddleware
 from dotenv import load_dotenv
 from ultralytics import YOLO
@@ -26,6 +26,7 @@ app.add_middleware(
     allow_headers=["*"]
 )
 
+# Connect to Supabase
 SUPABASE_URL = os.getenv("SUPABASE_URL")
 SUPABASE_KEY = os.getenv("SUPABASE_KEY")
 
@@ -33,6 +34,8 @@ if not SUPABASE_URL or not SUPABASE_KEY:
     raise ValueError("Supabase credentials not found. Please set them in your environment variables.")
 supabase: Client = create_client(SUPABASE_URL, SUPABASE_KEY)
 
+
+
 def convert_to_decimal(coord):
     if coord and len(coord.values) >= 3:
         deg = float(coord.values[0])
@@ -56,6 +59,101 @@ def get_gps_location(file_stream):
         return lat, lon
     return None, None
 
+
+
+def process_video_in_background(video_data: bytes, video_guid: str, filename: str):
+
+    bucket_name = 'pothole-images'
+    
+    try:
+        supabase.table("videos").insert({
+            "guid": video_guid,
+            "video_name": filename
+        }).execute()
+    except Exception as e:
+        print(f"Database Error on video insert: {str(e)}")
+        return
+
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as temp_video_file:
+        temp_video_file.write(video_data)
+        temp_path = temp_video_file.name
+
+    cap = cv2.VideoCapture(temp_path)
+    frame_number = 0
+    
+    while cap.isOpened():
+        ret, frame = cap.read()
+        if not ret:
+            break
+
+        if frame_number % 3 == 0:
+            results = model(frame, device='cpu')
+            
+            if len(results[0].boxes) > 0:  #
+                annotated_frame = results[0].plot()
+                is_success, buffer = cv2.imencode(".jpg", annotated_frame)
+                
+                if is_success:
+                    frame_bytes = buffer.tobytes()
+                    frame_path = f"{video_guid}/frame_{frame_number}.jpg"
+
+                    try:
+                        supabase.storage.from_(bucket_name).upload(
+                            path=frame_path,
+                            file=frame_bytes,
+                            file_options={"content-type": "image/jpeg"}
+                        )
+                        frame_url = supabase.storage.from_(bucket_name).get_public_url(frame_path)
+                        
+                        # Save frame information to the 'detected_frames' table
+                        supabase.table("detected_frames").insert({
+                            "video_guid": video_guid,
+                            "frame_image": frame_url,
+                            "frame_number": frame_number
+                        }).execute()
+                    except Exception as e:
+                        print(f"Error saving frame {frame_number}: {str(e)}")
+        
+        frame_number += 1
+    
+    cap.release()
+    os.remove(temp_path)
+    print(f"Finished processing video {video_guid}")
+
+
+
+@app.get("/")
+async def root():
+    return {"message": "API is running"}
+
+@app.post("/upload_video")
+async def upload_video(background_tasks: BackgroundTasks, file: UploadFile = File(...)):
+    if not file.content_type.startswith('video/'):
+        raise HTTPException(status_code=400, detail="File is not a video.")
+    
+    video_data = await file.read()
+    video_guid = str(uuid.uuid4())
+    
+    background_tasks.add_task(process_video_in_background, video_data, video_guid, file.filename)
+    
+    return {"message": "Video upload successful. Processing has started.", "video_guid": video_guid}
+
+@app.get("/video_report/{guid}")
+async def get_video_report(guid: str):
+    try:
+        video_response = supabase.table("videos").select("*").eq("guid", guid).single().execute()
+        frames_response = supabase.table("detected_frames").select("*").eq("video_guid", guid).order("frame_number").execute()
+
+        if not video_response.data:
+            raise HTTPException(status_code=404, detail="Video report not found")
+        
+        return {
+            "video_info": video_response.data,
+            "detected_frames": frames_response.data
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Database Error: {str(e)}")
+
 @app.get("/reports")
 async def get_reports():
     try:
@@ -68,20 +166,13 @@ async def get_reports():
 async def get_report(guid: str):
     try:
         response = supabase.table("potholes").select("guid, image_name, image_url, location, created_at, location_text").eq("guid", guid).execute()
-        
         if response.data and len(response.data) > 0:
             return response.data[0]
         else:
             raise HTTPException(status_code=404, detail=f"Report with guid {guid} not found.")
-            
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Database Error: {str(e)}")
 
-# *** ADD THIS NEW BLOCK ***
-@app.get("/")
-async def root():
-    return {"message": "API is running"}
-
 @app.post("/upload")
 async def upload_image(file: UploadFile = File(...), location: str = Form(None)):
     image_data = await file.read()
@@ -99,7 +190,6 @@ async def upload_image(file: UploadFile = File(...), location: str = Form(None))
         raise HTTPException(status_code=500, detail="Failed to encode annotated image.")
     
     annotated_image_bytes = buffer.tobytes()
-    
     bucket_name = 'pothole-images'
     uuid_path = f"annotated_{uuid.uuid4()}.jpg"
 
@@ -139,5 +229,6 @@ async def upload_image(file: UploadFile = File(...), location: str = Form(None))
 
     return {"message": "Upload successful", "image_url": url, "db_response": response.data}
 
+
 if __name__ == "__main__":
     uvicorn.run(app, port=8000, host="127.0.0.1")