UPLOAD: code upload

.gitignore

@@ -0,0 +1,162 @@
+# 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
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .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
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__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
+.spyproject
+
+# 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
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Rauhan Ahmed Siddiqui
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

app.py

@@ -0,0 +1,52 @@
+from src.pipelines.completePipeline import Pipeline
+from src.utils.functions import getImages
+import gradio as gr
+
+# initializing the pipeline for clothing and necklace try-ons
+pipeline = Pipeline()
+
+# loading a set of images for examples
+allImages = getImages(nImages = 100)
+
+# creating a Gradio interface using Blocks
+with gr.Blocks(title = "GemFit") as interface:
+    # Row for input images
+    with gr.Row():
+        inputImage = gr.Image(label = "Input Image", type = "pil", image_mode = "RGB", interactive = True)
+        selectedNecklace = gr.Image(label = "Selected Necklace", type = "pil", image_mode = "RGBA", visible = False)
+        necklaceTryOn = gr.Image(label = "Necklace Try-On", type = "pil", interactive = False)
+
+    # Row for model examples
+    with gr.Row():
+        gr.Examples(examples = allImages["models"], inputs = [inputImage], label = "Models")
+
+    # Row for choker examples
+    with gr.Row():
+        gr.Examples(examples = allImages["chokers"], inputs = [selectedNecklace], label = "Chokers")
+
+    # Row for short necklace examples
+    with gr.Row():
+        gr.Examples(examples = allImages["shortNecklaces"], inputs = [selectedNecklace], label = "Short Necklaces")
+
+    # Row for long necklace examples
+    with gr.Row():
+        gr.Examples(examples = allImages["longNecklaces"], inputs = [selectedNecklace], label = "Long Necklaces")
+
+    # Row for output images
+    with gr.Row():
+        outputOne = gr.Image(label = "Output 1", interactive = False)
+        outputTwo = gr.Image(label = "Output 2", interactive = False)
+        outputThree = gr.Image(label = "Output 3", interactive = False)
+
+    # Row for the submit button
+    with gr.Row():
+        submit = gr.Button("Enter")
+
+    # Connect input changes to the necklace try-on function
+    selectedNecklace.change(fn = pipeline.necklaceTryOn, inputs = [inputImage, selectedNecklace], outputs = [necklaceTryOn])
+    
+    # Connect the submit button to the clothing try-on function
+    submit.click(fn = pipeline.clothingTryOn, inputs = [inputImage, selectedNecklace], outputs = [outputOne, outputTwo, outputThree])
+
+# Launch the Gradio interface with debug mode enabled
+interface.launch(server_name = "0.0.0.0", server_port = 7860)

config.ini

@@ -0,0 +1,6 @@
+[CLOTHING TRY ON]
+device = cuda
+modelId = stabilityai/stable-diffusion-2-inpainting
+
+[NECKLACE TRY ON]
+offsetFactor = 0.8

requirements.txt

@@ -0,0 +1,10 @@
+appwrite==7.0.0
+cvzone==1.6.1
+diffusers==0.30.3
+gradio==5.1.0
+mediapipe==0.10.15
+numpy==1.26.4
+opencv-python==4.10.0.84
+pillow==10.4.0
+torch
+transformers==4.44.2

setup.py

@@ -0,0 +1,17 @@
+from setuptools import setup, find_packages
+
+HYPEN_E_DOT = "-e ."
+def getRequirements() -> list[str]:
+    with open("requirements.txt", "r") as file:
+        requirements = file.read().split("\n")
+    requirements.remove(HYPEN_E_DOT)
+    return requirements
+
+setup(
+    name = "GemFit",
+    version = "0.1",
+    author = "Rauhan Ahmed Siddiqui",
+    author_email = "rauhaan.siddiqui@gmail.com",
+    packages = find_packages(where = "."), 
+    requires = getRequirements()
+)

src/components/clothingTryOn.py

@@ -0,0 +1,228 @@
+from diffusers import StableDiffusionInpaintPipeline
+from src.utils.exceptions import CustomException
+from cvzone.PoseModule import PoseDetector
+from src.utils.functions import getConfig
+from src.utils.logger import logger
+from PIL.ImageOps import grayscale
+from PIL import Image
+import numpy as np
+import cvzone
+import torch
+import math
+import cv2
+import gc
+
+class ClothingTryOn:
+    """
+    A class to simulate clothing try-ons by overlaying clothing images on user images 
+    and generating modified outputs using inpainting techniques.
+
+    This class utilizes a pose detection model to identify key landmarks on the user's 
+    body, allowing for accurate placement and scaling of clothing images. It integrates 
+    with a Stable Diffusion model for image generation, providing realistic visual 
+    outputs based on specified prompts while ensuring that jewelry and accessories 
+    do not interfere with the clothing representation.
+
+    Attributes:
+        detector (PoseDetector): An instance of PoseDetector for identifying body landmarks.
+        config (ConfigParser): Configuration settings loaded from an external config file.
+        pipeline (StableDiffusionInpaintPipeline): The Stable Diffusion inpainting model for 
+            generating images based on user prompts and masks.
+
+    Methods:
+        getBinaryMask(image: Image.Image, jewellery: Image.Image) -> tuple[Image.Image]:
+            Generates a binary mask indicating the presence of the clothing on the user's image.
+        
+        generateImage(image: Image.Image, mask: Image.Image) -> tuple[Image.Image]:
+            Applies inpainting to an image using the provided binary mask, generating new images 
+            based on specific color prompts while excluding jewelry and accessories.
+    """
+
+    def __init__(self):
+        """Initialize the NecklaceTryOn class with a PoseDetector and configuration settings."""
+        self.detector = PoseDetector()
+        self.config = getConfig("config.ini")
+        modelId = self.config.get("CLOTHING TRY ON", "modelId")
+        device = self.config.get("CLOTHING TRY ON", "device")
+        self.pipeline = StableDiffusionInpaintPipeline.from_pretrained(
+            modelId, torch_dtype = torch.float16
+        ).to(device)
+
+    def getBinaryMask(self, image: Image.Image, jewellery: Image.Image) -> tuple[Image.Image]:
+        """
+        Generate a binary mask indicating the presence of the necklace on the user's image.
+
+        This function overlays a jewelry image on the user's image and creates a binary mask, where
+        the necklace is represented in white and the background in black.
+
+        Args:
+            image (Image.Image): The user's image, ideally captured in a standing, upright position.
+            jewellery (Image.Image): The image of the jewelry piece (e.g., necklace) to be overlaid.
+
+        Returns:
+            tuple[Image.Image]: A tuple containing:
+                - The first image as the necklace try-on output.
+                - The second image as the binary mask, with the necklace shown in white and the background in black.
+
+        Raises:
+            CustomException: If an error occurs during the image processing.
+        """
+        try:
+            logger.info("converting images to numpy arrays")
+            image = np.array(image)
+            jewellery = np.array(jewellery)
+
+            logger.info("creating a copy of original image for actual overlay")
+            copyImage = image.copy()
+            
+            logger.info("detecting body landmarks from the input image")
+            image = self.detector.findPose(image)
+            lmList, _ = self.detector.findPosition(image, bboxWithHands = False, draw = False)
+            pt12, pt11, pt10, pt9 = (
+                lmList[12][:2],
+                lmList[11][:2],
+                lmList[10][:2],
+                lmList[9][:2],
+            )        
+
+            logger.info("calculating the precise neck points")
+            avgX1 = int(pt12[0] + (pt10[0] - pt12[0]) / 1.75)
+            avgY1 = int(pt12[1] - (pt12[1] - pt10[1]) / 1.75)
+            avgX2 = int(pt11[0] - (pt11[0] - pt9[0]) / 1.75)
+            avgY2 = int(pt11[1] - (pt11[1] - pt9[1]) / 1.75)
+
+            logger.info("rescaling the necklace to appropriate dimensions")
+            xDist = avgX2 - avgX1
+            origImgRatio = xDist / jewellery.shape[1]
+            yDist = jewellery.shape[0] * origImgRatio
+            jewellery = cv2.resize(
+                jewellery, (int(xDist), int(yDist)), interpolation = cv2.INTER_CUBIC
+            )        
+
+            logger.info("calculating required offset to be added to the necklace image for perfect fitting")
+            imageGray = cv2.cvtColor(jewellery, cv2.COLOR_BGRA2GRAY)
+            for offsetOrig in range(imageGray.shape[1]):
+                pixelValue = imageGray[0, :][offsetOrig]
+                if (pixelValue != 255) & (pixelValue != 0):
+                    break
+                else:
+                    continue
+            offset = int(self.config.getfloat("NECKLACE TRY ON", "offsetFactor") * xDist * (offsetOrig / jewellery.shape[1]))
+            yCoordinate = avgY1 - offset
+
+            logger.info("tilting the necklace image as per the necklace points")
+            angle = math.ceil(
+                self.detector.findAngle(
+                    p1 = (avgX2, avgY2), p2 = (avgX1, avgY1), p3 = (avgX2, avgY1)
+                )[0]
+            )
+            if avgY2 < avgY1:
+                pass
+            else:
+                angle = angle * -1
+            jewellery = cvzone.rotateImage(jewellery, angle)
+
+            logger.info("checking if the necklace is getting out of the frame and trimming from above if needed")
+            availableSpace = copyImage.shape[0] - yCoordinate
+            extra = jewellery.shape[0] - availableSpace
+
+            logger.info("applying the calculated settings")
+            if extra > 0:
+                jewellery = jewellery[extra + 10 :, :]
+                return self.getBinaryMask(
+                    Image.fromarray(copyImage), Image.fromarray(jewellery)
+                )
+            else:
+                tryOnOutput = cvzone.overlayPNG(copyImage, jewellery, (avgX1, yCoordinate))
+                tryOnOutput = Image.fromarray(tryOnOutput.astype(np.uint8))
+                blackedNecklace = np.zeros(shape = copyImage.shape)
+                cvzone.overlayPNG(blackedNecklace, jewellery, (avgX1, yCoordinate))
+                blackedNecklace = cv2.cvtColor(blackedNecklace.astype(np.uint8), cv2.COLOR_BGR2GRAY)
+                binaryMask = blackedNecklace * ((blackedNecklace > 5) * 255)
+                binaryMask[binaryMask >= 255] = 255
+                binaryMask[binaryMask < 255] = 0
+                binaryMask = Image.fromarray(binaryMask.astype(np.uint8))
+                return (tryOnOutput, binaryMask)
+
+        except Exception as e:
+            logger.error(CustomException(e))
+            print(CustomException(e))
+
+
+    def generateImage(self, image: Image.Image, mask: Image.Image) -> tuple[Image.Image]:
+        """
+        Apply inpainting to an image using the provided binary mask.
+
+        This function utilizes the binary mask to inpaint areas of the image, enhancing the visual output
+        by generating new images based on specific color prompts while excluding jewelry and other accessories.
+
+        Args:
+            image (Image.Image): The input image where inpainting will be applied.
+            mask (Image.Image): The binary mask indicating areas to be inpainted.
+
+        Returns:
+            tuple: A tuple containing three images generated based on different color prompts.
+
+        Raises:
+            CustomException: If an error occurs during the image processing.
+        """
+        try:
+            logger.info("creating a mask where the jewellery is represented")
+            jewelleryMask = Image.fromarray(np.bitwise_and(np.array(mask.convert("RGB")), np.array(image.convert("RGB"))))
+            arrOrig = np.array(grayscale(mask))
+
+            logger.info("inpainting the image using the original mask")
+            image = cv2.inpaint(np.array(image), arrOrig, 15, cv2.INPAINT_TELEA)
+            image = Image.fromarray(image)
+
+            logger.info("preparing the mask for processing")
+            arr = arrOrig.copy()
+            maskY = np.where(arr == arr[arr != 0][0])[0][0]
+            arr[maskY:, :] = 255
+            newMask = Image.fromarray(arr)
+            mask = newMask.copy()
+
+            logger.info("resizing images for consistency")
+            origSize = image.size
+            image = image.resize((512, 512))
+            mask = mask.resize((512, 512))
+
+            logger.info("generating images for different colors")
+            results = []
+            for colour in ["Red", "Blue", "Green"]:
+                prompt = f"{colour}, South Indian Saree, properly worn, natural setting, elegant, natural look, neckline without jewellery, simple"
+                negativePrompt = ("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, "
+                                "blurry, ugly")
+                output = self.pipeline(
+                    prompt = prompt,
+                    negative_prompt = negativePrompt,
+                    image = image,
+                    mask_image = mask,
+                    strength = 0.95,
+                    guidance_score = 9,
+                ).images[0]
+
+                logger.info("resizing the output to original size")
+                output = output.resize(origSize)
+                tempGenerated = np.bitwise_and(
+                    np.array(output),
+                    np.bitwise_not(np.array(Image.fromarray(arrOrig).convert("RGB"))),
+                )
+                results.append(tempGenerated)
+
+            logger.info("combining the results with the jewellery mask")
+            results = [
+                Image.fromarray(np.bitwise_or(x, np.array(jewelleryMask))) for x in results
+            ]
+
+            logger.info("Image generation completed successfully.")
+            gc.collect()
+            torch.cuda.empty_cache()
+            return (results[0], results[1], results[2])
+
+        except Exception as e:
+            logger.error(CustomException(e))
+            print(CustomException(e))

src/components/necklaceTryOn.py

@@ -0,0 +1,122 @@
+from src.utils.exceptions import CustomException
+from cvzone.PoseModule import PoseDetector
+from src.utils.functions import getConfig
+from src.utils.logger import logger
+from PIL import Image
+import numpy as np
+import cvzone
+import math
+import cv2
+
+class NecklaceTryOn:
+    """
+    A class for simulating the wearing of necklaces in images.
+
+    This class utilizes a pose detection algorithm to accurately overlay 
+    a necklace image onto a user's photo, adjusting for the user's neck 
+    position and orientation.
+
+    Attributes:
+        detector (PoseDetector): An instance of the PoseDetector for identifying 
+            body landmarks in images.
+        config (ConfigParser): Configuration settings loaded from a specified 
+            configuration file (config.ini).
+
+    Methods:
+        necklaceTryOn(image: Image.Image, jewellery: Image.Image) -> Image.Image:
+            Overlays a necklace onto the user's image based on detected pose 
+            landmarks and returns the resulting image.
+    """
+    
+    def __init__(self):
+        """Initialize the NecklaceTryOn class with a PoseDetector and configuration settings."""
+        self.detector = PoseDetector()
+        self.config = getConfig("config.ini")
+
+    def necklaceTryOn(self, image: Image.Image, jewellery: Image.Image) -> Image.Image:
+        """
+        Overlay a jewelry image onto a person's image to simulate wearing the jewelry.
+
+        Args:
+            image (Image.Image): The user's image, ideally captured in a standing, upright position.
+            jewellery (Image.Image): The image of the jewelry piece (e.g., necklace) to be overlaid.
+
+        Returns:
+            Image.Image: A PIL Image depicting the user wearing the specified jewelry.
+
+        Raises:
+            CustomException: If an error occurs during the image processing.
+        """
+        try:
+            logger.info("converting images to numpy arrays")
+            image = np.array(image)
+            jewellery = np.array(jewellery)
+
+            logger.info("creating a copy of original image for actual overlay")
+            copyImage = image.copy()
+            
+            logger.info("detecting body landmarks from the input image")
+            image = self.detector.findPose(image)
+            lmList, _ = self.detector.findPosition(image, bboxWithHands = False, draw = False)
+            pt12, pt11, pt10, pt9 = (
+                lmList[12][:2],
+                lmList[11][:2],
+                lmList[10][:2],
+                lmList[9][:2],
+            )        
+
+            logger.info("calculating the precise neck points")
+            avgX1 = int(pt12[0] + (pt10[0] - pt12[0]) / 1.75)
+            avgY1 = int(pt12[1] - (pt12[1] - pt10[1]) / 1.75)
+            avgX2 = int(pt11[0] - (pt11[0] - pt9[0]) / 1.75)
+            avgY2 = int(pt11[1] - (pt11[1] - pt9[1]) / 1.75)
+
+            logger.info("rescaling the necklace to appropriate dimensions")
+            xDist = avgX2 - avgX1
+            origImgRatio = xDist / jewellery.shape[1]
+            yDist = jewellery.shape[0] * origImgRatio
+            jewellery = cv2.resize(
+                jewellery, (int(xDist), int(yDist)), interpolation = cv2.INTER_CUBIC
+            )        
+
+            logger.info("calculating required offset to be added to the necklace image for perfect fitting")
+            imageGray = cv2.cvtColor(jewellery, cv2.COLOR_BGRA2GRAY)
+            for offsetOrig in range(imageGray.shape[1]):
+                pixelValue = imageGray[0, :][offsetOrig]
+                if (pixelValue != 255) & (pixelValue != 0):
+                    break
+                else:
+                    continue
+            offset = int(self.config.getfloat("NECKLACE TRY ON", "offsetFactor") * xDist * (offsetOrig / jewellery.shape[1]))
+            yCoordinate = avgY1 - offset
+
+            logger.info("tilting the necklace image as per the necklace points")
+            angle = math.ceil(
+                self.detector.findAngle(
+                    p1 = (avgX2, avgY2), p2 = (avgX1, avgY1), p3 = (avgX2, avgY1)
+                )[0]
+            )
+            if avgY2 < avgY1:
+                pass
+            else:
+                angle = angle * -1
+            jewellery = cvzone.rotateImage(jewellery, angle)
+
+            logger.info("checking if the necklace is getting out of the frame and trimming from above if needed")
+            availableSpace = copyImage.shape[0] - yCoordinate
+            extra = jewellery.shape[0] - availableSpace
+
+            logger.info("applying the calculated settings")
+            if extra > 0:
+                jewellery = jewellery[extra + 10 :, :]
+                return self.necklaceTryOn(
+                    Image.fromarray(copyImage), Image.fromarray(jewellery)
+                )
+            else:
+                result = cvzone.overlayPNG(copyImage, jewellery, (avgX1, yCoordinate))
+                result = Image.fromarray(result.astype(np.uint8))
+                return result
+        
+        except Exception as e:
+            logger.error(CustomException(e))
+            print(CustomException(e))

src/pipelines/completePipeline.py

@@ -0,0 +1,55 @@
+from src.components.necklaceTryOn import NecklaceTryOn
+from src.components.clothingTryOn import ClothingTryOn
+from PIL import Image
+
+class Pipeline:
+    """
+    A pipeline for performing jewelry and clothing try-on operations.
+
+    This class encapsulates the functionality for overlaying jewelry 
+    and clothing on user images using the NecklaceTryOn and ClothingTryOn
+    components.
+
+    Attributes:
+        necklaceTryOnObject (NecklaceTryOn): Instance for necklace try-on functionality.
+        clothingTryOnObject (ClothingTryOn): Instance for clothing try-on functionality.
+    """
+
+    def __init__(self):
+        """
+        Initializes the Pipeline with instances of NecklaceTryOn and ClothingTryOn.
+
+        This constructor sets up the necessary objects required for the 
+        try-on functionalities.
+        """
+        self.necklaceTryOnObject = NecklaceTryOn()
+        self.clothingTryOnObject = ClothingTryOn()
+
+    def necklaceTryOn(self, image: Image.Image, jewellery: Image.Image) -> Image.Image:
+        """
+        Overlay a necklace image onto the user's image.
+
+        Args:
+            image (Image.Image): The user's image, ideally captured in a standing position.
+            jewellery (Image.Image): The image of the necklace to be overlaid.
+
+        Returns:
+            Image.Image: A PIL Image depicting the user wearing the specified necklace.
+        """
+        result = self.necklaceTryOnObject.necklaceTryOn(image = image, jewellery = jewellery)
+        return result
+    
+    def clothingTryOn(self, image: Image.Image, jewellery: Image.Image) -> Image.Image:
+        """
+        Simulate wearing clothing on the user's image and generate the final output.
+
+        Args:
+            image (Image.Image): The user's image, ideally captured in a standing position.
+            jewellery (Image.Image): The image of the clothing item to be overlaid.
+
+        Returns:
+            Image.Image: A PIL Image depicting the user wearing the specified clothing.
+        """
+        tryOnOutput, mask = self.clothingTryOnObject.getBinaryMask(image = image, jewellery = jewellery)
+        results = self.clothingTryOnObject.generateImage(image = tryOnOutput, mask = mask)
+        return results

src/utils/exceptions.py

@@ -0,0 +1,19 @@
+import sys
+
+def error_message_detail(error):
+    """
+    Get exception information
+    """
+    _, _, 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)  # Call the parent class constructor
+        self.error_message = error_message_detail(error_message) 
+
+    def __str__(self) -> str:
+        return self.error_message 

src/utils/functions.py

@@ -0,0 +1,71 @@
+from appwrite.services.storage import Storage
+from appwrite.client import Client
+from appwrite.query import Query
+from io import BytesIO
+from PIL import Image
+import configparser
+import os
+
+
+def getImages(nImages: int) -> dict[str, list[Image.Image]]:
+    """
+    Retrieves images from the configured Appwrite S3 bucket.
+
+    Args:
+        nImages (int): The maximum number of images to retrieve from the bucket.
+
+    Returns:
+        dict[str, list[Image.Image]]: A dictionary where each key is a category (str) and each value is a list of PIL images (list[Image.Image]) belonging to that category.
+    """
+    # configuring the appwrite client
+    client = Client()
+    (client
+    .set_endpoint(os.environ["APPWRITE_ENDPOINT"]) 
+    .set_project(os.environ["APPWRITE_PROJECT_ID"]) 
+    .set_key(os.environ["APPWRITE_API_KEY"]) 
+    .set_self_signed()
+    .set_session("")
+    )
+
+    # retrieving names of all files from the storage bucket
+    storage = Storage(client)
+    allFiles = storage.list_files(bucket_id = os.environ["APPWRITE_BUCKET_ID"], queries = [Query.limit(nImages)])
+    allFiles = [file["$id"] for file in allFiles["files"]]
+    extractedData = {
+        "chokers": [x for x in allFiles if x.startswith("CH")],
+        "shortNecklaces": [x for x in allFiles if x.startswith("SN")],
+        "longNecklaces": [x for x in allFiles if x.startswith("LN")],
+        "models": [x for x in allFiles if x.startswith("MD")]
+    }
+    
+    # getting PIL images out of the files
+    extractedData = {
+        x: [
+            Image.open(
+                BytesIO(
+                    storage.get_file_view(
+                        bucket_id = os.environ["APPWRITE_BUCKET_ID"],
+                        file_id = y
+                    )
+                )
+            ) for y in extractedData[x]
+        ] for x in extractedData
+    }
+
+    return extractedData
+
+
+
+def getConfig(path: str):
+    """
+    Load configuration from a specified file.
+
+    Args:
+        path (str): The path to the configuration file.
+
+    Returns:
+        ConfigParser: The loaded configuration object.
+    """
+    config = configparser.ConfigParser()
+    config.read(path)
+    return config

src/utils/logger.py

@@ -0,0 +1,28 @@
+import logging
+import os
+
+# Create a logger instance
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.DEBUG)  
+
+# Define the directory for log files
+LOG_DIR = os.path.join(os.getcwd(), "logs")
+os.makedirs(LOG_DIR, exist_ok=True)  
+LOG_FILE = os.path.join(LOG_DIR, "runningLogs.log")
+
+# Initialize stream handler and file handler for console output
+streamHandler = logging.StreamHandler()
+fileHandler = logging.FileHandler(LOG_FILE)
+
+# Set the logging level for each handler
+streamHandler.setLevel(logging.INFO)  
+fileHandler.setLevel(logging.DEBUG)    
+
+# Configure the logging format for both handlers
+logFormatter = logging.Formatter("[%(asctime)s: %(levelname)s: %(module)s: %(message)s]")
+streamHandler.setFormatter(logFormatter)  
+fileHandler.setFormatter(logFormatter)    
+
+# Add the configured handlers to the logger
+logger.addHandler(streamHandler)
+logger.addHandler(fileHandler)