add: storedashboard nto

app.py

@@ -8,6 +8,9 @@ from datetime import datetime, timedelta, timezone
 
 from fastapi import FastAPI, Depends, HTTPException
 from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from starlette.middleware.cors import CORSMiddleware
+from starlette.responses import JSONResponse
+
 from src.api.batch_api import batch_router
 from src.api.image_prep_api import preprocessing_router
 from src.api.image_regeneration_api import image_regeneration_router
@@ -15,8 +18,7 @@ from src.api.makeup_tryon_api import makeup_tryon_router
 from src.api.mannequin_to_model_api import mto_router
 from src.api.nto_api import nto_cto_router
 from src.api.nto_api import supabase
-from starlette.middleware.cors import CORSMiddleware
-from starlette.responses import JSONResponse
+from src.api.store_dashboard_api import store_dashboard_router
 
 security = HTTPBearer()
 
@@ -54,7 +56,9 @@ app.include_router(batch_router, tags=['Realtime'])
 
 app.include_router(mto_router, tags=["MTO"])
 
-app.include_router(makeup_tryon_router, tags=["makeup_tryon"])
+app.include_router(makeup_tryon_router, tags=["Makeup_TryOn"])
+
+app.include_router(store_dashboard_router, tags=['Store-Dashboard'])
 
 app.add_middleware(
     CORSMiddleware,

src/api/nto_api.py

@@ -583,7 +583,8 @@ async def clothing_and_necklace_try_on(
             if result is None:
                 raise ValueError("Failed to process necklace try-on")
 
-            result_url = await supabase_upload_and_return_url(prefix="NTOCTO", image=result, necklace_id=necklaceImageId)
+            result_url = await supabase_upload_and_return_url(prefix="NTOCTO", image=result,
+                                                              necklace_id=necklaceImageId)
 
             if not result_url:
                 raise ValueError("Failed to upload result image")
@@ -650,7 +651,8 @@ async def mannequin_nto(necklace_try_on_id: NecklaceTryOnIDEntity = Depends(pars
         start_time_saving = time.time()
 
         # Upload both images concurrently
-        upload_tasks = supabase_upload_and_return_url(prefix="MNTO", image=result, necklace_id=necklace_try_on_id.necklaceImageId)
+        upload_tasks = supabase_upload_and_return_url(prefix="MNTO", image=result,
+                                                      necklace_id=necklace_try_on_id.necklaceImageId)
         result_url = await asyncio.gather(upload_tasks)
 
         if result_url[0] is None:

src/api/store_dashboard_api.py

@@ -0,0 +1,97 @@
+"""
+project @ NTO-TCP-HF
+created @ 2024-12-18
+author  @ github.com/ishworrsubedii
+"""
+import base64
+import gc
+import time
+from io import BytesIO
+
+from PIL import Image
+from fastapi import File, UploadFile, APIRouter
+from fastapi.responses import JSONResponse
+
+from src.api.nto_api import pipeline
+from src.utils.logger import logger
+
+store_dashboard_router = APIRouter()
+
+
+@store_dashboard_router.post("/necklace_try_on")
+async def necklace_try_on(offset_x: float, offset_y: float, storename, image: UploadFile = File(...),
+                          necklace: UploadFile = File(...)):
+    logger.info("-" * 50)
+    logger.info(">>> NECKLACE TRY ON ID STARTED <<<")
+    logger.info(f"Parameters: offset_x={offset_x}, offset_y={offset_x}")
+    logger.info(f"Parameters: storename={storename}")
+
+    start_time = time.time()
+
+    try:
+        image_loading_start = time.time()
+        imageBytes = await image.read()
+        jewelleryBytes = await necklace.read()
+        image, jewellery = Image.open(BytesIO(imageBytes)), Image.open(BytesIO(jewelleryBytes))
+        image_loading_time = round(time.time() - image_loading_start, 2)
+        logger.info(f">>> IMAGES LOADED SUCCESSFULLY in {image_loading_time}s <<<")
+    except Exception as e:
+        logger.error(f">>> IMAGE LOADING ERROR: {str(e)} <<<")
+        return JSONResponse(content={
+            "error": f"The requested resource (Image, necklace category, or store) is not available. Please verify the availability and try again",
+            "code": 404}, status_code=404)
+
+    try:
+        nto_start_time = time.time()
+        result, headerText, mask = await pipeline.necklaceTryOnDynamicOffset_(
+            image=image,
+            jewellery=jewellery,
+            storename=storename,
+            offset=[offset_x, offset_y]
+        )
+        nto_time = round(time.time() - nto_start_time, 2)
+        logger.info(f">>> NECKLACE TRY ON PROCESSING COMPLETED in {nto_time}s <<<")
+
+        if result is None:
+            logger.error(">>> NO FACE DETECTED IN THE IMAGE <<<")
+            return JSONResponse(
+                content={"error": "No face detected in the image please try again with a different image",
+                         "code": 400}, status_code=400)
+
+    except Exception as e:
+        logger.error(f">>> NECKLACE TRY ON PROCESSING ERROR: {str(e)} <<<")
+        return JSONResponse(content={"error": f"Error during necklace try-on process", "code": 500},
+                            status_code=500)
+    result_base_64 = BytesIO()
+    result.save(result_base_64, format="WEBP")
+    result_bytes_ = base64.b64encode(result_base_64.getvalue()).decode("utf-8")
+    image_base64 = f"data:image/webp;base64,{result_bytes_}"
+
+    try:
+        total_time = round(time.time() - start_time, 2)
+        response = {
+            "code": 200,
+            "output": f"{image_base64}",
+            "timing": {
+                "image_loading": image_loading_time,
+                "nto_processing": nto_time,
+                "total": total_time
+            }
+        }
+
+        logger.info(f">>> TIMING BREAKDOWN <<<")
+        logger.info(f"Image Loading: {image_loading_time}s")
+        logger.info(f"NTO Processing: {nto_time}s")
+        logger.info(f"Total Time: {total_time}s")
+        logger.info(">>> NECKLACE TRY ON COMPLETED <<<")
+        logger.info("-" * 50)
+
+        return JSONResponse(content=response, status_code=200)
+
+    except Exception as e:
+        logger.error(f">>> RESPONSE GENERATION ERROR: {str(e)} <<<")
+        return JSONResponse(content={"error": f"Error generating response", "code": 500}, status_code=500)
+
+    finally:
+        if 'result' in locals(): del result
+        gc.collect()