initial commit

.github/workflows/workflow.yml

@@ -0,0 +1,39 @@
+name: Publish Docker image
+
+on:
+  push:
+    branches: [main]
+
+jobs:
+  push_to_registry:
+    name: Push Docker image to Docker Hub
+    runs-on: ubuntu-latest
+    permissions:
+      packages: write
+      contents: read
+      attestations: write
+    steps:
+      - name: Check out the repo
+        uses: actions/checkout@v4
+
+      - name: Log in to Docker Hub
+        uses: docker/login-action@f4ef78c080cd8ba55a85445d5b36e214a81df20a
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_PASSWORD }}
+
+      - name: Extract metadata (tags, labels) for Docker
+        id: meta
+        uses: docker/metadata-action@9ec57ed1fcdbf14dcef7dfbe97b2010124a938b7
+        with:
+          images: techconsp/jecmdvhgyyqtmjvzggkbukxyiphuvbwjdjadfagx
+
+      - name: Build and push Docker image
+        id: push
+        uses: docker/build-push-action@3b5e8027fcad23fda98b2e3ac259d8d67585f671
+        with:
+          context: .
+          file: ./Dockerfile
+          push: true
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}

.gitignore

@@ -0,0 +1,144 @@
+# .gitignore
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#  According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#  However, in case of collaboration, if having platform-specific dependencies or dependencies
+#  having no cross-platform support, pipenv may install dependencies that don't work, or not
+#  install all needed dependencies.
+# Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyderworkspace
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+.idea/
+
+# Local logs
+*.log
+examples

Dockerfile

@@ -0,0 +1,25 @@
+FROM python:3.10-slim
+
+WORKDIR /api
+
+COPY . /api
+
+RUN apt-get update && apt-get install -y \
+    libgl1-mesa-glx \
+    ffmpeg \
+    libsm6 \
+    libxext6
+
+RUN pip install -r requirements.txt
+
+RUN mkdir -p /.cache /root/.cache /tmp/.cache /api/.cache && \
+    chmod -R 777 /.cache /root/.cache /tmp/.cache /api/.cache
+
+ENV MPLCONFIGDIR=/tmp/.cache/matplotlib
+ENV HUGGINGFACE_HUB_CACHE=/tmp/.cache/huggingface
+
+RUN chmod -R 777 /api /tmp /root /.cache
+
+EXPOSE 7860
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -0,0 +1,70 @@
+"""
+project @ NTO-TCP-HF
+created @ 2024-10-28
+author  @ github.com/ishworrsubedii
+"""
+import time
+from datetime import datetime, timedelta, timezone
+
+from fastapi import FastAPI, Depends, HTTPException
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+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
+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
+
+security = HTTPBearer()
+
+
+async def verify_login_token(credentials: HTTPAuthorizationCredentials = Depends(security)):
+    try:
+        response = supabase.table("JewelMirrorUserLogins").select("*").eq("LoginToken",
+                                                                          credentials.credentials).execute()
+
+        if not response.data:
+            raise HTTPException(status_code=401, detail="Unauthorized: Token not found")
+
+        token_data = response.data[0]
+
+        created_at = datetime.fromisoformat(token_data["UpdatedAt"].replace("Z", "+00:00"))
+        current_time = datetime.now(timezone.utc)
+        time_difference = current_time - created_at
+
+        if time_difference <= timedelta(minutes=30):
+            return JSONResponse({"status": "Authorized", "message": "Token is valid"}, status_code=200)
+
+        raise HTTPException(status_code=401, detail="Unauthorized: Token expired")
+
+    except Exception as e:
+        print(f"Token verification error: {e}")
+        raise HTTPException(status_code=401, detail="Invalid token")
+
+
+app = FastAPI(title="NTO-TCP-HF", version="1.0.0")
+app.include_router(nto_cto_router, tags=["NTO-CTO"])
+app.include_router(preprocessing_router, tags=["Image-Preprocessing"])
+app.include_router(image_regeneration_router, tags=["Image-Regeneration"])
+time.sleep(1)
+app.include_router(batch_router, tags=['Realtime'])
+
+app.include_router(mto_router, tags=["MTO"])
+
+app.include_router(makeup_tryon_router, tags=["makeup_tryon"])
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+if __name__ == '__main__':
+    import uvicorn
+
+    uvicorn.run(app)

requirements.txt

@@ -0,0 +1,83 @@
+absl-py==2.1.0
+annotated-types==0.7.0
+anyio==4.4.0
+attrs==23.2.0
+certifi==2024.7.4
+cffi==1.16.0
+charset-normalizer==3.3.2
+click==8.1.7
+contourpy==1.2.1
+cvzone==1.6.1
+cycler==0.12.1
+deprecation==2.1.0
+dnspython==2.6.1
+email_validator==2.2.0
+exceptiongroup==1.2.1
+fastapi==0.111.0
+fastapi-cli==0.0.4
+flatbuffers==24.3.25
+fonttools==4.53.1
+gotrue==2.5.4
+h11==0.14.0
+httpcore==1.0.5
+httptools==0.6.1
+httpx==0.27.0
+idna==3.7
+jax==0.4.30
+jaxlib==0.4.30
+Jinja2==3.1.4
+kiwisolver==1.4.5
+markdown-it-py==3.0.0
+MarkupSafe==2.1.5
+matplotlib==3.9.1
+mdurl==0.1.2
+mediapipe
+ml-dtypes==0.4.0
+numpy==2.0.0
+opencv-contrib-python==4.10.0.84
+opencv-python==4.10.0.84
+opt-einsum==3.3.0
+orjson==3.10.6
+packaging==24.1
+pandas==2.2.2
+pillow==10.4.0
+postgrest==0.16.8
+protobuf==4.25.3
+pycparser==2.22
+pydantic==2.8.2
+pydantic_core==2.20.1
+Pygments==2.18.0
+pyparsing==3.1.2
+python-dateutil==2.9.0.post0
+python-dotenv==1.0.1
+python-multipart==0.0.9
+pytz==2024.1
+PyYAML==6.0.1
+realtime==1.0.6
+requests==2.32.3
+rich==13.7.1
+scikit-build==0.18.0
+scipy==1.14.0
+shellingham==1.5.4
+six==1.16.0
+sniffio==1.3.1
+sounddevice==0.4.7
+starlette==0.37.2
+storage3==0.7.6
+StrEnum==0.4.15
+supabase==2.5.1
+supafunc==0.4.6
+tomli==2.0.1
+typer==0.12.3
+typing_extensions==4.12.2
+tzdata==2024.1
+ujson==5.10.0
+urllib3==2.2.2
+uvicorn==0.30.1
+uvloop==0.19.0
+watchfiles==0.22.0
+websockets==12.0
+replicate
+google-generativeai
+aiohttp
+-e .

setup.py

@@ -0,0 +1,20 @@
+from setuptools import setup, find_packages
+
+HYPER_E_DOT = "-e ."
+
+
+def getRequirements(requirementsPath: str) -> list[str]:
+    with open(requirementsPath) as file:
+        requirements = file.read().split("\n")
+    requirements.remove(HYPER_E_DOT)
+    return requirements
+
+
+setup(
+    name="Jewel Mirror",
+    author="Ishwor Subedi",
+    author_email="ishworr.subedi@gmail.com",
+    version="0.1",
+    packages=find_packages(),
+    install_requires=getRequirements(requirementsPath="./requirements.txt")
+)

src/__init__.py

@@ -0,0 +1,5 @@
+"""
+project @ NTO-TCP-HF
+created @ 2024-10-28
+author  @ github/ishworrsubedii
+"""

src/api/__init__.py

@@ -0,0 +1,5 @@
+"""
+project @ NTO-TCP-HF
+created @ 2024-10-28
+author  @ github/ishworrsubedii
+"""

src/api/batch_api.py

@@ -0,0 +1,752 @@
+"""
+project @ CTO_TCP_ZERO_GPU
+created @ 2024-11-14
+author  @ github.com/ishworrsubedii
+"""
+import asyncio
+import base64
+import gc
+import json
+import time
+from io import BytesIO
+from typing import List
+
+import aiohttp
+import cv2
+import numpy as np
+from PIL import Image
+from fastapi import File, UploadFile, Form
+from fastapi.responses import JSONResponse
+from fastapi.responses import StreamingResponse
+from fastapi.routing import APIRouter
+from pydantic import BaseModel
+
+from src.api.makeup_tryon_api import get_colors
+from src.api.nto_api import pipeline, replicate_run_cto, supabase_upload_and_return_url
+from src.utils import returnBytesData
+from src.utils.logger import logger
+
+batch_router = APIRouter()
+colors = get_colors()
+
+
+class ClothingRequest(BaseModel):
+    c_list: List[str]
+
+
+@batch_router.post("/rt_cto")
+async def rt_cto(
+        image: UploadFile = File(...),
+        c_list: str = Form(...)
+):
+    logger.info("-" * 50)
+    logger.info(">>> REAL-TIME CTO STARTED <<<")
+    logger.info(f"Parameters: clothing_list={c_list}")
+
+    setup_start_time = time.time()
+    try:
+        clothing_list = [item.strip() for item in c_list.split(",")]
+        image_bytes = await image.read()
+        pil_image = Image.open(BytesIO(image_bytes)).convert("RGB")
+        setup_time = round(time.time() - setup_start_time, 2)
+        logger.info(f">>> IMAGE LOADED SUCCESSFULLY in {setup_time}s <<<")
+    except Exception as e:
+        logger.error(f">>> IMAGE LOADING ERROR: {str(e)} <<<")
+        return {"error": "Error reading image", "code": 500}
+
+    async def generate():
+        logger.info("-" * 50)
+        logger.info(">>> CLOTHING TRY ON V2 STARTED <<<")
+
+        # Mask generation timing
+        mask_start_time = time.time()
+        try:
+            mask, _, _ = await pipeline.shoulderPointMaskGeneration_(image=pil_image)
+            mask_time = round(time.time() - mask_start_time, 2)
+            logger.info(f">>> MASK GENERATION COMPLETED in {mask_time}s <<<")
+        except Exception as e:
+            logger.error(f">>> MASK GENERATION ERROR: {str(e)} <<<")
+            yield json.dumps({"error": "Error generating mask", "code": 500}) + "\n"
+            await asyncio.sleep(0.1)
+            return
+
+        # Encoding timing
+        encoding_start_time = time.time()
+        try:
+            mask_img_base_64, act_img_base_64 = BytesIO(), BytesIO()
+            mask.save(mask_img_base_64, format="WEBP")
+            pil_image.save(act_img_base_64, format="WEBP")
+            mask_bytes_ = base64.b64encode(mask_img_base_64.getvalue()).decode("utf-8")
+            image_bytes_ = base64.b64encode(act_img_base_64.getvalue()).decode("utf-8")
+
+            mask_data_uri = f"data:image/webp;base64,{mask_bytes_}"
+            image_data_uri = f"data:image/webp;base64,{image_bytes_}"
+            encoding_time = round(time.time() - encoding_start_time, 2)
+            logger.info(f">>> IMAGE ENCODING COMPLETED in {encoding_time}s <<<")
+        except Exception as e:
+            logger.error(f">>> IMAGE ENCODING ERROR: {str(e)} <<<")
+            yield json.dumps({"error": "Error converting images to base64", "code": 500}) + "\n"
+            await asyncio.sleep(0.1)
+            return
+
+        for idx, clothing_type in enumerate(clothing_list):
+            if not clothing_type:
+                continue
+
+            iteration_start_time = time.time()
+            try:
+                inference_start_time = time.time()
+                output = replicate_run_cto({
+                    "mask": mask_data_uri,
+                    "image": image_data_uri,
+                    "prompt": f"Dull {clothing_type}, non-reflective clothing, properly worn, natural setting, elegant, natural look, neckline without jewellery, simple, perfect eyes, perfect face, perfect body, high quality, realistic, photorealistic, high resolution,traditional full sleeve blouse",
+                    "negative_prompt": "necklaces, jewellery, jewelry, necklace, neckpiece, garland, chain, neck wear, jewelled neck, jeweled neck, necklace on neck, jewellery on neck, accessories, watermark, text, changed background, wider body, narrower body, bad proportions, extra limbs, mutated hands, changed sizes, altered proportions, unnatural body proportions, blury, ugly",
+                    "num_inference_steps": 25
+                })
+                inference_time = round(time.time() - inference_start_time, 2)
+                logger.info(f">>> REPLICATE PROCESSING COMPLETED FOR {clothing_type} in {inference_time}s <<<")
+
+                output_url = str(output[0]) if output and output[0] else None
+                iteration_time = round(time.time() - iteration_start_time, 2)
+
+                result = {
+                    "code": 200,
+                    "output": output_url,
+                    "timing": {
+                        "setup": setup_time,
+                        "mask_generation": mask_time,
+                        "encoding": encoding_time,
+                        "inference": inference_time,
+                        "iteration": iteration_time
+                    },
+                    "clothing_type": clothing_type,
+                    "progress": f"{idx + 1}/{len(clothing_list)}"
+                }
+                yield json.dumps(result) + "\n"
+                await asyncio.sleep(0.1)
+
+            except Exception as e:
+                logger.error(f">>> REPLICATE PROCESSING ERROR: {str(e)} <<<")
+                error_result = {
+                    "error": str(e),
+                    "details": str(e),
+                    "code": 500,
+                    "clothing_type": clothing_type,
+                    "progress": f"{idx + 1}/{len(clothing_list)}"
+                }
+                yield json.dumps(error_result) + "\n"
+                await asyncio.sleep(0.1)
+
+    return StreamingResponse(
+        generate(),
+        media_type="application/x-ndjson",
+        headers={
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+            "X-Accel-Buffering": "no",
+            "Transfer-Encoding": "chunked"
+        }
+    )
+
+
+@batch_router.post("/rt_nto")
+async def rt_nto(
+        image: UploadFile = File(...),
+        necklace_id_list: str = Form(...),
+        category_list: str = Form(...),
+        storename_list: str = Form(...),
+        offset_x_list: str = Form(...),
+        offset_y_list: str = Form(...)
+):
+    logger.info("-" * 50)
+    logger.info(">>> REAL-TIME NECKLACE TRY ON STARTED <<<")
+    logger.info(f"Parameters: storename={storename_list}, categories={category_list}, necklace_ids={necklace_id_list}")
+
+    try:
+        # Parse all lists
+        necklace_ids = [id.strip() for id in necklace_id_list.split(",")]
+        categories = [cat.strip() for cat in category_list.split(",")]
+        stores = [store.strip() for store in storename_list.split(",")]
+        offset_x_values = [float(x.strip()) for x in offset_x_list.split(",")]
+        offset_y_values = [float(y.strip()) for y in offset_y_list.split(",")]
+
+        # Validate list lengths
+        if len(necklace_ids) != len(categories) or \
+                len(necklace_ids) != len(stores) or \
+                len(necklace_ids) != len(offset_x_values) or \
+                len(necklace_ids) != len(offset_y_values):
+            return JSONResponse(
+                content={
+                    "error": "Number of necklace IDs must match number of categories, stores, and offset values",
+                    "code": 400
+                },
+                status_code=400
+            )
+
+        # Load the source image
+        image_bytes = await image.read()
+        source_image = Image.open(BytesIO(image_bytes))
+        logger.info(">>> SOURCE IMAGE LOADED SUCCESSFULLY <<<")
+    except Exception as e:
+        logger.error(f">>> INITIAL SETUP ERROR: {str(e)} <<<")
+        return JSONResponse(
+            content={"error": "Error in initial setup", "details": str(e), "code": 500},
+            status_code=500
+        )
+
+    async def generate():
+        setup_start_time = time.time()  # Add setup timing
+
+        # After loading images
+        setup_time = round(time.time() - setup_start_time, 2)
+        logger.info(f">>> SETUP COMPLETED in {setup_time}s <<<")
+
+        for idx, (necklace_id, category, storename, offset_x, offset_y) in enumerate(
+                zip(necklace_ids, categories, stores, offset_x_values, offset_y_values)
+        ):
+            iteration_start_time = time.time()
+            try:
+                # Load jewellery timing
+                jewellery_load_start = time.time()
+                jewellery_url = f"https://lvuhhlrkcuexzqtsbqyu.supabase.co/storage/v1/object/public/Stores/{storename}/{category}/image/{necklace_id}.png"
+                jewellery = Image.open(returnBytesData(url=jewellery_url))
+                jewellery_time = round(time.time() - jewellery_load_start, 2)
+                logger.info(f">>> JEWELLERY LOADED in {jewellery_time}s <<<")
+
+                # NTO timing
+                nto_start_time = time.time()
+                result, headetText, mask = await pipeline.necklaceTryOnDynamicOffset_(
+                    image=source_image,
+                    jewellery=jewellery,
+                    storename=storename,
+                    offset=[offset_x, offset_y]
+                )
+                nto_time = round(time.time() - nto_start_time, 2)
+
+                # Upload timing
+                upload_start_time = time.time()
+                upload_tasks = [
+                    supabase_upload_and_return_url(prefix="NTO", image=result, necklace_id=necklace_id),
+                    supabase_upload_and_return_url(prefix="NTO", image=mask, necklace_id=necklace_id)
+                ]
+                result_url, mask_url = await asyncio.gather(*upload_tasks)
+                upload_time = round(time.time() - upload_start_time, 2)
+
+                result = {
+                    "code": 200,
+                    "output": result_url,
+                    "mask": mask_url,
+                    "timing": {
+                        "setup": setup_time,
+                        "jewellery_load": jewellery_time,
+                        "nto_inference": nto_time,
+                        "upload": upload_time,
+                        "total_iteration": round(time.time() - iteration_start_time, 2)
+                    },
+                    "necklace_id": necklace_id,
+                    "category": category,
+                    "progress": f"{idx + 1}/{len(necklace_ids)}"
+                }
+                yield json.dumps(result) + "\n"
+                await asyncio.sleep(0.1)
+
+                del result
+                del mask
+                gc.collect()
+
+            except Exception as e:
+                logger.error(f">>> PROCESSING ERROR FOR {necklace_id}: {str(e)} <<<")
+                error_result = {
+                    "error": f"Error processing necklace {necklace_id}",
+                    "details": str(e),
+                    "code": 500,
+                    "necklace_id": necklace_id,
+                    "category": category,
+                    "progress": f"{idx + 1}/{len(necklace_ids)}"
+                }
+                yield json.dumps(error_result) + "\n"
+                await asyncio.sleep(0.1)
+
+    return StreamingResponse(
+        generate(),
+        media_type="application/x-ndjson",
+        headers={
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+            "X-Accel-Buffering": "no",
+            "Transfer-Encoding": "chunked"
+        }
+    )
+
+
+@batch_router.post("/rt_cto_nto")
+async def rt_cto_nto(
+        image: UploadFile = File(...),
+        c_list: str = Form(...),
+        necklace_id_list: str = Form(...),
+        necklace_category_list: str = Form(...),
+        storename_list: str = Form(...),
+        offset_x_list: str = Form(...),
+        offset_y_list: str = Form(...)
+):
+    logger.info("-" * 50)
+    logger.info(">>> REAL-TIME CTO-NTO STARTED <<<")
+    logger.info(f"Parameters: storenames={storename_list}, necklace_categories={necklace_category_list}, "
+                f"necklace_ids={necklace_id_list}, clothing_list={c_list}")
+
+    try:
+        # Parse all input lists
+        clothing_list = [item.strip() for item in c_list.split(",")]
+        necklace_ids = [id.strip() for id in necklace_id_list.split(",")]
+        categories = [cat.strip() for cat in necklace_category_list.split(",")]
+        stores = [store.strip() for store in storename_list.split(",")]
+        offset_x_values = [float(x.strip()) for x in offset_x_list.split(",")]
+        offset_y_values = [float(y.strip()) for y in offset_y_list.split(",")]
+
+        # Validate list lengths
+        if len(necklace_ids) != len(categories) or \
+                len(necklace_ids) != len(stores) or \
+                len(necklace_ids) != len(offset_x_values) or \
+                len(necklace_ids) != len(offset_y_values):
+            return JSONResponse(
+                content={
+                    "error": "Number of necklace IDs must match number of categories, stores, and offset values",
+                    "code": 400
+                },
+                status_code=400
+            )
+
+        # Load source image
+        image_bytes = await image.read()
+        source_image = Image.open(BytesIO(image_bytes)).convert("RGB")
+
+        # Load all jewellery images
+        jewellery_data = []
+        for nid, cat, store in zip(necklace_ids, categories, stores):
+            jewellery_url = f"https://lvuhhlrkcuexzqtsbqyu.supabase.co/storage/v1/object/public/Stores/{store}/{cat}/image/{nid}.png"
+            jewellery = Image.open(returnBytesData(url=jewellery_url)).convert("RGBA")
+            jewellery_data.append({
+                'image': jewellery,
+                'id': nid,
+                'category': cat,
+                'store': store
+            })
+
+        logger.info(">>> IMAGES LOADED SUCCESSFULLY <<<")
+    except Exception as e:
+        logger.error(f">>> INITIAL SETUP ERROR: {str(e)} <<<")
+        return JSONResponse(
+            content={"error": "Error in initial setup", "details": str(e), "code": 500},
+            status_code=500
+        )
+
+    async def generate():
+        setup_start_time = time.time()
+
+        try:
+            # Mask generation timing
+            mask_start_time = time.time()
+            mask, _, _ = await pipeline.shoulderPointMaskGeneration_(image=source_image)
+            mask_time = round(time.time() - mask_start_time, 2)
+            logger.info(f">>> MASK GENERATION COMPLETED in {mask_time}s <<<")
+
+            # Encoding
+            encoding_start_time = time.time()
+            mask_img_base_64, act_img_base_64 = BytesIO(), BytesIO()
+            mask.save(mask_img_base_64, format="WEBP")
+            source_image.save(act_img_base_64, format="WEBP")
+            mask_bytes_ = base64.b64encode(mask_img_base_64.getvalue()).decode("utf-8")
+            image_bytes_ = base64.b64encode(act_img_base_64.getvalue()).decode("utf-8")
+
+            mask_data_uri = f"data:image/webp;base64,{mask_bytes_}"
+            image_data_uri = f"data:image/webp;base64,{image_bytes_}"
+            encoding_time = round(time.time() - encoding_start_time, 2)
+            logger.info(f">>> IMAGE ENCODING COMPLETED in {encoding_time}s <<<")
+
+            total_combinations = len(clothing_list) * len(jewellery_data)
+            current_combination = 0
+
+            for clothing_type in clothing_list:
+                # First do CTO
+                cto_start_time = time.time()
+                cto_output = replicate_run_cto({
+                    "mask": mask_data_uri,
+                    "image": image_data_uri,
+                    "prompt": f"Dull {clothing_type}, non-reflective clothing, properly worn, natural setting, elegant, natural look, neckline without jewellery, simple, perfect eyes, perfect face, perfect body, high quality, realistic, photorealistic, high resolution,traditional full sleeve blouse",
+                    "negative_prompt": "necklaces, jewellery, jewelry, necklace, neckpiece, garland, chain, neck wear, jewelled neck, jeweled neck, necklace on neck, jewellery on neck, accessories, watermark, text, changed background, wider body, narrower body, bad proportions, extra limbs, mutated hands, changed sizes, altered proportions, unnatural body proportions, blury, ugly",
+                    "num_inference_steps": 25
+                })
+                cto_time = round(time.time() - cto_start_time, 2)
+                logger.info(f">>> CTO COMPLETED for {clothing_type} in {cto_time}s <<<")
+
+                # Get CTO result image
+                async with aiohttp.ClientSession() as session:
+                    async with session.get(str(cto_output[0])) as response:
+                        if response.status != 200:
+                            raise ValueError("Failed to fetch CTO output")
+                        cto_result_bytes = await response.read()
+
+                cto_result_image = Image.open(BytesIO(cto_result_bytes)).convert("RGB")
+
+                # Now apply each necklace to the CTO result
+                for jewellery_item, offset_x, offset_y in zip(jewellery_data, offset_x_values, offset_y_values):
+                    current_combination += 1
+                    iteration_start_time = time.time()
+
+                    try:
+                        # Perform NTO
+                        nto_start_time = time.time()
+                        result, headerText, nto_mask = await pipeline.necklaceTryOnDynamicOffset_(
+                            image=cto_result_image,
+                            jewellery=jewellery_item['image'],
+                            storename=jewellery_item['store'],
+                            offset=[offset_x, offset_y]
+                        )
+                        nto_time = round(time.time() - nto_start_time, 2)
+                        logger.info(f">>> NTO COMPLETED for {jewellery_item['id']} in {nto_time}s <<<")
+
+                        # Upload result
+                        upload_start_time = time.time()
+                        result_url = await supabase_upload_and_return_url(
+                            prefix="NTOCTO",
+                            image=result,
+                            necklace_id=jewellery_item['id']
+                        )
+                        upload_time = round(time.time() - upload_start_time, 2)
+
+                        output_result = {
+                            "code": 200,
+                            "output": result_url,
+                            "timing": {
+                                "setup": round(time.time() - setup_start_time, 2),
+                                "mask_generation": mask_time,
+                                "encoding": encoding_time,
+                                "cto_inference": cto_time,
+                                "nto_inference": nto_time,
+                                "upload": upload_time,
+                                "total_iteration": round(time.time() - iteration_start_time, 2)
+                            },
+                            "clothing_type": clothing_type,
+                            "necklace_id": jewellery_item['id'],
+                            "necklace_category": jewellery_item['category'],
+                            "store": jewellery_item['store'],
+                            "progress": f"{current_combination}/{total_combinations}"
+                        }
+                        yield json.dumps(output_result) + "\n"
+                        await asyncio.sleep(0.1)
+
+                        del result
+                        gc.collect()
+
+                    except Exception as e:
+                        logger.error(
+                            f">>> PROCESSING ERROR FOR {clothing_type} with {jewellery_item['id']}: {str(e)} <<<")
+                        error_result = {
+                            "error": f"Error processing combination",
+                            "details": str(e),
+                            "code": 500,
+                            "clothing_type": clothing_type,
+                            "necklace_id": jewellery_item['id'],
+                            "necklace_category": jewellery_item['category'],
+                            "store": jewellery_item['store'],
+                            "progress": f"{current_combination}/{total_combinations}"
+                        }
+                        yield json.dumps(error_result) + "\n"
+                        await asyncio.sleep(0.1)
+
+        except Exception as e:
+            logger.error(f">>> GENERAL PROCESSING ERROR: {str(e)} <<<")
+            yield json.dumps({
+                "error": "General processing error",
+                "details": str(e),
+                "code": 500
+            }) + "\n"
+            await asyncio.sleep(0.1)
+
+    return StreamingResponse(
+        generate(),
+        media_type="application/x-ndjson",
+        headers={
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+            "X-Accel-Buffering": "no",
+            "Transfer-Encoding": "chunked"
+        }
+    )
+
+
+@batch_router.post("/rt_makeup")
+async def rt_makeup(
+        image: UploadFile = File(...),
+        lipstick_colors: str = Form(...),
+        eyeliner_colors: str = Form(...),
+        eyeshadow_colors: str = Form(...)
+):
+    logger.info("-" * 50)
+    logger.info(">>> REAL-TIME MAKEUP STARTED <<<")
+    logger.info(f"Parameters: lipstick_colors={lipstick_colors}, "
+                f"eyeliner_colors={eyeliner_colors}, eyeshadow_colors={eyeshadow_colors}")
+
+    try:
+        # Parse color lists
+        lipstick_colors_list = [color.strip() for color in lipstick_colors.split(",")]
+        eyeliner_colors_list = [color.strip() for color in eyeliner_colors.split(",")]
+        eyeshadow_colors_list = [color.strip() for color in eyeshadow_colors.split(",")]
+
+        # Read uploaded image
+        image_bytes = await image.read()
+        source_image = Image.open(BytesIO(image_bytes)).convert("RGB").resize((1080, 1080))
+        cv_image = cv2.cvtColor(np.array(source_image), cv2.COLOR_RGB2BGR)
+
+        logger.info(">>> INPUT PARSING SUCCESSFUL <<<")
+    except Exception as e:
+        logger.error(f">>> INPUT PARSING ERROR: {str(e)} <<<")
+        return JSONResponse(
+            content={"error": "Error in parsing inputs", "details": str(e), "code": 500},
+            status_code=500
+        )
+
+    async def generate():
+        setup_start_time = time.time()
+
+        try:
+            combinations = list(zip(
+                lipstick_colors_list,
+                eyeliner_colors_list,
+                eyeshadow_colors_list
+            ))
+            total_combinations = len(combinations)
+            current_combination = 0
+
+            for lipstick_color, eyeliner_color, eyeshadow_color in combinations:
+                lipstick_color_set = tuple(colors["Lipstick"][lipstick_color])
+                eyeliner_color_set = tuple(colors["Eyeliner"][eyeliner_color])
+                eyeshadow_color_set = tuple(colors["Eyeshadow"][eyeshadow_color])
+
+                current_combination += 1
+                iteration_start_time = time.time()
+
+                try:
+                    makeup_start_time = time.time()
+                    result = await pipeline.makeup_tryon(
+                        image=cv_image.copy(),
+                        lipstick_color=lipstick_color_set,
+                        eyeliner_color=eyeliner_color_set,
+                        eyeshadow_color=eyeshadow_color_set
+                    )
+                    makeup_time = round(time.time() - makeup_start_time, 2)
+                    logger.info(f">>> MAKEUP APPLICATION COMPLETED in {makeup_time}s <<<")
+
+                    # Upload result
+                    upload_start_time = time.time()
+                    result_image = Image.fromarray(cv2.cvtColor(result, cv2.COLOR_BGR2RGB))
+
+                    result_url = await supabase_upload_and_return_url(
+                        prefix="MTO",
+                        image=result_image,
+                        necklace_id="JEWELMIRRORMAKEUP"
+                    )
+                    upload_time = round(time.time() - upload_start_time, 2)
+                    logger.info(f">>> RESULT UPLOADED in {upload_time}s <<<")
+
+                    output_result = {
+                        "code": 200,
+                        "output": result_url,
+                        "timing": {
+                            "setup": round(time.time() - setup_start_time, 2),
+                            "makeup_application": makeup_time,
+                            "upload": upload_time,
+                            "total_iteration": round(time.time() - iteration_start_time, 2)
+                        },
+                        "progress": f"{current_combination}/{total_combinations}",
+                        "lipstick_color": lipstick_color,
+                        "eyeliner_color": eyeliner_color,
+                        "eyeshadow_color": eyeshadow_color
+                    }
+                    yield json.dumps(output_result) + "\n"
+                    await asyncio.sleep(0.1)
+
+                    del result
+                    gc.collect()
+
+                except Exception as e:
+                    logger.error(f">>> PROCESSING ERROR: {str(e)} <<<")
+                    error_result = {
+                        "error": "Error processing makeup application",
+                        "details": str(e),
+                        "code": 500,
+                        "progress": f"{current_combination}/{total_combinations}",
+                        "lipstick_color": lipstick_color,
+                        "eyeliner_color": eyeliner_color,
+                        "eyeshadow_color": eyeshadow_color
+                    }
+                    yield json.dumps(error_result) + "\n"
+                    await asyncio.sleep(0.1)
+
+        except Exception as e:
+            logger.error(f">>> GENERAL PROCESSING ERROR: {str(e)} <<<")
+            yield json.dumps({
+                "error": "General processing error",
+                "details": str(e),
+                "code": 500
+            }) + "\n"
+            await asyncio.sleep(0.1)
+
+    return StreamingResponse(
+        generate(),
+        media_type="application/x-ndjson",
+        headers={
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+            "X-Accel-Buffering": "no",
+            "Transfer-Encoding": "chunked"
+        }
+    )
+
+
+@batch_router.post("/batch_rt_makeup")
+async def batch_rt_makeup(
+        image_urls: str = Form(...),
+        lipstick_colors: str = Form(...),
+        eyeliner_colors: str = Form(...),
+        eyeshadow_colors: str = Form(...)
+):
+    logger.info("-" * 50)
+    logger.info(">>> REAL-TIME MAKEUP STARTED <<<")
+    logger.info(f"Parameters: image_urls={image_urls}, lipstick_colors={lipstick_colors}, "
+                f"eyeliner_colors={eyeliner_colors}, eyeshadow_colors={eyeshadow_colors}")
+
+    try:
+        # Parse all input lists
+        image_urls_list = [url.strip() for url in image_urls.split(",")]
+        lipstick_colors_list = [color.strip() for color in lipstick_colors.split(",")]
+        eyeliner_colors_list = [color.strip() for color in eyeliner_colors.split(",")]
+        eyeshadow_colors_list = [color.strip() for color in eyeshadow_colors.split(",")]
+
+        # Validate list lengths
+        if not (len(image_urls_list) == len(lipstick_colors_list) ==
+                len(eyeliner_colors_list) == len(eyeshadow_colors_list)):
+            return JSONResponse(
+                content={
+                    "error": "All input lists must have the same number of elements.",
+                    "code": 400
+                },
+                status_code=400
+            )
+
+        logger.info(">>> INPUT PARSING SUCCESSFUL <<<")
+    except Exception as e:
+        logger.error(f">>> INPUT PARSING ERROR: {str(e)} <<<")
+        return JSONResponse(
+            content={"error": "Error in parsing inputs", "details": str(e), "code": 500},
+            status_code=500
+        )
+
+    async def generate():
+        setup_start_time = time.time()
+
+        try:
+            total_combinations = len(image_urls_list)
+            current_combination = 0
+
+            for image_url, lipstick_color, eyeliner_color, eyeshadow_color in zip(
+                    image_urls_list, lipstick_colors_list, eyeliner_colors_list, eyeshadow_colors_list):
+                lipstick_color_set = tuple(colors["Lipstick"][lipstick_color])
+                eyeliner_color_set = tuple(colors["Eyeliner"][eyeliner_color])
+                eyeshadow_color_set = tuple(colors["Eyeshadow"][eyeshadow_color])
+
+                current_combination += 1
+                iteration_start_time = time.time()
+                lipstick_color
+
+                try:
+                    fetch_start_time = time.time()
+                    async with aiohttp.ClientSession() as session:
+                        async with session.get(image_url) as response:
+                            if response.status != 200:
+                                raise ValueError("Failed to fetch image")
+                            image_bytes = await response.read()
+
+                    source_image = Image.open(BytesIO(image_bytes)).convert("RGB").resize((1080, 1080))
+                    fetch_time = round(time.time() - fetch_start_time, 2)
+                    logger.info(f">>> IMAGE FETCHED SUCCESSFULLY in {fetch_time}s <<<")
+                    image = cv2.cvtColor(np.array(source_image), cv2.COLOR_RGB2BGR)
+
+                    makeup_start_time = time.time()
+                    result = await pipeline.makeup_tryon(
+                        image=image,
+                        lipstick_color=lipstick_color_set,
+                        eyeliner_color=eyeliner_color_set,
+                        eyeshadow_color=eyeshadow_color_set
+                    )
+                    makeup_time = round(time.time() - makeup_start_time, 2)
+                    logger.info(f">>> MAKEUP APPLICATION COMPLETED in {makeup_time}s <<<")
+
+                    # Upload result
+                    upload_start_time = time.time()
+                    result_image = Image.fromarray(cv2.cvtColor(result, cv2.COLOR_BGR2RGB))
+
+                    result_url = await supabase_upload_and_return_url(
+                        prefix="MTO",
+                        image=result_image,
+                        necklace_id="JEWELMIRRORMAKEUP"
+                    )
+                    upload_time = round(time.time() - upload_start_time, 2)
+                    logger.info(f">>> RESULT UPLOADED in {upload_time}s <<<")
+
+                    output_result = {
+                        "code": 200,
+                        "output": result_url,
+                        "timing": {
+                            "setup": round(time.time() - setup_start_time, 2),
+                            "fetch": fetch_time,
+                            "makeup_application": makeup_time,
+                            "upload": upload_time,
+                            "total_iteration": round(time.time() - iteration_start_time, 2)
+                        },
+                        "progress": f"{current_combination}/{total_combinations}",
+                        "lipstick_color": lipstick_color,
+                        "eyeliner_color": eyeliner_color,
+                        "eyeshadow_color": eyeshadow_color
+                    }
+                    yield json.dumps(output_result) + "\n"
+                    await asyncio.sleep(0.1)
+
+                    del result
+                    gc.collect()
+
+                except Exception as e:
+                    logger.error(
+                        f">>> PROCESSING ERROR FOR IMAGE {image_url}: {str(e)} <<<")
+                    error_result = {
+                        "error": "Error processing makeup application",
+                        "details": str(e),
+                        "code": 500,
+                        "progress": f"{current_combination}/{total_combinations}",
+                        "lipstick_color": lipstick_color,
+                        "eyeliner_color": eyeliner_color,
+                        "eyeshadow_color": eyeshadow_color
+                    }
+                    yield json.dumps(error_result) + "\n"
+                    await asyncio.sleep(0.1)
+
+
+        except Exception as e:
+            logger.error(f">>> GENERAL PROCESSING ERROR: {str(e)} <<<")
+            yield json.dumps({
+                "error": "General processing error",
+                "details": str(e),
+                "code": 500
+            }) + "\n"
+            await asyncio.sleep(0.1)
+
+    return StreamingResponse(
+        generate(),
+        media_type="application/x-ndjson",
+        headers={
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+            "X-Accel-Buffering": "no",
+            "Transfer-Encoding": "chunked"
+        }
+    )

src/api/image_prep_api.py

@@ -0,0 +1,367 @@
+"""
+project @ NTO-TCP-HF
+created @ 2024-10-28
+author  @ github.com/ishworrsubedii
+"""
+import base64
+import os
+import time
+from io import BytesIO
+
+import cv2
+import numpy as np
+import replicate
+import requests
+from PIL import Image
+from fastapi import APIRouter, UploadFile, File, HTTPException
+from fastapi.responses import JSONResponse
+
+from src.components.auto_crop import crop_transparent_image
+from src.components.color_extraction import ColorExtractionRMBG
+from src.components.title_des_gen import NecklaceProductListing
+from src.utils.logger import logger
+
+preprocessing_router = APIRouter()
+
+rmbg: str = os.getenv("RMBG")
+
+enhancer: str = os.getenv("ENHANCER")
+prod_listing_api_key: str = os.getenv("PROD_LISTING_API_KEY")
+
+color_extraction_rmbg = ColorExtractionRMBG()
+product_listing_obj = NecklaceProductListing(prod_listing_api_key)
+
+
+def replicate_bg(input):
+    output = replicate.run(
+        rmbg,
+        input=input
+    )
+    return output
+
+
+def replicate_enhancer(input):
+    output = replicate.run(
+        enhancer,
+        input=input
+    )
+    return output
+
+
+@preprocessing_router.post("/rem_bg")
+async def remove_background(image: UploadFile = File(...)):
+    logger.info("-" * 50)
+    logger.info(">>> REMOVE BACKGROUND STARTED <<<")
+    start_time = time.time()
+
+    try:
+        image_bytes = await image.read()
+        image = Image.open(BytesIO(image_bytes)).convert("RGB")
+        logger.info(">>> IMAGE LOADED SUCCESSFULLY <<<")
+    except Exception as e:
+        logger.error(f">>> IMAGE LOADING ERROR: {str(e)} <<<")
+        return JSONResponse(status_code=500, content={"error": f"Error reading image: {str(e)}", "code": 500})
+
+    try:
+        act_img_base_64 = BytesIO()
+        image.save(act_img_base_64, format="WEBP")
+        image_bytes_ = base64.b64encode(act_img_base_64.getvalue()).decode("utf-8")
+        image_data_uri = f"data:image/WEBP;base64,{image_bytes_}"
+        logger.info(">>> IMAGE ENCODING COMPLETED <<<")
+    except Exception as e:
+        logger.error(f">>> IMAGE ENCODING ERROR: {str(e)} <<<")
+        return JSONResponse(status_code=500,
+                            content={"error": f"Error converting image to base64: {str(e)}", "code": 500})
+
+    try:
+        output = replicate_bg({"image": image_data_uri})
+        logger.info(">>> BACKGROUND REMOVAL COMPLETED <<<")
+    except Exception as e:
+        logger.error(f">>> BACKGROUND REMOVAL ERROR: {str(e)} <<<")
+        return JSONResponse(status_code=500,
+                            content={"error": f"Error running background removal: {str(e)}", "code": 500})
+
+    try:
+        response = requests.get(output)
+        base_64 = base64.b64encode(response.content).decode('utf-8')
+        base64_prefix = "data:image/WEBP;base64,"
+
+        total_inference_time = round((time.time() - start_time), 2)
+
+        response = {
+            "output": f"{base64_prefix}{base_64}",
+            "inference_time": total_inference_time,
+            "code": 200
+        }
+        logger.info(">>> RESPONSE PREPARATION COMPLETED <<<")
+        logger.info(f">>> TOTAL INFERENCE TIME: {total_inference_time}s <<<")
+        logger.info(">>> REQUEST COMPLETED SUCCESSFULLY <<<")
+        logger.info("-" * 50)
+        return JSONResponse(content=response, status_code=200)
+
+    except Exception as e:
+        logger.error(f">>> RESPONSE PROCESSING ERROR: {str(e)} <<<")
+        return JSONResponse(status_code=500,
+                            content={"error": f"Error processing response: {str(e)}", "code": 500})
+
+
+@preprocessing_router.post("/upscale_image")
+async def upscale_image(image: UploadFile = File(...), scale: int = 1):
+    logger.info("-" * 50)
+    logger.info(">>> IMAGE UPSCALING STARTED <<<")
+    start_time = time.time()
+
+    try:
+        image_bytes = await image.read()
+        image = Image.open(BytesIO(image_bytes)).convert("RGBA")
+        logger.info(">>> IMAGE LOADED SUCCESSFULLY <<<")
+    except Exception as e:
+        logger.error(f">>> IMAGE LOADING ERROR: {str(e)} <<<")
+        return JSONResponse(status_code=500, content={"error": f"Error reading image: {str(e)}", "code": 500})
+
+    try:
+        act_img_base_64 = BytesIO()
+        image.save(act_img_base_64, format="PNG")
+        image_bytes_ = base64.b64encode(act_img_base_64.getvalue()).decode("utf-8")
+        image_data_uri = f"data:image/png;base64,{image_bytes_}"
+        logger.info(">>> IMAGE ENCODING COMPLETED <<<")
+    except Exception as e:
+        logger.error(f">>> IMAGE ENCODING ERROR: {str(e)} <<<")
+        return JSONResponse(status_code=500,
+                            content={"error": f"Error converting image to base64: {str(e)}", "code": 500})
+
+    try:
+        input = {
+            "image": image_data_uri,
+            "scale": scale,
+            "face_enhance": False
+        }
+        output = replicate_enhancer(input)
+        logger.info(">>> IMAGE ENHANCEMENT COMPLETED <<<")
+    except Exception as e:
+        logger.error(f">>> IMAGE ENHANCEMENT ERROR: {str(e)} <<<")
+        return JSONResponse(status_code=500,
+                            content={"error": f"Error running image enhancement: {str(e)}", "code": 500})
+
+    try:
+        response = requests.get(output)
+        base_64 = base64.b64encode(response.content).decode('utf-8')
+        base64_prefix = image_data_uri.split(",")[0] + ","
+
+        total_inference_time = round((time.time() - start_time), 2)
+
+        response = {
+            "output": f"{base64_prefix}{base_64}",
+            "inference_time": total_inference_time,
+            "code": 200
+        }
+        logger.info(">>> RESPONSE PREPARATION COMPLETED <<<")
+        logger.info(f">>> TOTAL INFERENCE TIME: {total_inference_time}s <<<")
+        logger.info(">>> REQUEST COMPLETED SUCCESSFULLY <<<")
+        logger.info("-" * 50)
+        return JSONResponse(content=response, status_code=200)
+
+    except Exception as e:
+        logger.error(f">>> RESPONSE PROCESSING ERROR: {str(e)} <<<")
+        return JSONResponse(status_code=500,
+                            content={"error": f"Error processing response: {str(e)}", "code": 500})
+
+
+@preprocessing_router.post("/crop_transparent")
+async def crop_transparent(image: UploadFile):
+    logger.info("-" * 50)
+    logger.info(">>> CROP TRANSPARENT STARTED <<<")
+    start_time = time.time()
+
+    try:
+        if not image.content_type == "image/png":
+            logger.error(">>> INVALID FILE TYPE: NOT PNG <<<")
+            return JSONResponse(status_code=400,
+                                content={"error": "Only PNG files are supported", "code": 400})
+    except Exception as e:
+        logger.error(f">>> FILE TYPE CHECK ERROR: {str(e)} <<<")
+        return JSONResponse(status_code=500,
+                            content={"error": f"Error checking file type: {str(e)}", "code": 500})
+
+    try:
+        contents = await image.read()
+        cropped_image_bytes, metadata = crop_transparent_image(contents)
+        logger.info(">>> IMAGE CROPPING COMPLETED <<<")
+    except Exception as e:
+        logger.error(f">>> IMAGE CROPPING ERROR: {str(e)} <<<")
+        return JSONResponse(status_code=500,
+                            content={"error": f"Error cropping image: {str(e)}", "code": 500})
+
+    try:
+        base64_image = base64.b64encode(cropped_image_bytes).decode('utf-8')
+        base64_prefix = "data:image/png;base64,"
+
+        total_inference_time = round((time.time() - start_time), 2)
+
+        logger.info(">>> RESPONSE PREPARATION COMPLETED <<<")
+        logger.info(f">>> TOTAL INFERENCE TIME: {total_inference_time}s <<<")
+        logger.info(">>> REQUEST COMPLETED SUCCESSFULLY <<<")
+        logger.info("-" * 50)
+
+        return JSONResponse(content={
+            "status": "success",
+            "code": 200,
+            "data": {
+                "image": f"{base64_prefix}{base64_image}",
+                "metadata": metadata,
+                "inference_time": total_inference_time
+            }
+        }, status_code=200)
+    except Exception as e:
+        logger.error(f">>> RESPONSE PROCESSING ERROR: {str(e)} <<<")
+        return JSONResponse(status_code=500,
+                            content={"error": f"Error processing response: {str(e)}", "code": 500})
+
+
+@preprocessing_router.post("/background_replace")
+async def bg_replace(image: UploadFile = File(...), bg_image: UploadFile = File(...)):
+    logger.info("-" * 50)
+    logger.info(">>> BACKGROUND REPLACE STARTED <<<")
+    start_time = time.time()
+
+    try:
+        image_bytes = await image.read()
+        bg_bytes = await bg_image.read()
+        image = Image.open(BytesIO(image_bytes)).convert("RGBA")
+        bg_image = Image.open(BytesIO(bg_bytes)).convert("RGB")
+        logger.info(">>> IMAGES LOADED SUCCESSFULLY <<<")
+    except Exception as e:
+        logger.error(f">>> IMAGE LOADING ERROR: {str(e)} <<<")
+        return JSONResponse(status_code=500,
+                            content={"error": f"Error reading images: {str(e)}", "code": 500})
+
+    try:
+        width, height = bg_image.size
+        background = Image.fromarray(np.array(bg_image)).resize((width, height))
+        orig_img = Image.fromarray(np.array(image)).resize((width, height))
+        background.paste(orig_img, (0, 0), mask=orig_img)
+        logger.info(">>> IMAGE PROCESSING COMPLETED <<<")
+    except Exception as e:
+        logger.error(f">>> IMAGE PROCESSING ERROR: {str(e)} <<<")
+        return JSONResponse(status_code=500,
+                            content={"error": f"Error processing images: {str(e)}", "code": 500})
+
+    try:
+        act_img_base_64 = BytesIO()
+        background.save(act_img_base_64, format="WEBP")
+        image_bytes_ = base64.b64encode(act_img_base_64.getvalue()).decode("utf-8")
+        image_data_uri = f"data:image/webp;base64,{image_bytes_}"
+
+        total_inference_time = round((time.time() - start_time), 2)
+
+        logger.info(">>> RESPONSE PREPARATION COMPLETED <<<")
+        logger.info(f">>> TOTAL INFERENCE TIME: {total_inference_time}s <<<")
+        logger.info(">>> REQUEST COMPLETED SUCCESSFULLY <<<")
+        logger.info("-" * 50)
+
+        return JSONResponse(content={
+            "output": image_data_uri,
+            "code": 200,
+            "inference_time": total_inference_time
+        }, status_code=200)
+    except Exception as e:
+        logger.error(f">>> RESPONSE PROCESSING ERROR: {str(e)} <<<")
+        return JSONResponse(status_code=500,
+                            content={"error": f"Error creating response: {str(e)}", "code": 500})
+
+
+@preprocessing_router.post("/rem_bg_color_extraction")
+async def remove_background_color_extraction(image: UploadFile = File(...),
+                                             hex_color: str = "#FFFFFF",
+                                             threshold: int = 30):
+    logger.info("-" * 50)
+    logger.info(">>> COLOR EXTRACTION STARTED <<<")
+    start_time = time.time()
+
+    try:
+        image_bytes = await image.read()
+        image = Image.open(BytesIO(image_bytes)).convert("RGBA")
+        image = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR)
+        logger.info(">>> IMAGE LOADED SUCCESSFULLY <<<")
+    except Exception as e:
+        logger.error(f">>> IMAGE LOADING ERROR: {str(e)} <<<")
+        return JSONResponse(status_code=500,
+                            content={"error": f"Error reading image: {str(e)}", "code": 500})
+
+    try:
+        result = color_extraction_rmbg.extract_color(image, hex_color, threshold)
+        result = Image.fromarray(cv2.cvtColor(result, cv2.COLOR_RGB2BGRA)).convert("RGBA")
+        logger.info(">>> COLOR EXTRACTION COMPLETED <<<")
+    except Exception as e:
+        logger.error(f">>> COLOR EXTRACTION ERROR: {str(e)} <<<")
+        return JSONResponse(status_code=500,
+                            content={"error": f"Error extracting colors: {str(e)}", "code": 500})
+
+    try:
+        act_img_base_64 = BytesIO()
+        result.save(act_img_base_64, format="PNG")
+        image_bytes_ = base64.b64encode(act_img_base_64.getvalue()).decode("utf-8")
+        image_data_uri = f"data:image/png;base64,{image_bytes_}"
+
+        total_inference_time = round((time.time() - start_time), 2)
+
+        logger.info(">>> RESPONSE PREPARATION COMPLETED <<<")
+        logger.info(f">>> TOTAL INFERENCE TIME: {total_inference_time}s <<<")
+        logger.info(">>> REQUEST COMPLETED SUCCESSFULLY <<<")
+        logger.info("-" * 50)
+
+        return JSONResponse(content={
+            "output": image_data_uri,
+            "code": 200,
+            "inference_time": total_inference_time
+        }, status_code=200)
+    except Exception as e:
+        logger.error(f">>> RESPONSE PROCESSING ERROR: {str(e)} <<<")
+        return JSONResponse(status_code=500,
+                            content={"error": f"Error creating response: {str(e)}", "code": 500})
+
+
+@preprocessing_router.post("/title_description_generator")
+async def product_title_description_generator(image: UploadFile = File(...)):
+    logger.info("-" * 50)
+    logger.info(">>> TITLE DESCRIPTION GENERATION STARTED <<<")
+    start_time = time.time()
+
+    try:
+        image_bytes = await image.read()
+        image = Image.open(BytesIO(image_bytes)).convert("RGB")
+        logger.info(">>> IMAGE LOADED SUCCESSFULLY <<<")
+    except Exception as e:
+        logger.error(f">>> IMAGE LOADING ERROR: {str(e)} <<<")
+        return JSONResponse(status_code=500,
+                            content={"error": f"Error reading image: {str(e)}", "code": 500})
+
+    try:
+        result = product_listing_obj.gen_title_desc(image=image)
+        title = result.split("Title:")[1].split("Description:")[0]
+        description = result.split("Description:")[1]
+        logger.info(">>> TITLE AND DESCRIPTION GENERATION COMPLETED <<<")
+    except Exception as e:
+        logger.error(">>> TITLE DESCRIPTION GENERATION ERROR <<<")
+        return JSONResponse(status_code=500,
+                            content={"error": "Please make sure the image is clear and necklaces are visible",
+                                     "code": 500})
+
+    try:
+        total_inference_time = round((time.time() - start_time), 2)
+
+        logger.info(">>> RESPONSE PREPARATION COMPLETED <<<")
+        logger.info(f">>> TOTAL INFERENCE TIME: {total_inference_time}s <<<")
+        logger.info(">>> REQUEST COMPLETED SUCCESSFULLY <<<")
+        logger.info("-" * 50)
+
+        return JSONResponse(content={
+            "code": 200,
+            "title": title,
+            "description": description,
+            "inference_time": total_inference_time
+        }, status_code=200)
+    except Exception as e:
+        logger.error(f">>> RESPONSE PROCESSING ERROR: {str(e)} <<<")
+        return JSONResponse(status_code=500,
+                            content={"error": f"Error creating response: {str(e)}", "code": 500})

src/api/image_regeneration_api.py

@@ -0,0 +1,172 @@
+"""
+project @ NTO-TCP-HF
+created @ 2024-10-29
+author  @ github.com/ishworrsubedii
+"""
+import base64
+import time
+from io import BytesIO
+from typing import Optional
+
+import replicate
+import requests
+from PIL import Image
+from fastapi import APIRouter, UploadFile, File, Form
+from fastapi.responses import JSONResponse
+from src.utils.logger import logger
+
+image_regeneration_router = APIRouter()
+
+
+def image_regeneration_replicate(input):
+    output = replicate.run(
+        "konieshadow/fooocus-api:fda927242b1db6affa1ece4f54c37f19b964666bf23b0d06ae2439067cd344a4",
+        input=input
+    )
+    return output
+
+
+@image_regeneration_router.post("/image_redesign")
+async def image_re_gen(
+        prompt: str = Form(...),
+        negative_prompt: str = Form(""),
+        image: UploadFile = File(...),
+        mask_image: Optional[UploadFile] = File(default=None),
+        reference_image_c1: Optional[UploadFile] = File(default=None),
+        reference_image_c1_type: Optional[str] = Form(default=""),
+        reference_image_c1_weight: Optional[float] = Form(default=0.0),
+        reference_image_c1_stop: Optional[float] = Form(default=0.0),
+        reference_image_c2: Optional[UploadFile] = File(default=None),
+        reference_image_c2_type: Optional[str] = Form(default=""),
+        reference_image_c2_weight: Optional[float] = Form(default=0.0),
+        reference_image_c2_stop: Optional[float] = Form(default=0.0),
+        reference_image_c3: Optional[UploadFile] = File(default=None),
+        reference_image_c3_type: Optional[str] = Form(default=""),
+        reference_image_c3_weight: Optional[float] = Form(default=0.0),
+        reference_image_c3_stop: Optional[float] = Form(default=0.0),
+        reference_image_c4: Optional[UploadFile] = File(default=None),
+        reference_image_c4_type: Optional[str] = Form(default=""),
+        reference_image_c4_weight: Optional[float] = Form(default=0.0),
+        reference_image_c4_stop: Optional[float] = Form(default=0.0),
+):
+    logger.info("-" * 50)
+    logger.info(">>> IMAGE REDESIGN STARTED <<<")
+    start_time = time.time()
+
+    try:
+        async def process_reference_image(reference_image: Optional[UploadFile]) -> Optional[str]:
+            if reference_image is not None:
+                reference_image_bytes = await reference_image.read()
+                reference_image = Image.open(BytesIO(reference_image_bytes)).convert("RGB")
+                ref_img_base64 = BytesIO()
+                reference_image.save(ref_img_base64, format="WEBP")
+                reference_image_b64 = base64.b64encode(ref_img_base64.getvalue()).decode("utf-8")
+                return f"data:image/WEBP;base64,{reference_image_b64}"
+            return None
+        logger.info(">>> REFERENCE IMAGE PROCESSING FUNCTION INITIALIZED <<<")
+    except Exception as e:
+        logger.error(f">>> REFERENCE IMAGE PROCESSING ERROR: {str(e)} <<<")
+        return JSONResponse(status_code=500, 
+                          content={"error": f"Error processing reference image: {str(e)}", "code": 500})
+
+    try:
+        image_bytes = await image.read()
+        image = Image.open(BytesIO(image_bytes)).convert("RGB")
+        img_base64 = BytesIO()
+        image.save(img_base64, format="WEBP")
+        image_data_uri = f"data:image/WEBP;base64,{base64.b64encode(img_base64.getvalue()).decode('utf-8')}"
+        logger.info(">>> MAIN IMAGE PROCESSED SUCCESSFULLY <<<")
+    except Exception as e:
+        logger.error(f">>> MAIN IMAGE PROCESSING ERROR: {str(e)} <<<")
+        return JSONResponse(status_code=500,
+                          content={"error": f"Error processing main image: {str(e)}", "code": 500})
+
+    try:
+        reference_images = {
+            'c1': await process_reference_image(reference_image_c1),
+            'c2': await process_reference_image(reference_image_c2),
+            'c3': await process_reference_image(reference_image_c3),
+            'c4': await process_reference_image(reference_image_c4)
+        }
+        logger.info(">>> REFERENCE IMAGES PROCESSED SUCCESSFULLY <<<")
+    except Exception as e:
+        logger.error(f">>> REFERENCE IMAGES PROCESSING ERROR: {str(e)} <<<")
+        return JSONResponse(status_code=500,
+                          content={"error": f"Error processing reference images: {str(e)}", "code": 500})
+
+    try:
+        input_data = {
+            "prompt": prompt,
+            "inpaint_input_image": image_data_uri,
+            "sharpness": 2,
+            "guidance_scale": 4,
+            "refiner_switch": 0.5,
+            "performance_selection": "Quality",
+            "aspect_ratios_selection": "1024*1024"
+        }
+
+        if negative_prompt:
+            input_data["negative_prompt"] = negative_prompt
+
+        if mask_image is not None:
+            mask_image_bytes = await mask_image.read()
+            mask_image = Image.open(BytesIO(mask_image_bytes)).convert("RGB")
+            mask_base64 = BytesIO()
+            mask_image.save(mask_base64, format="WEBP")
+            mask_image_data_uri = f"data:image/WEBP;base64,{base64.b64encode(mask_base64.getvalue()).decode('utf-8')}"
+            input_data["inpaint_input_mask"] = mask_image_data_uri
+        logger.info(">>> INPUT DATA PREPARED SUCCESSFULLY <<<")
+    except Exception as e:
+        logger.error(f">>> INPUT DATA PREPARATION ERROR: {str(e)} <<<")
+        return JSONResponse(status_code=500,
+                          content={"error": f"Error preparing input data: {str(e)}", "code": 500})
+
+    try:
+        for i in range(1, 5):
+            c = f'c{i}'
+            if reference_images[c] is not None:
+                input_data[f"cn_img{i}"] = reference_images[c]
+
+                type_value = locals()[f'reference_image_{c}_type']
+                if type_value:
+                    input_data[f"cn_type{i}"] = type_value
+
+                weight_value = locals()[f'reference_image_{c}_weight']
+                if weight_value != 0.0:
+                    input_data[f"cn_weight{i}"] = weight_value
+
+                stop_value = locals()[f'reference_image_{c}_stop']
+                if stop_value != 0.0 or stop_value != 0:
+                    input_data[f"cn_stop{i}"] = stop_value
+        logger.info(">>> REFERENCE IMAGE PARAMETERS PROCESSED <<<")
+    except Exception as e:
+        logger.error(f">>> REFERENCE IMAGE PARAMETERS ERROR: {str(e)} <<<")
+        return JSONResponse(status_code=500,
+                          content={"error": f"Error processing reference image parameters: {str(e)}", "code": 500})
+
+    try:
+        output = image_regeneration_replicate(input_data)
+        response = requests.get(output[0])
+        output_base64 = base64.b64encode(response.content).decode('utf-8')
+        base64_prefix = image_data_uri.split(",")[0] + ","
+        logger.info(">>> IMAGE REGENERATION COMPLETED <<<")
+    except Exception as e:
+        logger.error(f">>> IMAGE REGENERATION ERROR: {str(e)} <<<")
+        return JSONResponse(status_code=500,
+                          content={"error": f"Error generating image: {str(e)}", "code": 500})
+
+    try:
+        inference_time = round(time.time() - start_time, 2)
+        response = {
+            "output": f"{base64_prefix}{output_base64}",
+            "inference_time": inference_time,
+            "code": 200,
+        }
+        logger.info(f">>> TOTAL INFERENCE TIME: {inference_time}s <<<")
+        logger.info(">>> REQUEST COMPLETED SUCCESSFULLY <<<")
+        logger.info("-" * 50)
+        return JSONResponse(content=response, status_code=200)
+    except Exception as e:
+        logger.error(f">>> RESPONSE CREATION ERROR: {str(e)} <<<")
+        return JSONResponse(status_code=500,
+                          content={"error": f"Error creating response: {str(e)}", "code": 500})

src/api/makeup_tryon_api.py

@@ -0,0 +1,171 @@
+"""
+project @ NTO-TCP-HF
+created @ 2024-12-05
+author  @ github.com/ishworrsubedii
+"""
+import asyncio
+import gc
+from io import BytesIO
+from time import time
+
+import cv2
+import numpy as np
+import requests
+from PIL import Image
+from fastapi import APIRouter, File, Form, UploadFile
+from fastapi.responses import JSONResponse
+from src.api.nto_api import pipeline, supabase_upload_and_return_url
+from src.utils.logger import logger
+
+makeup_tryon_router = APIRouter(tags=["makeup_tryon"], prefix="/makeup_tryon")
+
+
+def get_colors():
+    logger.info(">>> FETCHING COLORS FROM BACKEND <<<")
+    start_time = time()
+    try:
+        response = requests.get(
+            "https://lvuhhlrkcuexzqtsbqyu.supabase.co/storage/v1/object/public/JewelMirrorMakeupTryOn/jewelmirror_makeup_colors.json"
+        )
+        response.raise_for_status()
+        colors = response.json()
+        fetch_time = round(time() - start_time, 2)
+        logger.info(f">>> COLORS FETCHED SUCCESSFULLY IN {fetch_time}s <<<")
+        return colors
+    except requests.exceptions.RequestException as e:
+        logger.error(f">>> ERROR FETCHING COLORS: {str(e)} <<<")
+        return None
+
+
+@makeup_tryon_router.post("/tryon")
+async def tryon(image: UploadFile = File(...), lipstick_color: str = Form(...), eyeliner_color: str = Form(...),
+                eyeshadow_color: str = Form(...)):
+    logger.info("-" * 50)
+    logger.info(">>> MAKE UP TRY ON STARTED <<<")
+    logger.info(
+        f">>> LIPSTICK COLOR: {lipstick_color}, EYELINER COLOR: {eyeliner_color}, EYESHADOW COLOR: {eyeshadow_color} <<<")
+    start_time = time()
+
+    colors = get_colors()
+    if colors is None:
+        return JSONResponse(status_code=500, content={"error": "Error fetching colors", "code": 500})
+
+    # Validate and fetch colors
+    try:
+        lipstick_set = tuple(colors["Lipstick"][lipstick_color])
+        eyeliner_set = tuple(colors["Eyeliner"][eyeliner_color])
+        eyeshadow_set = tuple(colors["Eyeshadow"][eyeshadow_color])
+        logger.info(
+            f">>> COLORS FETCHED SUCCESSFULLY LIPSTICK:{lipstick_color}|{lipstick_set} EYELINER:{eyeliner_color}|{eyeliner_set} EYESHADOW:{eyeshadow_color}|{eyeshadow_set} <<<")
+    except KeyError as e:
+        logger.error(f"Invalid color selection: {str(e)}")
+        return JSONResponse(status_code=400, content={"error": f"Invalid color: {str(e)}", "code": 400})
+
+    try:
+        image_bytes = await image.read()
+        image = Image.open(BytesIO(image_bytes))
+        image = np.array(image)
+        image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
+        logger.info(">>> IMAGE LOADED SUCCESSFULLY <<<")
+    except Exception as e:
+        logger.error(f">>> IMAGE LOADING ERROR: {str(e)} <<<")
+        return JSONResponse(status_code=500, content={"error": "Error reading image", "code": 500})
+
+    try:
+        result = await pipeline.makeup_tryon(image, lipstick_set, eyeliner_set, eyeshadow_set)
+        logger.info(">>> MAKE UP TRY ON COMPLETED <<<")
+    except Exception as e:
+        logger.error(f">>> MAKE UP TRY ON PROCESSING ERROR: {str(e)} <<<")
+        return JSONResponse(status_code=500, content={"error": "Error during makeup try-on process", "code": 500})
+
+    try:
+        # Convert numpy array to PIL Image
+        result_image = Image.fromarray(cv2.cvtColor(result, cv2.COLOR_BGR2RGB))
+
+        upload_start_time = time()
+        upload_tasks = [
+            supabase_upload_and_return_url(prefix="MTO", image=result_image,necklace_id="JEWELMIRRORMAKEUPTRYON")
+        ]
+        result_url = await asyncio.gather(*upload_tasks)
+        upload_time = round(time() - upload_start_time, 2)
+
+        if result_url[0] is None:
+            raise Exception("Failed to upload result image")
+
+        logger.info(f">>> RESULT IMAGES SAVED IN {upload_time}s <<<")
+    except Exception as e:
+        logger.error(f">>> RESULT SAVING ERROR: {str(e)} <<<")
+        return JSONResponse(content={"error": f"Error saving result images", "code": 500}, status_code=500)
+
+    try:
+        total_time = round(time() - start_time, 2)
+        response = {
+            "code": 200,
+            "output": f"{result_url[0]}",
+            "timing": {
+                "upload": upload_time,
+                "total": total_time
+            }
+        }
+
+        logger.info(f">>> TIMING BREAKDOWN <<<")
+        logger.info(f"Upload Time: {upload_time}s")
+        logger.info(f"Total Time: {total_time}s")
+        logger.info(">>> MAKE UP TRY ON COMPLETED SUCCESSFULLY <<<")
+        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()
+
+
+def bgr_to_hex(bgr):
+    """Convert BGR to HEX."""
+    b, g, r = bgr
+    return f"#{r:02x}{g:02x}{b:02x}"
+
+
+@makeup_tryon_router.get("/available_colors")
+async def color_fetch():
+    logger.info(">>> FETCHING AVAILABLE COLORS <<<")
+    start_time = time()
+
+    colors = get_colors()
+    if colors is None:
+        return JSONResponse(status_code=500, content={"error": "Error fetching colors", "code": 500})
+
+    try:
+        colors_with_hex = {
+            category: {
+                name: {
+                    "bgr": bgr,
+                    "hex": bgr_to_hex(bgr)
+                }
+                for name, bgr in items.items()
+            }
+            for category, items in colors.items()
+        }
+
+        fetch_time = round(time() - start_time, 2)
+        logger.info(f">>> COLORS FETCHED SUCCESSFULLY IN {fetch_time}s <<<")
+
+        return JSONResponse(content={
+            "code": 200,
+            "colors": colors_with_hex,
+            "timing": {
+                "total": fetch_time
+            }
+        })
+
+    except Exception as e:
+        logger.error(f">>> ERROR PROCESSING COLORS: {str(e)} <<<")
+        return JSONResponse(
+            status_code=500,
+            content={"error": "Error processing color data", "code": 500}
+        )

src/api/mannequin_to_model_api.py

@@ -0,0 +1,135 @@
+"""
+project @ CTO_TCP_ZERO_GPU
+created @ 2024-11-14
+author  @ github.com/ishworrsubedii
+"""
+import base64
+import json
+import os
+import time
+
+import requests
+from fastapi.routing import APIRouter
+from fastapi import File, UploadFile, Form
+import replicate
+from starlette.responses import JSONResponse
+from src.api.nto_api import supabase
+from src.utils.logger import logger
+
+mto_router = APIRouter()
+
+
+def run_mto(input):
+    try:
+        logger.info("Starting mannequin to model conversion")
+        output = replicate.run(
+            "xiankgx/face-swap:cff87316e31787df12002c9e20a78a017a36cb31fde9862d8dedd15ab29b7288",
+            input=input
+        )
+        logger.info("Mannequin to model conversion completed successfully")
+        return output
+    except Exception as e:
+        logger.error(f"Error in mannequin to model conversion: {str(e)}")
+        return None
+
+
+def read_return(url):
+    try:
+        res = requests.get(url)
+        logger.info("Image fetched successfully")
+        return res.content
+    except Exception as e:
+        logger.error(f"Error fetching image: {str(e)}")
+        return None
+
+
+@mto_router.post("/mto_image")
+async def mto_image(image: UploadFile = File(...), store_name: str = Form(...),
+                    clothing_category: str = Form(...),
+                    product_id: str = Form(...),
+                    body_structure: str = Form(...),
+                    skin_complexion: str = Form(...),
+                    facial_structure: str = Form(...), ):
+    start_time = time.time()
+    try:
+
+        logger.info(f"Starting MTO image process for store: {store_name}")
+
+        if body_structure == "medium":
+            body_structure = "fat"
+            logger.info("Body structure adjusted from 'medium' to 'fat'")
+
+        image_bytes = await image.read()
+        logger.info("Source image read successfully")
+
+        mannequin_image_url = f"https://lvuhhlrkcuexzqtsbqyu.supabase.co/storage/v1/object/public/ClothingTryOn/{store_name}/{clothing_category}/{product_id}/{product_id}_{skin_complexion}_{facial_structure}_{body_structure}.webp"
+        logger.info(f"Fetching mannequin image")
+
+        reference_image_bytes = read_return(mannequin_image_url)
+        if reference_image_bytes is None:
+            logger.error("Failed to fetch reference image")
+            return JSONResponse({"error": "Failed to fetch reference image"}, status_code=500)
+
+        image_uri = f"data:image/jpeg;base64,{base64.b64encode(image_bytes).decode()}"
+        reference_image_uri = f"data:image/jpeg;base64,{base64.b64encode(reference_image_bytes).decode()}"
+
+        input = {
+            "local_source": image_uri,
+            "local_target": reference_image_uri
+        }
+
+        output = run_mto(input)
+        if output is None:
+            logger.error("Face swap process failed")
+            return JSONResponse({"error": "Face swap process failed"}, status_code=500)
+
+        try:
+            response = requests.get(str(output['image']))
+            image_content = response.content
+
+            base64_image = base64.b64encode(image_content).decode('utf-8')
+
+            logger.info("MTO image process completed successfully")
+            return JSONResponse(content={
+                "output": f"data:image/webp;base64,{base64_image}",
+                "status": "success",
+                "inference_time": round((time.time() - start_time), 2)
+            }, status_code=200)
+
+        except Exception as e:
+            logger.error(f"Error converting output to base64: {str(e)}")
+            return JSONResponse({"error": "Error processing output image"}, status_code=500)
+
+    except Exception as e:
+        logger.error(f"Error in MTO image process: {str(e)}")
+        return JSONResponse({"error": str(e)}, status_code=500)
+
+
+@mto_router.get("/mannequin_catalogue")
+async def returnJsonData(gender: str):
+    try:
+        logger.info(f"Fetching mannequin catalogue for gender: {gender}")
+
+        folderImageURL = supabase.storage.get_bucket("JSON").create_signed_url(
+            path=os.path.join("MannequinInfo.json"),
+            expires_in=3600
+        )["signedURL"]
+
+        logger.info("Fetching JSON data from Supabase")
+        r = requests.get(folderImageURL).content.decode()
+        mannequin_data = json.loads(r)
+
+        if gender.lower() == "female":
+            res = [item for item in mannequin_data if item["gender"] == "female"]
+        elif gender.lower() == "male":
+            res = [item for item in mannequin_data if item["gender"] == "male"]
+        else:
+            res = []
+            logger.warning(f"Invalid gender parameter: {gender}")
+
+        logger.info(f"Successfully retrieved {len(res)} mannequin entries")
+        return res
+
+    except Exception as e:
+        logger.error(f"Error in mannequin catalogue: {str(e)}")
+        return JSONResponse({"error": str(e)}, status_code=500)

src/api/nto_api.py

@@ -0,0 +1,911 @@
+"""
+project @ NTO-TCP-HF
+created @ 2024-10-28
+author  @ github/ishworrsubedii
+"""
+import asyncio
+import base64
+import gc
+import os
+import secrets
+import time
+from io import BytesIO
+
+import aiohttp
+import cv2
+import numpy as np
+import replicate
+import requests
+from PIL import Image
+from PIL.ImageOps import grayscale
+from fastapi import File, UploadFile, HTTPException, Form, Depends, APIRouter
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel
+from supabase import create_client
+
+from src.utils import deductAndTrackCredit, returnBytesData
+from src.utils.logger import logger
+
+nto_cto_router = APIRouter()
+
+url: str = os.getenv("SUPABASE_URL")
+key: str = os.getenv("SUPABASE_KEY")
+
+supabase = create_client(supabase_url=url, supabase_key=key)
+supabase_storage: str = os.getenv("SUPABASE_STORAGE")
+
+from src.pipelines.completePipeline import Pipeline
+
+pipeline = Pipeline()
+
+cto_replicate: str = os.getenv(
+    "CTO")
+
+bucket = supabase.storage.from_("JewelMirrorOutputs")
+
+
+def replicate_run_cto(input):
+    output = replicate.run(
+        cto_replicate,
+        input=input)
+    return output
+
+
+class NecklaceTryOnIDEntity(BaseModel):
+    necklaceImageId: str
+    necklaceCategory: str
+    storename: str
+    offset_x: float
+    offset_y: float
+
+
+@nto_cto_router.post("/clothingTryOnV2")
+async def clothing_try_on_v2(image: UploadFile = File(...), clothing_type: str = Form(...)):
+    logger.info("-" * 50)
+    logger.info(">>> CLOTHING TRY ON V2 STARTED <<<")
+    logger.info(f"Parameters: clothing_type={clothing_type}")
+    start_time = time.time()
+
+    try:
+        image_bytes = await image.read()
+        image = Image.open(BytesIO(image_bytes)).convert("RGB")
+        logger.info(">>> IMAGE LOADED SUCCESSFULLY <<<")
+    except Exception as e:
+        logger.error(f">>> IMAGE LOADING ERROR: {str(e)} <<<")
+        return JSONResponse(status_code=500, content={"error": f"Error reading image", "code": 500})
+
+    try:
+        mask, _, _ = await pipeline.shoulderPointMaskGeneration_(image=image)
+        logger.info(">>> MASK GENERATION COMPLETED <<<")
+    except Exception as e:
+        logger.error(f">>> MASK GENERATION ERROR: {str(e)} <<<")
+        return JSONResponse(status_code=500,
+                            content={"error": f"Error generating mask", "code": 500})
+
+    try:
+        mask_img_base_64, act_img_base_64 = BytesIO(), BytesIO()
+        mask.save(mask_img_base_64, format="WEBP")
+        image.save(act_img_base_64, format="WEBP")
+        mask_bytes_ = base64.b64encode(mask_img_base_64.getvalue()).decode("utf-8")
+        image_bytes_ = base64.b64encode(act_img_base_64.getvalue()).decode("utf-8")
+
+        mask_data_uri = f"data:image/webp;base64,{mask_bytes_}"
+        image_data_uri = f"data:image/webp;base64,{image_bytes_}"
+        logger.info(">>> IMAGE ENCODING COMPLETED <<<")
+    except Exception as e:
+        logger.error(f">>> IMAGE ENCODING ERROR: {str(e)} <<<")
+        return JSONResponse(status_code=500,
+                            content={"error": f"Error converting images to base64", "code": 500})
+
+    input = {
+        "mask": mask_data_uri,
+        "image": image_data_uri,
+        "prompt": f"Dull {clothing_type}, non-reflective clothing, properly worn, natural setting, elegant, natural look, neckline without jewellery, simple, perfect eyes, perfect face, perfect body, high quality, realistic, photorealistic, high resolution,traditional full sleeve blouse",
+        "negative_prompt": "necklaces, jewellery, jewelry, necklace, neckpiece, garland, chain, neck wear, jewelled neck, jeweled neck, necklace on neck, jewellery on neck, accessories, watermark, text, changed background, wider body, narrower body, bad proportions, extra limbs, mutated hands, changed sizes, altered proportions, unnatural body proportions, blury, ugly",
+        "num_inference_steps": 25
+    }
+
+    try:
+        output = replicate_run_cto(input)
+        logger.info(">>> REPLICATE PROCESSING COMPLETED <<<")
+    except Exception as e:
+        logger.error(f">>> REPLICATE PROCESSING ERROR: {str(e)} <<<")
+        return JSONResponse(content={"error": f"Error running CTO Replicate", "code": 500}, status_code=500)
+
+    total_inference_time = round((time.time() - start_time), 2)
+    logger.info(f">>> TOTAL INFERENCE TIME: {total_inference_time}s <<<")
+    logger.info(">>> REQUEST COMPLETED SUCCESSFULLY <<<")
+    logger.info("-" * 50)
+
+    response = {
+        "code": 200,
+        "output": f"{output[0]}",
+        "inference_time": total_inference_time
+    }
+
+    return JSONResponse(content=response, status_code=200)
+
+
+@nto_cto_router.post("/clothingTryOn")
+async def clothing_try_on(image: UploadFile = File(...),
+                          mask: UploadFile = File(...), clothing_type: str = Form(...)):
+    logger.info("-" * 50)
+    logger.info(">>> CLOTHING TRY ON STARTED <<<")
+    logger.info(f"Parameters: clothing_type={clothing_type}")
+    start_time = time.time()
+
+    try:
+        image_bytes = await image.read()
+        mask_bytes = await mask.read()
+        image, mask = Image.open(BytesIO(image_bytes)).convert("RGB"), Image.open(BytesIO(mask_bytes)).convert("RGB")
+        logger.info(">>> IMAGES LOADED SUCCESSFULLY <<<")
+    except Exception as e:
+        logger.error(f">>> IMAGE LOADING ERROR: {str(e)} <<<")
+        return JSONResponse(status_code=500, content={"error": f"Error reading image or mask", "code": 500})
+
+    try:
+        actual_image = image.copy()
+        jewellery_mask = Image.fromarray(np.bitwise_and(np.array(mask), np.array(image)))
+        arr_orig = np.array(grayscale(mask))
+
+        image = cv2.inpaint(np.array(image), arr_orig, 15, cv2.INPAINT_TELEA)
+        image = Image.fromarray(image).resize((512, 512))
+
+        arr = arr_orig.copy()
+        mask_y = np.where(arr == arr[arr != 0][0])[0][0]
+        arr[mask_y:, :] = 255
+
+        mask = Image.fromarray(arr).resize((512, 512))
+        logger.info(">>> IMAGE PROCESSING COMPLETED <<<")
+    except Exception as e:
+        logger.error(f">>> IMAGE PROCESSING ERROR: {str(e)} <<<")
+        return JSONResponse(status_code=500,
+                            content={"error": f"Error processing image or mask", "code": 500})
+
+    try:
+        mask_img_base_64, act_img_base_64 = BytesIO(), BytesIO()
+        mask.save(mask_img_base_64, format="WEBP")
+        image.save(act_img_base_64, format="WEBP")
+        mask_bytes_ = base64.b64encode(mask_img_base_64.getvalue()).decode("utf-8")
+        image_bytes_ = base64.b64encode(act_img_base_64.getvalue()).decode("utf-8")
+
+        mask_data_uri = f"data:image/webp;base64,{mask_bytes_}"
+        image_data_uri = f"data:image/webp;base64,{image_bytes_}"
+        logger.info(">>> IMAGE ENCODING COMPLETED <<<")
+    except Exception as e:
+        logger.error(f">>> IMAGE ENCODING ERROR: {str(e)} <<<")
+        return JSONResponse(status_code=500,
+                            content={"error": f"Error encoding images", "code": 500})
+
+    input = {
+        "mask": mask_data_uri,
+        "image": image_data_uri,
+        "prompt": f"Dull {clothing_type}, non-reflective clothing, properly worn, natural setting, elegant, natural look, neckline without jewellery, simple, perfect eyes, perfect face, perfect body, high quality, realistic, photorealistic, high resolution,traditional full sleeve blouse",
+        "negative_prompt": "necklaces, jewellery, jewelry, necklace, neckpiece, garland, chain, neck wear, jewelled neck, jeweled neck, necklace on neck, jewellery on neck, accessories, watermark, text, changed background, wider body, narrower body, bad proportions, extra limbs, mutated hands, changed sizes, altered proportions, unnatural body proportions, blury, ugly",
+        "num_inference_steps": 25
+    }
+
+    try:
+        output = replicate_run_cto(input)
+        logger.info(">>> REPLICATE PROCESSING COMPLETED <<<")
+    except Exception as e:
+        logger.error(f">>> REPLICATE PROCESSING ERROR: {str(e)} <<<")
+        return JSONResponse(content={"error": f"Error running clothing try on", "code": 500}, status_code=500)
+
+    try:
+        response = requests.get(output[0])
+        output_image = Image.open(BytesIO(response.content)).resize(actual_image.size)
+        output_image = np.bitwise_and(np.array(output_image),
+                                      np.bitwise_not(np.array(Image.fromarray(arr_orig).convert("RGB"))))
+        result = Image.fromarray(np.bitwise_or(np.array(output_image), np.array(jewellery_mask)))
+
+        in_mem_file = BytesIO()
+        result.save(in_mem_file, format="WEBP", quality=85)
+        base_64_output = base64.b64encode(in_mem_file.getvalue()).decode('utf-8')
+        total_inference_time = round((time.time() - start_time), 2)
+        logger.info(">>> OUTPUT IMAGE PROCESSING COMPLETED <<<")
+
+        response = {
+            "output": f"data:image/WEBP;base64,{base_64_output}",
+            "code": 200,
+            "inference_time": total_inference_time
+        }
+    except Exception as e:
+        logger.error(f">>> OUTPUT IMAGE PROCESSING ERROR: {str(e)} <<<")
+        return JSONResponse(status_code=500, content={"error": f"Error processing output image", "code": 500})
+
+    logger.info(f">>> TOTAL INFERENCE TIME: {total_inference_time}s <<<")
+    logger.info(">>> REQUEST COMPLETED SUCCESSFULLY <<<")
+    logger.info("-" * 50)
+
+    return JSONResponse(content=response, status_code=200)
+
+
+async def parse_necklace_try_on_id(necklaceImageId: str = Form(...),
+                                   necklaceCategory: str = Form(...),
+                                   storename: str = Form(...),
+                                   offset_x: float = Form(...),
+                                   offset_y: float = Form(...)
+                                   ) -> NecklaceTryOnIDEntity:
+    return NecklaceTryOnIDEntity(
+        necklaceImageId=necklaceImageId,
+        necklaceCategory=necklaceCategory,
+        storename=storename,
+        offset_x=offset_x,
+        offset_y=offset_y
+    )
+
+
+async def supabase_upload_and_return_url(prefix: str, necklace_id: str, image: Image.Image, quality: int = 85):
+    try:
+        filename = f"{prefix}_{necklace_id}_{secrets.token_hex(8)}.webp"
+
+        loop = asyncio.get_event_loop()
+        image_bytes = await loop.run_in_executor(
+            None,
+            process_image,
+            image,
+            quality
+        )
+
+        async with aiohttp.ClientSession() as session:
+            headers = {
+                "Authorization": f"Bearer {key}",
+                "Content-Type": "image/webp"
+            }
+
+            upload_url = f"{url}/storage/v1/object/JewelMirrorOutputs/{filename}"
+
+            async with session.post(
+                    upload_url,
+                    data=image_bytes,
+                    headers=headers
+            ) as response:
+                if response.status != 200:
+                    raise Exception(f"Upload failed with status {response.status}")
+
+        return bucket.get_public_url(filename)
+
+    except Exception as e:
+        logger.error(f"Failed to upload image: {str(e)}")
+        return None
+
+
+def process_image(image: Image.Image, quality: int) -> bytes:
+    try:
+        if image.mode in ['RGBA', 'P']:
+            image = image.convert('RGB')
+
+        max_size = 3000
+        if image.width > max_size or image.height > max_size:
+            ratio = min(max_size / image.width, max_size / image.height)
+            new_size = (int(image.width * ratio), int(image.height * ratio))
+            image = image.resize(new_size, Image.Resampling.LANCZOS)
+
+        with BytesIO() as buffer:
+            image.save(
+                buffer,
+                format='WEBP',
+                quality=quality,
+                optimize=True,
+                method=6
+            )
+            return buffer.getvalue()
+    except Exception as e:
+        logger.error(f"Image processing failed: {str(e)}")
+        raise
+
+
+@nto_cto_router.post("/necklaceTryOnID")
+async def necklace_try_on_id(necklace_try_on_id: NecklaceTryOnIDEntity = Depends(parse_necklace_try_on_id),
+                             image: UploadFile = File(...)):
+    logger.info("-" * 50)
+    logger.info(">>> NECKLACE TRY ON ID STARTED <<<")
+    logger.info(f"Parameters: storename={necklace_try_on_id.storename}, "
+                f"necklaceCategory={necklace_try_on_id.necklaceCategory}, "
+                f"necklaceImageId={necklace_try_on_id.necklaceImageId}")
+    start_time = time.time()
+
+    try:
+        image_loading_start = time.time()
+        imageBytes = await image.read()
+        jewellery_url = f"https://lvuhhlrkcuexzqtsbqyu.supabase.co/storage/v1/object/public/Stores/{necklace_try_on_id.storename}/{necklace_try_on_id.necklaceCategory}/image/{necklace_try_on_id.necklaceImageId}.png"
+        image, jewellery = Image.open(BytesIO(imageBytes)), Image.open(returnBytesData(url=jewellery_url))
+        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=necklace_try_on_id.storename,
+            offset=[necklace_try_on_id.offset_x, necklace_try_on_id.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)
+
+    try:
+        upload_start_time = time.time()
+        upload_tasks = [
+            supabase_upload_and_return_url(prefix="NTO", image=result, necklace_id=necklace_try_on_id.necklaceImageId),
+            supabase_upload_and_return_url(prefix="NTO", image=mask, necklace_id=necklace_try_on_id.necklaceImageId)
+        ]
+        result_url, mask_url = await asyncio.gather(*upload_tasks)
+        upload_time = round(time.time() - upload_start_time, 2)
+
+        if not result_url or not mask_url:
+            raise Exception("Failed to upload one or both images")
+
+        logger.info(f">>> RESULT IMAGES SAVED IN {upload_time}s <<<")
+    except Exception as e:
+        logger.error(f">>> RESULT SAVING ERROR: {str(e)} <<<")
+        return JSONResponse(content={"error": f"Error saving result images", "code": 500}, status_code=500)
+
+    try:
+        total_time = round(time.time() - start_time, 2)
+        response = {
+            "code": 200,
+            "output": f"{result_url}",
+            "mask": f"{mask_url}",
+            "timing": {
+                "image_loading": image_loading_time,
+                "nto_processing": nto_time,
+                "upload": upload_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"Upload Time: {upload_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()
+
+
+#
+# @nto_cto_router.post("/canvasPoints")
+# async def canvas_points(necklace_try_on_id: NecklaceTryOnIDEntity = Depends(parse_necklace_try_on_id),
+#                         image: UploadFile = File(...)):
+#     logger.info("-" * 50)
+#     logger.info(">>> CANVAS POINTS STARTED <<<")
+#     logger.info(f"Parameters: storename={necklace_try_on_id.storename}, "
+#                 f"necklaceCategory={necklace_try_on_id.necklaceCategory}, "
+#                 f"necklaceImageId={necklace_try_on_id.necklaceImageId}")
+#     start_time = time.time()
+#
+#     try:
+#         imageBytes = await image.read()
+#         jewellery_url = f"https://lvuhhlrkcuexzqtsbqyu.supabase.co/storage/v1/object/public/Stores/{necklace_try_on_id.storename}/{necklace_try_on_id.necklaceCategory}/image/{necklace_try_on_id.necklaceImageId}.png"
+#         image, jewellery = Image.open(BytesIO(imageBytes)), Image.open(returnBytesData(url=jewellery_url))
+#         logger.info(">>> IMAGES LOADED SUCCESSFULLY <<<")
+#     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. Error",
+#             "code": 404}, status_code=404)
+#
+#     try:
+#         response = await pipeline.canvasPoint(image=image, jewellery=jewellery, storename=necklace_try_on_id.storename)
+#         response = {"code": 200, "output": response}
+#         logger.info(">>> CANVAS POINTS PROCESSING COMPLETED <<<")
+#     except Exception as e:
+#         logger.error(f">>> CANVAS POINTS PROCESSING ERROR: {str(e)} <<<")
+#         return JSONResponse(content={"error": f"Error during canvas point process", "code": 500},
+#                             status_code=500)
+#
+#     try:
+#         creditResponse = deductAndTrackCredit(storename=necklace_try_on_id.storename, endpoint="/necklaceTryOnID")
+#         if creditResponse == "No Credits Available":
+#             logger.error(">>> NO CREDITS REMAINING <<<")
+#             return JSONResponse(content={"error": "No Credits Remaining", "code": 402}, status_code=402)
+#         logger.info(">>> CREDITS DEDUCTED SUCCESSFULLY <<<")
+#     except Exception as e:
+#         logger.error(f">>> CREDIT DEDUCTION ERROR: {str(e)} <<<")
+#         return JSONResponse(content={"error": f"Error deducting credits", "code": 500}, status_code=500)
+#
+#     total_inference_time = round((time.time() - start_time), 2)
+#     logger.info(f">>> TOTAL INFERENCE TIME: {total_inference_time}s <<<")
+#     logger.info(f">>> CANVAS POINTS COMPLETED <<<")
+#     logger.info("-" * 50)
+#
+#     return JSONResponse(status_code=200, content=response)
+
+
+@nto_cto_router.post("/necklaceTryOnWithPoints")
+async def necklace_try_on_with_points(necklace_try_on_id: NecklaceTryOnIDEntity = Depends(parse_necklace_try_on_id),
+                                      image: UploadFile = File(...),
+                                      left_x: int = Form(...),
+                                      left_y: int = Form(...),
+                                      right_x: int = Form(...),
+                                      right_y: int = Form(...)):
+    logger.info("-" * 50)
+    logger.info(">>> NECKLACE TRY ON WITH POINTS STARTED <<<")
+    logger.info(f"Parameters: storename={necklace_try_on_id.storename}, "
+                f"necklaceCategory={necklace_try_on_id.necklaceCategory}, "
+                f"necklaceImageId={necklace_try_on_id.necklaceImageId}, "
+                f"left_point=({left_x}, {left_y}), right_point=({right_x}, {right_y})")
+    start_time = time.time()
+
+    try:
+        imageBytes = await image.read()
+        jewellery_url = f"https://lvuhhlrkcuexzqtsbqyu.supabase.co/storage/v1/object/public/Stores/{necklace_try_on_id.storename}/{necklace_try_on_id.necklaceCategory}/image/{necklace_try_on_id.necklaceImageId}.png"
+        image, jewellery = Image.open(BytesIO(imageBytes)), Image.open(returnBytesData(url=jewellery_url))
+        logger.info(">>> IMAGES LOADED SUCCESSFULLY <<<")
+    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. Error: {str(e)}",
+            "code": 404}, status_code=404)
+
+    try:
+        result, headerText, mask = await pipeline.necklaceTryOnWithPoints_(
+            image=image, jewellery=jewellery, left_shoulder=(left_x, left_y), right_shoulder=(right_x, right_y),
+            storename=necklace_try_on_id.storename
+        )
+        logger.info(">>> NECKLACE TRY ON PROCESSING COMPLETED <<<")
+    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)
+
+    try:
+        inMemFile = BytesIO()
+        inMemFileMask = BytesIO()
+        result.save(inMemFile, format="WEBP", quality=85)
+        mask.save(inMemFileMask, format="WEBP", quality=85)
+        outputBytes = inMemFile.getvalue()
+        maskBytes = inMemFileMask.getvalue()
+        logger.info(">>> RESULT IMAGES SAVED <<<")
+    except Exception as e:
+        logger.error(f">>> RESULT SAVING ERROR: {str(e)} <<<")
+        return JSONResponse(content={"error": f"Error saving result images", "code": 500}, status_code=500)
+
+    try:
+        creditResponse = deductAndTrackCredit(storename=necklace_try_on_id.storename, endpoint="/necklaceTryOnID")
+        total_inference_time = round((time.time() - start_time), 2)
+        response = {
+            "code": 200,
+            "output": f"data:image/WEBP;base64,{base64.b64encode(outputBytes).decode('utf-8')}",
+            "mask": f"data:image/WEBP;base64,{base64.b64encode(maskBytes).decode('utf-8')}",
+            "inference_time": total_inference_time
+        }
+        if creditResponse == "No Credits Available":
+            logger.error(">>> NO CREDITS REMAINING <<<")
+            response = {"error": "No Credits Remaining"}
+            return JSONResponse(content=response, status_code=402)
+        logger.info(">>> CREDITS DEDUCTED SUCCESSFULLY <<<")
+    except Exception as e:
+        logger.error(f">>> CREDIT DEDUCTION ERROR: {str(e)} <<<")
+        return JSONResponse(content={"error": f"Error deducting credits", "code": 500}, status_code=500)
+
+    logger.info(f">>> TOTAL INFERENCE TIME: {total_inference_time}s <<<")
+    logger.info(f">>> NECKLACE TRY ON WITH POINTS COMPLETED <<<")
+    logger.info("-" * 50)
+
+    return JSONResponse(content=response, status_code=200)
+
+
+@nto_cto_router.post("/clothingAndNecklaceTryOn")
+async def clothing_and_necklace_try_on(
+        image: UploadFile = File(...),
+        necklaceImageId: str = Form(...),
+        necklaceCategory: str = Form(...),
+        storename: str = Form(...),
+        clothing_type: str = Form(...)
+):
+    logger.info("-" * 50)
+    logger.info(">>> CLOTHING AND NECKLACE TRY ON STARTED <<<")
+    logger.info(f"Parameters: storename={storename}, "
+                f"necklaceCategory={necklaceCategory}, "
+                f"necklaceImageId={necklaceImageId}, "
+                f"clothing_type={clothing_type}")
+    start_time = time.time()
+
+    def image_to_base64(img: Image.Image) -> str:
+        buffer = BytesIO()
+        img.save(buffer, format="WEBP", quality=85, optimize=True)
+        return f"data:image/webp;base64,{base64.b64encode(buffer.getvalue()).decode('utf-8')}"
+
+    try:
+        person_bytes = await image.read()
+        person_image = Image.open(BytesIO(person_bytes)).convert("RGB").resize((512, 512))
+
+        jewellery_url = f"https://lvuhhlrkcuexzqtsbqyu.supabase.co/storage/v1/object/public/Stores/{storename}/{necklaceCategory}/image/{necklaceImageId}.png"
+        necklace_image = Image.open(returnBytesData(url=jewellery_url)).convert("RGBA")
+
+        logger.info(">>> IMAGES LOADED SUCCESSFULLY <<<")
+
+        mask, left_point, right_point = await pipeline.shoulderPointMaskGeneration_(image=person_image)
+        logger.info(">>> MASK AND POINTS GENERATION COMPLETED <<<")
+
+        mask_data_uri, image_data_uri = await asyncio.gather(
+            asyncio.to_thread(image_to_base64, mask),
+            asyncio.to_thread(image_to_base64, person_image)
+        )
+
+        cto_output = replicate_run_cto({
+            "mask": mask_data_uri,
+            "image": image_data_uri,
+            "prompt": f"Dull {clothing_type}, non-reflective clothing, properly worn, natural setting, elegant, natural look, neckline without jewellery, simple, perfect eyes, perfect face, perfect body, high quality, realistic, photorealistic, high resolution,traditional full sleeve blouse",
+            "negative_prompt": "necklaces, jewellery, jewelry, necklace, neckpiece, garland, chain, neck wear, jewelled neck, jeweled neck, necklace on neck, jewellery on neck, accessories, watermark, text, changed background, wider body, narrower body, bad proportions, extra limbs, mutated hands, changed sizes, altered proportions, unnatural body proportions, blury, ugly",
+            "num_inference_steps": 20
+        })
+
+        if not cto_output or not isinstance(cto_output, (list, tuple)) or not cto_output[0]:
+            raise ValueError("Invalid output from clothing try-on")
+
+        async with aiohttp.ClientSession() as session:
+            async with session.get(str(cto_output[0])) as response:
+                if response.status != 200:
+                    raise HTTPException(status_code=response.status, detail="Failed to fetch CTO output")
+                cto_result_bytes = await response.read()
+
+        with BytesIO(cto_result_bytes) as buf:
+            cto_result_image = Image.open(buf).convert("RGB")
+
+            result, headerText, _ = await pipeline.necklaceTryOnWithPoints_(
+                image=cto_result_image,
+                jewellery=necklace_image,
+                left_shoulder=left_point,
+                right_shoulder=right_point,
+                storename=storename
+            )
+
+            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)
+
+            if not result_url:
+                raise ValueError("Failed to upload result image")
+
+        response = {
+            "code": 200,
+            "output": result_url,
+            "inference_time": round((time.time() - start_time), 2)
+        }
+
+    except ValueError as ve:
+        logger.error(f">>> PROCESSING ERROR: {str(ve)} <<<")
+        return JSONResponse(status_code=400, content={"error": str(ve), "code": 400})
+    except Exception as e:
+        logger.error(f">>> PROCESSING ERROR: {str(e)} <<<")
+        return JSONResponse(status_code=500, content={"error": "Error during image processing", "code": 500})
+    finally:
+        gc.collect()
+
+    logger.info(f">>> TOTAL INFERENCE TIME: {response['inference_time']}s <<<")
+    logger.info(">>> REQUEST COMPLETED SUCCESSFULLY <<<")
+    logger.info("-" * 50)
+
+    return JSONResponse(content=response, status_code=200)
+
+
+@nto_cto_router.post("/m_nto")
+async def mannequin_nto(necklace_try_on_id: NecklaceTryOnIDEntity = Depends(parse_necklace_try_on_id),
+                        image: UploadFile = File(...)):
+    logger.info("-" * 50)
+    logger.info(">>> MANNEQUIN NTO STARTED <<<")
+    logger.info(f"Parameters: storename={necklace_try_on_id.storename}, "
+                f"necklaceCategory={necklace_try_on_id.necklaceCategory}, "
+                f"necklaceImageId={necklace_try_on_id.necklaceImageId}")
+    start_time = time.time()
+
+    try:
+        imageBytes = await image.read()
+        jewellery_url = f"https://lvuhhlrkcuexzqtsbqyu.supabase.co/storage/v1/object/public/Stores/{necklace_try_on_id.storename}/{necklace_try_on_id.necklaceCategory}/image/{necklace_try_on_id.necklaceImageId}.png"
+        image, jewellery = Image.open(BytesIO(imageBytes)), Image.open(returnBytesData(url=jewellery_url))
+        logger.info(">>> IMAGES LOADED SUCCESSFULLY <<<")
+    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:
+        result, resized_img = await pipeline.necklaceTryOnMannequin_(image=image, jewellery=jewellery)
+
+        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)
+        logger.info(">>> NECKLACE TRY ON PROCESSING COMPLETED <<<")
+    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)
+
+    try:
+        logger.info(">>> SAVING RESULT IMAGES <<<")
+        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)
+        result_url = await asyncio.gather(upload_tasks)
+
+        if result_url[0] is None:
+            raise Exception("Failed to upload one or both images")
+
+        logger.info(f">>> RESULT IMAGES SAVED IN {round((time.time() - start_time_saving), 2)}s <<<")
+        logger.info(">>> RESULT IMAGES SAVED <<<")
+    except Exception as e:
+        logger.error(f">>> RESULT SAVING ERROR: {str(e)} <<<")
+        return JSONResponse(content={"error": f"Error saving result images", "code": 500}, status_code=500)
+    try:
+        try:
+            total_backend_time = round((time.time() - start_time), 2)
+            response = {
+                "code": 200,
+                "output": f"{result_url[0]}",
+                "inference_time": total_backend_time
+            }
+
+
+
+        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)
+
+        logger.info(f">>> TOTAL INFERENCE TIME: {total_backend_time}s <<<")
+        logger.info(f">>> NECKLACE TRY ON COMPLETED :: {necklace_try_on_id.storename} <<<")
+        logger.info("-" * 50)
+
+        return JSONResponse(content=response, status_code=200)
+
+    finally:
+        if 'result' in locals(): del result
+        gc.collect()
+
+
+@nto_cto_router.post("/nto_mto_combined")
+async def combined_cto_nto(
+        image: UploadFile = File(...),
+        clothing_type: str = Form(...),
+        necklace_id: str = Form(...),
+        necklace_category: str = Form(...),
+        storename: str = Form(...),
+        offset_x: float = Form(...),
+        offset_y: float = Form(...)
+):
+    logger.info("-" * 50)
+    logger.info(">>> COMBINED CTO-NTO STARTED <<<")
+    logger.info(f"Parameters: storename={storename}, necklace_category={necklace_category}, "
+                f"necklace_id={necklace_id}, clothing_type={clothing_type}")
+    start_time = time.time()
+
+    def image_to_base64(img: Image.Image) -> str:
+        buffer = BytesIO()
+        img.save(buffer, format="WEBP", quality=85, optimize=True)
+        return f"data:image/webp;base64,{base64.b64encode(buffer.getvalue()).decode('utf-8')}"
+
+    try:
+        # Load source image and necklace
+        image_bytes = await image.read()
+        source_image = Image.open(BytesIO(image_bytes)).convert("RGB").resize((512, 512))
+
+        jewellery_url = f"https://lvuhhlrkcuexzqtsbqyu.supabase.co/storage/v1/object/public/Stores/{storename}/{necklace_category}/image/{necklace_id}.png"
+        necklace_image = Image.open(returnBytesData(url=jewellery_url)).convert("RGBA")
+        logger.info(">>> IMAGES LOADED SUCCESSFULLY <<<")
+    except Exception as e:
+        logger.error(f">>> IMAGE LOADING ERROR: {str(e)} <<<")
+        return JSONResponse(content={
+            "error": "Error loading images. Please verify the image and necklace availability.",
+            "code": 404
+        }, status_code=404)
+
+    try:
+        # Generate mask and shoulder points
+        mask_start_time = time.time()
+        mask, _, _ = await pipeline.shoulderPointMaskGeneration_(image=source_image)
+        mask_time = round(time.time() - mask_start_time, 2)
+        logger.info(f">>> MASK GENERATION COMPLETED in {mask_time}s <<<")
+
+        # Convert images to base64
+        encoding_start_time = time.time()
+        mask_data_uri, image_data_uri = await asyncio.gather(
+            asyncio.to_thread(image_to_base64, mask),
+            asyncio.to_thread(image_to_base64, source_image)
+        )
+        encoding_time = round(time.time() - encoding_start_time, 2)
+        logger.info(f">>> IMAGE ENCODING COMPLETED in {encoding_time}s <<<")
+
+        # Perform CTO
+        cto_start_time = time.time()
+        cto_output = replicate_run_cto({
+            "mask": mask_data_uri,
+            "image": image_data_uri,
+            "prompt": f"Dull {clothing_type}, non-reflective clothing, properly worn, natural setting, elegant, natural look, neckline without jewellery, simple, perfect eyes, perfect face, perfect body, high quality, realistic, photorealistic, high resolution,traditional full sleeve blouse",
+            "negative_prompt": "necklaces, jewellery, jewelry, necklace, neckpiece, garland, chain, neck wear, jewelled neck, jeweled neck, necklace on neck, jewellery on neck, accessories, watermark, text, changed background, wider body, narrower body, bad proportions, extra limbs, mutated hands, changed sizes, altered proportions, unnatural body proportions, blury, ugly",
+            "num_inference_steps": 20
+        })
+        cto_time = round(time.time() - cto_start_time, 2)
+        logger.info(f">>> CTO COMPLETED in {cto_time}s <<<")
+
+        if not cto_output or not isinstance(cto_output, (list, tuple)) or not cto_output[0]:
+            raise ValueError("Invalid output from clothing try-on")
+
+        # Get CTO result image
+        async with aiohttp.ClientSession() as session:
+            async with session.get(str(cto_output[0])) as response:
+                if response.status != 200:
+                    raise HTTPException(status_code=response.status, detail="Failed to fetch CTO output")
+                cto_result_bytes = await response.read()
+
+        # Perform NTO
+        nto_start_time = time.time()
+        with BytesIO(cto_result_bytes) as buf:
+            cto_result_image = Image.open(buf).convert("RGB")
+            result, headerText, _ = await pipeline.necklaceTryOnDynamicOffset_(
+                image=cto_result_image,
+                jewellery=necklace_image,
+                storename=storename,
+                offset=[offset_x, offset_y]
+            )
+        nto_time = round(time.time() - nto_start_time, 2)
+        logger.info(f">>> NTO COMPLETED in {nto_time}s <<<")
+
+        if result is None:
+            raise ValueError("Failed to process necklace try-on")
+
+        upload_start_time = time.time()
+        result_url = await supabase_upload_and_return_url(
+            prefix="NTOCTO",
+            image=result,
+            necklace_id=necklace_id
+        )
+        upload_time = round(time.time() - upload_start_time, 2)
+        logger.info(f">>> RESULT UPLOADED in {upload_time}s <<<")
+
+        if not result_url:
+            raise ValueError("Failed to upload result image")
+
+        total_time = round(time.time() - start_time, 2)
+        response = {
+            "code": 200,
+            "output": result_url,
+            "timing": {
+                "mask_generation": mask_time,
+                "encoding": encoding_time,
+                "cto_inference": cto_time,
+                "nto_inference": nto_time,
+                "upload": upload_time,
+                "total": total_time
+            }
+        }
+
+    except ValueError as ve:
+        logger.error(f">>> PROCESSING ERROR: {str(ve)} <<<")
+        return JSONResponse(status_code=400, content={"error": str(ve), "code": 400})
+    except Exception as e:
+        logger.error(f">>> PROCESSING ERROR: {str(e)} <<<")
+        return JSONResponse(status_code=500, content={"error": "Error during image processing", "code": 500})
+    finally:
+        if 'result' in locals(): del result
+        gc.collect()
+
+    logger.info(f">>> TOTAL PROCESSING TIME: {total_time}s <<<")
+    logger.info(">>> COMBINED CTO-NTO COMPLETED SUCCESSFULLY <<<")
+    logger.info("-" * 50)
+
+    return JSONResponse(content=response, status_code=200)
+
+
+@nto_cto_router.post("/nto-dynamic-offset")
+async def necklace_try_on_id_dynamic_offset(
+        necklace_try_on_id: NecklaceTryOnIDEntity = Depends(parse_necklace_try_on_id),
+        image: UploadFile = File(...)):
+    logger.info("-" * 50)
+    logger.info(">>> NECKLACE TRY ON ID STARTED <<<")
+    logger.info(f"Parameters: storename={necklace_try_on_id.storename}, "
+                f"necklaceCategory={necklace_try_on_id.necklaceCategory}, "
+                f"necklaceImageId={necklace_try_on_id.necklaceImageId}")
+    start_time = time.time()
+
+    try:
+        image_loading_start = time.time()
+        imageBytes = await image.read()
+        jewellery_url = f"https://lvuhhlrkcuexzqtsbqyu.supabase.co/storage/v1/object/public/Stores/{necklace_try_on_id.storename}/{necklace_try_on_id.necklaceCategory}/image/{necklace_try_on_id.necklaceImageId}.png"
+        image, jewellery = Image.open(BytesIO(imageBytes)), Image.open(returnBytesData(url=jewellery_url))
+        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=necklace_try_on_id.storename,
+            offset=[necklace_try_on_id.offset_x, necklace_try_on_id.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)
+
+    try:
+        upload_start_time = time.time()
+        upload_tasks = [
+            supabase_upload_and_return_url(prefix="NTO", image=result, necklace_id=necklace_try_on_id.necklaceImageId)
+        ]
+        result_url = await asyncio.gather(*upload_tasks)
+        upload_time = round(time.time() - upload_start_time, 2)
+
+        logger.info(f">>> RESULT IMAGES SAVED IN {upload_time}s <<<")
+    except Exception as e:
+        logger.error(f">>> RESULT SAVING ERROR: {str(e)} <<<")
+        return JSONResponse(content={"error": f"Error saving result images", "code": 500}, status_code=500)
+
+    try:
+        total_time = round(time.time() - start_time, 2)
+        response = {
+            "code": 200,
+            "output": f"{result_url[0]}",
+            "timing": {
+                "image_loading": image_loading_time,
+                "nto_processing": nto_time,
+                "upload": upload_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"Upload Time: {upload_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()

src/components/auto_crop.py

@@ -0,0 +1,61 @@
+"""
+project @ NTO-TCP-HF
+created @ 2024-10-28
+author  @ github.com/ishworrsubedii
+"""
+from io import BytesIO
+
+from PIL import Image
+
+
+def crop_transparent_image(image_data: bytes) -> tuple[bytes, dict]:
+    try:
+        image = Image.open(BytesIO(image_data))
+
+        if image.format != 'PNG':
+            raise ValueError("Only PNG images are supported")
+
+        width = image.size[0]
+        height = image.size[1]
+        pixels = image.load()
+
+        top = height
+        bottom = 0
+        left = width
+        right = 0
+
+        # Find boundaries of non-transparent pixels
+        for y in range(height):
+            for x in range(width):
+                pixel = pixels[x, y]
+                if isinstance(pixel, tuple) and len(pixel) == 4:
+                    if pixel[3] != 0:
+                        left = min(left, x)
+                        top = min(top, y)
+                        right = max(right, x)
+                        bottom = max(bottom, y)
+
+        left = max(0, left)
+        top = max(0, top)
+        right = min(width, right + 1)
+        bottom = min(height, bottom + 1)
+
+        if left >= right or top >= bottom:
+            left, top, right, bottom = 0, 0, width, height
+
+        # Crop image
+        cropped_image = image.crop((left, top, right, bottom))
+
+        output_buffer = BytesIO()
+        cropped_image.save(output_buffer, format='PNG')
+        output_buffer.seek(0)
+
+        metadata = {
+            "original_size": f"{width}x{height}",
+            "cropped_size": f"{cropped_image.width}x{cropped_image.height}"
+        }
+
+        return output_buffer.getvalue(), metadata
+
+    except Exception as e:
+        raise ValueError(f"Error processing image: {str(e)}")

src/components/color_extraction.py

@@ -0,0 +1,38 @@
+"""
+project @ NTO-TCP-HF
+created @ 2024-10-28
+author  @ github.com/ishworrsubedii
+"""
+
+import cv2
+import numpy as np
+
+
+class ColorExtractionRMBG:
+    def __init__(self):
+        self.HSV_LOWER = None
+        self.HSV_UPPER = None
+
+    def hex_to_rgb(self, hex_color: str):
+        hex_color = hex_color.lstrip("#")
+        return tuple(int(hex_color[i:i + 2], 16) for i in (0, 2, 4))
+
+    def rgb_to_hsv(self, rgb_color):
+        rgb_array = np.uint8([[rgb_color]])
+        hsv_array = cv2.cvtColor(rgb_array, cv2.COLOR_RGB2HSV)
+        return hsv_array[0][0]
+
+    def set_thresholds(self, hex_color: str, threshold: int):
+        hsv_color = self.rgb_to_hsv(self.hex_to_rgb(hex_color))
+        lower_bound = np.clip([hsv_color[0] - threshold, 50, 50], 0, 255)
+        upper_bound = np.clip([hsv_color[0] + threshold, 255, 255], 0, 255)
+        return lower_bound, upper_bound
+
+    def extract_color(self, image: np.ndarray, hex_color: str, threshold: int):
+        self.HSV_LOWER, self.HSV_UPPER = self.set_thresholds(hex_color, threshold)
+        hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
+        mask = cv2.inRange(hsv, self.HSV_LOWER, self.HSV_UPPER)
+        result = cv2.bitwise_and(image, image, mask=mask)
+        result = cv2.cvtColor(result, cv2.COLOR_BGR2BGRA)
+        result[:, :, 3] = mask
+        return result

src/components/makeup_try_on.py

@@ -0,0 +1,104 @@
+"""
+project @ NTO-TCP-HF
+created @ 2024-12-05
+author  @ github.com/ishworrsubedii
+"""
+import cv2
+import mediapipe as mp
+import numpy as np
+
+
+class MakeupTryOn:
+    def __init__(self):
+        self.mp_face_mesh = mp.solutions.face_mesh
+        self.mp_drawing = mp.solutions.drawing_utils
+        self.face_points = {
+            "LIP_UPPER": [61, 185, 40, 39, 37, 0, 267, 269, 270, 409, 291, 308, 415, 310, 312, 13, 82, 81, 80, 191, 78],
+            "LIP_LOWER": [61, 146, 91, 181, 84, 17, 314, 405, 321, 375, 291, 308, 324, 402, 317, 14, 87, 178, 88, 95,
+                          78, 61],
+            "EYESHADOW_LEFT": [226, 247, 30, 29, 27, 28, 56, 190, 243, 173, 157, 158, 159, 160, 161, 246, 33, 130, 226],
+            "EYESHADOW_RIGHT": [463, 414, 286, 258, 257, 259, 260, 467, 446, 359, 263, 466, 388, 387, 386, 385, 384,
+                                398,
+                                362,
+                                463],
+            "EYELINER_LEFT": [243, 112, 26, 22, 23, 24, 110, 25, 226, 130, 33, 7, 163, 144, 145, 153, 154, 155, 133,
+                              243],
+            "EYELINER_RIGHT": [463, 362, 382, 381, 380, 374, 373, 390, 249, 263, 359, 446, 255, 339, 254, 253, 252, 256,
+                               341,
+                               463],
+        }
+
+    # Read landmarks
+    def read_landmarks(self, image: np.array):
+        with self.mp_face_mesh.FaceMesh(refine_landmarks=True) as face_mesh:
+            results = face_mesh.process(image)
+            if not results.multi_face_landmarks:
+                raise ValueError("No face detected")
+            face_landmarks = results.multi_face_landmarks[0].landmark
+
+        landmark_coordinates = {}
+        for idx, landmark in enumerate(face_landmarks):
+            landmark_px = self.mp_drawing._normalized_to_pixel_coordinates(
+                landmark.x, landmark.y, image.shape[1], image.shape[0]
+            )
+            if landmark_px:
+                landmark_coordinates[idx] = landmark_px
+
+        return landmark_coordinates
+
+    # Add makeup
+    def add_makeup(self, image, mask, landmarks, feature, color):
+        # Create mask for facial features with color
+        points = np.array([landmarks[idx] for idx in self.face_points[feature] if idx in landmarks])
+        if points.size > 0:
+            cv2.fillPoly(mask, [points], color)
+        return mask
+
+    # Apply makeup functions
+    def apply_lipstick(self, image, landmarks, lipstick_color):
+        mask = np.zeros_like(image)
+        mask = self.add_makeup(image, mask, landmarks, "LIP_UPPER", lipstick_color)
+        mask = self.add_makeup(image, mask, landmarks, "LIP_LOWER", lipstick_color)
+        return mask
+
+    def apply_eyeshadow(self, image, landmarks, eyeshadow_color):
+        mask = np.zeros_like(image)
+        mask = self.add_makeup(image, mask, landmarks, "EYESHADOW_LEFT", eyeshadow_color)
+        mask = self.add_makeup(image, mask, landmarks, "EYESHADOW_RIGHT", eyeshadow_color)
+        return mask
+
+    def apply_eyeliner(self, image, landmarks, eyeliner_color):
+        mask = np.zeros_like(image)
+        mask = self.add_makeup(image, mask, landmarks, "EYELINER_LEFT", eyeliner_color)
+        mask = self.add_makeup(image, mask, landmarks, "EYELINER_RIGHT", eyeliner_color)
+        return mask
+
+    def realistic_makeup(self, image, mask):
+        # Convert to float32 for better precision in calculations
+        image = image.astype(np.float32) / 255.0
+        mask = mask.astype(np.float32) / 255.0
+
+        # Apply Gaussian blur for natural blending
+        blurred_mask = cv2.GaussianBlur(mask, (7, 7), 4)
+
+        # Create alpha channel for better color blending
+        alpha = blurred_mask[:, :, -1] if mask.shape[-1] == 4 else np.mean(blurred_mask, axis=2)
+        alpha = np.expand_dims(alpha, axis=2)
+
+        # Blend colors using alpha compositing
+        output = image * (1.0 - alpha) + mask * alpha
+
+        # Ensure values are in valid range and convert back to uint8
+        output = np.clip(output * 255.0, 0, 255).astype(np.uint8)
+
+        return output
+
+    def full_makeup(self, image, lipstick_color, eyeliner_color, eyeshadow_color):
+        landmarks = self.read_landmarks(image)
+
+        mask_lipstick = self.apply_lipstick(image, landmarks, lipstick_color)
+        mask_eyeliner = self.apply_eyeliner(image, landmarks, eyeliner_color)
+        mask_eyeshadow = self.apply_eyeshadow(image, landmarks, eyeshadow_color)
+        final_mask = mask_lipstick + mask_eyeliner + mask_eyeshadow
+        output = self.realistic_makeup(image, final_mask)
+        return output

src/components/necklaceTryOn.py

@@ -0,0 +1,471 @@
+import gc
+import math
+import time
+from dataclasses import dataclass
+from typing import Union
+
+import cv2
+import cvzone
+import numpy as np
+from PIL import Image
+from cvzone.FaceMeshModule import FaceMeshDetector
+from cvzone.PoseModule import PoseDetector
+
+from src.api.nto_api import supabase
+from src.utils import add_watermark_store, add_watermark_jewelmirror, returnBytesData, addWatermark
+from src.utils.exceptions import CustomException
+from src.utils.logger import logger
+
+
+@dataclass
+class NecklaceTryOnConfig:
+    logoURL: str = "https://lvuhhlrkcuexzqtsbqyu.supabase.co/storage/v1/object/public/MagicMirror/FullImages/{}.png"
+
+
+class NecklaceTryOn:
+    def __init__(self) -> None:
+        self.detector = PoseDetector()
+        self.necklaceTryOnConfig = NecklaceTryOnConfig()
+        self.meshDetector = FaceMeshDetector(staticMode=True, maxFaces=1)
+        self.logo_cache = {}
+        self.jewelmirror_logo_cache = {}
+        # self.BODY_THRESHOLD = 0.36
+
+    def offset_calculate(self, necklace_id, body_type):
+        try:
+            start_time = time.time()
+            row = supabase.table("MagicMirror").select("*").eq("Id", necklace_id).execute()
+            data = row.data
+
+            if data and len(data) > 0:
+                x_offset = float(data[0][f"x_{body_type}"])
+                y_offset = float(data[0][f"y_{body_type}"])
+                logger.info(
+                    f">>> NECKLACE TRY ON :: OFFSET CALCULATION TAKEN: {round(time.time() - start_time, 2)}s <<<")
+                return [x_offset, y_offset]
+            else:
+                return [0.2, 0.5]
+
+        except Exception as e:
+            logger.error(f"Error in offset_calculate: {str(e)}")
+            return [0.2, 0.5]
+
+    # def calculate_body_type(self, lmList, faces, necklace_id):
+    #     try:
+    #         start_time = time.time()
+    #         face = faces[0]
+    #         left_face = np.array(face[234])
+    #         right_face = np.array(face[454])
+    #
+    #         left_shoulder = np.array([lmList[11][1], lmList[11][2]])
+    #         right_shoulder = np.array([lmList[12][1], lmList[12][2]])
+    #
+    #         face_width = np.linalg.norm(right_face - left_face)
+    #         shoulder_width = np.linalg.norm(right_shoulder - left_shoulder)
+    #
+    #         body_ratio = shoulder_width / face_width
+    #
+    #         body_type = "lean" if body_ratio > self.BODY_THRESHOLD else "chubby"
+    #         logger.info(f">>> NECKLACE TRY ON :: BODY TYPE: {body_type} <<<")
+    #         logger.info(f">>> NECKLACE TRY ON :: Time taken to calculate body type: {round(time.time() - start_time, 2)}s <<<")
+    #         offset = self.offset_calculate(body_type=body_type, necklace_id=necklace_id)
+    #
+    #         measurements = {
+    #             'face_width': round(face_width, 2),
+    #             'shoulder_width': round(shoulder_width, 2),
+    #             'ratio': round(body_ratio, 2)
+    #         }
+    #         logger.info(f">>> NECKLACE TRY ON :: OFFSET CALCULATED: {offset}")
+    #         logger.info(f">>> NECKLACE TRY ON :: BODY MEASUREMENTS: {measurements} <<<")
+    #         logger.info(f">>> NECKLACE TRY ON :: TOTAL OFFSET CALCULATION TAKEN: {round(time.time() - start_time, 2)}s <<<")
+    #         return offset
+    #
+    #     except Exception as e:
+    #         logger.error(f">>> NECKLACE TRY ON :: ERROR IN CALCULATE BODY TYPE: {str(e)} <<<")
+    #         return [0.2, 0.5]
+
+    def necklaceTryOnOffsetBody(self, image: Image.Image, jewellery: Image.Image, storename: str,
+                                offset: list[float]) -> list[
+        Union[Image.Image, str]]:
+        try:
+            logger.info(f">>> NECKLACE TRY ON STARTED :: {storename} <<<")
+
+            image = np.array(image.convert("RGB").resize((3000, 3000)))
+            copy_image = image.copy()
+            jewellery = np.array(jewellery.convert("RGBA"))
+
+            logger.info(f"NECKLACE TRY ON :: detecting pose and landmarks :: {storename}")
+            image = self.detector.findPose(image)
+            lmList, _ = self.detector.findPosition(image, bboxWithHands=False, draw=False)
+
+            img, faces = self.meshDetector.findFaceMesh(image, draw=False)
+            leftLandmark, rightLandmark = faces[0][172], faces[0][397]
+            # offset = self.calculate_body_type(lmList, faces, necklace_id)
+            logger.info(f"NECKLACE TRY ON :: offset: {offset}")
+
+            landmarksDistance = np.linalg.norm(np.array(leftLandmark) - np.array(rightLandmark))
+
+            logger.info(f"NECKLACE TRY ON :: estimating neck points :: {storename}")
+            avg_x1 = int(leftLandmark[0] - landmarksDistance * offset[0])
+            avg_x2 = int(rightLandmark[0] + landmarksDistance * offset[0])
+            avg_y1 = int(leftLandmark[1] + landmarksDistance * offset[1])
+            avg_y2 = int(rightLandmark[1] + landmarksDistance * offset[1])
+
+            logger.info(f"NECKLACE TRY ON :: scaling the necklace image :: {storename}")
+            angle = math.ceil(self.detector.findAngle((avg_x2, avg_y2), (avg_x1, avg_y1), (avg_x2, avg_y1))[0])
+            if avg_y2 >= avg_y1:
+                angle *= -1
+
+            xdist = avg_x2 - avg_x1
+            origImgRatio = xdist / jewellery.shape[1]
+            ydist = jewellery.shape[0] * origImgRatio
+
+            logger.info(f"NECKLACE TRY ON :: adding offset based on the necklace shape :: {storename}")
+            image_gray = cv2.cvtColor(jewellery, cv2.COLOR_BGRA2GRAY)
+            offset = int(0.8 * xdist * (np.argmax(image_gray[0, :] != 255) / jewellery.shape[1]))
+
+            jewellery = cv2.resize(jewellery, (int(xdist), int(ydist)), interpolation=cv2.INTER_AREA)
+            jewellery = cvzone.rotateImage(jewellery, angle)
+            y_coordinate = avg_y1 - offset
+            available_space = copy_image.shape[0] - y_coordinate
+            extra = jewellery.shape[0] - available_space
+
+            headerText = "To see more of the necklace, please step back slightly." if extra > 0 else "success"
+
+            logger.info(f"NECKLACE TRY ON :: generating output :: {storename}")
+            result = cvzone.overlayPNG(copy_image, jewellery, (avg_x1, y_coordinate))
+            result = Image.fromarray(result.astype(np.uint8))
+
+            # Add JewelMirror logo
+            if "default" not in self.jewelmirror_logo_cache:
+                self.jewelmirror_logo_cache["default"] = Image.open(
+                    returnBytesData(url=self.necklaceTryOnConfig.logoURL.format("default")))
+
+            # Try to add store logo if it exists
+            store_logo_exists = False
+            if storename != "default":
+                try:
+                    if storename not in self.logo_cache:
+                        self.logo_cache[storename] = Image.open(
+                            returnBytesData(url=self.necklaceTryOnConfig.logoURL.format(storename)))
+                    result = add_watermark_store(background=result, logo=self.logo_cache[storename])
+                    store_logo_exists = True
+                except Exception as e:
+                    logger.warning(f"Store logo not found for {storename}: {str(e)}")
+
+            # Add JewelMirror logo based on store logo existence
+            result = add_watermark_jewelmirror(
+                background=result, 
+                logo=self.jewelmirror_logo_cache["default"],
+                position="right" if store_logo_exists else "left"
+            )
+
+            # Create binary mask
+            blackedNecklace = np.zeros_like(copy_image)
+            cvzone.overlayPNG(blackedNecklace, jewellery, (avg_x1, y_coordinate))
+            binaryMask = cv2.cvtColor(blackedNecklace.astype(np.uint8), cv2.COLOR_BGR2GRAY)
+            binaryMask = (binaryMask > 5).astype(np.uint8) * 255
+            mask = Image.fromarray(binaryMask).convert("RGB")
+            
+            logger.info(f"NECKLACE TRY ON :: output generated successfully :: {storename}")
+
+            gc.collect()
+            return [result, headerText, mask]
+
+        except Exception as e:
+            logger.error(f">>> NECKLACE TRY ON ERROR: {str(e)} <<<")
+            logger.error(f"{CustomException(e)}:: {storename}")
+            return [None, "error", None]
+
+    def necklaceTryOn(self, image: Image.Image, jewellery: Image.Image, storename: str) -> list[
+        Union[Image.Image, str]]:
+        try:
+            logger.info(f">>> NECKLACE TRY ON STARTED :: {storename} <<<")
+
+            image = np.array(image.convert("RGB").resize((3000, 3000)))
+            copy_image = image.copy()
+            jewellery = np.array(jewellery.convert("RGBA"))
+
+            logger.info(f"NECKLACE TRY ON :: detecting pose and landmarks :: {storename}")
+            image = self.detector.findPose(image)
+            lmList, _ = self.detector.findPosition(image, bboxWithHands=False, draw=False)
+
+            img, faces = self.meshDetector.findFaceMesh(image, draw=False)
+            leftLandmark, rightLandmark = faces[0][172], faces[0][397]
+
+            landmarksDistance = np.linalg.norm(np.array(leftLandmark) - np.array(rightLandmark))
+
+            logger.info(f"NECKLACE TRY ON :: estimating neck points :: {storename}")
+            avg_x1 = int(leftLandmark[0] - landmarksDistance * 0.12)
+            avg_x2 = int(rightLandmark[0] + landmarksDistance * 0.12)
+            avg_y1 = int(leftLandmark[1] + landmarksDistance * 0.5)
+            avg_y2 = int(rightLandmark[1] + landmarksDistance * 0.5)
+
+            logger.info(f"NECKLACE TRY ON :: scaling the necklace image :: {storename}")
+            angle = math.ceil(self.detector.findAngle((avg_x2, avg_y2), (avg_x1, avg_y1), (avg_x2, avg_y1))[0])
+            if avg_y2 >= avg_y1:
+                angle *= -1
+
+            xdist = avg_x2 - avg_x1
+            origImgRatio = xdist / jewellery.shape[1]
+            ydist = jewellery.shape[0] * origImgRatio
+
+            logger.info(f"NECKLACE TRY ON :: adding offset based on the necklace shape :: {storename}")
+            image_gray = cv2.cvtColor(jewellery, cv2.COLOR_BGRA2GRAY)
+            offset = int(0.8 * xdist * (np.argmax(image_gray[0, :] != 255) / jewellery.shape[1]))
+
+            jewellery = cv2.resize(jewellery, (int(xdist), int(ydist)), interpolation=cv2.INTER_AREA)
+            jewellery = cvzone.rotateImage(jewellery, angle)
+            y_coordinate = avg_y1 - offset
+            available_space = copy_image.shape[0] - y_coordinate
+            extra = jewellery.shape[0] - available_space
+
+            headerText = "To see more of the necklace, please step back slightly." if extra > 0 else "success"
+
+            logger.info(f"NECKLACE TRY ON :: generating output :: {storename}")
+            result = cvzone.overlayPNG(copy_image, jewellery, (avg_x1, y_coordinate))
+            image = Image.fromarray(result.astype(np.uint8))
+
+            if storename not in self.logo_cache:
+                self.logo_cache[storename] = Image.open(
+                    returnBytesData(url=self.necklaceTryOnConfig.logoURL.format(storename)))
+            result = addWatermark(background=image, logo=self.logo_cache[storename])
+
+            # Create binary mask
+            blackedNecklace = np.zeros_like(copy_image)
+            cvzone.overlayPNG(blackedNecklace, jewellery, (avg_x1, y_coordinate))
+            binaryMask = cv2.cvtColor(blackedNecklace.astype(np.uint8), cv2.COLOR_BGR2GRAY)
+            binaryMask = (binaryMask > 5).astype(np.uint8) * 255
+            mask = Image.fromarray(binaryMask).convert("RGB")
+
+            gc.collect()
+            return [result, headerText, mask]
+
+        except Exception as e:
+            logger.error(f">>> NECKLACE TRY ON ERROR: {str(e)} <<<")
+            logger.error(f"{CustomException(e)}:: {storename}")
+
+            raise [None, "error", None]
+
+    def necklaceTryOnMannequin(self, image, jewellery) -> list[
+        Union[Image.Image, str]]:
+        try:
+            image_np = np.array(image.convert("RGB"))
+            jewellery = np.array(jewellery.convert("RGBA"))
+
+            height = image_np.shape[0]
+            middle_point = height // 3
+            upper_half = image_np[:middle_point, :]
+            lower_half = image_np[middle_point:, :]
+
+            upper_half = cv2.resize(upper_half, (upper_half.shape[1] * 3, upper_half.shape[0] * 3))
+            copy_upper = upper_half.copy()
+
+            # Apply pose detection on upper half
+            upper_half = self.detector.findPose(upper_half)
+            lmList, _ = self.detector.findPosition(upper_half, bboxWithHands=False, draw=True)
+
+            img, faces = self.meshDetector.findFaceMesh(upper_half, draw=True)
+
+            if not faces:
+                return Exception("No face detected in the image")
+
+            leftLandmark, rightLandmark = faces[0][172], faces[0][397]
+
+            landmarksDistance = np.linalg.norm(np.array(leftLandmark) - np.array(rightLandmark))
+
+            avg_x1 = int(leftLandmark[0] - landmarksDistance * 0.12)
+            avg_x2 = int(rightLandmark[0] + landmarksDistance * 0.12)
+            avg_y1 = int(leftLandmark[1] + landmarksDistance * 0.5)
+            avg_y2 = int(rightLandmark[1] + landmarksDistance * 0.5)
+
+            angle = math.ceil(self.detector.findAngle((avg_x2, avg_y2), (avg_x1, avg_y1), (avg_x2, avg_y1))[0])
+            if avg_y2 >= avg_y1:
+                angle *= -1
+
+            xdist = avg_x2 - avg_x1
+            origImgRatio = xdist / jewellery.shape[1]
+            ydist = jewellery.shape[0] * origImgRatio
+
+            image_gray = cv2.cvtColor(jewellery, cv2.COLOR_BGRA2GRAY)
+            offset = int(0.8 * xdist * (np.argmax(image_gray[0, :] != 255) / jewellery.shape[1]))
+
+            jewellery = cv2.resize(jewellery, (int(xdist), int(ydist)), interpolation=cv2.INTER_AREA)
+            jewellery = cvzone.rotateImage(jewellery, angle)
+
+            y_coordinate = avg_y1 - offset
+
+            result_upper = cvzone.overlayPNG(copy_upper, jewellery, (avg_x1, y_coordinate))
+
+            final_result = cv2.resize(result_upper, (image_np.shape[1], image_np.shape[0] - middle_point))
+
+            final_result = np.vstack((final_result, lower_half))
+
+            gc.collect()
+            return Image.fromarray(final_result.astype(np.uint8)), Image.fromarray(result_upper.astype(np.uint8))
+
+        except Exception as e:
+            print(f"Error: {e}")
+            return e
+
+    def shoulderPointMaskGeneration(self, image: Image.Image) -> tuple[Image.Image, tuple[int, int], tuple[int, int]]:
+        try:
+            image = np.array(image)
+            copy_image = image.copy()
+
+            logger.info("SHOULDER POINT MASK GENERATION :: detecting pose and landmarks")
+            image = self.detector.findPose(image)
+            lmList, _ = self.detector.findPosition(image, bboxWithHands=False, draw=False)
+
+            img, faces = self.meshDetector.findFaceMesh(image, draw=False)
+            leftLandmark, rightLandmark = faces[0][172], faces[0][397]
+
+            landmarksDistance = np.linalg.norm(np.array(leftLandmark) - np.array(rightLandmark))
+
+            logger.info("SHOULDER POINT MASK GENERATION :: estimating neck points")
+            # Using the same point calculation logic as necklaceTryOn
+            avg_x1 = int(leftLandmark[0] - landmarksDistance * 0.12)
+            avg_x2 = int(rightLandmark[0] + landmarksDistance * 0.12)
+            avg_y1 = int(leftLandmark[1] + landmarksDistance * 0.5)
+            avg_y2 = int(rightLandmark[1] + landmarksDistance * 0.5)
+
+            logger.info("SHOULDER POINT MASK GENERATION :: generating shoulder point mask")
+            mask = np.zeros_like(image[:, :, 0])
+            mask[avg_y1:, :] = 255
+            pts = np.array([[0, 0], [image.shape[1], 0], [avg_x2, avg_y2], [avg_x1, avg_y1]], np.int32)
+            pts = pts.reshape((-1, 1, 2))
+            cv2.fillPoly(mask, [pts], 0)
+
+            black_n_white_mask = np.zeros_like(image[:, :, 0])
+            black_n_white_mask[avg_y1:, :] = 255
+            logger.info("SHOULDER POINT MASK GENERATION :: mask generated successfully")
+
+            left_point = (avg_x1, avg_y1)
+            right_point = (avg_x2, avg_y2)
+
+            return Image.fromarray(black_n_white_mask.astype(np.uint8)), left_point, right_point
+
+        except Exception as e:
+            logger.error(f"SHOULDER POINT MASK GENERATION ERROR: {str(e)}")
+            raise CustomException(e)
+
+    def necklaceTryOnWithPoints(self, image: Image.Image, jewellery: Image.Image, storename: str,
+                                left_point: tuple[int, int], right_point: tuple[int, int]) -> list[
+        Union[Image.Image, str]]:
+        try:
+            logger.info(f">>> NECKLACE TRY ON WITH POINTS STARTED :: {storename} <<<")
+
+            image = np.array(image.convert("RGB"))
+            # .resize((3000, 3000)))
+            copy_image = image.copy()
+            jewellery = np.array(jewellery.convert("RGBA"))
+
+            logger.info(f"NECKLACE TRY ON :: scaling the necklace image based on given points :: {storename}")
+
+            avg_x1 = left_point[0]
+            avg_x2 = right_point[0]
+            avg_y1 = left_point[1]
+            avg_y2 = right_point[1]
+
+            angle = math.ceil(self.detector.findAngle((avg_x2, avg_y2), (avg_x1, avg_y1), (avg_x2, avg_y1))[0])
+            if avg_y2 >= avg_y1:
+                angle *= -1
+
+            xdist = avg_x2 - avg_x1
+            origImgRatio = xdist / jewellery.shape[1]
+            ydist = jewellery.shape[0] * origImgRatio
+
+            logger.info(f"NECKLACE TRY ON :: adding offset based on the necklace shape :: {storename}")
+            image_gray = cv2.cvtColor(jewellery, cv2.COLOR_BGRA2GRAY)
+            offset = int(0.8 * xdist * (np.argmax(image_gray[0, :] != 255) / jewellery.shape[1]))
+
+            jewellery = cv2.resize(jewellery, (int(xdist), int(ydist)), interpolation=cv2.INTER_AREA)
+            jewellery = cvzone.rotateImage(jewellery, angle)
+            y_coordinate = avg_y1 - offset
+            available_space = copy_image.shape[0] - y_coordinate
+            extra = jewellery.shape[0] - available_space
+
+            headerText = "To see more of the necklace, please step back slightly." if extra > 0 else "success"
+
+            logger.info(f"NECKLACE TRY ON :: generating output with given points :: {storename}")
+            result = cvzone.overlayPNG(copy_image, jewellery, (avg_x1, y_coordinate))
+            image = Image.fromarray(result.astype(np.uint8))
+
+            if storename not in self.logo_cache:
+                self.logo_cache[storename] = Image.open(
+                    returnBytesData(url=self.necklaceTryOnConfig.logoURL.format(storename)))
+            result = addWatermark(background=image, logo=self.logo_cache[storename])
+
+            # Create binary mask
+            blackedNecklace = np.zeros_like(copy_image)
+            cvzone.overlayPNG(blackedNecklace, jewellery, (avg_x1, y_coordinate))
+            binaryMask = cv2.cvtColor(blackedNecklace.astype(np.uint8), cv2.COLOR_BGR2GRAY)
+            binaryMask = (binaryMask > 5).astype(np.uint8) * 255
+            mask = Image.fromarray(binaryMask).convert("RGB")
+
+            gc.collect()
+            return [result, headerText, mask]
+
+        except Exception as e:
+            logger.error(f"{CustomException(e)}:: {storename}")
+            raise CustomException(e)
+
+    def necklaceTryOnOffset(self, image: Image.Image, jewellery: Image.Image, storename: str, offset_x: float = 0.12,
+                            offset_y: float = 0.5) -> list[Union[Image.Image, str]]:
+        try:
+            image = np.array(image.convert("RGB").resize((3000, 3000)))
+            copy_image = image.copy()
+            jewellery = np.array(jewellery.convert("RGBA"))
+
+            image = self.detector.findPose(image)
+            lmList, _ = self.detector.findPosition(image, bboxWithHands=False, draw=False)
+
+            img, faces = self.meshDetector.findFaceMesh(image, draw=False)
+            leftLandmark, rightLandmark = faces[0][172], faces[0][397]
+            landmarksDistance = np.linalg.norm(np.array(leftLandmark) - np.array(rightLandmark))
+
+            avg_x1 = int(leftLandmark[0] - landmarksDistance * offset_x)
+            avg_x2 = int(rightLandmark[0] + landmarksDistance * offset_x)
+            avg_y1 = int(leftLandmark[1] + landmarksDistance * offset_y)
+            avg_y2 = int(rightLandmark[1] + landmarksDistance * offset_y)
+
+            angle = math.ceil(self.detector.findAngle((avg_x2, avg_y2), (avg_x1, avg_y1), (avg_x2, avg_y1))[0])
+            if avg_y2 >= avg_y1:
+                angle *= -1
+
+            xdist = avg_x2 - avg_x1
+            origImgRatio = xdist / jewellery.shape[1]
+            ydist = jewellery.shape[0] * origImgRatio
+
+            image_gray = cv2.cvtColor(jewellery, cv2.COLOR_BGRA2GRAY)
+            offset = int(0.8 * xdist * (np.argmax(image_gray[0, :] != 255) / jewellery.shape[1]))
+
+            jewellery = cv2.resize(jewellery, (int(xdist), int(ydist)), interpolation=cv2.INTER_AREA)
+            jewellery = cvzone.rotateImage(jewellery, angle)
+
+            y_coordinate = avg_y1 - offset
+            available_space = copy_image.shape[0] - y_coordinate
+
+            result = cvzone.overlayPNG(copy_image, jewellery, (avg_x1, y_coordinate))
+            headerText = "To see more of the necklace, please step back slightly." if available_space < jewellery.shape[
+                0] else "success"
+            image = Image.fromarray(result.astype(np.uint8))
+
+            if storename not in self.logo_cache:
+                self.logo_cache[storename] = Image.open(
+                    returnBytesData(url=self.necklaceTryOnConfig.logoURL.format(storename)))
+            result = addWatermark(background=image, logo=self.logo_cache[storename])
+
+            blackedNecklace = np.zeros_like(copy_image)
+            cvzone.overlayPNG(blackedNecklace, jewellery, (avg_x1, y_coordinate))
+            binaryMask = cv2.cvtColor(blackedNecklace.astype(np.uint8), cv2.COLOR_BGR2GRAY)
+            binaryMask = (binaryMask > 5).astype(np.uint8) * 255
+            mask = Image.fromarray(binaryMask).convert("RGB")
+
+            gc.collect()
+            return [result, headerText, mask]
+
+        except Exception as e:
+            logger.error(f">>> NECKLACE TRY ON ERROR: {str(e)} <<<")
+            logger.error(f"{CustomException(e)}:: {storename}")
+            raise [None, "error", None]

src/components/title_des_gen.py

@@ -0,0 +1,46 @@
+"""
+project @ NTO-TCP-HF
+created @ 2024-10-29
+author  @ github.com/ishworrsubedii
+"""
+import os
+
+import google.generativeai as genai
+from tempfile import NamedTemporaryFile
+
+
+class NecklaceProductListing:
+    def __init__(self, api_key):
+        genai.configure(api_key=api_key)
+        self.model = genai.GenerativeModel(model_name="gemini-1.5-flash")
+        self.prompt = """Analyze this necklace image and create an e-commerce product listing with:
+        1. An SEO-friendly, compelling product title (3-8 words)
+        2. A persuasive product description for online shoppers (80-120 words)
+        Format your response exactly like this:
+        Title: [Product Title]
+        Description: [Product Description]
+        For the description, include:
+        - Opening hook about the piece's beauty or uniqueness
+        - Key materials and specifications (metal type, gemstones, length, closure type)
+        - Highlight 2-3 standout design features
+        - Styling suggestions (what to wear it with, occasions)
+        - Quality/craftsmanship mentions
+        - One emotional benefit (how it makes the wearer feel)
+        Write in a professional yet warm tone that appeals to online jewelry shoppers. Focus on benefits and value proposition."""
+
+    def save_image_tempfile(self, pil_image):
+        with NamedTemporaryFile(suffix=".png", delete=False) as temp_file:
+            pil_image.save(temp_file, format="PNG")
+            return temp_file.name
+
+    def image_upload(self, image_path):
+        sample_file = genai.upload_file(path=image_path, display_name="necklace_image")
+        return sample_file
+
+    def gen_title_desc(self, image):
+        image_path = self.save_image_tempfile(image)
+        sample_file = self.image_upload(image_path)
+        os.remove(image_path)
+
+        response = self.model.generate_content([sample_file, self.prompt])
+        return response.text

src/pipelines/completePipeline.py

@@ -0,0 +1,64 @@
+from typing import Union
+
+from PIL import Image
+
+from src.components.makeup_try_on import MakeupTryOn
+from src.components.necklaceTryOn import NecklaceTryOn
+
+
+class Pipeline:
+    def __init__(self) -> None:
+        self.necklaceTryOnObj = NecklaceTryOn()
+        self.makeup_tryon_obj = MakeupTryOn()
+
+    async def necklaceTryOn_(self, image: Image.Image, jewellery: Image.Image, storename: str) -> \
+            list[
+                Union[Image.Image, str]]:
+        result, headerText, mask = self.necklaceTryOnObj.necklaceTryOn(image=image, jewellery=jewellery,
+                                                                       storename=storename)
+        return [result, headerText, mask]
+
+    async def necklaceTryOnDynamicOffset_(self, image: Image.Image, jewellery: Image.Image, storename: str,
+                                          offset: list) -> \
+            list[
+                Union[Image.Image, str]]:
+        result, headerText, mask = self.necklaceTryOnObj.necklaceTryOnOffsetBody(image=image, jewellery=jewellery,
+                                                                                 storename=storename,
+                                                                                 offset=offset)
+        return [result, headerText, mask]
+
+    async def shoulderPointMaskGeneration_(self, image: Image.Image):
+        mask, left, right = self.necklaceTryOnObj.shoulderPointMaskGeneration(image=image)
+        return mask, left, right
+
+    async def canvasPoint(self, image: Image.Image, jewellery: Image.Image, storename: str) -> dict:
+        points = self.necklaceTryOnObj.canvasPoints(image=image, jewellery=jewellery, storename=storename)
+        return points
+
+    async def necklaceTryOnWithPoints_(self, image: Image.Image, jewellery: Image.Image, left_shoulder: tuple[int, int],
+                                       right_shoulder: tuple[int, int], storename: str) -> list[
+        Union[Image.Image, str]]:
+        result, headerText, mask = self.necklaceTryOnObj.necklaceTryOnWithPoints(image=image, jewellery=jewellery,
+                                                                                 left_point=left_shoulder,
+                                                                                 right_point=right_shoulder,
+                                                                                 storename=storename)
+        return [result, headerText, mask]
+
+    def necklaceTryOnMannequin_(self, image: Image.Image, jewellery: Image.Image):
+        result, resized_image = self.necklaceTryOnObj.necklaceTryOnMannequin(image, jewellery)
+
+        return result, resized_image
+
+    async def necklace_try_on_offset(self, image: Image.Image, jewellery: Image.Image, offset_x: float = 0.12,
+                                     offset_y: float = 0.5, storename: str = "default") -> list[
+        Union[Image.Image, str]]:
+        result, header_text, mask = self.necklaceTryOnObj.necklaceTryOnOffset(image, jewellery, offset_x=offset_x,
+                                                                              offset_y=offset_y, storename=storename)
+
+        return result, header_text, mask
+
+    async def makeup_tryon(self, image: Image.Image, lipstick_color: set, eyeliner_color: set, eyeshadow_color: set):
+
+        result = self.makeup_tryon_obj.full_makeup(image, lipstick_color=lipstick_color, eyeliner_color=eyeliner_color,
+                                                   eyeshadow_color=eyeshadow_color)
+        return result

src/utils/__init__.py

@@ -0,0 +1,98 @@
+import os
+from io import BytesIO
+
+import requests
+from PIL import Image
+from supabase import create_client, Client
+
+
+# function to add watermark to images
+def addWatermark(background: Image.Image, logo: Image.Image) -> Image.Image:
+    background = background.convert("RGBA")
+    logo = logo.convert("RGBA").resize((int(0.08 * background.size[0]), int(0.08 * background.size[0])))
+    background.paste(logo, (10, background.size[0] - logo.size[0] - 10), logo)
+    return background
+
+
+def add_watermark_store(background: Image.Image, logo: Image.Image) -> Image.Image:
+    """Add store logo watermark to top-left corner"""
+    background = background.convert("RGBA")
+
+    # Calculate size based on image dimensions (10% of width for store logo)
+    width = int(0.20 * background.size[0])
+    height = int(width * (logo.size[1] / logo.size[0]))  # maintain aspect ratio
+    logo = logo.convert("RGBA").resize((width, height))
+
+    padding = int(0.01 * background.size[0])
+
+    background.paste(logo, (padding, padding), logo)
+    return background
+
+
+def add_watermark_jewelmirror(background: Image.Image, logo: Image.Image, position: str = "right") -> Image.Image:
+    """
+    Add JewelMirror logo watermark
+    position: "right" for top-right corner, "left" for top-left corner
+    """
+    background = background.convert("RGBA")
+
+    # Calculate size based on image dimensions (8% of width for JewelMirror logo)
+    width = int(0.20 * background.size[0])
+    height = int(width * (logo.size[1] / logo.size[0]))  # maintain aspect ratio
+    logo = logo.convert("RGBA").resize((width, height))
+
+    # Add padding from corners (1% of image width)
+    padding = int(0.01 * background.size[0])
+
+    # Position based on parameter
+    background.paste(logo, (background.size[0] - logo.size[0] - padding, padding), logo)
+
+    return background
+
+
+def add_watermark_jewelmirror_bottom_right(background: Image.Image, logo: Image.Image) -> Image.Image:
+    background = background.convert("RGBA")
+    logo = logo.convert("RGBA")
+
+    w, h = int(0.08 * background.size[0]), int(0.06 * background.size[1])
+    logo = logo.resize((w, h))
+
+    padding = 0
+    logo_x = background.size[0] - logo.size[0] - padding
+    logo_y = background.size[1] - logo.size[1] - padding
+
+    background.paste(logo, (logo_x, logo_y), logo)
+
+    return background
+
+
+# function to download an image from url and return as bytes objects
+def returnBytesData(url: str) -> BytesIO:
+    response = requests.get(url)
+    return BytesIO(response.content)
+
+
+# function to get public URLs of paths
+def supabaseGetPublicURL(path: str) -> str:
+    url_string = f"https://lvuhhlrkcuexzqtsbqyu.supabase.co/storage/v1/object/public/Stores/{path}"
+    return url_string.replace(" ", "%20")
+
+
+# function to deduct credit
+def deductAndTrackCredit(storename: str, endpoint: str) -> str:
+    url: str = os.environ["SUPABASE_URL"]
+    key: str = os.environ["SUPABASE_KEY"]
+    supabase: Client = create_client(url, key)
+    current, _ = supabase.table('ClientConfig').select('CreditBalance').eq("StoreName", f"{storename}").execute()
+    if current[1] == []:
+        return "Not Found"
+    else:
+        current = current[1][0]["CreditBalance"]
+        if current > 0:
+            data, _ = supabase.table('ClientConfig').update({'CreditBalance': current - 1}).eq("StoreName",
+                                                                                               f"{storename}").execute()
+            data, _ = supabase.table('UsageHistory').insert(
+                {'StoreName': f"{storename}", 'APIEndpoint': f"{endpoint}"}).execute()
+            return "Success"
+        else:
+            return "No Credits Available"

src/utils/backgroundEnhancerArchitecture.py

@@ -0,0 +1,454 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from huggingface_hub import PyTorchModelHubMixin
+
+
+class REBNCONV(nn.Module):
+    def __init__(self, in_ch=3, out_ch=3, dirate=1, stride=1):
+        super(REBNCONV, self).__init__()
+
+        self.conv_s1 = nn.Conv2d(in_ch, out_ch, 3, padding=1 * dirate, dilation=1 * dirate, stride=stride)
+        self.bn_s1 = nn.BatchNorm2d(out_ch)
+        self.relu_s1 = nn.ReLU(inplace=True)
+
+    def forward(self, x):
+        hx = x
+        xout = self.relu_s1(self.bn_s1(self.conv_s1(hx)))
+
+        return xout
+
+
+## upsample tensor 'src' to have the same spatial size with tensor 'tar'
+def _upsample_like(src, tar):
+    src = F.interpolate(src, size=tar.shape[2:], mode='bilinear')
+
+    return src
+
+
+### RSU-7 ###
+class RSU7(nn.Module):
+
+    def __init__(self, in_ch=3, mid_ch=12, out_ch=3, img_size=512):
+        super(RSU7, self).__init__()
+
+        self.in_ch = in_ch
+        self.mid_ch = mid_ch
+        self.out_ch = out_ch
+
+        self.rebnconvin = REBNCONV(in_ch, out_ch, dirate=1)  ## 1 -> 1/2
+
+        self.rebnconv1 = REBNCONV(out_ch, mid_ch, dirate=1)
+        self.pool1 = nn.MaxPool2d(2, stride=2, ceil_mode=True)
+
+        self.rebnconv2 = REBNCONV(mid_ch, mid_ch, dirate=1)
+        self.pool2 = nn.MaxPool2d(2, stride=2, ceil_mode=True)
+
+        self.rebnconv3 = REBNCONV(mid_ch, mid_ch, dirate=1)
+        self.pool3 = nn.MaxPool2d(2, stride=2, ceil_mode=True)
+
+        self.rebnconv4 = REBNCONV(mid_ch, mid_ch, dirate=1)
+        self.pool4 = nn.MaxPool2d(2, stride=2, ceil_mode=True)
+
+        self.rebnconv5 = REBNCONV(mid_ch, mid_ch, dirate=1)
+        self.pool5 = nn.MaxPool2d(2, stride=2, ceil_mode=True)
+
+        self.rebnconv6 = REBNCONV(mid_ch, mid_ch, dirate=1)
+
+        self.rebnconv7 = REBNCONV(mid_ch, mid_ch, dirate=2)
+
+        self.rebnconv6d = REBNCONV(mid_ch * 2, mid_ch, dirate=1)
+        self.rebnconv5d = REBNCONV(mid_ch * 2, mid_ch, dirate=1)
+        self.rebnconv4d = REBNCONV(mid_ch * 2, mid_ch, dirate=1)
+        self.rebnconv3d = REBNCONV(mid_ch * 2, mid_ch, dirate=1)
+        self.rebnconv2d = REBNCONV(mid_ch * 2, mid_ch, dirate=1)
+        self.rebnconv1d = REBNCONV(mid_ch * 2, out_ch, dirate=1)
+
+    def forward(self, x):
+        b, c, h, w = x.shape
+
+        hx = x
+        hxin = self.rebnconvin(hx)
+
+        hx1 = self.rebnconv1(hxin)
+        hx = self.pool1(hx1)
+
+        hx2 = self.rebnconv2(hx)
+        hx = self.pool2(hx2)
+
+        hx3 = self.rebnconv3(hx)
+        hx = self.pool3(hx3)
+
+        hx4 = self.rebnconv4(hx)
+        hx = self.pool4(hx4)
+
+        hx5 = self.rebnconv5(hx)
+        hx = self.pool5(hx5)
+
+        hx6 = self.rebnconv6(hx)
+
+        hx7 = self.rebnconv7(hx6)
+
+        hx6d = self.rebnconv6d(torch.cat((hx7, hx6), 1))
+        hx6dup = _upsample_like(hx6d, hx5)
+
+        hx5d = self.rebnconv5d(torch.cat((hx6dup, hx5), 1))
+        hx5dup = _upsample_like(hx5d, hx4)
+
+        hx4d = self.rebnconv4d(torch.cat((hx5dup, hx4), 1))
+        hx4dup = _upsample_like(hx4d, hx3)
+
+        hx3d = self.rebnconv3d(torch.cat((hx4dup, hx3), 1))
+        hx3dup = _upsample_like(hx3d, hx2)
+
+        hx2d = self.rebnconv2d(torch.cat((hx3dup, hx2), 1))
+        hx2dup = _upsample_like(hx2d, hx1)
+
+        hx1d = self.rebnconv1d(torch.cat((hx2dup, hx1), 1))
+
+        return hx1d + hxin
+
+
+### RSU-6 ###
+class RSU6(nn.Module):
+
+    def __init__(self, in_ch=3, mid_ch=12, out_ch=3):
+        super(RSU6, self).__init__()
+
+        self.rebnconvin = REBNCONV(in_ch, out_ch, dirate=1)
+
+        self.rebnconv1 = REBNCONV(out_ch, mid_ch, dirate=1)
+        self.pool1 = nn.MaxPool2d(2, stride=2, ceil_mode=True)
+
+        self.rebnconv2 = REBNCONV(mid_ch, mid_ch, dirate=1)
+        self.pool2 = nn.MaxPool2d(2, stride=2, ceil_mode=True)
+
+        self.rebnconv3 = REBNCONV(mid_ch, mid_ch, dirate=1)
+        self.pool3 = nn.MaxPool2d(2, stride=2, ceil_mode=True)
+
+        self.rebnconv4 = REBNCONV(mid_ch, mid_ch, dirate=1)
+        self.pool4 = nn.MaxPool2d(2, stride=2, ceil_mode=True)
+
+        self.rebnconv5 = REBNCONV(mid_ch, mid_ch, dirate=1)
+
+        self.rebnconv6 = REBNCONV(mid_ch, mid_ch, dirate=2)
+
+        self.rebnconv5d = REBNCONV(mid_ch * 2, mid_ch, dirate=1)
+        self.rebnconv4d = REBNCONV(mid_ch * 2, mid_ch, dirate=1)
+        self.rebnconv3d = REBNCONV(mid_ch * 2, mid_ch, dirate=1)
+        self.rebnconv2d = REBNCONV(mid_ch * 2, mid_ch, dirate=1)
+        self.rebnconv1d = REBNCONV(mid_ch * 2, out_ch, dirate=1)
+
+    def forward(self, x):
+        hx = x
+
+        hxin = self.rebnconvin(hx)
+
+        hx1 = self.rebnconv1(hxin)
+        hx = self.pool1(hx1)
+
+        hx2 = self.rebnconv2(hx)
+        hx = self.pool2(hx2)
+
+        hx3 = self.rebnconv3(hx)
+        hx = self.pool3(hx3)
+
+        hx4 = self.rebnconv4(hx)
+        hx = self.pool4(hx4)
+
+        hx5 = self.rebnconv5(hx)
+
+        hx6 = self.rebnconv6(hx5)
+
+        hx5d = self.rebnconv5d(torch.cat((hx6, hx5), 1))
+        hx5dup = _upsample_like(hx5d, hx4)
+
+        hx4d = self.rebnconv4d(torch.cat((hx5dup, hx4), 1))
+        hx4dup = _upsample_like(hx4d, hx3)
+
+        hx3d = self.rebnconv3d(torch.cat((hx4dup, hx3), 1))
+        hx3dup = _upsample_like(hx3d, hx2)
+
+        hx2d = self.rebnconv2d(torch.cat((hx3dup, hx2), 1))
+        hx2dup = _upsample_like(hx2d, hx1)
+
+        hx1d = self.rebnconv1d(torch.cat((hx2dup, hx1), 1))
+
+        return hx1d + hxin
+
+
+### RSU-5 ###
+class RSU5(nn.Module):
+
+    def __init__(self, in_ch=3, mid_ch=12, out_ch=3):
+        super(RSU5, self).__init__()
+
+        self.rebnconvin = REBNCONV(in_ch, out_ch, dirate=1)
+
+        self.rebnconv1 = REBNCONV(out_ch, mid_ch, dirate=1)
+        self.pool1 = nn.MaxPool2d(2, stride=2, ceil_mode=True)
+
+        self.rebnconv2 = REBNCONV(mid_ch, mid_ch, dirate=1)
+        self.pool2 = nn.MaxPool2d(2, stride=2, ceil_mode=True)
+
+        self.rebnconv3 = REBNCONV(mid_ch, mid_ch, dirate=1)
+        self.pool3 = nn.MaxPool2d(2, stride=2, ceil_mode=True)
+
+        self.rebnconv4 = REBNCONV(mid_ch, mid_ch, dirate=1)
+
+        self.rebnconv5 = REBNCONV(mid_ch, mid_ch, dirate=2)
+
+        self.rebnconv4d = REBNCONV(mid_ch * 2, mid_ch, dirate=1)
+        self.rebnconv3d = REBNCONV(mid_ch * 2, mid_ch, dirate=1)
+        self.rebnconv2d = REBNCONV(mid_ch * 2, mid_ch, dirate=1)
+        self.rebnconv1d = REBNCONV(mid_ch * 2, out_ch, dirate=1)
+
+    def forward(self, x):
+        hx = x
+
+        hxin = self.rebnconvin(hx)
+
+        hx1 = self.rebnconv1(hxin)
+        hx = self.pool1(hx1)
+
+        hx2 = self.rebnconv2(hx)
+        hx = self.pool2(hx2)
+
+        hx3 = self.rebnconv3(hx)
+        hx = self.pool3(hx3)
+
+        hx4 = self.rebnconv4(hx)
+
+        hx5 = self.rebnconv5(hx4)
+
+        hx4d = self.rebnconv4d(torch.cat((hx5, hx4), 1))
+        hx4dup = _upsample_like(hx4d, hx3)
+
+        hx3d = self.rebnconv3d(torch.cat((hx4dup, hx3), 1))
+        hx3dup = _upsample_like(hx3d, hx2)
+
+        hx2d = self.rebnconv2d(torch.cat((hx3dup, hx2), 1))
+        hx2dup = _upsample_like(hx2d, hx1)
+
+        hx1d = self.rebnconv1d(torch.cat((hx2dup, hx1), 1))
+
+        return hx1d + hxin
+
+
+### RSU-4 ###
+class RSU4(nn.Module):
+
+    def __init__(self, in_ch=3, mid_ch=12, out_ch=3):
+        super(RSU4, self).__init__()
+
+        self.rebnconvin = REBNCONV(in_ch, out_ch, dirate=1)
+
+        self.rebnconv1 = REBNCONV(out_ch, mid_ch, dirate=1)
+        self.pool1 = nn.MaxPool2d(2, stride=2, ceil_mode=True)
+
+        self.rebnconv2 = REBNCONV(mid_ch, mid_ch, dirate=1)
+        self.pool2 = nn.MaxPool2d(2, stride=2, ceil_mode=True)
+
+        self.rebnconv3 = REBNCONV(mid_ch, mid_ch, dirate=1)
+
+        self.rebnconv4 = REBNCONV(mid_ch, mid_ch, dirate=2)
+
+        self.rebnconv3d = REBNCONV(mid_ch * 2, mid_ch, dirate=1)
+        self.rebnconv2d = REBNCONV(mid_ch * 2, mid_ch, dirate=1)
+        self.rebnconv1d = REBNCONV(mid_ch * 2, out_ch, dirate=1)
+
+    def forward(self, x):
+        hx = x
+
+        hxin = self.rebnconvin(hx)
+
+        hx1 = self.rebnconv1(hxin)
+        hx = self.pool1(hx1)
+
+        hx2 = self.rebnconv2(hx)
+        hx = self.pool2(hx2)
+
+        hx3 = self.rebnconv3(hx)
+
+        hx4 = self.rebnconv4(hx3)
+
+        hx3d = self.rebnconv3d(torch.cat((hx4, hx3), 1))
+        hx3dup = _upsample_like(hx3d, hx2)
+
+        hx2d = self.rebnconv2d(torch.cat((hx3dup, hx2), 1))
+        hx2dup = _upsample_like(hx2d, hx1)
+
+        hx1d = self.rebnconv1d(torch.cat((hx2dup, hx1), 1))
+
+        return hx1d + hxin
+
+
+### RSU-4F ###
+class RSU4F(nn.Module):
+
+    def __init__(self, in_ch=3, mid_ch=12, out_ch=3):
+        super(RSU4F, self).__init__()
+
+        self.rebnconvin = REBNCONV(in_ch, out_ch, dirate=1)
+
+        self.rebnconv1 = REBNCONV(out_ch, mid_ch, dirate=1)
+        self.rebnconv2 = REBNCONV(mid_ch, mid_ch, dirate=2)
+        self.rebnconv3 = REBNCONV(mid_ch, mid_ch, dirate=4)
+
+        self.rebnconv4 = REBNCONV(mid_ch, mid_ch, dirate=8)
+
+        self.rebnconv3d = REBNCONV(mid_ch * 2, mid_ch, dirate=4)
+        self.rebnconv2d = REBNCONV(mid_ch * 2, mid_ch, dirate=2)
+        self.rebnconv1d = REBNCONV(mid_ch * 2, out_ch, dirate=1)
+
+    def forward(self, x):
+        hx = x
+
+        hxin = self.rebnconvin(hx)
+
+        hx1 = self.rebnconv1(hxin)
+        hx2 = self.rebnconv2(hx1)
+        hx3 = self.rebnconv3(hx2)
+
+        hx4 = self.rebnconv4(hx3)
+
+        hx3d = self.rebnconv3d(torch.cat((hx4, hx3), 1))
+        hx2d = self.rebnconv2d(torch.cat((hx3d, hx2), 1))
+        hx1d = self.rebnconv1d(torch.cat((hx2d, hx1), 1))
+
+        return hx1d + hxin
+
+
+class myrebnconv(nn.Module):
+    def __init__(self, in_ch=3,
+                 out_ch=1,
+                 kernel_size=3,
+                 stride=1,
+                 padding=1,
+                 dilation=1,
+                 groups=1):
+        super(myrebnconv, self).__init__()
+
+        self.conv = nn.Conv2d(in_ch,
+                              out_ch,
+                              kernel_size=kernel_size,
+                              stride=stride,
+                              padding=padding,
+                              dilation=dilation,
+                              groups=groups)
+        self.bn = nn.BatchNorm2d(out_ch)
+        self.rl = nn.ReLU(inplace=True)
+
+    def forward(self, x):
+        return self.rl(self.bn(self.conv(x)))
+
+
+class BackgroundEnhancerArchitecture(nn.Module, PyTorchModelHubMixin):
+
+    def __init__(self, config: dict = {"in_ch": 3, "out_ch": 1}):
+        super(BackgroundEnhancerArchitecture, self).__init__()
+        in_ch = config["in_ch"]
+        out_ch = config["out_ch"]
+        self.conv_in = nn.Conv2d(in_ch, 64, 3, stride=2, padding=1)
+        self.pool_in = nn.MaxPool2d(2, stride=2, ceil_mode=True)
+
+        self.stage1 = RSU7(64, 32, 64)
+        self.pool12 = nn.MaxPool2d(2, stride=2, ceil_mode=True)
+
+        self.stage2 = RSU6(64, 32, 128)
+        self.pool23 = nn.MaxPool2d(2, stride=2, ceil_mode=True)
+
+        self.stage3 = RSU5(128, 64, 256)
+        self.pool34 = nn.MaxPool2d(2, stride=2, ceil_mode=True)
+
+        self.stage4 = RSU4(256, 128, 512)
+        self.pool45 = nn.MaxPool2d(2, stride=2, ceil_mode=True)
+
+        self.stage5 = RSU4F(512, 256, 512)
+        self.pool56 = nn.MaxPool2d(2, stride=2, ceil_mode=True)
+
+        self.stage6 = RSU4F(512, 256, 512)
+
+        # decoder
+        self.stage5d = RSU4F(1024, 256, 512)
+        self.stage4d = RSU4(1024, 128, 256)
+        self.stage3d = RSU5(512, 64, 128)
+        self.stage2d = RSU6(256, 32, 64)
+        self.stage1d = RSU7(128, 16, 64)
+
+        self.side1 = nn.Conv2d(64, out_ch, 3, padding=1)
+        self.side2 = nn.Conv2d(64, out_ch, 3, padding=1)
+        self.side3 = nn.Conv2d(128, out_ch, 3, padding=1)
+        self.side4 = nn.Conv2d(256, out_ch, 3, padding=1)
+        self.side5 = nn.Conv2d(512, out_ch, 3, padding=1)
+        self.side6 = nn.Conv2d(512, out_ch, 3, padding=1)
+
+        # self.outconv = nn.Conv2d(6*out_ch,out_ch,1)
+
+    def forward(self, x):
+        hx = x
+
+        hxin = self.conv_in(hx)
+        # hx = self.pool_in(hxin)
+
+        # stage 1
+        hx1 = self.stage1(hxin)
+        hx = self.pool12(hx1)
+
+        # stage 2
+        hx2 = self.stage2(hx)
+        hx = self.pool23(hx2)
+
+        # stage 3
+        hx3 = self.stage3(hx)
+        hx = self.pool34(hx3)
+
+        # stage 4
+        hx4 = self.stage4(hx)
+        hx = self.pool45(hx4)
+
+        # stage 5
+        hx5 = self.stage5(hx)
+        hx = self.pool56(hx5)
+
+        # stage 6
+        hx6 = self.stage6(hx)
+        hx6up = _upsample_like(hx6, hx5)
+
+        # -------------------- decoder --------------------
+        hx5d = self.stage5d(torch.cat((hx6up, hx5), 1))
+        hx5dup = _upsample_like(hx5d, hx4)
+
+        hx4d = self.stage4d(torch.cat((hx5dup, hx4), 1))
+        hx4dup = _upsample_like(hx4d, hx3)
+
+        hx3d = self.stage3d(torch.cat((hx4dup, hx3), 1))
+        hx3dup = _upsample_like(hx3d, hx2)
+
+        hx2d = self.stage2d(torch.cat((hx3dup, hx2), 1))
+        hx2dup = _upsample_like(hx2d, hx1)
+
+        hx1d = self.stage1d(torch.cat((hx2dup, hx1), 1))
+
+        # side output
+        d1 = self.side1(hx1d)
+        d1 = _upsample_like(d1, x)
+
+        d2 = self.side2(hx2d)
+        d2 = _upsample_like(d2, x)
+
+        d3 = self.side3(hx3d)
+        d3 = _upsample_like(d3, x)
+
+        d4 = self.side4(hx4d)
+        d4 = _upsample_like(d4, x)
+
+        d5 = self.side5(hx5d)
+        d5 = _upsample_like(d5, x)
+
+        d6 = self.side6(hx6)
+        d6 = _upsample_like(d6, x)
+
+        return [F.sigmoid(d1), F.sigmoid(d2), F.sigmoid(d3), F.sigmoid(d4), F.sigmoid(d5), F.sigmoid(d6)], [hx1d, hx2d,
+                                                                                                            hx3d, hx4d,
+                                                                                                            hx5d, hx6]

src/utils/exceptions.py

@@ -0,0 +1,16 @@
+import sys
+
+def error_message_detail(error):
+    _, _, exc_info = sys.exc_info()
+    filename = exc_info.tb_frame.f_code.co_filename
+    lineno = exc_info.tb_lineno
+    error_message = "Error encountered in line no [{}], filename : [{}], saying [{}]".format(lineno, filename, error)
+    return error_message
+
+class CustomException(Exception):
+    def __init__(self, error_message):
+        super().__init__(error_message)
+        self.error_message = error_message_detail(error_message)
+
+    def __str__(self) -> str:
+        return self.error_message

src/utils/logger.py

@@ -0,0 +1,22 @@
+import logging
+import os
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+
+log_dir = os.path.join(os.getcwd(), "logs")
+os.makedirs(log_dir, exist_ok=True)
+
+LOG_FILE = os.path.join(log_dir, "running_logs.log")
+
+logFormat = "[%(asctime)s: %(levelname)s: %(module)s: %(message)s]"
+logFormatter = logging.Formatter(fmt=logFormat, style="%")
+
+streamHandler = logging.StreamHandler()
+streamHandler.setFormatter(logFormatter)
+
+fileHandler = logging.FileHandler(filename=LOG_FILE)
+fileHandler.setFormatter(logFormatter)
+
+logger.addHandler(streamHandler)
+logger.addHandler(fileHandler)