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 = "[email protected]",
+ 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)