Deploy latest version to Hugging Face Space

main.py

@@ -1,547 +0,0 @@
-import os
-import pickle
-import shutil
-import uuid
-from fastapi import FastAPI, File, UploadFile
-from fastapi.responses import JSONResponse
-from pymongo.mongo_client import MongoClient
-from pymongo.server_api import ServerApi
-import cloudinary
-import cloudinary.uploader
-from cloudinary.utils import cloudinary_url
-from SkinBurns_Classification import extract_features
-from SkinBurns_Segmentation import segment_burn
-import requests
-import joblib
-import numpy as np
-from ECG.ECG_Classify import classify_ecg
-from ECG.ECG_MultiClass import analyze_ecg_pdf
-from ultralytics import YOLO
-import tensorflow as tf
-from fastapi import HTTPException
-from fastapi import WebSocket, WebSocketDisconnect
-import base64
-import cv2
-import time
-from CPR.CPRAnalyzer import CPRAnalyzer as OfflineAnalyzer
-import tempfile
-import matplotlib.pyplot as plt
-import json
-import asyncio
-import concurrent.futures
-from CPRRealTime.main import CPRAnalyzer as RealtimeAnalyzer
-from threading import Thread
-from starlette.responses import StreamingResponse
-import threading
-import queue
-from CPRRealTime.analysis_socket_server import AnalysisSocketServer  # adjust if needed
-from CPRRealTime.logging_config import cpr_logger
-import logging
-import sys
-import re
-import signal
-
-
-app = FastAPI()
-
-SCREENSHOTS_DIR = "screenshots"  # Folder containing screenshots to upload
-OUTPUT_DIR = "Output"            # Folder containing the .mp4 video and graph .png
-UPLOAD_DIR = "uploads"
-os.makedirs(UPLOAD_DIR, exist_ok=True)
-
-# Load the YOLO model
-try:
-    model = YOLO("yolo11n-pose_float16.tflite")
-    print("Model loaded successfully")
-except Exception as e:
-    print(f"❌ Model loading failed: {str(e)}")
-    model = None
-
-
-
-# ✅ Cloudinary config
-cloudinary.config( 
-    cloud_name = "darumyfpl", 
-    api_key = "493972437417214", 
-    api_secret = "jjOScVGochJYA7IxDam7L4HU2Ig",  # Replace in production
-    secure=True
-)
-
-# Basic Hello route
-@app.get("/")
-def greet_json():
-    return {"Hello": "World!"}
-
-@app.post("/predict_burn")
-async def predict_burn(file: UploadFile = File(...)):
-    try:
-        #  Save the uploaded file temporarily
-        temp_file_path = f"temp_{file.filename}"
-        with open(temp_file_path, "wb") as temp_file:
-            temp_file.write(await file.read())
-
-
-        # Load the saved SVM model
-        with open('svm_model.pkl', 'rb') as model_file:
-            loaded_svm = pickle.load(model_file)
-
-        # Extract features from the uploaded image
-        features = extract_features(temp_file_path)
-
-        # Remove the temporary file
-        os.remove(temp_file_path)
-
-        if features is None:
-            return JSONResponse(content={"error": "Failed to extract features from the image."}, status_code=400)
-
-        # Reshape features to match the SVM model's expected input
-        features = features.reshape(1, -1)
-
-        # Predict the class 
-        prediction = loaded_svm.predict(features)
-        prediction_label = "Burn" if prediction[0] == 1 else "No Burn"
-
-        if prediction[0] == 1:
-            prediction_label = "First Class"
-        elif prediction[0] == 2:
-            prediction_label = "Second Class"
-        else:
-            prediction_label = "Zero Class"
-            
-        return {
-            "prediction": prediction_label
-        }
-
-    except Exception as e:
-        return JSONResponse(content={"error": str(e)}, status_code=500)
-
-@app.post("/segment_burn")
-async def segment_burn_endpoint(reference: UploadFile = File(...), patient: UploadFile = File(...)):
-    try:
-        # Save the reference image temporarily
-        reference_path = f"temp_ref_{reference.filename}"
-        reference_bytes = await reference.read()
-        with open(reference_path, "wb") as ref_file:
-            ref_file.write(reference_bytes)
-
-        # Save the patient image temporarily
-        patient_path = f"temp_patient_{patient.filename}"
-        patient_bytes = await patient.read()
-        with open(patient_path, "wb") as pat_file:
-            pat_file.write(patient_bytes)
-
-        # Call the segmentation logic
-        burn_crop_clean, burn_crop_debug = segment_burn(patient_path, reference_path)
-
-        # Save the cropped outputs
-        burn_crop_clean_path = f"temp_burn_crop_clean_{uuid.uuid4()}.png"
-        burn_crop_debug_path = f"temp_burn_crop_debug_{uuid.uuid4()}.png"
-  
-
-        plt.imsave(burn_crop_clean_path, burn_crop_clean)
-        plt.imsave(burn_crop_debug_path, burn_crop_debug)
-
-        # Upload to Cloudinary
-        crop_clean_upload = cloudinary.uploader.upload(burn_crop_clean_path, public_id=f"ref_{reference.filename}")
-        crop_debug_upload = cloudinary.uploader.upload(burn_crop_debug_path, public_id=f"pat_{patient.filename}")
-        crop_clean_url = crop_clean_upload["secure_url"]
-        crop_debug_url = crop_debug_upload["secure_url"]
-
-        # Clean up temp files
-        
-        os.remove(burn_crop_clean_path)
-        os.remove(burn_crop_debug_path)
-
-
-        return {
-            "crop_clean_url": crop_clean_url,
-            "crop_debug_url": crop_debug_url
-        }
-
-    except Exception as e:
-        return JSONResponse(content={"error": str(e)}, status_code=500)
-
-
-@app.post("/classify-ecg")
-async def classify_ecg_endpoint(file: UploadFile = File(...)):
-    model = joblib.load('voting_classifier.pkl')
-    # Load the model
-
-    try:
-        # Save the uploaded file temporarily
-        temp_file_path = f"temp_{file.filename}"
-        with open(temp_file_path, "wb") as temp_file:
-            temp_file.write(await file.read())
-
-        # Call the ECG classification function
-        result = classify_ecg(temp_file_path, model, debug=True, is_pdf=True)
-
-        # Remove the temporary file
-        os.remove(temp_file_path)
-
-        return {"result": result}
-
-    except Exception as e:
-        return JSONResponse(content={"error": str(e)}, status_code=500)
-    
-@app.post("/diagnose-ecg")
-async def diagnose_ecg(file: UploadFile = File(...)):
-    try:
-        # Save the uploaded file temporarily
-        temp_file_path = f"temp_{file.filename}"
-        with open(temp_file_path, "wb") as temp_file:
-            temp_file.write(await file.read())
-
-        model_path = 'deep-multiclass.h5'  # Update with actual path
-        mlb_path = 'deep-multiclass.pkl'     # Update with actual path
-    
-
-        # Call the ECG classification function
-        result = analyze_ecg_pdf(
-        temp_file_path, 
-        model_path, 
-        mlb_path, 
-        cleanup=False,  # Keep the digitized file
-        debug=False,     # Print debug information
-        visualize=False  # Visualize the digitized signal
-    )
-    
-
-        # Remove the temporary file
-        os.remove(temp_file_path)
-        
-        if result and result["diagnosis"]:
-            return {"result": result["diagnosis"]}
-        else:
-            return {"result": "No diagnosis"}
-
-    except Exception as e:
-        return JSONResponse(content={"error": str(e)}, status_code=500)
-
-
-def clean_warning_name(filename: str) -> str:
-    """
-    Remove frame index and underscores from filename base
-    E.g. "posture_001.png" -> "posture"
-    """
-    name, _ = os.path.splitext(filename)
-    # Remove trailing underscore + digits
-    cleaned = re.sub(r'_\d+$', '', name)
-    # Remove all underscores in the name for description
-    cleaned_desc = cleaned.replace('_', ' ')
-    return cleaned, cleaned_desc
-
-@app.post("/process_video")
-async def process_video(file: UploadFile = File(...)):
-    if not file.content_type.startswith("video/"):
-        raise HTTPException(status_code=400, detail="File must be a video.")
-
-    print("File content type:", file.content_type)
-    print("File filename:", file.filename)
-
-    # Prepare directories
-    os.makedirs(UPLOAD_DIR, exist_ok=True)
-    os.makedirs(SCREENSHOTS_DIR, exist_ok=True)
-    os.makedirs(OUTPUT_DIR, exist_ok=True)
-
-    folders = ["screenshots", "uploads", "Output"]
-
-    for folder in folders:
-        if os.path.exists(folder):
-            for filename in os.listdir(folder):
-                file_path = os.path.join(folder, filename)
-                if os.path.isfile(file_path):
-                    os.remove(file_path)
-
-    # Save uploaded video file
-    video_path = os.path.join(UPLOAD_DIR, file.filename)
-    with open(video_path, "wb") as buffer:
-        shutil.copyfileobj(file.file, buffer)
-
-    print(f"\n[API] CPR Analysis Started on {video_path}")
-
-    # Prepare output paths for the analyzer
-    video_output_path = os.path.join(OUTPUT_DIR, "Myoutput.mp4")
-    plot_output_path = os.path.join(OUTPUT_DIR, "Myoutput.png")
-
-    # Initialize analyzer with input video and output paths
-    start_time = time.time()
-    analyzer = OfflineAnalyzer(video_path, video_output_path, plot_output_path, requested_fps=30)
-
-    # Run the analysis (choose your method)
-    chunks = analyzer.run_analysis_video()
-
-    warnings = []  # Start empty list
-
-    # Upload screenshots and build warnings list with descriptions and URLs
-    if os.path.exists(SCREENSHOTS_DIR):
-        for filename in os.listdir(SCREENSHOTS_DIR):
-            if filename.lower().endswith(('.png', '.jpg', '.jpeg')):
-                local_path = os.path.join(SCREENSHOTS_DIR, filename)
-                cleaned_name, description = clean_warning_name(filename)
-
-                upload_result = cloudinary.uploader.upload(
-                    local_path,
-                    folder="posture_warnings",
-                    public_id=cleaned_name,
-                    overwrite=True
-                )
-
-                # Add new warning with image_url and description
-                warnings.append({
-                    "image_url": upload_result['secure_url'],
-                    "description": description
-                })
-
-    video_path = "Output/Myoutput_final.mp4"
-
-    if os.path.isfile(video_path):
-        upload_result = cloudinary.uploader.upload_large(
-            video_path,
-            resource_type="video",
-            folder="output_videos",
-            public_id="Myoutput_final",
-            overwrite=True
-        )
-        wholevideoURL = upload_result['secure_url']
-    else:
-        wholevideoURL = None
-
-    # Upload graph output
-    graphURL = None
-    if os.path.isfile(plot_output_path):
-        upload_graph_result = cloudinary.uploader.upload(
-            plot_output_path,
-            folder="output_graphs",
-            public_id=os.path.splitext(os.path.basename(plot_output_path))[0],
-            overwrite=True
-        )
-        graphURL = upload_graph_result['secure_url']
-
-    print(f"[API] CPR Analysis Completed on {video_path}")
-    analysis_time = time.time() - start_time
-    print(f"[TIMING] Analysis time: {analysis_time:.2f}s")
-
-    if wholevideoURL is None:
-        raise HTTPException(status_code=500, detail="No chunk data was generated from the video.")
-
-    return JSONResponse(content={
-        "videoURL": wholevideoURL,
-        "graphURL": graphURL,
-        "warnings": warnings,
-        "chunks": chunks,
-    })
-
-
-# @app.websocket("/ws/process_video")
-# async def websocket_process_video(websocket: WebSocket):
-
-#     await websocket.accept()
-
-#     frame_buffer = []
-#     frame_limit = 50
-#     frame_size = (640, 480)  # Adjust if needed
-#     fps = 30  # Adjust if needed
-#     loop = asyncio.get_event_loop()
-
-#     # Progress reporting during analysis
-#     async def progress_callback(data):
-#         await websocket.send_text(json.dumps(data))
-
-#     def sync_callback(data):
-#         asyncio.run_coroutine_threadsafe(progress_callback(data), loop)
-
-#     def save_frames_to_video(frames, path):
-#         out = cv2.VideoWriter(path, cv2.VideoWriter_fourcc(*'mp4v'), fps, frame_size)
-#         for frame in frames:
-#             resized = cv2.resize(frame, frame_size)
-#             out.write(resized)
-#         out.release()
-
-#     def run_analysis_on_buffer(frames):
-#         try:
-#             tmp_path = "temp_video.mp4"
-#             save_frames_to_video(frames, tmp_path)
-
-#             # Notify: video saved
-#             asyncio.run_coroutine_threadsafe(
-#                 websocket.send_text(json.dumps({
-#                     "status": "info",
-#                     "message": "Video saved. Starting CPR analysis..."
-#                 })),
-#                 loop
-#             )
-
-#             # Run analysis
-#             analyzer = CPRAnalyzer(video_path=tmp_path)
-#             analyzer.run_analysis(progress_callback=sync_callback)
-
-#         except Exception as e:
-#             asyncio.run_coroutine_threadsafe(
-#                 websocket.send_text(json.dumps({"error": str(e)})),
-#                 loop
-#             )
-
-#     try:
-#         while True:
-#             data: bytes = await websocket.receive_bytes()
-#             np_arr = np.frombuffer(data, np.uint8)
-#             frame = cv2.imdecode(np_arr, cv2.IMREAD_COLOR)
-#             if frame is None:
-#                 continue
-
-#             frame_buffer.append(frame)
-#             print(f"Frame added to buffer: {len(frame_buffer)}")
-
-#             if len(frame_buffer) == frame_limit:
-#                 # Notify Flutter that we're switching to processing
-#                 await websocket.send_text(json.dumps({
-#                     "status": "ready",
-#                     "message": "Prepare Right CPR: First 150 frames received. Starting processing."
-#                 }))
-
-#                 # Copy and clear buffer
-#                 buffer_copy = frame_buffer[:]
-#                 frame_buffer.clear()
-
-#                 # Launch background processing
-#                 executor = concurrent.futures.ThreadPoolExecutor()
-#                 loop.run_in_executor(executor, run_analysis_on_buffer, buffer_copy)
-#             else:
-#                 # Tell Flutter to send the next frame
-#                 await websocket.send_text(json.dumps({
-#                     "status": "continue",
-#                     "message": f"Frame {len(frame_buffer)} received. Send next."
-#                 }))
-
-#     except WebSocketDisconnect:
-#         print("Client disconnected")
-
-#     except Exception as e:
-#         await websocket.send_text(json.dumps({"error": str(e)}))
-
-#     finally:
-#         cv2.destroyAllWindows()
-
-
-logger = logging.getLogger("cpr_logger")
-clients = set()
-analyzer_thread = None
-analysis_started = False
-analyzer_lock = threading.Lock()
-socket_server: AnalysisSocketServer = None  # Global reference
-
-
-async def forward_results_from_queue(websocket: WebSocket, warning_queue):
-    try:
-        while True:
-            warnings = await asyncio.to_thread(warning_queue.get)
-            serialized = json.dumps(warnings)
-            await websocket.send_text(serialized)
-    except asyncio.CancelledError:
-        logger.info("[WebSocket] Forwarding task cancelled")
-    except Exception as e:
-        logger.error(f"[WebSocket] Error forwarding data: {e}")
-
-
-def run_cpr_analysis(source, requested_fps, output_path):
-    global socket_server
-    logger.info(f"[MAIN] CPR Analysis Started")
-
-    requested_fps = 30
-    input_video = source
-
-    output_dir = r"D:\BackendGp\Deploy_El7a2ny_Application\CPRRealTime\outputs"
-    os.makedirs(output_dir, exist_ok=True)
-
-    video_output_path = os.path.join(output_dir, "output.mp4")
-    plot_output_path = os.path.join(output_dir, "output.png")
-
-    logger.info(f"[CONFIG] Input video: {input_video}")
-    logger.info(f"[CONFIG] Video output: {video_output_path}")
-    logger.info(f"[CONFIG] Plot output: {plot_output_path}")
-
-    initialization_start_time = time.time()
-    analyzer = RealtimeAnalyzer(input_video, video_output_path, plot_output_path, requested_fps)
-    socket_server = analyzer.socket_server
-    analyzer.plot_output_path = plot_output_path
-
-    elapsed_time = time.time() - initialization_start_time
-    logger.info(f"[TIMING] Initialization time: {elapsed_time:.2f}s")
-
-    try:
-        analyzer.run_analysis()
-    finally:
-        if analyzer.socket_server:
-            analyzer.socket_server.stop_server()
-        logger.info("[MAIN] Analyzer stopped")
-
-
-@app.websocket("/ws/real")
-async def websocket_analysis(websocket: WebSocket):
-    global analyzer_thread, analysis_started, socket_server
-
-    await websocket.accept()
-    clients.add(websocket)
-    logger.info("[WebSocket] Flutter connected")
-
-    try:
-        # Wait for the client to send the stream URL as first message
-        source = await websocket.receive_text()
-        logger.info(f"[WebSocket] Received stream URL: {source}")
-
-        # Ensure analyzer starts only once using a thread-safe lock
-        with analyzer_lock:
-            if not analysis_started:
-                requested_fps = 30
-                output_path = r"D:\CPR\End to End\Code Refactor\output\output.mp4"
-
-                analyzer_thread = threading.Thread(
-                    target=run_cpr_analysis,
-                    args=(source, requested_fps, output_path),
-                    daemon=True
-                )
-                analyzer_thread.start()
-                analysis_started = True
-                logger.info("[WebSocket] Analysis thread started")
-
-        # Rest of your existing code remains exactly the same...
-        while socket_server is None or socket_server.warning_queue is None:
-            await asyncio.sleep(0.1)
-
-        forward_task = asyncio.create_task(
-            forward_results_from_queue(websocket, socket_server.warning_queue)
-        )
-
-        while True:
-            await asyncio.sleep(1)  # Keep alive
-
-    except WebSocketDisconnect:
-        logger.warning("[WebSocket] Client disconnected")
-        if 'forward_task' in locals():
-            forward_task.cancel()
-    except Exception as e:
-        logger.error(f"[WebSocket] Error receiving stream URL: {str(e)}")
-        await websocket.close(code=1011)  # 1011 = Internal Error
-    finally:
-        clients.discard(websocket)
-        logger.info(f"[WebSocket] Active clients: {len(clients)}")
-
-        if not clients and socket_server:
-            logger.info("[WebSocket] No clients left. Stopping analyzer.")
-            socket_server.stop_server()
-            analysis_started = False
-            socket_server = None
-
-
-def shutdown_handler(signum, frame):
-    logger.info("Received shutdown signal")
-    if socket_server:
-        try:
-            socket_server.stop_server()
-        except Exception as e:
-            logger.warning(f"Error during socket server shutdown: {e}")
-    os._exit(0)
-
-signal.signal(signal.SIGINT, shutdown_handler)
-signal.signal(signal.SIGTERM, shutdown_handler)