add: new endpoint ntoctoconbined

src/api/nto_api.py

@@ -76,7 +76,7 @@ async def clothing_try_on_v2(image: UploadFile = File(...), clothing_type: str =
         return JSONResponse(status_code=500, content={"error": f"Error reading image", "code": 500})
 
     try:
-        mask = await pipeline.shoulderPointMaskGeneration_(image=image)
+        mask, _, _ = await pipeline.shoulderPointMaskGeneration_(image=image)
         logger.info(">>> MASK GENERATION COMPLETED <<<")
     except Exception as e:
         logger.error(f">>> MASK GENERATION ERROR: {str(e)} <<<")
@@ -129,60 +129,55 @@ async def clothing_try_on_v2(image: UploadFile = File(...), clothing_type: str =
 
 @nto_cto_router.post("/clothingTryOn")
 async def clothing_try_on(image: UploadFile = File(...),
-                         mask: UploadFile = File(...), 
-                         clothing_type: str = Form(...)):
+                          mask: UploadFile = File(...), clothing_type: str = Form(...)):
     logger.info("-" * 50)
     logger.info(">>> CLOTHING TRY ON STARTED <<<")
     start_time = time.time()
 
-    # Helper function to convert image to base64
-    def image_to_base64(img: Image.Image, format="WEBP", quality=85) -> str:
-        with BytesIO() as buffer:
-            img.save(buffer, format=format, quality=quality)
-            return f"data:image/{format.lower()};base64,{base64.b64encode(buffer.getvalue()).decode('utf-8')}"
-
     try:
-        # Load images concurrently using asyncio
-        image_data, mask_data = await asyncio.gather(
-            image.read(),
-            mask.read()
-        )
-        
-        image = Image.open(BytesIO(image_data)).convert("RGB")
-        mask = Image.open(BytesIO(mask_data)).convert("RGB")
+        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": "Error reading image or mask", "code": 500})
+        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 = Image.fromarray(
-            cv2.inpaint(np.array(image), arr_orig, 15, cv2.INPAINT_TELEA)
-        ).resize((512, 512))
+        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": "Error processing image or mask", "code": 500})
+        return JSONResponse(status_code=500,
+                            content={"error": f"Error processing image or mask", "code": 500})
 
     try:
-        mask_data_uri = image_to_base64(mask)
-        image_data_uri = image_to_base64(image)
+        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": "Error encoding images", "code": 500})
+        return JSONResponse(status_code=500,
+                            content={"error": f"Error encoding images", "code": 500})
 
-    input_data = {
+    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",
@@ -191,65 +186,33 @@ async def clothing_try_on(image: UploadFile = File(...),
     }
 
     try:
-        output = replicate_run_cto(input_data)
+        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": "Error running clothing try on", "code": 500}, status_code=500)
+        return JSONResponse(content={"error": f"Error running clothing try on", "code": 500}, status_code=500)
 
     try:
-        # Fetch the output image URL
-        output_url = output[0]
-        if not isinstance(output_url, str):
-            raise ValueError("Invalid output URL format from replicate")
-
-        # Download the output image
-        async with aiohttp.ClientSession() as session:
-            async with session.get(output_url) as response:
-                if response.status != 200:
-                    raise HTTPException(status_code=response.status, 
-                                     detail="Failed to fetch output image")
-                output_bytes = await response.read()
-        
-        # Process the output image
-        output_image = Image.open(BytesIO(output_bytes)).resize(actual_image.size)
-        
-        # Convert arrays and process final image
-        mask_array = np.array(Image.fromarray(arr_orig).convert("RGB"))
-        output_array = np.array(output_image)
-        
-        # Perform bitwise operations
-        mask_inverse = np.bitwise_not(mask_array)
-        intermediate = np.bitwise_and(output_array, mask_inverse)
-        result = Image.fromarray(np.bitwise_or(intermediate, np.array(jewellery_mask)))
-        
-        # Convert result to base64
-        result_base64 = image_to_base64(result)
-        
+        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": result_base64,
+            "output": f"data:image/WEBP;base64,{base_64_output}",
             "code": 200,
             "inference_time": total_inference_time
         }
-    except ValueError as ve:
-        logger.error(f">>> OUTPUT IMAGE PROCESSING ERROR: {str(ve)} <<<")
-        return JSONResponse(status_code=500, 
-                          content={"error": "Invalid response from image generation service", 
-                                 "code": 500})
     except Exception as e:
         logger.error(f">>> OUTPUT IMAGE PROCESSING ERROR: {str(e)} <<<")
-        return JSONResponse(status_code=500, 
-                          content={"error": "Error processing output image", 
-                                 "code": 500})
-    finally:
-        # Clean up resources
-        for var in ['output_image', 'output_array', 'intermediate', 'mask_array', 'mask_inverse']:
-            if var in locals():
-                del locals()[var]
-        gc.collect()
+        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 <<<")
@@ -257,7 +220,6 @@ async def clothing_try_on(image: UploadFile = File(...),
 
     return JSONResponse(content=response, status_code=200)
 
-
 @nto_cto_router.post("/productData/{storeId}")
 async def product_data(
         storeId: str,
@@ -501,11 +463,10 @@ async def necklace_try_on_id(necklace_try_on_id: NecklaceTryOnIDEntity = Depends
         # Upload both images concurrently
         upload_tasks = [
             supabase_upload_and_return_url(prefix="necklace_try_on", image=result),
-            supabase_upload_and_return_url(prefix="necklace_try_on_mask", image=mask)
         ]
-        result_url, mask_url = await asyncio.gather(*upload_tasks)
+        result_url = await asyncio.gather(*upload_tasks)
 
-        if not result_url or not mask_url:
+        if not result_url:
             raise Exception("Failed to upload one or both images")
 
         logger.info(f">>> RESULT IMAGES SAVED IN {round((time.time() - start_time_saving), 2)}s <<<")
@@ -519,11 +480,10 @@ async def necklace_try_on_id(necklace_try_on_id: NecklaceTryOnIDEntity = Depends
             response = {
                 "code": 200,
                 "output": f"{result_url}",
-                "mask": f"{mask_url}",
                 "inference_time": total_backend_time
             }
 
-    
+
 
         except Exception as e:
             logger.error(f">>> RESPONSE GENERATION ERROR: {str(e)} <<<")
@@ -534,7 +494,7 @@ async def necklace_try_on_id(necklace_try_on_id: NecklaceTryOnIDEntity = Depends
         logger.info("-" * 50)
 
         return JSONResponse(content=response, status_code=200)
-    
+
     finally:
         if 'result' in locals(): del result
         if 'mask' in locals(): del mask
@@ -654,3 +614,102 @@ async def necklace_try_on_with_points(necklace_try_on_id: NecklaceTryOnIDEntity
     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(...),
+        necklace: UploadFile = File(...),
+        clothing_type: str = Form(...)
+):
+    logger.info("-" * 50)
+    logger.info(">>> CLOTHING AND NECKLACE TRY ON STARTED <<<")
+    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 both images concurrently
+        person_bytes, necklace_bytes = await asyncio.gather(
+            image.read(),
+            necklace.read()
+        )
+
+        # Convert bytes to PIL Images
+        person_image = Image.open(BytesIO(person_bytes)).convert("RGB").resize((512, 512))
+        necklace_image = Image.open(BytesIO(necklace_bytes)).convert("RGBA")
+        logger.info(">>> IMAGES LOADED SUCCESSFULLY <<<")
+
+        # Generate mask and get shoulder points in one go
+        mask, left_point, right_point = await pipeline.shoulderPointMaskGeneration_(image=person_image)
+        logger.info(">>> MASK AND POINTS GENERATION COMPLETED <<<")
+
+        # Prepare base64 encodings concurrently
+        mask_data_uri, image_data_uri = await asyncio.gather(
+            asyncio.to_thread(image_to_base64, mask),
+            asyncio.to_thread(image_to_base64, person_image)
+        )
+
+        # Run CTO
+        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  # reduced from 25 for optimization
+        })
+
+        if not cto_output or not isinstance(cto_output, (list, tuple)) or not cto_output[0]:
+            raise ValueError("Invalid output from clothing try-on")
+
+        # Download CTO result
+        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()
+
+        # Process CTO result and perform NTO with points
+        with BytesIO(cto_result_bytes) as buf:
+            cto_result_image = Image.open(buf).convert("RGB")
+
+            # Use necklaceTryOnWithPoints directly with the points we already have
+            result, headerText, _ = await pipeline.necklaceTryOnWithPoints_(
+                image=cto_result_image,
+                jewellery=necklace_image,
+                left_shoulder=left_point,
+                right_shoulder=right_point,
+                storename="default"
+            )
+            result.show()
+
+            if result is None:
+                raise ValueError("Failed to process necklace try-on")
+
+            final_base64 = await asyncio.to_thread(image_to_base64, result)
+
+        logger.info(f"Left Shoulder: {left_point}, Right Shoulder: {right_point}")
+
+        response = {
+            "code": 200,
+            "output": final_base64,
+            "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)

src/components/necklaceTryOn.py

@@ -96,179 +96,48 @@ class NecklaceTryOn:
             logger.error(f"{CustomException(e)}:: {storename}")
             return [None, "error", None]
 
-    def necklaceTryOnV3(self, image: Image.Image, jewellery: Image.Image, storename: str) -> list[
-        Union[Image.Image, str]]:
+    def shoulderPointMaskGeneration(self, image: Image.Image) -> tuple[Image.Image, tuple[int, int], tuple[int, int]]:
         try:
-            logger.info(f">>> NECKLACE TRY ON STARTED :: {storename} <<<")
-
-            # reading the images
-            image, jewellery = image.convert("RGB"), jewellery.convert("RGBA")
-            image = np.array(image.resize((4000, 4000)))
+            image = np.array(image)
             copy_image = image.copy()
-            jewellery = np.array(jewellery)
-
-            logger.info(f"NECKLACE TRY ON :: detecting pose and landmarks :: {storename}")
 
+            logger.info("SHOULDER POINT MASK GENERATION :: detecting pose and landmarks")
             image = self.detector.findPose(image)
             lmList, _ = self.detector.findPosition(image, bboxWithHands=False, draw=False)
-            meshDetector = FaceMeshDetector(staticMode=True, maxFaces=1)
-            img, faces = meshDetector.findFaceMesh(image, draw=False)
-            left_lip_point = faces[0][61]
-            right_lip_point = faces[0][291]
-            pt12, pt11, pt10, pt9 = (
-                lmList[12][:2],
-                lmList[11][:2],
-                lmList[10][:2],
-                lmList[9][:2],
-            )
-
-            mid_lips = (
-                int((left_lip_point[0] + right_lip_point[0]) / 2), int((left_lip_point[1] + right_lip_point[1]) / 2))
-
-            mid_lips_x1 = int(pt12[0] + (mid_lips[0] - pt12[0]) / 2)
-            mid_lips_y1 = int(pt12[1] + (mid_lips[1] - pt12[1]) / 2)
-
-            mid_lips_x2 = int(pt11[0] + (mid_lips[0] - pt11[0]) / 2)
-            mid_lips_y2 = int(pt11[1] + (mid_lips[1] - pt11[1]) / 2)
-
-            # left right lip
-            left_right_lip_org_x11 = int(pt12[0] + (right_lip_point[0] - pt12[0]) / 2)
-            left_right_lip_org_y11 = int(pt12[1] + (right_lip_point[1] - pt12[1]) / 2)
-
-            left_right_lip_org_x12 = int(pt11[0] + (left_lip_point[0] - pt11[0]) / 2)
-            left_right_lip_org_y12 = int(pt11[1] + (left_lip_point[1] - pt11[1]) / 2)
-
-            # left right lip 2
-            left_right_lip_org_x21 = int(pt12[0] + (left_lip_point[0] - pt12[0]) / 2)
-            left_right_lip_org_y21 = int(pt12[1] + (left_lip_point[1] - pt12[1]) / 2)
-
-            left_right_lip_org_x22 = int(pt11[0] + (right_lip_point[0] - pt11[0]) / 2)
-            left_right_lip_org_y22 = int(pt11[1] + (right_lip_point[1] - pt11[1]) / 2)
-
-            logger.info(f"NECKLACE TRY ON :: estimating neck points :: {storename}")
-
-            avg_x1 = int((mid_lips_x1 + left_right_lip_org_x11 + left_right_lip_org_x21) / 3)
-            avg_y1 = int((mid_lips_y1 + left_right_lip_org_y11 + left_right_lip_org_y21) / 3)
-
-            avg_x2 = int((mid_lips_x2 + left_right_lip_org_x12 + left_right_lip_org_x22) / 3)
-            avg_y2 = int((mid_lips_y2 + left_right_lip_org_y12 + left_right_lip_org_y22) / 3)
-
-            logger.info(f"NECKLACE TRY ON :: scaling the necklace image :: {storename}")
-
-            if avg_y2 < avg_y1:
-                angle = math.ceil(
-                    self.detector.findAngle(
-                        p1=(avg_x2, avg_y2), p2=(avg_x1, avg_y1), p3=(avg_x2, avg_y1)
-                    )[0]
-                )
-            else:
-                angle = math.ceil(
-                    self.detector.findAngle(
-                        p1=(avg_x2, avg_y2), p2=(avg_x1, avg_y1), p3=(avg_x2, avg_y1)
-                    )[0]
-                )
-                angle = 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)
-            for offset_orig in range(image_gray.shape[1]):
-                pixel_value = image_gray[0, :][offset_orig]
-                if (pixel_value != 255) & (pixel_value != 0):
-                    break
-                else:
-                    continue
-            offset = int(0.8 * xdist * (offset_orig / 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
 
-            logger.info(f"NECKLACE TRY ON :: generating necklace placement status :: {storename}")
-
-            if extra > 0:
-                headerText = "To see more of the necklace, please step back slightly."
-            else:
-                headerText = "success"
-
-            logger.info(f"NECKLACE TRY ON :: generating output :: {storename}")
+            img, faces = self.meshDetector.findFaceMesh(image, draw=False)
+            leftLandmark, rightLandmark = faces[0][172], faces[0][397]
+            
+            # Using the same distance calculation as necklaceTryOn
+            landmarksDistance = np.linalg.norm(np.array(leftLandmark) - np.array(rightLandmark))
 
-            result = cvzone.overlayPNG(copy_image, jewellery, (avg_x1, y_coordinate))
-            image = Image.fromarray(result.astype(np.uint8))
-            logo = Image.open(returnBytesData(url=self.necklaceTryOnConfig.logoURL.format({storename})))
-            result = addWatermark(background=image, logo=logo)
+            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)
 
-            blackedNecklace = np.zeros(shape=copy_image.shape)
-            cvzone.overlayPNG(blackedNecklace, jewellery, (avg_x1, y_coordinate))
-            blackedNecklace = cv2.cvtColor(blackedNecklace.astype(np.uint8), cv2.COLOR_BGR2GRAY)
-            binaryMask = blackedNecklace * ((blackedNecklace > 5) * 255)
-            binaryMask[binaryMask >= 255] = 255
-            binaryMask[binaryMask < 255] = 0
+            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)
 
-            mask = Image.fromarray(binaryMask.astype(np.uint8)).convert("RGB")
+            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")
 
-            gc.collect()
+            left_point = (avg_x1, avg_y1)
+            right_point = (avg_x2, avg_y2)
 
-            return [result, headerText, mask]
+            return Image.fromarray(black_n_white_mask.astype(np.uint8)), left_point, right_point
 
         except Exception as e:
-            logger.error(f"{CustomException(e)}:: {storename}")
+            logger.error(f"SHOULDER POINT MASK GENERATION ERROR: {str(e)}")
             raise CustomException(e)
 
-    def shoulderPointMaskGeneration(self, image: Image.Image) -> Image.Image:
-        image = np.array(image)
-        copy_image = image.copy()
-
-        logger.info(f"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)
-        leftLandmarkIndex = 172
-        rightLandmarkIndex = 397
-
-        leftLandmark, rightLandmark = faces[0][leftLandmarkIndex], faces[0][rightLandmarkIndex]
-        landmarksDistance = int(
-            ((leftLandmark[0] - rightLandmark[0]) ** 2 + (leftLandmark[1] - rightLandmark[1]) ** 2) ** 0.5)
-
-        logger.info(f"SHOULDER POINT MASK GENERATION :: estimating neck points")
-
-        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)
-
-        offset = 50
-        avg_y1 -= offset
-        avg_y2 -= offset
-
-        logger.info(f"SHOULDER POINT MASK GENERATION :: generating shoulder point mask")
-
-        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")
-
-        return Image.fromarray(black_n_white_mask.astype(np.uint8))
-
     def canvasPoints(self, image: Image.Image, jewellery: Image.Image, storename: str) -> dict:
         try:
             logger.info(f">>> NECKLACE TRY ON STARTED :: {storename} <<<")

src/pipelines/completePipeline.py

@@ -13,9 +13,9 @@ class Pipeline:
                                                                        storename=storename)
         return [result, headerText, mask]
 
-    async def shoulderPointMaskGeneration_(self, image: Image.Image) -> Image.Image:
-        mask = self.necklaceTryOnObj.shoulderPointMaskGeneration(image=image)
-        return 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)