Upload 35 files

app/app.py

@@ -0,0 +1,71 @@
+from flask import Flask, request, jsonify, send_from_directory
+from flask_cors import CORS
+from genai import gen_vton
+from werkzeug.utils import secure_filename
+import os
+import tempfile
+
+#app = Flask(__name__)
+
+app = Flask(__name__, static_folder='processed_images')
+
+CORS(app, supports_credentials=True)
+#CORS(app, supports_credentials=True, resources={r"/*": {"origins": "*"}})  # Allow requests from any originorigins=["http://localhost:3000"])
+
+#CORS(app, resources={r"/proc": {"origins": "http://localhost:3000"}}, supports_credentials=True)
+#@app.route("/proc")
+@app.route('/proc', methods=['POST'])
+def process_images():
+    # Retrieve images from the request
+    print("Request came here")
+    print(request)
+    print(request.headers)
+    print(request.files)
+   
+    
+    user_image_t = request.files.get('userImage')
+    dress_image_t = request.files.get('dressImage')
+    #print(dress_image_t.filename)
+    print(user_image_t.filename)
+    #file = request.files['file']
+    if dress_image_t:
+        # Save the file to a temporary file
+        temp_dir = tempfile.gettempdir()
+        filename = secure_filename(dress_image_t.filename)
+        temp_path = os.path.join(temp_dir, filename)
+        dress_image_t.save(temp_path)
+    dress_image = temp_path
+    if user_image_t:
+        temp_dir = tempfile.gettempdir()
+        filename = secure_filename(user_image_t.filename)
+        temp_path_1 = os.path.join(temp_dir, filename)
+        user_image_t.save(temp_path_1)
+    user_image = temp_path_1
+
+    gen_vton(user_image, dress_image)
+    processed_image_1_path = './processed_images/output_image.jpg'
+    processed_image_2_path = './processed_images/output_image_1.jpg'
+    
+    # Save your images using the paths above...
+
+    # Return the URL for the saved images
+    url_to_processed_image_1 = request.host_url + processed_image_1_path
+    url_to_processed_image_2 = request.host_url + processed_image_2_path
+    # Process images...
+    # For the sake of this example, let's say the processing function returns two image URLs
+    processed_image_urls = [url_to_processed_image_1, url_to_processed_image_2]
+    os.remove(temp_path)
+    os.remove(temp_path_1)
+    return jsonify({'processedImages': processed_image_urls})
+
+@app.route('/processed_images/<filename>')
+def processed_images(filename):
+    print("request_came_here")
+    return send_from_directory(app.static_folder, filename)
+    # Example of generating a unique filename for the output
+   
+
+#    
+
+if __name__ == '__main__':
+    app.run()

app/gen_mask.py

@@ -0,0 +1,63 @@
+from transformers import SegformerImageProcessor, AutoModelForSemanticSegmentation
+from PIL import Image
+import requests
+import matplotlib.pyplot as plt
+import torch.nn as nn
+
+processor = SegformerImageProcessor.from_pretrained("mattmdjaga/segformer_b2_clothes")
+model = AutoModelForSemanticSegmentation.from_pretrained("mattmdjaga/segformer_b2_clothes")
+
+url = "https://plus.unsplash.com/premium_photo-1673210886161-bfcc40f54d1f?ixlib=rb-4.0.3&ixid=MnwxMjA3fDB8MHxzZWFyY2h8MXx8cGVyc29uJTIwc3RhbmRpbmd8ZW58MHx8MHx8&w=1000&q=80"
+
+#image = Image.open(requests.get(url, stream=True).raw)
+image_path = "C:/Users/Admin/Downloads/dress1.jpg"
+image = Image.open(image_path)
+                   
+inputs = processor(images=image, return_tensors="pt")
+
+outputs = model(**inputs)
+logits = outputs.logits.cpu()
+print("here")
+upsampled_logits = nn.functional.interpolate(
+    logits,
+    size=image.size[::-1],
+    mode="bilinear",
+    align_corners=False,
+)
+print(upsampled_logits.argmax(dim=1))
+
+pred_seg = upsampled_logits.argmax(dim=1)[0]
+plt.imshow(pred_seg)
+import matplotlib as mpl
+label_names = list(model.config.id2label)
+# Create a color map with the same number of colors as your labels
+# Use the updated method to get the colormap
+cmap = mpl.colormaps['tab20']
+
+# Create the figure and axes for the plot and the colorbar
+fig, ax = plt.subplots()
+
+# Display the segmentation
+im = ax.imshow(pred_seg, cmap=cmap)
+
+# Create a colorbar
+cbar = fig.colorbar(im, ax=ax, ticks=range(len(label_names)))
+cbar.ax.set_yticklabels(label_names)
+
+plt.show()
+
+# Get the number of labels
+n_labels = len(label_names)
+
+# Extract RGB values for each color in the colormap
+colors = cmap.colors[:n_labels]
+
+# Convert RGBA to RGB by omitting the Alpha value
+rgb_colors = [color[:3] for color in colors]
+
+# Create a dictionary mapping labels to RGB colors
+label_to_color = dict(zip(label_names, rgb_colors))
+
+# Display the mapping
+for label, color in label_to_color.items():
+    print(f"{label}: {color}")

app/genai.py

@@ -0,0 +1,167 @@
+
+
+# Or save the image
+#output_image.save("output_image.jpg")
+from os import device_encoding
+from diffusers import StableDiffusionInpaintPipeline
+from PIL import Image
+import torch
+import numpy as np
+import torch
+import gc
+from diffusers import StableDiffusionPipeline, StableDiffusionImg2ImgPipeline, StableDiffusionInpaintPipelineLegacy, DDIMScheduler, AutoencoderKL
+from PIL import Image
+#import pose_estimation as pe
+import requests
+from rembg import remove
+from transformers import BlipProcessor, BlipForConditionalGeneration
+import sys
+import os
+import subprocess
+sys.path.append(
+    os.path.join(os.path.dirname(__file__), "huggingface-cloth-segmentation"))
+
+from process import load_seg_model, get_palette, generate_mask
+
+
+device = 'cpu'
+
+
+
+def initialize_and_load_models():
+
+    checkpoint_path = 'model/cloth_segm.pth'
+    net = load_seg_model(checkpoint_path, device=device)    
+
+    return net
+
+net = initialize_and_load_models()
+palette = get_palette(4)
+
+
+def run(img):
+
+    cloth_seg = generate_mask(img, net=net, palette=palette, device=device)
+    return cloth_seg
+
+def image_caption(image_path, img_type):
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    processor = BlipProcessor.from_pretrained("noamrot/FuseCap")
+    model = BlipForConditionalGeneration.from_pretrained("noamrot/FuseCap").to(device)
+ 
+    raw_image = Image.open(image_path).convert('RGB')
+    if img_type == "dress":
+        raw_image = remove(raw_image)
+        print("bg removed")
+        raw_image.show
+    #raw_image = img_np_no_bg
+    
+    text = "a picture of "
+    inputs = processor(raw_image, text, return_tensors="pt").to(device)
+
+    out = model.generate(**inputs, num_beams = 3)
+    print(processor.decode(out[0], skip_special_tokens=True))
+    caption = processor.decode(out[0], skip_special_tokens=True)
+    return caption
+
+def gen_vton(image_input, dress_input):
+# Load the pre-trained model
+    pipe = StableDiffusionInpaintPipeline.from_pretrained(
+        "runwayml/stable-diffusion-inpainting",
+    #revision="fp16",  # Or "full" to disable
+        torch_dtype=torch.float32,  # Or torch.float32
+    )
+    image_path = image_input
+    #submodule_path =  os.path.join(os.path.dirname(__file__), "huggingface-cloth-segmentation/process.py")
+    
+    img_open = Image.open(image_path)
+#  
+    run(img_open) 
+    gen_mask_1 = "./huggingface-cloth-segmentation/output/alpha/1.png"
+    gen_mask_2 = "./huggingface-cloth-segmentation/output/alpha/2.png"
+    gen_mask_3 = "./huggingface-cloth-segmentation/output/alpha/3.png"
+    print("mask_generated")
+    if gen_mask_1:
+         mask_path = gen_mask_1
+    elif gen_mask_2:
+        mask_path = gen_mask_2
+    else:
+        mask_path = gen_mask_3
+
+    dress_path = dress_input
+    
+    image = Image.open(image_path)
+    mask = Image.open(mask_path) # Convert mask to grayscale
+#image = Image.open("/content/drive/MyDrive/train1/train/image/000025.jpg")
+#mask = Image.open("/content/drive/MyDrive/train1/train/image/000014.jpg")# Convert mask to grayscale
+#image = download_image(img_url).resize((512, 512))
+#mask = download_image(mask_url).resize((512, 512))
+
+#image = Image.open(image_path)
+#mask_image = Image.open(mask_path)
+    image = image.resize((512, 512))
+    mask = mask.resize((512, 512))
+# Define your prompt (text input)
+
+    user_caption = image_caption(image_path, "user")
+    dress_caption = image_caption(dress_path, "dress")
+    print(user_caption)
+    print(dress_caption)
+    prompt = " a human wearing a {dress_caption} "
+    neg_prompt = "{user_caption}"
+
+# Note: `image` and `mask_image` should be PIL images.
+# The mask structure is white for inpainting and black for keeping as is.
+# Replace `image` and `mask_image` with your actual images.
+
+    guidance_scale=7.5
+    denoising_strength=0.9
+    num_samples = 2
+    generator = torch.Generator(device="cpu")  # Explicitly create a CPU generator
+
+
+
+
+    images = pipe(
+        prompt=prompt,
+        negative_prompt=neg_prompt,
+        image=image,
+        mask_image=mask,
+        guidance_scale=guidance_scale,
+        denoising_strength=denoising_strength,
+        generator=generator,
+        num_images_per_prompt=num_samples,
+    ).images
+
+#Image_1 = pipe(prompt=prompt, image=image, mask_image=mask).images[0]
+
+
+#images[0] # Display the image
+
+#img = Image.open(images[0])
+#img.show()
+#img = Image.open(images[1])
+#img.show()
+
+#images[2].show
+# Or save the image
+    images[0].save("./processed_images/output_image.jpg")
+    images[1].save("./processed_images/output_image_1.jpg")
+
+    #images[2].save("output_image_2.jpg")
+    #images[3].save("output_image_3.jpg")
+    #images[3].save("output_image_4.jpg")
+ 
+
+#if app == "__main__":
+#gen_vton()
+#user_image = "C:/Users/Admin/Downloads/woman.jpg"
+#dress_image = "C:/Users/Admin/Downloads/dress1.jpg"
+#gen_vton(user_image, dress_image)
+
+def predict(dict, prompt):
+  image =  dict['image'].convert("RGB").resize((512, 512))
+  mask_image = dict['mask'].convert("RGB").resize((512, 512))
+  #images = pipe(prompt=prompt, image=image, mask_image=mask_image).images
+  return(images[0])
+     

app/huggingface-cloth-segmentation/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Alok Pandey
+
+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/huggingface-cloth-segmentation/README.md

@@ -0,0 +1,38 @@
+# Huggingface cloth segmentation using U2NET
+
+![Python 3.8](https://img.shields.io/badge/python-3.8-green.svg)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1LGgLiHiWcmpQalgazLgq4uQuVUm9ZM4M?usp=sharing)
+
+This repo contains inference code and gradio demo script using pre-trained U2NET model for Cloths Parsing from human portrait.</br>
+Here clothes are parsed into 3 category: Upper body(red), Lower body(green) and Full body(yellow). The provided script also generates alpha images for each class. 
+
+
+# Inference
+- clone the repo `git clone https://github.com/wildoctopus/huggingface-cloth-segmentation.git`.
+- Install dependencies `pip install -r requirements.txt`
+- Run `python process.py --image 'input/03615_00.jpg'` . **Script will automatically download the pretrained model**. 
+- Outputs will be saved in `output` folder.
+- `output/alpha/..` contains alpha images corresponding to each class.
+- `output/cloth_seg` contains final segmentation.
+- 
+
+# Gradio Demo
+- Run `python app.py`
+- Navigate to local or public url provided by app on successfull execution. 
+### OR 
+- Inference in colab from here [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1LGgLiHiWcmpQalgazLgq4uQuVUm9ZM4M?usp=sharing)
+
+# Huggingface Demo 
+- Check gradio demo on Huggingface space from here [huggingface-cloth-segmentation](https://huggingface.co/spaces/wildoctopus/cloth-segmentation).
+
+# Output samples
+![Sample 000](assets/1.png)
+![Sample 024](assets/2.png)
+
+
+This model works well with any background and almost all poses. 
+
+# Acknowledgements
+- U2net model is from original [u2net repo](https://github.com/xuebinqin/U-2-Net). Thanks to Xuebin Qin for amazing repo.
+- Most of the code is taken and modified from  [levindabhi/cloth-segmentation](https://github.com/levindabhi/cloth-segmentation)

app/huggingface-cloth-segmentation/app.py

@@ -0,0 +1,39 @@
+import PIL
+import torch
+import gradio as gr
+from process import load_seg_model, get_palette, generate_mask
+
+
+device = 'cpu'
+
+
+
+def initialize_and_load_models():
+
+    checkpoint_path = 'model/cloth_segm.pth'
+    net = load_seg_model(checkpoint_path, device=device)    
+
+    return net
+
+net = initialize_and_load_models()
+palette = get_palette(4)
+
+
+def run(img):
+
+    cloth_seg = generate_mask(img, net=net, palette=palette, device=device)
+    return cloth_seg
+
+# Define input and output interfaces
+input_image = gr.inputs.Image(label="Input Image", type="pil")
+
+# Define the Gradio interface
+cloth_seg_image = gr.outputs.Image(label="Cloth Segmentation", type="pil")
+
+title = "Demo for Cloth Segmentation"
+description = "An app for Cloth Segmentation"
+inputs = [input_image]
+outputs = [cloth_seg_image]
+
+
+gr.Interface(fn=run, inputs=inputs, outputs=outputs, title=title, description=description).launch(share=True)

app/huggingface-cloth-segmentation/model/cloth_segm.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f71fad2bc11789a996acc507d1a5a1602ae0edefc2b9aba1cd198be5cc9c1a44
+size 176625341

app/huggingface-cloth-segmentation/network.py

@@ -0,0 +1,560 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class REBNCONV(nn.Module):
+    def __init__(self, in_ch=3, out_ch=3, dirate=1):
+        super(REBNCONV, self).__init__()
+
+        self.conv_s1 = nn.Conv2d(
+            in_ch, out_ch, 3, padding=1 * dirate, dilation=1 * dirate
+        )
+        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.upsample(src, size=tar.shape[2:], mode="bilinear")
+
+    return src
+
+
+### RSU-7 ###
+class RSU7(nn.Module):  # UNet07DRES(nn.Module):
+    def __init__(self, in_ch=3, mid_ch=12, out_ch=3):
+        super(RSU7, 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.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):
+
+        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))
+
+        """
+        del hx1, hx2, hx3, hx4, hx5, hx6, hx7
+        del hx6d, hx5d, hx3d, hx2d
+        del hx2dup, hx3dup, hx4dup, hx5dup, hx6dup
+        """
+
+        return hx1d + hxin
+
+
+### RSU-6 ###
+class RSU6(nn.Module):  # UNet06DRES(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))
+
+        """
+        del hx1, hx2, hx3, hx4, hx5, hx6
+        del hx5d, hx4d, hx3d, hx2d
+        del hx2dup, hx3dup, hx4dup, hx5dup
+        """
+
+        return hx1d + hxin
+
+
+### RSU-5 ###
+class RSU5(nn.Module):  # UNet05DRES(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))
+
+        """
+        del hx1, hx2, hx3, hx4, hx5
+        del hx4d, hx3d, hx2d
+        del hx2dup, hx3dup, hx4dup
+        """
+
+        return hx1d + hxin
+
+
+### RSU-4 ###
+class RSU4(nn.Module):  # UNet04DRES(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))
+
+        """
+        del hx1, hx2, hx3, hx4
+        del hx3d, hx2d
+        del hx2dup, hx3dup
+        """
+
+        return hx1d + hxin
+
+
+### RSU-4F ###
+class RSU4F(nn.Module):  # UNet04FRES(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))
+
+        """
+        del hx1, hx2, hx3, hx4
+        del hx3d, hx2d
+        """
+
+        return hx1d + hxin
+
+
+##### U^2-Net ####
+class U2NET(nn.Module):
+    def __init__(self, in_ch=3, out_ch=1):
+        super(U2NET, self).__init__()
+
+        self.stage1 = RSU7(in_ch, 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
+
+        # stage 1
+        hx1 = self.stage1(hx)
+        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)
+
+        d2 = self.side2(hx2d)
+        d2 = _upsample_like(d2, d1)
+
+        d3 = self.side3(hx3d)
+        d3 = _upsample_like(d3, d1)
+
+        d4 = self.side4(hx4d)
+        d4 = _upsample_like(d4, d1)
+
+        d5 = self.side5(hx5d)
+        d5 = _upsample_like(d5, d1)
+
+        d6 = self.side6(hx6)
+        d6 = _upsample_like(d6, d1)
+
+        d0 = self.outconv(torch.cat((d1, d2, d3, d4, d5, d6), 1))
+
+        """
+        del hx1, hx2, hx3, hx4, hx5, hx6
+        del hx5d, hx4d, hx3d, hx2d, hx1d
+        del hx6up, hx5dup, hx4dup, hx3dup, hx2dup
+        """
+
+        return d0, d1, d2, d3, d4, d5, d6
+
+
+### U^2-Net small ###
+class U2NETP(nn.Module):
+    def __init__(self, in_ch=3, out_ch=1):
+        super(U2NETP, self).__init__()
+
+        self.stage1 = RSU7(in_ch, 16, 64)
+        self.pool12 = nn.MaxPool2d(2, stride=2, ceil_mode=True)
+
+        self.stage2 = RSU6(64, 16, 64)
+        self.pool23 = nn.MaxPool2d(2, stride=2, ceil_mode=True)
+
+        self.stage3 = RSU5(64, 16, 64)
+        self.pool34 = nn.MaxPool2d(2, stride=2, ceil_mode=True)
+
+        self.stage4 = RSU4(64, 16, 64)
+        self.pool45 = nn.MaxPool2d(2, stride=2, ceil_mode=True)
+
+        self.stage5 = RSU4F(64, 16, 64)
+        self.pool56 = nn.MaxPool2d(2, stride=2, ceil_mode=True)
+
+        self.stage6 = RSU4F(64, 16, 64)
+
+        # decoder
+        self.stage5d = RSU4F(128, 16, 64)
+        self.stage4d = RSU4(128, 16, 64)
+        self.stage3d = RSU5(128, 16, 64)
+        self.stage2d = RSU6(128, 16, 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(64, out_ch, 3, padding=1)
+        self.side4 = nn.Conv2d(64, out_ch, 3, padding=1)
+        self.side5 = nn.Conv2d(64, out_ch, 3, padding=1)
+        self.side6 = nn.Conv2d(64, out_ch, 3, padding=1)
+
+        self.outconv = nn.Conv2d(6 * out_ch, out_ch, 1)
+
+    def forward(self, x):
+
+        hx = x
+
+        # stage 1
+        hx1 = self.stage1(hx)
+        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)
+
+        d2 = self.side2(hx2d)
+        d2 = _upsample_like(d2, d1)
+
+        d3 = self.side3(hx3d)
+        d3 = _upsample_like(d3, d1)
+
+        d4 = self.side4(hx4d)
+        d4 = _upsample_like(d4, d1)
+
+        d5 = self.side5(hx5d)
+        d5 = _upsample_like(d5, d1)
+
+        d6 = self.side6(hx6)
+        d6 = _upsample_like(d6, d1)
+
+        d0 = self.outconv(torch.cat((d1, d2, d3, d4, d5, d6), 1))
+
+
+        return d0, d1, d2, d3, d4, d5, d6

app/huggingface-cloth-segmentation/options.py

@@ -0,0 +1,12 @@
+import os.path as osp
+import os
+
+
+class parser(object):
+    def __init__(self):
+        
+        self.output = "./output"  # output image folder path  
+        self.logs_dir = './logs'
+        self.device = 'cuda:0'
+
+opt = parser()

app/huggingface-cloth-segmentation/process.py

@@ -0,0 +1,190 @@
+from network import U2NET
+
+import os
+from PIL import Image
+import cv2
+import gdown
+import argparse
+import numpy as np
+
+import torch
+import torch.nn.functional as F
+import torchvision.transforms as transforms
+
+from collections import OrderedDict
+from options import opt
+
+
+def load_checkpoint(model, checkpoint_path):
+    if not os.path.exists(checkpoint_path):
+        print("----No checkpoints at given path----")
+        return
+    model_state_dict = torch.load(checkpoint_path, map_location=torch.device("cpu"))
+    new_state_dict = OrderedDict()
+    for k, v in model_state_dict.items():
+        name = k[7:]  # remove `module.`
+        new_state_dict[name] = v
+
+    model.load_state_dict(new_state_dict)
+    print("----checkpoints loaded from path: {}----".format(checkpoint_path))
+    return model
+
+
+def get_palette(num_cls):
+    """ Returns the color map for visualizing the segmentation mask.
+    Args:
+        num_cls: Number of classes
+    Returns:
+        The color map
+    """
+    n = num_cls
+    palette = [0] * (n * 3)
+    for j in range(0, n):
+        lab = j
+        palette[j * 3 + 0] = 0
+        palette[j * 3 + 1] = 0
+        palette[j * 3 + 2] = 0
+        i = 0
+        while lab:
+            palette[j * 3 + 0] |= (((lab >> 0) & 1) << (7 - i))
+            palette[j * 3 + 1] |= (((lab >> 1) & 1) << (7 - i))
+            palette[j * 3 + 2] |= (((lab >> 2) & 1) << (7 - i))
+            i += 1
+            lab >>= 3
+    return palette
+
+
+class Normalize_image(object):
+    """Normalize given tensor into given mean and standard dev
+
+    Args:
+        mean (float): Desired mean to substract from tensors
+        std (float): Desired std to divide from tensors
+    """
+
+    def __init__(self, mean, std):
+        assert isinstance(mean, (float))
+        if isinstance(mean, float):
+            self.mean = mean
+
+        if isinstance(std, float):
+            self.std = std
+
+        self.normalize_1 = transforms.Normalize(self.mean, self.std)
+        self.normalize_3 = transforms.Normalize([self.mean] * 3, [self.std] * 3)
+        self.normalize_18 = transforms.Normalize([self.mean] * 18, [self.std] * 18)
+
+    def __call__(self, image_tensor):
+        if image_tensor.shape[0] == 1:
+            return self.normalize_1(image_tensor)
+
+        elif image_tensor.shape[0] == 3:
+            return self.normalize_3(image_tensor)
+
+        elif image_tensor.shape[0] == 18:
+            return self.normalize_18(image_tensor)
+
+        else:
+            assert "Please set proper channels! Normlization implemented only for 1, 3 and 18"
+
+
+
+
+def apply_transform(img):
+    transforms_list = []
+    transforms_list += [transforms.ToTensor()]
+    transforms_list += [Normalize_image(0.5, 0.5)]
+    transform_rgb = transforms.Compose(transforms_list)
+    return transform_rgb(img)
+
+
+
+def generate_mask(input_image, net, palette, device = 'cpu'):
+
+    #img = Image.open(input_image).convert('RGB')
+    img = input_image
+    img_size = img.size
+    img = img.resize((768, 768), Image.BICUBIC)
+    image_tensor = apply_transform(img)
+    image_tensor = torch.unsqueeze(image_tensor, 0)
+
+    alpha_out_dir = os.path.join(opt.output,'alpha')
+    cloth_seg_out_dir = os.path.join(opt.output,'cloth_seg')
+
+    os.makedirs(alpha_out_dir, exist_ok=True)
+    os.makedirs(cloth_seg_out_dir, exist_ok=True)
+
+    with torch.no_grad():
+        output_tensor = net(image_tensor.to(device))
+        output_tensor = F.log_softmax(output_tensor[0], dim=1)
+        output_tensor = torch.max(output_tensor, dim=1, keepdim=True)[1]
+        output_tensor = torch.squeeze(output_tensor, dim=0)
+        output_arr = output_tensor.cpu().numpy()
+
+    classes_to_save = []
+
+    # Check which classes are present in the image
+    for cls in range(1, 4):  # Exclude background class (0)
+        if np.any(output_arr == cls):
+            classes_to_save.append(cls)
+
+    # Save alpha masks
+    for cls in classes_to_save:
+        alpha_mask = (output_arr == cls).astype(np.uint8) * 255
+        alpha_mask = alpha_mask[0]  # Selecting the first channel to make it 2D
+        alpha_mask_img = Image.fromarray(alpha_mask, mode='L')
+        alpha_mask_img = alpha_mask_img.resize(img_size, Image.BICUBIC)
+        alpha_mask_img.save(os.path.join(alpha_out_dir, f'{cls}.png'))
+
+    # Save final cloth segmentations
+    cloth_seg = Image.fromarray(output_arr[0].astype(np.uint8), mode='P')
+    cloth_seg.putpalette(palette)
+    cloth_seg = cloth_seg.resize(img_size, Image.BICUBIC)
+    cloth_seg.save(os.path.join(cloth_seg_out_dir, 'final_seg.png'))
+    return cloth_seg
+
+
+
+def check_or_download_model(file_path):
+    if not os.path.exists(file_path):
+        os.makedirs(os.path.dirname(file_path), exist_ok=True)
+        url = "https://drive.google.com/uc?id=11xTBALOeUkyuaK3l60CpkYHLTmv7k3dY"
+        gdown.download(url, file_path, quiet=False)
+        print("Model downloaded successfully.")
+    else:
+        print("Model already exists.")
+
+
+def load_seg_model(checkpoint_path, device='cpu'):
+    net = U2NET(in_ch=3, out_ch=4)
+    check_or_download_model(checkpoint_path)
+    net = load_checkpoint(net, checkpoint_path)
+    net = net.to(device)
+    net = net.eval()
+
+    return net
+
+
+def main(args):
+
+    device = 'cuda:0' if args.cuda else 'cpu'
+
+    # Create an instance of your model
+    model = load_seg_model(args.checkpoint_path, device=device)
+
+    palette = get_palette(4)
+
+    img = Image.open(args.image).convert('RGB')
+
+    cloth_seg = generate_mask(img, net=model, palette=palette, device=device)
+
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description='Help to set arguments for Cloth Segmentation.')
+    parser.add_argument('--image', type=str, help='Path to the input image')
+    parser.add_argument('--cuda', action='store_true', help='Enable CUDA (default: False)')
+    parser.add_argument('--checkpoint_path', type=str, default='model/cloth_segm.pth', help='Path to the checkpoint file')
+    args = parser.parse_args()
+
+    main(args)

app/huggingface-cloth-segmentation/requirements.txt

@@ -0,0 +1,7 @@
+torch
+torchvision
+gradio
+gdown
+Pillow
+opencv-python
+numpy

app/main.py

@@ -0,0 +1,71 @@
+from flask import Flask, request, jsonify, send_from_directory
+from flask_cors import CORS
+from genai import gen_vton
+from werkzeug.utils import secure_filename
+import os
+import tempfile
+
+#app = Flask(__name__)
+
+app = Flask(__name__, static_folder='processed_images')
+
+CORS(app, supports_credentials=True)
+#CORS(app, supports_credentials=True, resources={r"/*": {"origins": "*"}})  # Allow requests from any originorigins=["http://localhost:3000"])
+
+#CORS(app, resources={r"/proc": {"origins": "http://localhost:3000"}}, supports_credentials=True)
+#@app.route("/proc")
+@app.route('/proc', methods=['POST'])
+def process_images():
+    # Retrieve images from the request
+    print("Request came here")
+    print(request)
+    print(request.headers)
+    print(request.files)
+   
+    
+    user_image_t = request.files.get('userImage')
+    dress_image_t = request.files.get('dressImage')
+    #print(dress_image_t.filename)
+    print(user_image_t.filename)
+    #file = request.files['file']
+    if dress_image_t:
+        # Save the file to a temporary file
+        temp_dir = tempfile.gettempdir()
+        filename = secure_filename(dress_image_t.filename)
+        temp_path = os.path.join(temp_dir, filename)
+        dress_image_t.save(temp_path)
+    dress_image = temp_path
+    if user_image_t:
+        temp_dir = tempfile.gettempdir()
+        filename = secure_filename(user_image_t.filename)
+        temp_path_1 = os.path.join(temp_dir, filename)
+        user_image_t.save(temp_path_1)
+    user_image = temp_path_1
+
+    gen_vton(user_image, dress_image)
+    processed_image_1_path = './processed_images/output_image.jpg'
+    processed_image_2_path = './processed_images/output_image_1.jpg'
+    
+    # Save your images using the paths above...
+
+    # Return the URL for the saved images
+    url_to_processed_image_1 = request.host_url + processed_image_1_path
+    url_to_processed_image_2 = request.host_url + processed_image_2_path
+    # Process images...
+    # For the sake of this example, let's say the processing function returns two image URLs
+    processed_image_urls = [url_to_processed_image_1, url_to_processed_image_2]
+    os.remove(temp_path)
+    os.remove(temp_path_1)
+    return jsonify({'processedImages': processed_image_urls})
+
+@app.route('/processed_images/<filename>')
+def processed_images(filename):
+    print("request_came_here")
+    return send_from_directory(app.static_folder, filename)
+    # Example of generating a unique filename for the output
+   
+
+#    
+
+if __name__ == '__main__':
+    app.run(debug=True, host='0.0.0.0')

app/model/cloth_segm.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f71fad2bc11789a996acc507d1a5a1602ae0edefc2b9aba1cd198be5cc9c1a44
+size 176625341