Add files using upload-large-folder tool

VITON-Extends-Train/data/__init__.py

@@ -0,0 +1 @@
+# data_init

VITON-Extends-Train/data/aligned_dataset.py

@@ -0,0 +1,121 @@
+import os.path
+from data.base_dataset import BaseDataset, get_params, get_transform
+from data.image_folder import make_dataset
+from PIL import Image
+import torch
+import json
+import numpy as np
+import os.path as osp
+from PIL import ImageDraw
+
+
+class AlignedDataset(BaseDataset):
+    def initialize(self, opt):
+        self.opt = opt
+        self.root = opt.dataroot    
+        self.diction={}
+
+        if opt.isTrain or opt.use_encoded_image:
+            dir_A = '_A' if self.opt.label_nc == 0 else '_label'
+            self.dir_A = os.path.join(opt.dataroot, opt.phase + dir_A)
+            self.A_paths = sorted(make_dataset(self.dir_A))
+
+        self.fine_height=256
+        self.fine_width=192
+        self.radius=5
+
+        dir_B = '_B' if self.opt.label_nc == 0 else '_img'
+        self.dir_B = os.path.join(opt.dataroot, opt.phase + dir_B)  
+        self.B_paths = sorted(make_dataset(self.dir_B))
+
+        self.dataset_size = len(self.A_paths)
+
+        if opt.isTrain or opt.use_encoded_image:
+            dir_E = '_edge'
+            self.dir_E = os.path.join(opt.dataroot, opt.phase + dir_E)
+            self.E_paths = sorted(make_dataset(self.dir_E))
+
+        if opt.isTrain or opt.use_encoded_image:
+            dir_C = '_color'
+            self.dir_C = os.path.join(opt.dataroot, opt.phase + dir_C)
+            self.C_paths = sorted(make_dataset(self.dir_C))
+
+
+    def __getitem__(self, index):        
+
+        A_path = self.A_paths[index]
+        A = Image.open(A_path).convert('L')
+
+        params = get_params(self.opt, A.size)
+        if self.opt.label_nc == 0:
+            transform_A = get_transform(self.opt, params)
+            A_tensor = transform_A(A.convert('RGB'))
+        else:
+            transform_A = get_transform(self.opt, params, method=Image.NEAREST, normalize=False)
+            A_tensor = transform_A(A) * 255.0
+
+        B_path = self.B_paths[index]
+        B = Image.open(B_path).convert('RGB')
+        transform_B = get_transform(self.opt, params)      
+        B_tensor = transform_B(B)
+
+        C_path = self.C_paths[index]
+        C = Image.open(C_path).convert('RGB')
+        C_tensor = transform_B(C)
+
+        E_path = self.E_paths[index]
+        E = Image.open(E_path).convert('L')
+        E_tensor = transform_A(E)
+
+        index_un = np.random.randint(14221)
+        C_un_path = self.C_paths[index_un]
+        C_un = Image.open(C_un_path).convert('RGB')
+        C_un_tensor = transform_B(C_un)
+
+        E_un_path = self.E_paths[index_un]
+        E_un = Image.open(E_un_path).convert('L')
+        E_un_tensor = transform_A(E_un)
+
+        pose_name =B_path.replace('.png', '_keypoints.json').replace('.jpg','_keypoints.json').replace('train_img','train_pose')
+        with open(osp.join(pose_name), 'r') as f:
+            pose_label = json.load(f)
+            try:
+                pose_data = pose_label['people'][0]['pose_keypoints']
+            except IndexError:
+                pose_data = [0 for i in range(54)]
+            pose_data = np.array(pose_data)
+            pose_data = pose_data.reshape((-1,3))
+
+        point_num = pose_data.shape[0]
+        pose_map = torch.zeros(point_num, self.fine_height, self.fine_width)
+        r = self.radius
+        im_pose = Image.new('L', (self.fine_width, self.fine_height))
+        pose_draw = ImageDraw.Draw(im_pose)
+        for i in range(point_num):
+            one_map = Image.new('L', (self.fine_width, self.fine_height))
+            draw = ImageDraw.Draw(one_map)
+            pointx = pose_data[i,0]
+            pointy = pose_data[i,1]
+            if pointx > 1 and pointy > 1:
+                draw.rectangle((pointx-r, pointy-r, pointx+r, pointy+r), 'white', 'white')
+                pose_draw.rectangle((pointx-r, pointy-r, pointx+r, pointy+r), 'white', 'white')
+            one_map = transform_B(one_map.convert('RGB'))
+            pose_map[i] = one_map[0]
+        P_tensor=pose_map
+
+        densepose_name = B_path.replace('.png', '.npy').replace('.jpg','.npy').replace('train_img','train_densepose')
+        dense_mask = np.load(densepose_name).astype(np.float32)
+        dense_mask = transform_A(dense_mask)
+
+        if self.opt.isTrain:
+            input_dict = { 'label': A_tensor, 'image': B_tensor, 'path': A_path, 'img_path': B_path ,'color_path': C_path,'color_un_path': C_un_path,
+                            'edge': E_tensor, 'color': C_tensor, 'edge_un': E_un_tensor, 'color_un': C_un_tensor, 'pose':P_tensor, 'densepose':dense_mask
+                          }
+
+        return input_dict
+
+    def __len__(self):
+        return len(self.A_paths) // (self.opt.batchSize * self.opt.num_gpus) * (self.opt.batchSize * self.opt.num_gpus)
+
+    def name(self):
+        return 'AlignedDataset'

VITON-Extends-Train/data/base_data_loader.py

@@ -0,0 +1,13 @@
+class BaseDataLoader():
+    def __init__(self):
+        pass
+    
+    def initialize(self, opt):
+        self.opt = opt
+        pass
+
+    def load_data():
+        return None
+
+        
+        

VITON-Extends-Train/data/base_dataset.py

@@ -0,0 +1,116 @@
+import torch.utils.data as data
+from PIL import Image
+import torchvision.transforms as transforms
+import numpy as np
+import random
+
+class BaseDataset(data.Dataset):
+    def __init__(self):
+        super(BaseDataset, self).__init__()
+
+    def name(self):
+        return 'BaseDataset'
+
+    def initialize(self, opt):
+        pass
+
+def get_params(opt, size):
+    w, h = size
+    new_h = h
+    new_w = w
+    if opt.resize_or_crop == 'resize_and_crop':
+        new_h = new_w = opt.loadSize            
+    elif opt.resize_or_crop == 'scale_width_and_crop':
+        new_w = opt.loadSize
+        new_h = opt.loadSize * h // w
+
+    x = random.randint(0, np.maximum(0, new_w - opt.fineSize))
+    y = random.randint(0, np.maximum(0, new_h - opt.fineSize))
+    
+    #flip = random.random() > 0.5
+    flip = 0
+    return {'crop_pos': (x, y), 'flip': flip}
+
+def get_transform_resize(opt, params, method=Image.BICUBIC, normalize=True):
+    transform_list = []
+    transform_list.append(transforms.Lambda(lambda img: __scale_width(img, opt.loadSize, method)))
+    osize = [256,192]
+    transform_list.append(transforms.Scale(osize, method))
+    if 'crop' in opt.resize_or_crop:
+        transform_list.append(transforms.Lambda(lambda img: __crop(img, params['crop_pos'], opt.fineSize)))
+
+    if opt.resize_or_crop == 'none':
+        base = float(2 ** opt.n_downsample_global)
+        if opt.netG == 'local':
+            base *= (2 ** opt.n_local_enhancers)
+        transform_list.append(transforms.Lambda(lambda img: __make_power_2(img, base, method)))
+
+    if opt.isTrain and not opt.no_flip:
+        transform_list.append(transforms.Lambda(lambda img: __flip(img, params['flip'])))
+
+    transform_list += [transforms.ToTensor()]
+
+    if normalize:
+        transform_list += [transforms.Normalize((0.5, 0.5, 0.5),
+                                                (0.5, 0.5, 0.5))]
+    return transforms.Compose(transform_list)
+
+def get_transform(opt, params, method=Image.BICUBIC, normalize=True):
+    transform_list = []
+    if 'resize' in opt.resize_or_crop:
+        osize = [opt.loadSize, opt.loadSize]
+        transform_list.append(transforms.Scale(osize, method))   
+    elif 'scale_width' in opt.resize_or_crop:
+        transform_list.append(transforms.Lambda(lambda img: __scale_width(img, opt.loadSize, method)))
+        osize = [256,192]
+        transform_list.append(transforms.Scale(osize, method))  
+    if 'crop' in opt.resize_or_crop:
+        transform_list.append(transforms.Lambda(lambda img: __crop(img, params['crop_pos'], opt.fineSize)))
+
+    if opt.resize_or_crop == 'none':
+        base = float(2 ** opt.n_downsample_global)
+        if opt.netG == 'local':
+            base *= (2 ** opt.n_local_enhancers)
+        transform_list.append(transforms.Lambda(lambda img: __make_power_2(img, base, method)))
+
+    if opt.isTrain and not opt.no_flip:
+        transform_list.append(transforms.Lambda(lambda img: __flip(img, params['flip'])))
+
+    transform_list += [transforms.ToTensor()]
+
+    if normalize:
+        transform_list += [transforms.Normalize((0.5, 0.5, 0.5),
+                                                (0.5, 0.5, 0.5))]
+    return transforms.Compose(transform_list)
+
+def normalize():    
+    return transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
+
+def __make_power_2(img, base, method=Image.BICUBIC):
+    ow, oh = img.size        
+    h = int(round(oh / base) * base)
+    w = int(round(ow / base) * base)
+    if (h == oh) and (w == ow):
+        return img
+    return img.resize((w, h), method)
+
+def __scale_width(img, target_width, method=Image.BICUBIC):
+    ow, oh = img.size
+    if (ow == target_width):
+        return img    
+    w = target_width
+    h = int(target_width * oh / ow)    
+    return img.resize((w, h), method)
+
+def __crop(img, pos, size):
+    ow, oh = img.size
+    x1, y1 = pos
+    tw = th = size
+    if (ow > tw or oh > th):        
+        return img.crop((x1, y1, x1 + tw, y1 + th))
+    return img
+
+def __flip(img, flip):
+    if flip:
+        return img.transpose(Image.FLIP_LEFT_RIGHT)
+    return img

VITON-Extends-Train/data/custom_dataset_data_loader.py

@@ -0,0 +1,31 @@
+import torch.utils.data
+from data.base_data_loader import BaseDataLoader
+
+
+def CreateDataset(opt):
+    dataset = None
+    from data.aligned_dataset import AlignedDataset
+    dataset = AlignedDataset()
+
+    print("dataset [%s] was created" % (dataset.name()))
+    dataset.initialize(opt)
+    return dataset
+
+class CustomDatasetDataLoader(BaseDataLoader):
+    def name(self):
+        return 'CustomDatasetDataLoader'
+
+    def initialize(self, opt):
+        BaseDataLoader.initialize(self, opt)
+        self.dataset = CreateDataset(opt)
+        self.dataloader = torch.utils.data.DataLoader(
+            self.dataset,
+            batch_size=opt.batchSize,
+            shuffle=not opt.serial_batches,
+            num_workers=int(opt.nThreads))
+
+    def load_data(self):
+        return self.dataloader
+
+    def __len__(self):
+        return min(len(self.dataset), self.opt.max_dataset_size)

VITON-Extends-Train/data/data_loader.py

@@ -0,0 +1,6 @@
+def CreateDataLoader(opt):
+    from data.custom_dataset_data_loader import CustomDatasetDataLoader
+    data_loader = CustomDatasetDataLoader()
+    print(data_loader.name())
+    data_loader.initialize(opt)
+    return data_loader

VITON-Extends-Train/data/image_folder.py

@@ -0,0 +1,74 @@
+import torch.utils.data as data
+from PIL import Image
+import os
+
+IMG_EXTENSIONS = [
+    '.jpg', '.JPG', '.jpeg', '.JPEG',
+    '.png', '.PNG', '.ppm', '.PPM', '.bmp', '.BMP', '.tiff'
+]
+
+
+def is_image_file(filename):
+    return any(filename.endswith(extension) for extension in IMG_EXTENSIONS)
+
+def make_dataset(dir):
+    images = []
+    assert os.path.isdir(dir), '%s is not a valid directory' % dir
+
+    f = dir.split('/')[-1].split('_')[-1]
+    print (dir, f)
+    dirs= os.listdir(dir)
+    for img in dirs:
+
+        path = os.path.join(dir, img)
+        #print(path)
+        images.append(path)
+    return images
+
+def make_dataset_test(dir):
+    images = []
+    assert os.path.isdir(dir), '%s is not a valid directory' % dir
+
+    f = dir.split('/')[-1].split('_')[-1]
+    for i in range(len([name for name in os.listdir(dir) if os.path.isfile(os.path.join(dir, name))])):
+        if f == 'label' or f == 'labelref':
+            img = str(i) + '.png'
+        else:
+            img = str(i) + '.jpg'
+        path = os.path.join(dir, img)
+        #print(path)
+        images.append(path)
+    return images
+
+def default_loader(path):
+    return Image.open(path).convert('RGB')
+
+
+class ImageFolder(data.Dataset):
+
+    def __init__(self, root, transform=None, return_paths=False,
+                 loader=default_loader):
+        imgs = make_dataset(root)
+        if len(imgs) == 0:
+            raise(RuntimeError("Found 0 images in: " + root + "\n"
+                               "Supported image extensions are: " +
+                               ",".join(IMG_EXTENSIONS)))
+
+        self.root = root
+        self.imgs = imgs
+        self.transform = transform
+        self.return_paths = return_paths
+        self.loader = loader
+
+    def __getitem__(self, index):
+        path = self.imgs[index]
+        img = self.loader(path)
+        if self.transform is not None:
+            img = self.transform(img)
+        if self.return_paths:
+            return img, path
+        else:
+            return img
+
+    def __len__(self):
+        return len(self.imgs)

VITON-Extends-Train/models/__init__.py

@@ -0,0 +1 @@
+# model_init

VITON-Extends-Train/models/afwm.py

@@ -0,0 +1,273 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import numpy as np
+from options.train_options import TrainOptions
+from .correlation import correlation # the custom cost volume layer
+opt = TrainOptions().parse()
+
+def apply_offset(offset):
+    sizes = list(offset.size()[2:])
+    grid_list = torch.meshgrid([torch.arange(size, device=offset.device) for size in sizes])
+    grid_list = reversed(grid_list)
+    # apply offset
+    grid_list = [grid.float().unsqueeze(0) + offset[:, dim, ...]
+        for dim, grid in enumerate(grid_list)]
+    # normalize
+    grid_list = [grid / ((size - 1.0) / 2.0) - 1.0
+        for grid, size in zip(grid_list, reversed(sizes))] 
+
+    return torch.stack(grid_list, dim=-1)
+
+
+def TVLoss(x):
+    tv_h = x[:, :, 1:, :] - x[:, :, :-1, :]
+    tv_w = x[:, :, :, 1:] - x[:, :, :, :-1]
+
+    return torch.mean(torch.abs(tv_h)) + torch.mean(torch.abs(tv_w))
+
+
+# backbone 
+class ResBlock(nn.Module):
+    def __init__(self, in_channels):
+        super(ResBlock, self).__init__()
+        self.block = nn.Sequential(
+            nn.BatchNorm2d(in_channels),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(in_channels, in_channels, kernel_size=3, padding=1, bias=False),
+            nn.BatchNorm2d(in_channels),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(in_channels, in_channels, kernel_size=3, padding=1, bias=False)
+            )
+
+    def forward(self, x):
+        return self.block(x) + x
+
+
+class DownSample(nn.Module):
+    def __init__(self, in_channels, out_channels):
+        super(DownSample, self).__init__()
+        self.block=  nn.Sequential(
+            nn.BatchNorm2d(in_channels),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=2, padding=1, bias=False)
+            )
+
+    def forward(self, x):
+        return self.block(x)
+
+
+
+class FeatureEncoder(nn.Module):
+    def __init__(self, in_channels, chns=[64,128,256,256,256]):
+        # in_channels = 3 for images, and is larger (e.g., 17+1+1) for agnositc representation
+        super(FeatureEncoder, self).__init__()
+        self.encoders = []
+        for i, out_chns in enumerate(chns):
+            if i == 0:
+                encoder = nn.Sequential(DownSample(in_channels, out_chns),
+                                        ResBlock(out_chns),
+                                        ResBlock(out_chns))
+            else:
+                encoder = nn.Sequential(DownSample(chns[i-1], out_chns),
+                                         ResBlock(out_chns),
+                                         ResBlock(out_chns))
+            
+            self.encoders.append(encoder)
+
+        self.encoders = nn.ModuleList(self.encoders)
+
+
+    def forward(self, x):
+        encoder_features = []
+        for encoder in self.encoders:
+            x = encoder(x)
+            encoder_features.append(x)
+        return encoder_features
+
+class RefinePyramid(nn.Module):
+    def __init__(self, chns=[64,128,256,256,256], fpn_dim=256):
+        super(RefinePyramid, self).__init__()
+        self.chns = chns
+
+        # adaptive 
+        self.adaptive = []
+        for in_chns in list(reversed(chns)):
+            adaptive_layer = nn.Conv2d(in_chns, fpn_dim, kernel_size=1)
+            self.adaptive.append(adaptive_layer)
+        self.adaptive = nn.ModuleList(self.adaptive)
+        # output conv
+        self.smooth = []
+        for i in range(len(chns)):
+            smooth_layer = nn.Conv2d(fpn_dim, fpn_dim, kernel_size=3, padding=1)
+            self.smooth.append(smooth_layer)
+        self.smooth = nn.ModuleList(self.smooth)
+
+    def forward(self, x):
+        conv_ftr_list = x
+        
+        feature_list = []
+        last_feature = None
+        for i, conv_ftr in enumerate(list(reversed(conv_ftr_list))):
+            # adaptive
+            feature = self.adaptive[i](conv_ftr)
+            # fuse
+            if last_feature is not None:
+                feature = feature + F.interpolate(last_feature, scale_factor=2, mode='nearest')
+            # smooth
+            feature = self.smooth[i](feature)
+            last_feature = feature
+            feature_list.append(feature)
+
+        return tuple(reversed(feature_list))
+
+
+class AFlowNet(nn.Module):
+    def __init__(self, num_pyramid, fpn_dim=256):
+        super(AFlowNet, self).__init__()
+        self.netMain = []
+        self.netRefine = []
+        for i in range(num_pyramid):
+            netMain_layer = torch.nn.Sequential(
+                torch.nn.Conv2d(in_channels=49, out_channels=128, kernel_size=3, stride=1, padding=1),
+                torch.nn.LeakyReLU(inplace=False, negative_slope=0.1),
+                torch.nn.Conv2d(in_channels=128, out_channels=64, kernel_size=3, stride=1, padding=1),
+                torch.nn.LeakyReLU(inplace=False, negative_slope=0.1),
+                torch.nn.Conv2d(in_channels=64, out_channels=32, kernel_size=3, stride=1, padding=1),
+                torch.nn.LeakyReLU(inplace=False, negative_slope=0.1),
+                torch.nn.Conv2d(in_channels=32, out_channels=2, kernel_size=3, stride=1, padding=1)
+            )
+
+            netRefine_layer = torch.nn.Sequential(
+                torch.nn.Conv2d(2 * fpn_dim, out_channels=128, kernel_size=3, stride=1, padding=1),
+                torch.nn.LeakyReLU(inplace=False, negative_slope=0.1),
+                torch.nn.Conv2d(in_channels=128, out_channels=64, kernel_size=3, stride=1, padding=1),
+                torch.nn.LeakyReLU(inplace=False, negative_slope=0.1),
+                torch.nn.Conv2d(in_channels=64, out_channels=32, kernel_size=3, stride=1, padding=1),
+                torch.nn.LeakyReLU(inplace=False, negative_slope=0.1),
+                torch.nn.Conv2d(in_channels=32, out_channels=2, kernel_size=3, stride=1, padding=1)
+            )
+            self.netMain.append(netMain_layer)
+            self.netRefine.append(netRefine_layer)
+
+        self.netMain = nn.ModuleList(self.netMain)
+        self.netRefine = nn.ModuleList(self.netRefine)
+
+
+    def forward(self, x, x_edge, x_warps, x_conds, warp_feature=True):
+        last_flow = None
+        last_flow_all = []
+        delta_list = []
+        x_all = []
+        x_edge_all = []
+        cond_fea_all = []
+        delta_x_all = []
+        delta_y_all = []
+        filter_x = [[0, 0, 0],
+                    [1, -2, 1],
+                    [0, 0, 0]]
+        filter_y = [[0, 1, 0],
+                    [0, -2, 0],
+                    [0, 1, 0]]
+        filter_diag1 = [[1, 0, 0],
+                        [0, -2, 0],
+                        [0, 0, 1]]
+        filter_diag2 = [[0, 0, 1],
+                        [0, -2, 0],
+                        [1, 0, 0]]
+        weight_array = np.ones([3, 3, 1, 4])
+        weight_array[:, :, 0, 0] = filter_x
+        weight_array[:, :, 0, 1] = filter_y
+        weight_array[:, :, 0, 2] = filter_diag1
+        weight_array[:, :, 0, 3] = filter_diag2
+
+        weight_array = torch.cuda.FloatTensor(weight_array).permute(3,2,0,1)
+        self.weight = nn.Parameter(data=weight_array, requires_grad=False)
+
+        for i in range(len(x_warps)):
+              x_warp = x_warps[len(x_warps) - 1 - i]
+              x_cond = x_conds[len(x_warps) - 1 - i]
+              cond_fea_all.append(x_cond)
+
+              if last_flow is not None and warp_feature:
+                  x_warp_after = F.grid_sample(x_warp, last_flow.detach().permute(0, 2, 3, 1),
+                       mode='bilinear', padding_mode='border')
+              else:
+                  x_warp_after = x_warp
+
+              tenCorrelation = F.leaky_relu(input=correlation.FunctionCorrelation(tenFirst=x_warp_after, tenSecond=x_cond, intStride=1), negative_slope=0.1, inplace=False)
+              flow = self.netMain[i](tenCorrelation)
+              delta_list.append(flow)
+              flow = apply_offset(flow)
+              if last_flow is not None:
+                  flow = F.grid_sample(last_flow, flow, mode='bilinear', padding_mode='border')
+              else:
+                  flow = flow.permute(0, 3, 1, 2)
+
+              last_flow = flow
+              x_warp = F.grid_sample(x_warp, flow.permute(0, 2, 3, 1),mode='bilinear', padding_mode='border')
+              concat = torch.cat([x_warp,x_cond],1)
+              flow = self.netRefine[i](concat)
+              delta_list.append(flow)
+              flow = apply_offset(flow)
+              flow = F.grid_sample(last_flow, flow, mode='bilinear', padding_mode='border')
+
+              last_flow = F.interpolate(flow, scale_factor=2, mode='bilinear')
+              last_flow_all.append(last_flow)
+              cur_x = F.interpolate(x, scale_factor=0.5**(len(x_warps)-1-i), mode='bilinear')
+              cur_x_warp = F.grid_sample(cur_x, last_flow.permute(0, 2, 3, 1),mode='bilinear', padding_mode='border')
+              x_all.append(cur_x_warp)
+              cur_x_edge = F.interpolate(x_edge, scale_factor=0.5**(len(x_warps)-1-i), mode='bilinear')
+              cur_x_warp_edge = F.grid_sample(cur_x_edge, last_flow.permute(0, 2, 3, 1),mode='bilinear', padding_mode='zeros')
+              x_edge_all.append(cur_x_warp_edge)
+              flow_x,flow_y = torch.split(last_flow,1,dim=1)
+              delta_x = F.conv2d(flow_x, self.weight)
+              delta_y = F.conv2d(flow_y,self.weight)
+              delta_x_all.append(delta_x)
+              delta_y_all.append(delta_y)
+
+        x_warp = F.grid_sample(x, last_flow.permute(0, 2, 3, 1),
+                     mode='bilinear', padding_mode='border')
+        return x_warp, last_flow, cond_fea_all, last_flow_all, delta_list, x_all, x_edge_all, delta_x_all, delta_y_all
+
+
+class AFWM(nn.Module):
+
+    def __init__(self, opt, input_nc):
+        super(AFWM, self).__init__()
+        num_filters = [64,128,256,256,256]
+        self.image_features = FeatureEncoder(3, num_filters) 
+        self.cond_features = FeatureEncoder(input_nc, num_filters)
+        self.image_FPN = RefinePyramid(num_filters)
+        self.cond_FPN = RefinePyramid(num_filters)
+        self.aflow_net = AFlowNet(len(num_filters))
+        self.old_lr = opt.lr
+        self.old_lr_warp = opt.lr*0.2
+
+    def forward(self, cond_input, image_input, image_edge):
+        cond_pyramids = self.cond_FPN(self.cond_features(cond_input)) # maybe use nn.Sequential
+        image_pyramids = self.image_FPN(self.image_features(image_input))
+
+        x_warp, last_flow, last_flow_all, flow_all, delta_list, x_all, x_edge_all, delta_x_all, delta_y_all = self.aflow_net(image_input, image_edge, image_pyramids, cond_pyramids)
+
+        return x_warp, last_flow, last_flow_all, flow_all, delta_list, x_all, x_edge_all, delta_x_all, delta_y_all
+
+
+    def update_learning_rate(self,optimizer):
+        lrd = opt.lr / opt.niter_decay
+        lr = self.old_lr - lrd
+        for param_group in optimizer.param_groups:
+            param_group['lr'] = lr
+        if opt.verbose:
+            print('update learning rate: %f -> %f' % (self.old_lr, lr))
+        self.old_lr = lr
+
+    def update_learning_rate_warp(self,optimizer):
+        lrd = 0.2 * opt.lr / opt.niter_decay
+        lr = self.old_lr_warp - lrd
+        for param_group in optimizer.param_groups:
+            param_group['lr'] = lr
+        if opt.verbose:
+            print('update learning rate: %f -> %f' % (self.old_lr_warp, lr))
+        self.old_lr_warp = lr
+

VITON-Extends-Train/models/networks.py

@@ -0,0 +1,202 @@
+import torch
+import torch.nn as nn
+import torch.nn.parallel
+from torchvision import models
+from options.train_options import TrainOptions
+import os
+
+opt = TrainOptions().parse()
+
+class ResidualBlock(nn.Module):
+    def __init__(self, in_features=64, norm_layer=nn.BatchNorm2d):
+        super(ResidualBlock, self).__init__()
+        self.relu = nn.ReLU(True)
+        if norm_layer == None:
+            self.block = nn.Sequential(
+                nn.Conv2d(in_features, in_features, 3, 1, 1, bias=False),
+                nn.ReLU(inplace=True),
+                nn.Conv2d(in_features, in_features, 3, 1, 1, bias=False),
+            )
+        else:
+            self.block = nn.Sequential(
+                nn.Conv2d(in_features, in_features, 3, 1, 1, bias=False),
+                norm_layer(in_features),
+                nn.ReLU(inplace=True),
+                nn.Conv2d(in_features, in_features, 3, 1, 1, bias=False),
+                norm_layer(in_features)
+            )
+
+    def forward(self, x):
+        residual = x
+        out = self.block(x)
+        out += residual
+        out = self.relu(out)
+        return out
+
+
+class ResUnetGenerator(nn.Module):
+    def __init__(self, input_nc, output_nc, num_downs, ngf=64,
+                 norm_layer=nn.BatchNorm2d, use_dropout=False):
+        super(ResUnetGenerator, self).__init__()
+        # construct unet structure
+        unet_block = ResUnetSkipConnectionBlock(ngf * 8, ngf * 8, input_nc=None, submodule=None, norm_layer=norm_layer, innermost=True)
+
+        for i in range(num_downs - 5):
+            unet_block = ResUnetSkipConnectionBlock(ngf * 8, ngf * 8, input_nc=None, submodule=unet_block, norm_layer=norm_layer, use_dropout=use_dropout)
+        unet_block = ResUnetSkipConnectionBlock(ngf * 4, ngf * 8, input_nc=None, submodule=unet_block, norm_layer=norm_layer)
+        unet_block = ResUnetSkipConnectionBlock(ngf * 2, ngf * 4, input_nc=None, submodule=unet_block, norm_layer=norm_layer)
+        unet_block = ResUnetSkipConnectionBlock(ngf, ngf * 2, input_nc=None, submodule=unet_block, norm_layer=norm_layer)
+        unet_block = ResUnetSkipConnectionBlock(output_nc, ngf, input_nc=input_nc, submodule=unet_block, outermost=True, norm_layer=norm_layer)
+
+        self.model = unet_block
+        self.old_lr = opt.lr
+        self.old_lr_gmm = 0.1*opt.lr
+
+    def forward(self, input):
+        return self.model(input)
+
+
+# Defines the submodule with skip connection.
+# X -------------------identity---------------------- X
+#   |-- downsampling -- |submodule| -- upsampling --|
+class ResUnetSkipConnectionBlock(nn.Module):
+    def __init__(self, outer_nc, inner_nc, input_nc=None,
+                 submodule=None, outermost=False, innermost=False, norm_layer=nn.BatchNorm2d, use_dropout=False):
+        super(ResUnetSkipConnectionBlock, self).__init__()
+        self.outermost = outermost
+        use_bias = norm_layer == nn.InstanceNorm2d
+
+        if input_nc is None:
+            input_nc = outer_nc
+        downconv = nn.Conv2d(input_nc, inner_nc, kernel_size=3,
+                             stride=2, padding=1, bias=use_bias)
+        # add two resblock
+        res_downconv = [ResidualBlock(inner_nc, norm_layer), ResidualBlock(inner_nc, norm_layer)]
+        res_upconv = [ResidualBlock(outer_nc, norm_layer), ResidualBlock(outer_nc, norm_layer)]
+
+        downrelu = nn.ReLU(True)
+        uprelu = nn.ReLU(True)
+        if norm_layer != None:
+            downnorm = norm_layer(inner_nc)
+            upnorm = norm_layer(outer_nc)
+
+        if outermost:
+            upsample = nn.Upsample(scale_factor=2, mode='nearest')
+            upconv = nn.Conv2d(inner_nc * 2, outer_nc, kernel_size=3, stride=1, padding=1, bias=use_bias)
+            down = [downconv, downrelu] + res_downconv
+            up = [upsample, upconv]
+            model = down + [submodule] + up
+        elif innermost:
+            upsample = nn.Upsample(scale_factor=2, mode='nearest')
+            upconv = nn.Conv2d(inner_nc, outer_nc, kernel_size=3, stride=1, padding=1, bias=use_bias)
+            down = [downconv, downrelu] + res_downconv
+            if norm_layer == None:
+                up = [upsample, upconv, uprelu] + res_upconv
+            else:
+                up = [upsample, upconv, upnorm, uprelu] + res_upconv
+            model = down + up
+        else:
+            upsample = nn.Upsample(scale_factor=2, mode='nearest')
+            upconv = nn.Conv2d(inner_nc*2, outer_nc, kernel_size=3, stride=1, padding=1, bias=use_bias)
+            if norm_layer == None:
+                down = [downconv, downrelu] + res_downconv
+                up = [upsample, upconv, uprelu] + res_upconv
+            else:
+                down = [downconv, downnorm, downrelu] + res_downconv
+                up = [upsample, upconv, upnorm, uprelu] + res_upconv
+
+            if use_dropout:
+                model = down + [submodule] + up + [nn.Dropout(0.5)]
+            else:
+                model = down + [submodule] + up
+
+        self.model = nn.Sequential(*model)
+
+    def forward(self, x):
+        if self.outermost:
+            return self.model(x)
+        else:
+            return torch.cat([x, self.model(x)], 1)
+
+
+class Vgg19(nn.Module):
+    def __init__(self, requires_grad=False):
+        super(Vgg19, self).__init__()
+        vgg_pretrained_features = models.vgg19(pretrained=True).features
+        self.slice1 = nn.Sequential()
+        self.slice2 = nn.Sequential()
+        self.slice3 = nn.Sequential()
+        self.slice4 = nn.Sequential()
+        self.slice5 = nn.Sequential()
+        for x in range(2):
+            self.slice1.add_module(str(x), vgg_pretrained_features[x])
+        for x in range(2, 7):
+            self.slice2.add_module(str(x), vgg_pretrained_features[x])
+        for x in range(7, 12):
+            self.slice3.add_module(str(x), vgg_pretrained_features[x])
+        for x in range(12, 21):
+            self.slice4.add_module(str(x), vgg_pretrained_features[x])
+        for x in range(21, 30):
+            self.slice5.add_module(str(x), vgg_pretrained_features[x])
+        if not requires_grad:
+            for param in self.parameters():
+                param.requires_grad = False
+
+    def forward(self, X):
+        h_relu1 = self.slice1(X)
+        h_relu2 = self.slice2(h_relu1)
+        h_relu3 = self.slice3(h_relu2)
+        h_relu4 = self.slice4(h_relu3)
+        h_relu5 = self.slice5(h_relu4)
+        out = [h_relu1, h_relu2, h_relu3, h_relu4, h_relu5]
+        return out
+
+class VGGLoss(nn.Module):
+    def __init__(self, layids = None):
+        super(VGGLoss, self).__init__()
+        self.vgg = Vgg19()
+        self.vgg.cuda()
+        self.criterion = nn.L1Loss()
+        self.weights = [1.0/32, 1.0/16, 1.0/8, 1.0/4, 1.0]
+        self.layids = layids
+
+    def forward(self, x, y):
+        x_vgg, y_vgg = self.vgg(x), self.vgg(y)
+        loss = 0
+        if self.layids is None:
+            self.layids = list(range(len(x_vgg)))
+        for i in self.layids:
+            loss += self.weights[i] * self.criterion(x_vgg[i], y_vgg[i].detach())
+        return loss
+
+def save_checkpoint(model, save_path):
+    if not os.path.exists(os.path.dirname(save_path)):
+        os.makedirs(os.path.dirname(save_path))
+    torch.save(model.state_dict(), save_path)
+
+
+def load_checkpoint_parallel(model, checkpoint_path):
+
+    if not os.path.exists(checkpoint_path):
+        print('No checkpoint!')
+        return
+
+    checkpoint = torch.load(checkpoint_path, map_location='cuda:{}'.format(opt.local_rank))
+    checkpoint_new = model.state_dict()
+    for param in checkpoint_new:
+        checkpoint_new[param] = checkpoint[param]
+    model.load_state_dict(checkpoint_new)
+
+def load_checkpoint_part_parallel(model, checkpoint_path):
+
+    if not os.path.exists(checkpoint_path):
+        print('No checkpoint!')
+        return
+    checkpoint = torch.load(checkpoint_path,map_location='cuda:{}'.format(opt.local_rank))
+    checkpoint_new = model.state_dict()
+    for param in checkpoint_new:
+        if 'cond_' not in param and 'aflow_net.netRefine' not in param:
+            checkpoint_new[param] = checkpoint[param]
+    model.load_state_dict(checkpoint_new)
+
+

VITON-Extends-Train/options/__init__.py

@@ -0,0 +1 @@
+# options_init

VITON-Extends-Train/options/base_options.py

@@ -0,0 +1,88 @@
+import argparse
+import os
+from util import util
+import torch
+
+class BaseOptions():
+    def __init__(self):
+        self.parser = argparse.ArgumentParser()
+        self.initialized = False
+
+    def initialize(self):    
+        # experiment specifics
+        self.parser.add_argument('--name', type=str, default='flow', help='name of the experiment. It decides where to store samples and models')        
+        self.parser.add_argument('--gpu_ids', type=str, default='0', help='gpu ids: e.g. 0  0,1,2, 0,2. use -1 for CPU')
+        self.parser.add_argument('--num_gpus', type=int, default=1, help='the number of gpus')
+        self.parser.add_argument('--checkpoints_dir', type=str, default='./checkpoints', help='models are saved here')
+        self.parser.add_argument('--norm', type=str, default='instance', help='instance normalization or batch normalization')        
+        self.parser.add_argument('--use_dropout', action='store_true', help='use dropout for the generator')
+        self.parser.add_argument('--data_type', default=32, type=int, choices=[8, 16, 32], help="Supported data type i.e. 8, 16, 32 bit")
+        self.parser.add_argument('--verbose', action='store_true', default=False, help='toggles verbose')
+
+        # input/output sizes       
+        self.parser.add_argument('--batchSize', type=int, default=32, help='input batch size')
+        self.parser.add_argument('--loadSize', type=int, default=512, help='scale images to this size')
+        self.parser.add_argument('--fineSize', type=int, default=512, help='then crop to this size')
+        self.parser.add_argument('--label_nc', type=int, default=20, help='# of input label channels')
+        self.parser.add_argument('--input_nc', type=int, default=3, help='# of input image channels')
+        self.parser.add_argument('--output_nc', type=int, default=3, help='# of output image channels')
+
+        # for setting inputs
+        self.parser.add_argument('--dataroot', type=str,default='dataset/VITON_traindata/')
+        self.parser.add_argument('--resize_or_crop', type=str, default='scale_width', help='scaling and cropping of images at load time [resize_and_crop|crop|scale_width|scale_width_and_crop]')
+        self.parser.add_argument('--serial_batches', action='store_true', help='if true, takes images in order to make batches, otherwise takes them randomly')        
+        self.parser.add_argument('--no_flip', action='store_true', help='if specified, do not flip the images for data argumentation') 
+        self.parser.add_argument('--nThreads', default=1, type=int, help='# threads for loading data')                
+        self.parser.add_argument('--max_dataset_size', type=int, default=float("inf"), help='Maximum number of samples allowed per dataset. If the dataset directory contains more than max_dataset_size, only a subset is loaded.')
+
+        # for displays
+        self.parser.add_argument('--display_winsize', type=int, default=512,  help='display window size')
+        self.parser.add_argument('--tf_log', action='store_true', help='if specified, use tensorboard logging. Requires tensorflow installed')
+
+        # for generator
+        self.parser.add_argument('--netG', type=str, default='global', help='selects model to use for netG')
+        self.parser.add_argument('--ngf', type=int, default=64, help='# of gen filters in first conv layer')
+        self.parser.add_argument('--n_downsample_global', type=int, default=4, help='number of downsampling layers in netG') 
+        self.parser.add_argument('--n_blocks_global', type=int, default=4, help='number of residual blocks in the global generator network')
+        self.parser.add_argument('--n_blocks_local', type=int, default=3, help='number of residual blocks in the local enhancer network')
+        self.parser.add_argument('--n_local_enhancers', type=int, default=1, help='number of local enhancers to use')        
+        self.parser.add_argument('--niter_fix_global', type=int, default=0, help='number of epochs that we only train the outmost local enhancer')        
+        self.parser.add_argument('--tv_weight', type=float, default=0.1, help='weight for TV loss')
+
+        self.initialized = True
+
+    def parse(self, save=True):
+        if not self.initialized:
+            self.initialize()
+        self.opt = self.parser.parse_args()
+        self.opt.isTrain = self.isTrain   # train or test
+
+        str_ids = self.opt.gpu_ids.split(',')
+        self.opt.gpu_ids = []
+        for str_id in str_ids:
+            id = int(str_id)
+            if id >= 0:
+                self.opt.gpu_ids.append(id)
+        
+        # set gpu ids
+        if len(self.opt.gpu_ids) > 0:
+            torch.cuda.set_device(self.opt.gpu_ids[0])
+
+        args = vars(self.opt)
+
+        print('------------ Options -------------')
+        for k, v in sorted(args.items()):
+            print('%s: %s' % (str(k), str(v)))
+        print('-------------- End ----------------')
+
+        # save to the disk        
+        expr_dir = os.path.join(self.opt.checkpoints_dir, self.opt.name)
+        util.mkdirs(expr_dir)
+        if save and not self.opt.continue_train:
+            file_name = os.path.join(expr_dir, 'opt.txt')
+            with open(file_name, 'wt') as opt_file:
+                opt_file.write('------------ Options -------------\n')
+                for k, v in sorted(args.items()):
+                    opt_file.write('%s: %s\n' % (str(k), str(v)))
+                opt_file.write('-------------- End ----------------\n')
+        return self.opt

VITON-Extends-Train/options/train_options.py

@@ -0,0 +1,40 @@
+from .base_options import BaseOptions
+
+class TrainOptions(BaseOptions):
+    def initialize(self):
+        BaseOptions.initialize(self)
+        # for displays
+        self.parser.add_argument('--launcher', choices=['none', 'pytorch'], default='none',help='job launcher')
+        self.parser.add_argument('--local_rank', type=int, default=0)
+
+        self.parser.add_argument('--display_freq', type=int, default=100, help='frequency of showing training results on screen')
+        self.parser.add_argument('--print_freq', type=int, default=100, help='frequency of showing training results on console')
+        self.parser.add_argument('--save_latest_freq', type=int, default=1000, help='frequency of saving the latest results')
+        self.parser.add_argument('--save_epoch_freq', type=int, default=20, help='frequency of saving checkpoints at the end of epochs')        
+        self.parser.add_argument('--no_html', action='store_true', help='do not save intermediate training results to [opt.checkpoints_dir]/[opt.name]/web/')
+        self.parser.add_argument('--debug', action='store_true', help='only do one epoch and displays at each iteration')
+
+        # for training
+        self.parser.add_argument('--continue_train', action='store_true', help='continue training: load the latest model')
+        self.parser.add_argument('--load_pretrain', type=str, default='', help='load the pretrained model from the specified location')
+        self.parser.add_argument('--which_epoch', type=str, default='latest', help='which epoch to load? set to latest to use latest cached model')
+        self.parser.add_argument('--phase', type=str, default='train', help='train, val, test, etc')
+        self.parser.add_argument('--niter', type=int, default=50, help='# of iter at starting learning rate')
+        self.parser.add_argument('--niter_decay', type=int, default=50, help='# of iter to linearly decay learning rate to zero')
+        self.parser.add_argument('--beta1', type=float, default=0.5, help='momentum term of adam')
+        self.parser.add_argument('--lr', type=float, default=0.00005, help='initial learning rate for adam')
+        self.parser.add_argument('--PFAFN_warp_checkpoint', type=str, help='load the pretrained model from the specified location')
+        self.parser.add_argument('--PFAFN_gen_checkpoint', type=str,  help='load the pretrained model from the specified location')
+        self.parser.add_argument('--PBAFN_warp_checkpoint', type=str, help='load the pretrained model from the specified location')
+        self.parser.add_argument('--PBAFN_gen_checkpoint', type=str,  help='load the pretrained model from the specified location')
+        # for discriminators        
+        self.parser.add_argument('--num_D', type=int, default=2, help='number of discriminators to use')
+        self.parser.add_argument('--n_layers_D', type=int, default=3, help='only used if which_model_netD==n_layers')
+        self.parser.add_argument('--ndf', type=int, default=64, help='# of discrim filters in first conv layer')    
+        self.parser.add_argument('--lambda_feat', type=float, default=10.0, help='weight for feature matching loss')                
+        self.parser.add_argument('--no_ganFeat_loss', action='store_true', help='if specified, do *not* use discriminator feature matching loss')
+        self.parser.add_argument('--no_vgg_loss', action='store_true', help='if specified, do *not* use VGG feature matching loss')        
+        self.parser.add_argument('--no_lsgan', action='store_true', help='do *not* use least square GAN, if false, use vanilla GAN')
+        self.parser.add_argument('--pool_size', type=int, default=0, help='the size of image buffer that stores previously generated images')
+
+        self.isTrain = True

VITON-Extends-Train/runs/readme.txt

@@ -0,0 +1 @@
+The tensorboard logs will be saved here.

VITON-Extends-Train/sample/readme.txt

@@ -0,0 +1 @@
+The images during training will be saved here.

VITON-Extends-Train/scripts/train_VITON-Extends2_e2e.sh

@@ -0,0 +1,14 @@
+python -m torch.distributed.launch --nproc_per_node=8 --master_port=7129 train_VITON-Extends2_e2e.py --name VITON-Extends2_e2e   \
+--VITON-Extends2_warp_checkpoint 'checkpoints/VITON-Extends2_stage1/VITON-Extends2_warp_epoch_201.pth'  \
+--VITON-Extends_warp_checkpoint 'checkpoints/VITON-Extends_e2e/VITON-Extends_warp_epoch_101.pth' --VITON-Extends_gen_checkpoint 'checkpoints/VITON-Extends_e2e/VITON-Extends_gen_epoch_101.pth'  \
+--resize_or_crop None --verbose --tf_log --batchSize 4 --num_gpus 8 --label_nc 14 --launcher pytorch
+
+
+
+
+
+
+
+
+
+

VITON-Extends-Train/scripts/train_VITON-Extends2_stage1.sh

@@ -0,0 +1,13 @@
+python -m torch.distributed.launch --nproc_per_node=8 --master_port=4703 train_VITON-Extends2_stage1.py --name VITON-Extends2_stage1  \
+--PBAFN_warp_checkpoint 'checkpoints/VITON-Extends_e2e/VITON-Extends_warp_epoch_101.pth' --PBAFN_gen_checkpoint 'checkpoints/VITON-Extends_e2e/VITON-Extends_gen_epoch_101.pth'  \
+--lr 0.00003 --niter 100 --niter_decay 100 --resize_or_crop None --verbose --tf_log --batchSize 4 --num_gpus 8 --label_nc 14 --launcher pytorch
+
+
+
+
+
+
+
+
+
+

VITON-Extends-Train/scripts/train_VITON-Extends_e2e.sh

@@ -0,0 +1,12 @@
+python -m torch.distributed.launch --nproc_per_node=8 --master_port=4736 train_VITON-Extends_e2e.py --name VITON-Extends_e2e   \
+--VITON-Extends_warp_checkpoint 'checkpoints/VITON-Extends_stage1/VITON-Extends_warp_epoch_101.pth' --resize_or_crop None --verbose --tf_log --batchSize 4 --num_gpus 8 --label_nc 14 --launcher pytorch
+
+
+
+
+
+
+
+
+
+

VITON-Extends-Train/scripts/train_VITON-Extends_stage1.sh

@@ -0,0 +1,12 @@
+python -m torch.distributed.launch --nproc_per_node=8 --master_port=7129 train_VITON-Extends_stage1.py --name VITON-Extends_stage1   \
+--resize_or_crop None --verbose --tf_log --batchSize 4 --num_gpus 8 --label_nc 14 --launcher pytorch
+
+
+
+
+
+
+
+
+
+

VITON-Extends-Train/train_VITON-Extends2_e2e.py

@@ -0,0 +1,306 @@
+import time
+from options.train_options import TrainOptions
+from models.networks import ResUnetGenerator, VGGLoss, save_checkpoint, load_checkpoint_parallel
+from models.afwm import TVLoss, AFWM
+import torch.nn as nn
+import torch.nn.functional as F
+import os
+import numpy as np
+import torch
+from torch.utils.data import DataLoader
+from torch.utils.data.distributed import DistributedSampler
+from tensorboardX import SummaryWriter
+import datetime
+import cv2
+
+opt = TrainOptions().parse()
+path = 'runs/' + opt.name
+os.makedirs(path, exist_ok=True)
+
+
+def CreateDataset(opt):
+    from data.aligned_dataset import AlignedDataset
+    dataset = AlignedDataset()
+    print("dataset [%s] was created" % (dataset.name()))
+    dataset.initialize(opt)
+    return dataset
+
+
+os.makedirs('sample', exist_ok=True)
+opt = TrainOptions().parse()
+iter_path = os.path.join(opt.checkpoints_dir, opt.name, 'iter.txt')
+
+torch.cuda.set_device(opt.local_rank)
+torch.distributed.init_process_group(
+    'nccl',
+    init_method='env://'
+)
+device = torch.device(f'cuda:{opt.local_rank}')
+
+start_epoch, epoch_iter = 1, 0
+
+train_data = CreateDataset(opt)
+train_sampler = DistributedSampler(train_data)
+train_loader = DataLoader(train_data, batch_size=opt.batchSize, shuffle=False,
+                          num_workers=4, pin_memory=True, sampler=train_sampler)
+dataset_size = len(train_loader)
+
+PF_warp_model = AFWM(opt, 3)
+print(PF_warp_model)
+PF_warp_model.train()
+PF_warp_model.cuda()
+load_checkpoint_parallel(PF_warp_model, opt.PFAFN_warp_checkpoint)
+
+PF_gen_model = ResUnetGenerator(7, 4, 5, ngf=64, norm_layer=nn.BatchNorm2d)
+print(PF_gen_model)
+PF_gen_model.train()
+PF_gen_model.cuda()
+
+PB_warp_model = AFWM(opt, 45)
+print(PB_warp_model)
+PB_warp_model.eval()
+PB_warp_model.cuda()
+load_checkpoint_parallel(PB_warp_model, opt.PBAFN_warp_checkpoint)
+
+PB_gen_model = ResUnetGenerator(8, 4, 5, ngf=64, norm_layer=nn.BatchNorm2d)
+print(PB_gen_model)
+PB_gen_model.eval()
+PB_gen_model.cuda()
+load_checkpoint_parallel(PB_gen_model, opt.PBAFN_gen_checkpoint)
+
+PF_warp_model = torch.nn.SyncBatchNorm.convert_sync_batchnorm(PF_warp_model).to(device)
+PF_gen_model = torch.nn.SyncBatchNorm.convert_sync_batchnorm(PF_gen_model).to(device)
+
+if opt.isTrain and len(opt.gpu_ids):
+    PF_warp_model = torch.nn.parallel.DistributedDataParallel(PF_warp_model, device_ids=[opt.local_rank])
+    PF_gen_model = torch.nn.parallel.DistributedDataParallel(PF_gen_model, device_ids=[opt.local_rank])
+    PB_warp_model = torch.nn.parallel.DistributedDataParallel(PB_warp_model, device_ids=[opt.local_rank])
+    PB_gen_model = torch.nn.parallel.DistributedDataParallel(PB_gen_model, device_ids=[opt.local_rank])
+
+criterionL1 = nn.L1Loss()
+criterionVGG = VGGLoss()
+criterionL2 = nn.MSELoss('sum')
+
+params_warp = [p for p in PF_warp_model.parameters()]
+params_gen = [p for p in PF_gen_model.parameters()]
+optimizer_warp = torch.optim.Adam(params_warp, lr=0.2 * opt.lr, betas=(opt.beta1, 0.999))
+optimizer_gen = torch.optim.Adam(params_gen, lr=opt.lr, betas=(opt.beta1, 0.999))
+
+total_steps = (start_epoch - 1) * dataset_size + epoch_iter
+
+if opt.local_rank == 0:
+    writer = SummaryWriter(path)
+
+step = 0
+step_per_batch = dataset_size
+
+for epoch in range(start_epoch, opt.niter + opt.niter_decay + 1):
+    epoch_start_time = time.time()
+    if epoch != start_epoch:
+        epoch_iter = epoch_iter % dataset_size
+
+    train_sampler.set_epoch(epoch)
+
+    for i, data in enumerate(train_loader):
+
+        iter_start_time = time.time()
+
+        total_steps += 1
+        epoch_iter += 1
+        save_fake = True
+
+        t_mask = torch.FloatTensor((data['label'].cpu().numpy() == 7).astype(np.float))
+        data['label'] = data['label'] * (1 - t_mask) + t_mask * 4
+        edge = data['edge']
+        pre_clothes_edge = torch.FloatTensor((edge.detach().numpy() > 0.5).astype(np.int))
+        clothes = data['color']
+        clothes = clothes * pre_clothes_edge
+        edge_un = data['edge_un']
+        pre_clothes_edge_un = torch.FloatTensor((edge_un.detach().numpy() > 0.5).astype(np.int))
+        clothes_un = data['color_un']
+        clothes_un = clothes_un * pre_clothes_edge_un
+        person_clothes_edge = torch.FloatTensor((data['label'].cpu().numpy() == 4).astype(np.int))
+        real_image = data['image']
+        person_clothes = real_image * person_clothes_edge
+        pose = data['pose']
+        size = data['label'].size()
+        oneHot_size1 = (size[0], 25, size[2], size[3])
+        densepose = torch.cuda.FloatTensor(torch.Size(oneHot_size1)).zero_()
+        densepose = densepose.scatter_(1, data['densepose'].data.long().cuda(), 1.0)
+        densepose_fore = data['densepose'] / 24
+        face_mask = torch.FloatTensor((data['label'].cpu().numpy() == 1).astype(np.int)) + torch.FloatTensor((data['label'].cpu().numpy() == 12).astype(np.int))
+        other_clothes_mask = torch.FloatTensor((data['label'].cpu().numpy() == 5).astype(np.int)) + torch.FloatTensor((data['label'].cpu().numpy() == 6).astype(np.int)) \
+                             + torch.FloatTensor((data['label'].cpu().numpy() == 8).astype(np.int)) + torch.FloatTensor((data['label'].cpu().numpy() == 9).astype(np.int)) \
+                             + torch.FloatTensor((data['label'].cpu().numpy() == 10).astype(np.int))
+        face_img = face_mask * real_image
+        other_clothes_img = other_clothes_mask * real_image
+        preserve_mask = torch.cat([face_mask, other_clothes_mask], 1)
+
+        concat_un = torch.cat([preserve_mask.cuda(), densepose, pose.cuda()], 1)
+        flow_out_un = PB_warp_model(concat_un.cuda(), clothes_un.cuda(), pre_clothes_edge_un.cuda())
+        warped_cloth_un, last_flow_un, cond_un_all, flow_un_all, delta_list_un, x_all_un, x_edge_all_un, delta_x_all_un, delta_y_all_un = flow_out_un
+        warped_prod_edge_un = F.grid_sample(pre_clothes_edge_un.cuda(), last_flow_un.permute(0, 2, 3, 1),
+                                            mode='bilinear', padding_mode='zeros')
+
+        flow_out_sup = PB_warp_model(concat_un.cuda(), clothes.cuda(), pre_clothes_edge.cuda())
+        warped_cloth_sup, last_flow_sup, cond_sup_all, flow_sup_all, delta_list_sup, x_all_sup, x_edge_all_sup, delta_x_all_sup, delta_y_all_sup = flow_out_sup
+
+        arm_mask = torch.FloatTensor((data['label'].cpu().numpy() == 11).astype(np.float)) + torch.FloatTensor((data['label'].cpu().numpy() == 13).astype(np.float))
+        hand_mask = torch.FloatTensor((data['densepose'].cpu().numpy() == 3).astype(np.int)) + torch.FloatTensor((data['densepose'].cpu().numpy() == 4).astype(np.int))
+        dense_preserve_mask = torch.FloatTensor((data['densepose'].cpu().numpy() == 15).astype(np.int)) + torch.FloatTensor((data['densepose'].cpu().numpy() == 16).astype(np.int)) \
+                              + torch.FloatTensor((data['densepose'].cpu().numpy() == 17).astype(np.int)) + torch.FloatTensor((data['densepose'].cpu().numpy() == 18).astype(np.int)) \
+                              + torch.FloatTensor((data['densepose'].cpu().numpy() == 19).astype(np.int)) + torch.FloatTensor((data['densepose'].cpu().numpy() == 20).astype(np.int)) \
+                              + torch.FloatTensor((data['densepose'].cpu().numpy() == 21).astype(np.int)) + torch.FloatTensor((data['densepose'].cpu().numpy() == 22))
+        hand_img = (arm_mask * hand_mask) * real_image
+        dense_preserve_mask = dense_preserve_mask.cuda() * (1 - warped_prod_edge_un)
+        preserve_region = face_img + other_clothes_img + hand_img
+
+        gen_inputs_un = torch.cat([preserve_region.cuda(), warped_cloth_un, warped_prod_edge_un, dense_preserve_mask], 1)
+        gen_outputs_un = PB_gen_model(gen_inputs_un)
+        p_rendered_un, m_composite_un = torch.split(gen_outputs_un, [3, 1], 1)
+        p_rendered_un = torch.tanh(p_rendered_un)
+        m_composite_un = torch.sigmoid(m_composite_un)
+        m_composite_un = m_composite_un * warped_prod_edge_un
+        p_tryon_un = warped_cloth_un * m_composite_un + p_rendered_un * (1 - m_composite_un)
+
+        flow_out = PF_warp_model(p_tryon_un.detach(), clothes.cuda(), pre_clothes_edge.cuda())
+        warped_cloth, last_flow, cond_all, flow_all, delta_list, x_all, x_edge_all, delta_x_all, delta_y_all = flow_out
+        warped_prod_edge = x_edge_all[4]
+
+        epsilon = 0.001
+        loss_smooth = sum([TVLoss(x) for x in delta_list])
+        loss_warp = 0
+        loss_fea_sup_all = 0
+        loss_flow_sup_all = 0
+
+        l1_loss_batch = torch.abs(warped_cloth_sup.detach() - person_clothes.cuda())
+        l1_loss_batch = l1_loss_batch.reshape(opt.batchSize, 3 * 256 * 192)
+        l1_loss_batch = l1_loss_batch.sum(dim=1) / (3 * 256 * 192)
+        l1_loss_batch_pred = torch.abs(warped_cloth.detach() - person_clothes.cuda())
+        l1_loss_batch_pred = l1_loss_batch_pred.reshape(opt.batchSize, 3 * 256 * 192)
+        l1_loss_batch_pred = l1_loss_batch_pred.sum(dim=1) / (3 * 256 * 192)
+        weight = (l1_loss_batch < l1_loss_batch_pred).float()
+        num_all = len(np.where(weight.cpu().numpy() > 0)[0])
+        if num_all == 0:
+            num_all = 1
+
+        for num in range(5):
+            cur_person_clothes = F.interpolate(person_clothes, scale_factor=0.5 ** (4 - num), mode='bilinear')
+            cur_person_clothes_edge = F.interpolate(person_clothes_edge, scale_factor=0.5 ** (4 - num), mode='bilinear')
+            loss_l1 = criterionL1(x_all[num], cur_person_clothes.cuda())
+            loss_vgg = criterionVGG(x_all[num], cur_person_clothes.cuda())
+            loss_edge = criterionL1(x_edge_all[num], cur_person_clothes_edge.cuda())
+            b, c, h, w = delta_x_all[num].shape
+            loss_flow_x = (delta_x_all[num].pow(2) + epsilon * epsilon).pow(0.45)
+            loss_flow_x = torch.sum(loss_flow_x) / (b * c * h * w)
+            loss_flow_y = (delta_y_all[num].pow(2) + epsilon * epsilon).pow(0.45)
+            loss_flow_y = torch.sum(loss_flow_y) / (b * c * h * w)
+            loss_second_smooth = loss_flow_x + loss_flow_y
+            b1, c1, h1, w1 = cond_all[num].shape
+            weight_all = weight.reshape(-1, 1, 1, 1).repeat(1, 256, h1, w1)
+            cond_sup_loss = ((cond_sup_all[num].detach() - cond_all[num]) ** 2 * weight_all).sum() / (256 * h1 * w1 * num_all)
+            loss_fea_sup_all = loss_fea_sup_all + (5 - num) * 0.04 * cond_sup_loss
+            loss_warp = loss_warp + (num + 1) * loss_l1 + (num + 1) * 0.2 * loss_vgg + (num + 1) * 2 * loss_edge + (num + 1) * 6 * loss_second_smooth + (5 - num) * 0.04 * cond_sup_loss
+            if num >= 2:
+                b1, c1, h1, w1 = flow_all[num].shape
+                weight_all = weight.reshape(-1, 1, 1).repeat(1, h1, w1)
+                flow_sup_loss = (torch.norm(flow_sup_all[num].detach() - flow_all[num], p=2, dim=1) * weight_all).sum() / (h1 * w1 * num_all)
+                loss_flow_sup_all = loss_flow_sup_all + (num + 1) * 1 * flow_sup_loss
+                loss_warp = loss_warp + (num + 1) * 1 * flow_sup_loss
+
+        loss_warp = 0.01 * loss_smooth + loss_warp
+
+        if opt.local_rank == 0:
+            writer.add_scalar('loss_warp', loss_warp, step)
+            writer.add_scalar('loss_fea_sup_all', loss_fea_sup_all, step)
+            writer.add_scalar('loss_flow_sup_all', loss_flow_sup_all, step)
+
+        skin_mask = warped_prod_edge_un.detach() * (1 - person_clothes_edge.cuda())
+        gen_inputs = torch.cat([p_tryon_un.detach(), warped_cloth, warped_prod_edge], 1)
+        gen_outputs = PF_gen_model(gen_inputs)
+        p_rendered, m_composite = torch.split(gen_outputs, [3, 1], 1)
+        p_rendered = torch.tanh(p_rendered)
+        m_composite = torch.sigmoid(m_composite)
+        m_composite1 = m_composite * warped_prod_edge
+        m_composite = person_clothes_edge.cuda() * m_composite1
+        p_tryon = warped_cloth * m_composite + p_rendered * (1 - m_composite)
+
+        loss_mask_l1 = torch.mean(torch.abs(1 - m_composite))
+        loss_l1_skin = criterionL1(p_rendered * skin_mask, skin_mask * real_image.cuda())
+        loss_vgg_skin = criterionVGG(p_rendered * skin_mask, skin_mask * real_image.cuda())
+        loss_l1 = criterionL1(p_tryon, real_image.cuda())
+        loss_vgg = criterionVGG(p_tryon, real_image.cuda())
+        bg_loss_l1 = criterionL1(p_rendered, real_image.cuda())
+        bg_loss_vgg = criterionVGG(p_rendered, real_image.cuda())
+
+        if epoch < opt.niter:
+            loss_gen = (loss_l1 * 5 + loss_l1_skin * 30 + loss_vgg + loss_vgg_skin * 2 + bg_loss_l1 * 5 + bg_loss_vgg + 1 * loss_mask_l1)
+        else:
+            loss_gen = (loss_l1 * 5 + loss_l1_skin * 60 + loss_vgg + loss_vgg_skin * 4 + bg_loss_l1 * 5 + bg_loss_vgg + 1 * loss_mask_l1)
+
+        loss_all = 0.25 * loss_warp + loss_gen
+
+        if opt.local_rank == 0:
+            writer.add_scalar('loss_gen', loss_gen, step)
+
+        optimizer_warp.zero_grad()
+        optimizer_gen.zero_grad()
+        loss_all.backward()
+        optimizer_warp.step()
+        optimizer_gen.step()
+
+        ############## Display results and errors ##########
+        path = 'sample/' + opt.name
+        os.makedirs(path, exist_ok=True)
+        ### display output images
+        if step % 1000 == 0:
+            if opt.local_rank == 0:
+                a = real_image.float().cuda()
+                b = p_tryon_un.detach()
+                c = clothes.cuda()
+                d = person_clothes.cuda()
+                e = torch.cat([skin_mask.cuda(), skin_mask.cuda(), skin_mask.cuda()], 1)
+                f = warped_cloth
+                g = p_rendered
+                h = torch.cat([m_composite1, m_composite1, m_composite1], 1)
+                i = p_tryon
+                combine = torch.cat([a[0], b[0], c[0], d[0], e[0], f[0], g[0], h[0], i[0]], 2).squeeze()
+                cv_img = (combine.permute(1, 2, 0).detach().cpu().numpy() + 1) / 2
+                writer.add_image('combine', (combine.data + 1) / 2.0, step)
+                rgb = (cv_img * 255).astype(np.uint8)
+                bgr = cv2.cvtColor(rgb, cv2.COLOR_RGB2BGR)
+                cv2.imwrite('sample/' + opt.name + '/' + str(step) + '.jpg', bgr)
+
+        step += 1
+        iter_end_time = time.time()
+        iter_delta_time = iter_end_time - iter_start_time
+        step_delta = (step_per_batch - step % step_per_batch) + step_per_batch * (opt.niter + opt.niter_decay - epoch)
+        eta = iter_delta_time * step_delta
+        eta = str(datetime.timedelta(seconds=int(eta)))
+        time_stamp = datetime.datetime.now()
+        now = time_stamp.strftime('%Y.%m.%d-%H:%M:%S')
+
+        if step % 100 == 0:
+            if opt.local_rank == 0:
+                print('{}:{}:[step-{}]--[loss-{:.6f}]--[loss-{:.6f}]--[ETA-{}]'.format(now, epoch_iter, step, loss_gen, loss_warp, eta))
+
+        if epoch_iter >= dataset_size:
+            break
+
+    # end of epoch
+    iter_end_time = time.time()
+    if opt.local_rank == 0:
+        print('End of epoch %d / %d \t Time Taken: %d sec' %
+              (epoch, opt.niter + opt.niter_decay, time.time() - epoch_start_time))
+
+    if epoch % opt.save_epoch_freq == 0:
+        if opt.local_rank == 0:
+            print('saving the model at the end of epoch %d, iters %d' % (epoch, total_steps))
+            save_checkpoint(PF_warp_model.module,
+                            os.path.join(opt.checkpoints_dir, opt.name, 'PFAFN_warp_epoch_%03d.pth' % (epoch + 1)))
+            save_checkpoint(PF_gen_model.module,
+                            os.path.join(opt.checkpoints_dir, opt.name, 'PFAFN_gen_epoch_%03d.pth' % (epoch + 1)))
+
+    if epoch > opt.niter:
+        PF_warp_model.module.update_learning_rate_warp(optimizer_warp)
+        PF_warp_model.module.update_learning_rate(optimizer_gen)

VITON-Extends-Train/train_VITON-Extends2_stage1.py

@@ -0,0 +1,278 @@
+import time
+from options.train_options import TrainOptions
+from models.networks import ResUnetGenerator, VGGLoss, save_checkpoint, load_checkpoint_part_parallel, \
+    load_checkpoint_parallel
+from models.afwm import TVLoss, AFWM
+import torch.nn as nn
+import torch.nn.functional as F
+import os
+import numpy as np
+import torch
+from torch.utils.data import DataLoader
+from torch.utils.data.distributed import DistributedSampler
+from tensorboardX import SummaryWriter
+import cv2
+import datetime
+
+opt = TrainOptions().parse()
+path = 'runs/' + opt.name
+os.makedirs(path, exist_ok=True)
+
+
+def CreateDataset(opt):
+    from data.aligned_dataset import AlignedDataset
+    dataset = AlignedDataset()
+    print("dataset [%s] was created" % (dataset.name()))
+    dataset.initialize(opt)
+    return dataset
+
+
+os.makedirs('sample', exist_ok=True)
+opt = TrainOptions().parse()
+iter_path = os.path.join(opt.checkpoints_dir, opt.name, 'iter.txt')
+
+torch.cuda.set_device(opt.local_rank)
+torch.distributed.init_process_group(
+    'nccl',
+    init_method='env://'
+)
+device = torch.device(f'cuda:{opt.local_rank}')
+
+start_epoch, epoch_iter = 1, 0
+
+train_data = CreateDataset(opt)
+train_sampler = DistributedSampler(train_data)
+train_loader = DataLoader(train_data, batch_size=opt.batchSize, shuffle=False,
+                          num_workers=4, pin_memory=True, sampler=train_sampler)
+dataset_size = len(train_loader)
+print('#training images = %d' % dataset_size)
+
+PF_warp_model = AFWM(opt, 3)
+print(PF_warp_model)
+PF_warp_model.train()
+PF_warp_model.cuda()
+load_checkpoint_part_parallel(PF_warp_model, opt.PBAFN_warp_checkpoint)
+
+PB_warp_model = AFWM(opt, 45)
+print(PB_warp_model)
+PB_warp_model.eval()
+PB_warp_model.cuda()
+load_checkpoint_parallel(PB_warp_model, opt.PBAFN_warp_checkpoint)
+
+PB_gen_model = ResUnetGenerator(8, 4, 5, ngf=64, norm_layer=nn.BatchNorm2d)
+print(PB_gen_model)
+PB_gen_model.eval()
+PB_gen_model.cuda()
+load_checkpoint_parallel(PB_gen_model, opt.PBAFN_gen_checkpoint)
+
+PF_warp_model = torch.nn.SyncBatchNorm.convert_sync_batchnorm(PF_warp_model).to(device)
+
+if opt.isTrain and len(opt.gpu_ids):
+    PF_warp_model = torch.nn.parallel.DistributedDataParallel(PF_warp_model, device_ids=[opt.local_rank])
+    PB_warp_model = torch.nn.parallel.DistributedDataParallel(PB_warp_model, device_ids=[opt.local_rank])
+    PB_gen_model = torch.nn.parallel.DistributedDataParallel(PB_gen_model, device_ids=[opt.local_rank])
+
+criterionL1 = nn.L1Loss()
+criterionVGG = VGGLoss()
+criterionL2 = nn.MSELoss('sum')
+
+# optimizer
+params = [p for p in PF_warp_model.parameters()]
+optimizer = torch.optim.Adam(params, lr=opt.lr, betas=(opt.beta1, 0.999))
+
+params_part = []
+for name, param in PF_warp_model.named_parameters():
+    if 'cond_' in name or 'aflow_net.netRefine' in name:
+        params_part.append(param)
+optimizer_part = torch.optim.Adam(params_part, lr=opt.lr, betas=(opt.beta1, 0.999))
+
+total_steps = (start_epoch - 1) * dataset_size + epoch_iter
+
+if opt.local_rank == 0:
+    writer = SummaryWriter(path)
+
+step = 0
+step_per_batch = dataset_size
+
+for epoch in range(start_epoch, opt.niter + opt.niter_decay + 1):
+    epoch_start_time = time.time()
+    if epoch != start_epoch:
+        epoch_iter = epoch_iter % dataset_size
+
+    train_sampler.set_epoch(epoch)
+
+    for i, data in enumerate(train_loader):
+
+        iter_start_time = time.time()
+
+        total_steps += 1
+        epoch_iter += 1
+        save_fake = True
+
+        t_mask = torch.FloatTensor((data['label'].cpu().numpy() == 7).astype(np.float))
+        data['label'] = data['label'] * (1 - t_mask) + t_mask * 4
+        edge = data['edge']
+        pre_clothes_edge = torch.FloatTensor((edge.detach().numpy() > 0.5).astype(np.int))
+        clothes = data['color']
+        clothes = clothes * pre_clothes_edge
+        edge_un = data['edge_un']
+        pre_clothes_edge_un = torch.FloatTensor((edge_un.detach().numpy() > 0.5).astype(np.int))
+        clothes_un = data['color_un']
+        clothes_un = clothes_un * pre_clothes_edge_un
+        person_clothes_edge = torch.FloatTensor((data['label'].cpu().numpy() == 4).astype(np.int))
+        real_image = data['image']
+        person_clothes = real_image * person_clothes_edge
+        pose = data['pose']
+        size = data['label'].size()
+        oneHot_size1 = (size[0], 25, size[2], size[3])
+        densepose = torch.cuda.FloatTensor(torch.Size(oneHot_size1)).zero_()
+        densepose = densepose.scatter_(1, data['densepose'].data.long().cuda(), 1.0)
+        densepose_fore = data['densepose'] / 24
+        face_mask = torch.FloatTensor((data['label'].cpu().numpy() == 1).astype(np.int)) + torch.FloatTensor((data['label'].cpu().numpy() == 12).astype(np.int))
+        other_clothes_mask = torch.FloatTensor((data['label'].cpu().numpy() == 5).astype(np.int)) + torch.FloatTensor((data['label'].cpu().numpy() == 6).astype(np.int)) \
+                             + torch.FloatTensor((data['label'].cpu().numpy() == 8).astype(np.int)) + torch.FloatTensor((data['label'].cpu().numpy() == 9).astype(np.int)) \
+                             + torch.FloatTensor((data['label'].cpu().numpy() == 10).astype(np.int))
+        face_img = face_mask * real_image
+        other_clothes_img = other_clothes_mask * real_image
+        preserve_mask = torch.cat([face_mask, other_clothes_mask], 1)
+
+        concat_un = torch.cat([preserve_mask.cuda(), densepose, pose.cuda()], 1)
+        flow_out_un = PB_warp_model(concat_un.cuda(), clothes_un.cuda(), pre_clothes_edge_un.cuda())
+        warped_cloth_un, last_flow_un, cond_un_all, flow_un_all, delta_list_un, x_all_un, x_edge_all_un, delta_x_all_un, delta_y_all_un = flow_out_un
+        warped_prod_edge_un = F.grid_sample(pre_clothes_edge_un.cuda(), last_flow_un.permute(0, 2, 3, 1),
+                                            mode='bilinear', padding_mode='zeros')
+
+        flow_out_sup = PB_warp_model(concat_un.cuda(), clothes.cuda(), pre_clothes_edge.cuda())
+        warped_cloth_sup, last_flow_sup, cond_sup_all, flow_sup_all, delta_list_sup, x_all_sup, x_edge_all_sup, delta_x_all_sup, delta_y_all_sup = flow_out_sup
+
+        arm_mask = torch.FloatTensor((data['label'].cpu().numpy() == 11).astype(np.float)) + torch.FloatTensor((data['label'].cpu().numpy() == 13).astype(np.float))
+        hand_mask = torch.FloatTensor((data['densepose'].cpu().numpy() == 3).astype(np.int)) + torch.FloatTensor((data['densepose'].cpu().numpy() == 4).astype(np.int))
+        dense_preserve_mask = torch.FloatTensor((data['densepose'].cpu().numpy() == 15).astype(np.int)) + torch.FloatTensor((data['densepose'].cpu().numpy() == 16).astype(np.int)) \
+                              + torch.FloatTensor((data['densepose'].cpu().numpy() == 17).astype(np.int)) + torch.FloatTensor((data['densepose'].cpu().numpy() == 18).astype(np.int)) \
+                              + torch.FloatTensor((data['densepose'].cpu().numpy() == 19).astype(np.int)) + torch.FloatTensor((data['densepose'].cpu().numpy() == 20).astype(np.int)) \
+                              + torch.FloatTensor((data['densepose'].cpu().numpy() == 21).astype(np.int)) + torch.FloatTensor((data['densepose'].cpu().numpy() == 22))
+        hand_img = (arm_mask * hand_mask) * real_image
+        dense_preserve_mask = dense_preserve_mask.cuda() * (1 - warped_prod_edge_un)
+        preserve_region = face_img + other_clothes_img + hand_img
+
+        gen_inputs_un = torch.cat([preserve_region.cuda(), warped_cloth_un, warped_prod_edge_un, dense_preserve_mask], 1)
+        gen_outputs_un = PB_gen_model(gen_inputs_un)
+        p_rendered_un, m_composite_un = torch.split(gen_outputs_un, [3, 1], 1)
+        p_rendered_un = torch.tanh(p_rendered_un)
+        m_composite_un = torch.sigmoid(m_composite_un)
+        m_composite_un = m_composite_un * warped_prod_edge_un
+        p_tryon_un = warped_cloth_un * m_composite_un + p_rendered_un * (1 - m_composite_un)
+
+        flow_out = PF_warp_model(p_tryon_un.detach(), clothes.cuda(), pre_clothes_edge.cuda())
+        warped_cloth, last_flow, cond_all, flow_all, delta_list, x_all, x_edge_all, delta_x_all, delta_y_all = flow_out
+        warped_prod_edge = x_edge_all[4]
+
+        epsilon = 0.001
+        loss_smooth = sum([TVLoss(x) for x in delta_list])
+        loss_all = 0
+        loss_fea_sup_all = 0
+        loss_flow_sup_all = 0
+
+        l1_loss_batch = torch.abs(warped_cloth_sup.detach() - person_clothes.cuda())
+        l1_loss_batch = l1_loss_batch.reshape(opt.batchSize, 3 * 256 * 192)
+        l1_loss_batch = l1_loss_batch.sum(dim=1) / (3 * 256 * 192)
+        l1_loss_batch_pred = torch.abs(warped_cloth.detach() - person_clothes.cuda())
+        l1_loss_batch_pred = l1_loss_batch_pred.reshape(opt.batchSize, 3 * 256 * 192)
+        l1_loss_batch_pred = l1_loss_batch_pred.sum(dim=1) / (3 * 256 * 192)
+        weight = (l1_loss_batch < l1_loss_batch_pred).float()
+        num_all = len(np.where(weight.cpu().numpy() > 0)[0])
+        if num_all == 0:
+            num_all = 1
+
+        for num in range(5):
+            cur_person_clothes = F.interpolate(person_clothes, scale_factor=0.5 ** (4 - num), mode='bilinear')
+            cur_person_clothes_edge = F.interpolate(person_clothes_edge, scale_factor=0.5 ** (4 - num), mode='bilinear')
+            loss_l1 = criterionL1(x_all[num], cur_person_clothes.cuda())
+            loss_vgg = criterionVGG(x_all[num], cur_person_clothes.cuda())
+            loss_edge = criterionL1(x_edge_all[num], cur_person_clothes_edge.cuda())
+            b, c, h, w = delta_x_all[num].shape
+            loss_flow_x = (delta_x_all[num].pow(2) + epsilon * epsilon).pow(0.45)
+            loss_flow_x = torch.sum(loss_flow_x) / (b * c * h * w)
+            loss_flow_y = (delta_y_all[num].pow(2) + epsilon * epsilon).pow(0.45)
+            loss_flow_y = torch.sum(loss_flow_y) / (b * c * h * w)
+            loss_second_smooth = loss_flow_x + loss_flow_y
+            b1, c1, h1, w1 = cond_all[num].shape
+            weight_all = weight.reshape(-1, 1, 1, 1).repeat(1, 256, h1, w1)
+            cond_sup_loss = ((cond_sup_all[num].detach() - cond_all[num]) ** 2 * weight_all).sum() / (256 * h1 * w1 * num_all)
+            loss_fea_sup_all = loss_fea_sup_all + (5 - num) * 0.04 * cond_sup_loss
+            loss_all = loss_all + (num + 1) * loss_l1 + (num + 1) * 0.2 * loss_vgg + (num + 1) * 2 * loss_edge + (num + 1) * 6 * loss_second_smooth + (5 - num) * 0.04 * cond_sup_loss
+            if num >= 2:
+                b1, c1, h1, w1 = flow_all[num].shape
+                weight_all = weight.reshape(-1, 1, 1).repeat(1, h1, w1)
+                flow_sup_loss = (torch.norm(flow_sup_all[num].detach() - flow_all[num], p=2, dim=1) * weight_all).sum() / (h1 * w1 * num_all)
+                loss_flow_sup_all = loss_flow_sup_all + (num + 1) * 1 * flow_sup_loss
+                loss_all = loss_all + (num + 1) * 1 * flow_sup_loss
+
+        loss_all = 0.01 * loss_smooth + loss_all
+
+        # sum per device losses
+        if opt.local_rank == 0:
+            writer.add_scalar('loss_all', loss_all, step)
+            writer.add_scalar('loss_fea_sup_all', loss_fea_sup_all, step)
+            writer.add_scalar('loss_flow_sup_all', loss_flow_sup_all, step)
+
+        if epoch < opt.niter:
+            optimizer_part.zero_grad()
+            loss_all.backward()
+            optimizer_part.step()
+        else:
+            optimizer.zero_grad()
+            loss_all.backward()
+            optimizer.step()
+
+        ############## Display results and errors ##########
+        path = 'sample/' + opt.name
+        os.makedirs(path, exist_ok=True)
+        ### display output images
+        if step % 1000 == 0:
+            if opt.local_rank == 0:
+                a = real_image.float().cuda()
+                b = p_tryon_un.detach()
+                c = clothes.cuda()
+                d = person_clothes.cuda()
+                e = torch.cat([person_clothes_edge.cuda(), person_clothes_edge.cuda(), person_clothes_edge.cuda()], 1)
+                f = torch.cat([densepose_fore.cuda(), densepose_fore.cuda(), densepose_fore.cuda()], 1)
+                g = warped_cloth
+                h = torch.cat([warped_prod_edge, warped_prod_edge, warped_prod_edge], 1)
+                combine = torch.cat([a[0], b[0], c[0], d[0], e[0], f[0], g[0], h[0]], 2).squeeze()
+                cv_img = (combine.permute(1, 2, 0).detach().cpu().numpy() + 1) / 2
+                writer.add_image('combine', (combine.data + 1) / 2.0, step)
+                rgb = (cv_img * 255).astype(np.uint8)
+                bgr = cv2.cvtColor(rgb, cv2.COLOR_RGB2BGR)
+                cv2.imwrite('sample/' + opt.name + '/' + str(step) + '.jpg', bgr)
+
+        step += 1
+        iter_end_time = time.time()
+        iter_delta_time = iter_end_time - iter_start_time
+        step_delta = (step_per_batch - step % step_per_batch) + step_per_batch * (opt.niter + opt.niter_decay - epoch)
+        eta = iter_delta_time * step_delta
+        eta = str(datetime.timedelta(seconds=int(eta)))
+        time_stamp = datetime.datetime.now()
+        now = time_stamp.strftime('%Y.%m.%d-%H:%M:%S')
+        if step % 100 == 0:
+            if opt.local_rank == 0:
+                print('{}:{}:[step-{}]--[loss-{:.6f}]--[loss-{:.6f}]--[loss-{:.6f}]--[ETA-{}]'.format(now, epoch_iter, step, loss_all, loss_fea_sup_all, loss_flow_sup_all, eta))
+
+        if epoch_iter >= dataset_size:
+            break
+
+    # end of epoch
+    iter_end_time = time.time()
+    if opt.local_rank == 0:
+        print('End of epoch %d / %d \t Time Taken: %d sec' %
+              (epoch, opt.niter + opt.niter_decay, time.time() - epoch_start_time))
+
+    ### save model for this epoch
+    if epoch % opt.save_epoch_freq == 0:
+        if opt.local_rank == 0:
+            print('saving the model at the end of epoch %d, iters %d' % (epoch, total_steps))
+            save_checkpoint(PF_warp_model.module,
+                            os.path.join(opt.checkpoints_dir, opt.name, 'PFAFN_warp_epoch_%03d.pth' % (epoch + 1)))
+
+    if epoch > opt.niter:
+        PF_warp_model.module.update_learning_rate(optimizer)

VITON-Extends-Train/train_VITON-Extends_stage1.py

@@ -0,0 +1,181 @@
+import time
+from options.train_options import TrainOptions
+from models.networks import VGGLoss,save_checkpoint
+from models.afwm import TVLoss,AFWM
+import torch.nn as nn
+import torch.nn.functional as F
+import os
+import numpy as np
+import torch
+from torch.utils.data import DataLoader
+from torch.utils.data.distributed import DistributedSampler
+from tensorboardX import SummaryWriter
+import cv2
+import datetime
+
+opt = TrainOptions().parse()
+path = 'runs/'+opt.name
+os.makedirs(path,exist_ok=True)
+
+def CreateDataset(opt):
+    from data.aligned_dataset import AlignedDataset
+    dataset = AlignedDataset()
+    print("dataset [%s] was created" % (dataset.name()))
+    dataset.initialize(opt)
+    return dataset
+
+os.makedirs('sample',exist_ok=True)
+iter_path = os.path.join(opt.checkpoints_dir, opt.name, 'iter.txt')
+
+torch.cuda.set_device(opt.local_rank)
+torch.distributed.init_process_group(
+    'nccl',
+    init_method='env://'
+)
+device = torch.device(f'cuda:{opt.local_rank}')
+
+start_epoch, epoch_iter = 1, 0
+
+train_data = CreateDataset(opt)
+train_sampler = DistributedSampler(train_data)
+train_loader = DataLoader(train_data, batch_size=opt.batchSize, shuffle=False,
+                                               num_workers=4, pin_memory=True, sampler=train_sampler)
+dataset_size = len(train_loader)
+print('#training images = %d' % dataset_size)
+
+warp_model = AFWM(opt, 45)
+print(warp_model)
+warp_model.train()
+warp_model.cuda()
+warp_model = torch.nn.SyncBatchNorm.convert_sync_batchnorm(warp_model).to(device)
+
+if opt.isTrain and len(opt.gpu_ids):
+    model = torch.nn.parallel.DistributedDataParallel(warp_model, device_ids=[opt.local_rank])
+
+criterionL1 = nn.L1Loss()
+criterionVGG = VGGLoss()
+
+params_warp = [p for p in model.parameters()]
+optimizer_warp = torch.optim.Adam(params_warp, lr=opt.lr, betas=(opt.beta1, 0.999))
+
+total_steps = (start_epoch-1) * dataset_size + epoch_iter
+step = 0
+step_per_batch = dataset_size
+
+if opt.local_rank == 0:
+    writer = SummaryWriter(path)
+
+for epoch in range(start_epoch, opt.niter + opt.niter_decay + 1):
+    epoch_start_time = time.time()
+    if epoch != start_epoch:
+        epoch_iter = epoch_iter % dataset_size
+
+    train_sampler.set_epoch(epoch)
+
+    for i, data in enumerate(train_loader):
+        iter_start_time = time.time()
+
+        total_steps += 1
+        epoch_iter += 1
+        save_fake = True
+
+        t_mask = torch.FloatTensor((data['label'].cpu().numpy()==7).astype(np.float))
+        data['label'] = data['label']*(1-t_mask)+t_mask*4
+        edge = data['edge']
+        pre_clothes_edge = torch.FloatTensor((edge.detach().numpy() > 0.5).astype(np.int))
+        clothes = data['color']
+        clothes = clothes * pre_clothes_edge
+        person_clothes_edge = torch.FloatTensor((data['label'].cpu().numpy()==4).astype(np.int))
+        real_image = data['image']
+        person_clothes = real_image * person_clothes_edge
+        pose = data['pose']
+        size = data['label'].size()
+        oneHot_size1 = (size[0], 25, size[2], size[3])
+        densepose = torch.cuda.FloatTensor(torch.Size(oneHot_size1)).zero_()
+        densepose = densepose.scatter_(1,data['densepose'].data.long().cuda(),1.0)
+        densepose_fore = data['densepose']/24.0
+        face_mask = torch.FloatTensor((data['label'].cpu().numpy()==1).astype(np.int)) + torch.FloatTensor((data['label'].cpu().numpy()==12).astype(np.int))
+        other_clothes_mask = torch.FloatTensor((data['label'].cpu().numpy()==5).astype(np.int)) + torch.FloatTensor((data['label'].cpu().numpy()==6).astype(np.int)) + \
+                             torch.FloatTensor((data['label'].cpu().numpy()==8).astype(np.int)) + torch.FloatTensor((data['label'].cpu().numpy()==9).astype(np.int)) + \
+                             torch.FloatTensor((data['label'].cpu().numpy()==10).astype(np.int))
+        preserve_mask = torch.cat([face_mask,other_clothes_mask],1)
+        concat = torch.cat([preserve_mask.cuda(),densepose,pose.cuda()],1)
+
+        flow_out = model(concat.cuda(), clothes.cuda(), pre_clothes_edge.cuda())
+        warped_cloth, last_flow, _1, _2, delta_list, x_all, x_edge_all, delta_x_all, delta_y_all = flow_out
+        warped_prod_edge = x_edge_all[4]
+
+        epsilon = 0.001
+        loss_smooth = sum([TVLoss(x) for x in delta_list])
+        loss_all = 0
+
+        for num in range(5):
+            cur_person_clothes = F.interpolate(person_clothes, scale_factor=0.5**(4-num), mode='bilinear')
+            cur_person_clothes_edge = F.interpolate(person_clothes_edge, scale_factor=0.5**(4-num), mode='bilinear')
+            loss_l1 = criterionL1(x_all[num], cur_person_clothes.cuda())
+            loss_vgg = criterionVGG(x_all[num], cur_person_clothes.cuda())
+            loss_edge = criterionL1(x_edge_all[num], cur_person_clothes_edge.cuda())
+            b,c,h,w = delta_x_all[num].shape
+            loss_flow_x = (delta_x_all[num].pow(2)+ epsilon*epsilon).pow(0.45)
+            loss_flow_x = torch.sum(loss_flow_x)/(b*c*h*w)
+            loss_flow_y = (delta_y_all[num].pow(2)+ epsilon*epsilon).pow(0.45)
+            loss_flow_y = torch.sum(loss_flow_y)/(b*c*h*w)
+            loss_second_smooth = loss_flow_x + loss_flow_y
+            loss_all = loss_all + (num+1) * loss_l1 + (num + 1) * 0.2 * loss_vgg + (num+1) * 2 * loss_edge + (num + 1) * 6 * loss_second_smooth
+
+        loss_all = 0.01 * loss_smooth + loss_all
+
+        if opt.local_rank == 0:
+          writer.add_scalar('loss_all', loss_all, step)
+
+        optimizer_warp.zero_grad()
+        loss_all.backward()
+        optimizer_warp.step()
+        ############## Display results and errors ##########
+
+        path = 'sample/'+opt.name
+        os.makedirs(path,exist_ok=True)
+        if step % 1000 == 0:
+          if opt.local_rank == 0:
+            a = real_image.float().cuda()
+            b = person_clothes.cuda()
+            c = clothes.cuda()
+            d = torch.cat([densepose_fore.cuda(),densepose_fore.cuda(),densepose_fore.cuda()],1)
+            e = warped_cloth
+            f = torch.cat([warped_prod_edge,warped_prod_edge,warped_prod_edge],1)
+            combine = torch.cat([a[0],b[0],c[0],d[0],e[0],f[0]], 2).squeeze()
+            cv_img=(combine.permute(1,2,0).detach().cpu().numpy()+1)/2
+            writer.add_image('combine', (combine.data + 1) / 2.0, step)
+            rgb=(cv_img*255).astype(np.uint8)
+            bgr=cv2.cvtColor(rgb,cv2.COLOR_RGB2BGR)
+            cv2.imwrite('sample/'+opt.name+'/'+str(step)+'.jpg',bgr)
+
+        step += 1
+        iter_end_time = time.time()
+        iter_delta_time = iter_end_time - iter_start_time
+        step_delta = (step_per_batch-step%step_per_batch) + step_per_batch*(opt.niter + opt.niter_decay-epoch)
+        eta = iter_delta_time*step_delta
+        eta = str(datetime.timedelta(seconds=int(eta)))
+        time_stamp = datetime.datetime.now()
+        now = time_stamp.strftime('%Y.%m.%d-%H:%M:%S')
+        if step % 100 == 0:
+          if opt.local_rank == 0:
+            print('{}:{}:[step-{}]--[loss-{:.6f}]--[ETA-{}]'.format(now, epoch_iter,step, loss_all,eta))
+
+        if epoch_iter >= dataset_size:
+            break
+       
+    # end of epoch 
+    iter_end_time = time.time()
+    if opt.local_rank == 0:
+      print('End of epoch %d / %d \t Time Taken: %d sec' %
+            (epoch, opt.niter + opt.niter_decay, time.time() - epoch_start_time))
+
+    ### save model for this epoch
+    if epoch % opt.save_epoch_freq == 0:
+      if opt.local_rank == 0:
+        print('saving the model at the end of epoch %d, iters %d' % (epoch, total_steps))        
+        save_checkpoint(model.module, os.path.join(opt.checkpoints_dir, opt.name, 'PBAFN_warp_epoch_%03d.pth' % (epoch+1)))
+
+    if epoch > opt.niter:
+        model.module.update_learning_rate(optimizer_warp)

VITON-Extends-Train/train_VITON-Extendse2e.py

@@ -0,0 +1,242 @@
+import time
+from options.train_options import TrainOptions
+from models.networks import ResUnetGenerator, VGGLoss, save_checkpoint, load_checkpoint_parallel
+from models.afwm import TVLoss, AFWM
+import torch.nn as nn
+import torch.nn.functional as F
+import os
+import numpy as np
+import torch
+from torch.utils.data import DataLoader
+from torch.utils.data.distributed import DistributedSampler
+from tensorboardX import SummaryWriter
+import cv2
+import datetime
+
+opt = TrainOptions().parse()
+path = 'runs/'+opt.name
+os.makedirs(path,exist_ok=True)
+
+def CreateDataset(opt):
+    from data.aligned_dataset import AlignedDataset
+    dataset = AlignedDataset()
+    print("dataset [%s] was created" % (dataset.name()))
+    dataset.initialize(opt)
+    return dataset
+
+os.makedirs('sample',exist_ok=True)
+opt = TrainOptions().parse()
+iter_path = os.path.join(opt.checkpoints_dir, opt.name, 'iter.txt')
+
+torch.cuda.set_device(opt.local_rank)
+torch.distributed.init_process_group(
+    'nccl',
+    init_method='env://'
+)
+device = torch.device(f'cuda:{opt.local_rank}')
+
+start_epoch, epoch_iter = 1, 0
+
+train_data = CreateDataset(opt)
+train_sampler = DistributedSampler(train_data)
+train_loader = DataLoader(train_data, batch_size=opt.batchSize, shuffle=False,
+                                               num_workers=4, pin_memory=True, sampler=train_sampler)
+dataset_size = len(train_loader)
+
+warp_model = AFWM(opt, 45)
+print(warp_model)
+warp_model.train()
+warp_model.cuda()
+load_checkpoint_parallel(warp_model, opt.PBAFN_warp_checkpoint)
+
+gen_model = ResUnetGenerator(8, 4, 5, ngf=64, norm_layer=nn.BatchNorm2d)
+print(gen_model)
+gen_model.train()
+gen_model.cuda()
+
+warp_model = torch.nn.SyncBatchNorm.convert_sync_batchnorm(warp_model).to(device)
+gen_model = torch.nn.SyncBatchNorm.convert_sync_batchnorm(gen_model).to(device)
+
+if opt.isTrain and len(opt.gpu_ids):
+    model = torch.nn.parallel.DistributedDataParallel(warp_model, device_ids=[opt.local_rank])
+    model_gen = torch.nn.parallel.DistributedDataParallel(gen_model, device_ids=[opt.local_rank])
+
+criterionL1 = nn.L1Loss()
+criterionVGG = VGGLoss()
+# optimizer
+params_warp = [p for p in model.parameters()]
+params_gen = [p for p in model_gen.parameters()]
+optimizer_warp = torch.optim.Adam(params_warp, lr=0.2*opt.lr, betas=(opt.beta1, 0.999))
+optimizer_gen = torch.optim.Adam(params_gen, lr=opt.lr, betas=(opt.beta1, 0.999))
+
+total_steps = (start_epoch-1) * dataset_size + epoch_iter
+
+step = 0
+step_per_batch = dataset_size
+
+if opt.local_rank == 0:
+    writer = SummaryWriter(path)
+
+for epoch in range(start_epoch, opt.niter + opt.niter_decay + 1):
+    epoch_start_time = time.time()
+    if epoch != start_epoch:
+        epoch_iter = epoch_iter % dataset_size
+
+    train_sampler.set_epoch(epoch)
+
+    for i, data in enumerate(train_loader):
+
+        iter_start_time = time.time()
+
+        total_steps += 1
+        epoch_iter += 1
+        save_fake = True
+
+        t_mask = torch.FloatTensor((data['label'].cpu().numpy()==7).astype(np.float))
+        data['label'] = data['label']*(1-t_mask)+t_mask*4
+        edge = data['edge']
+        pre_clothes_edge = torch.FloatTensor((edge.detach().numpy() > 0.5).astype(np.int))
+        clothes = data['color']
+        clothes = clothes * pre_clothes_edge
+        person_clothes_edge = torch.FloatTensor((data['label'].cpu().numpy()==4).astype(np.int))
+        real_image = data['image']
+        person_clothes = real_image*person_clothes_edge
+        pose = data['pose']
+        size = data['label'].size()
+        oneHot_size1 = (size[0], 25, size[2], size[3])
+        densepose = torch.cuda.FloatTensor(torch.Size(oneHot_size1)).zero_()
+        densepose = densepose.scatter_(1,data['densepose'].data.long().cuda(),1.0)
+        densepose_fore = data['densepose']/24.0
+        face_mask = torch.FloatTensor((data['label'].cpu().numpy()==1).astype(np.int))+torch.FloatTensor((data['label'].cpu().numpy()==12).astype(np.int))
+        other_clothes_mask = torch.FloatTensor((data['label'].cpu().numpy()==5).astype(np.int)) + torch.FloatTensor((data['label'].cpu().numpy()==6).astype(np.int))\
+                             + torch.FloatTensor((data['label'].cpu().numpy()==8).astype(np.int)) + torch.FloatTensor((data['label'].cpu().numpy()==9).astype(np.int))\
+                             + torch.FloatTensor((data['label'].cpu().numpy()==10).astype(np.int))
+        face_img = face_mask * real_image
+        other_clothes_img = other_clothes_mask * real_image
+        preserve_region = face_img + other_clothes_img
+        preserve_mask = torch.cat([face_mask, other_clothes_mask],1)
+        concat = torch.cat([preserve_mask.cuda(), densepose, pose.cuda()],1)
+        arm_mask = torch.FloatTensor((data['label'].cpu().numpy()==11).astype(np.float)) + torch.FloatTensor((data['label'].cpu().numpy()==13).astype(np.float))
+        hand_mask = torch.FloatTensor((data['densepose'].cpu().numpy()==3).astype(np.int)) + torch.FloatTensor((data['densepose'].cpu().numpy()==4).astype(np.int))
+        hand_mask = arm_mask*hand_mask
+        hand_img = hand_mask*real_image
+        dense_preserve_mask = torch.FloatTensor((data['densepose'].cpu().numpy()==15).astype(np.int))+torch.FloatTensor((data['densepose'].cpu().numpy()==16).astype(np.int))\
+                              +torch.FloatTensor((data['densepose'].cpu().numpy()==17).astype(np.int))+torch.FloatTensor((data['densepose'].cpu().numpy()==18).astype(np.int))\
+                              +torch.FloatTensor((data['densepose'].cpu().numpy()==19).astype(np.int))+torch.FloatTensor((data['densepose'].cpu().numpy()==20).astype(np.int))\
+                              +torch.FloatTensor((data['densepose'].cpu().numpy()==21).astype(np.int))+torch.FloatTensor((data['densepose'].cpu().numpy()==22))
+        dense_preserve_mask = dense_preserve_mask.cuda()*(1-person_clothes_edge.cuda())
+        preserve_region = face_img + other_clothes_img +hand_img
+
+        flow_out = model(concat.cuda(), clothes.cuda(), pre_clothes_edge.cuda())
+        warped_cloth, last_flow, _1, _2, delta_list, x_all, x_edge_all, delta_x_all, delta_y_all = flow_out
+
+        epsilon = 0.001
+        loss_smooth = sum([TVLoss(x) for x in delta_list])
+        warp_loss = 0
+
+        for num in range(5):
+            cur_person_clothes = F.interpolate(person_clothes, scale_factor=0.5**(4-num), mode='bilinear')
+            cur_person_clothes_edge = F.interpolate(person_clothes_edge, scale_factor=0.5**(4-num), mode='bilinear')
+            loss_l1 = criterionL1(x_all[num], cur_person_clothes.cuda())
+            loss_vgg = criterionVGG(x_all[num], cur_person_clothes.cuda())
+            loss_edge = criterionL1(x_edge_all[num], cur_person_clothes_edge.cuda())
+            b,c,h,w = delta_x_all[num].shape
+            loss_flow_x = (delta_x_all[num].pow(2) + epsilon*epsilon).pow(0.45)
+            loss_flow_x = torch.sum(loss_flow_x) / (b*c*h*w)
+            loss_flow_y = (delta_y_all[num].pow(2) + epsilon*epsilon).pow(0.45)
+            loss_flow_y = torch.sum(loss_flow_y) / (b*c*h*w)
+            loss_second_smooth = loss_flow_x + loss_flow_y
+            warp_loss = warp_loss + (num+1) * loss_l1 + (num+1) * 0.2 * loss_vgg + (num+1) * 2 * loss_edge + (num+1) * 6 * loss_second_smooth
+
+        warp_loss = 0.01 * loss_smooth + warp_loss
+
+        if opt.local_rank == 0:
+          writer.add_scalar('warp_loss', warp_loss, step)
+
+        warped_prod_edge = x_edge_all[4]
+        gen_inputs = torch.cat([preserve_region.cuda(), warped_cloth, warped_prod_edge, dense_preserve_mask], 1)
+
+        gen_outputs = model_gen(gen_inputs)
+        p_rendered, m_composite = torch.split(gen_outputs, [3, 1], 1)
+        p_rendered = torch.tanh(p_rendered)
+        m_composite = torch.sigmoid(m_composite)
+        m_composite1 = m_composite * warped_prod_edge
+        m_composite =  person_clothes_edge.cuda()*m_composite1
+        p_tryon = warped_cloth * m_composite + p_rendered * (1 - m_composite)
+
+        loss_mask_l1 = torch.mean(torch.abs(1 - m_composite))
+        loss_l1 = criterionL1(p_tryon, real_image.cuda())
+        loss_vgg = criterionVGG(p_tryon,real_image.cuda())
+        bg_loss_l1 = criterionL1(p_rendered, real_image.cuda())
+        bg_loss_vgg = criterionVGG(p_rendered, real_image.cuda())
+        gen_loss = (loss_l1 * 5 + loss_vgg + bg_loss_l1 * 5 + bg_loss_vgg + loss_mask_l1)
+
+
+        if opt.local_rank == 0:
+          writer.add_scalar('gen_loss', gen_loss, step)
+
+        loss_all = 0.5 * warp_loss + 1.0 * gen_loss
+
+        if opt.local_rank == 0:
+          writer.add_scalar('loss_all', loss_all, step)
+
+        optimizer_warp.zero_grad()
+        optimizer_gen.zero_grad()
+        loss_all.backward()
+        optimizer_warp.step()
+        optimizer_gen.step()
+
+        ############## Display results and errors ##########
+        path = 'sample/'+opt.name
+        os.makedirs(path,exist_ok=True)
+        if step % 1000 == 0:
+          if opt.local_rank == 0:
+            a = real_image.float().cuda()
+            b = person_clothes.cuda()
+            c = clothes.cuda()
+            d = torch.cat([densepose_fore.cuda(),densepose_fore.cuda(),densepose_fore.cuda()],1)
+            e = warped_cloth
+            f = torch.cat([warped_prod_edge,warped_prod_edge,warped_prod_edge],1)
+            g = preserve_region.cuda()
+            h = torch.cat([dense_preserve_mask,dense_preserve_mask,dense_preserve_mask],1)
+            i = p_rendered
+            j = torch.cat([m_composite1,m_composite1,m_composite1],1)
+            k = p_tryon
+            combine = torch.cat([a[0],b[0],c[0],d[0],e[0],f[0],g[0],h[0],i[0],j[0],k[0]], 2).squeeze()
+            cv_img = (combine.permute(1,2,0).detach().cpu().numpy()+1)/2
+            writer.add_image('combine', (combine.data + 1) / 2.0, step)
+            rgb = (cv_img*255).astype(np.uint8)
+            bgr = cv2.cvtColor(rgb,cv2.COLOR_RGB2BGR)
+            cv2.imwrite('sample/'+opt.name+'/'+str(step)+'.jpg',bgr)
+
+        step += 1
+        iter_end_time = time.time()
+        iter_delta_time = iter_end_time - iter_start_time
+        step_delta = (step_per_batch-step%step_per_batch) + step_per_batch*(opt.niter + opt.niter_decay-epoch)
+        eta = iter_delta_time*step_delta
+        eta = str(datetime.timedelta(seconds=int(eta)))
+        time_stamp = datetime.datetime.now()
+        now = time_stamp.strftime('%Y.%m.%d-%H:%M:%S')
+
+        if step % 100 == 0:
+          if opt.local_rank == 0:
+            print('{}:{}:[step-{}]--[loss-{:.6f}]--[loss-{:.6f}]--[ETA-{}]'.format(now, epoch_iter, step, warp_loss, gen_loss, eta))
+
+        if epoch_iter >= dataset_size:
+            break
+
+    iter_end_time = time.time()
+    if opt.local_rank == 0:
+      print('End of epoch %d / %d \t Time Taken: %d sec' %
+            (epoch, opt.niter + opt.niter_decay, time.time() - epoch_start_time))
+
+    ### save model for this epoch
+    if epoch % opt.save_epoch_freq == 0:
+      if opt.local_rank == 0:
+        print('saving the model at the end of epoch %d, iters %d' % (epoch, total_steps))        
+        save_checkpoint(model.module, os.path.join(opt.checkpoints_dir, opt.name, 'PBAFN_warp_epoch_%03d.pth' % (epoch+1)))
+        save_checkpoint(model_gen.module, os.path.join(opt.checkpoints_dir, opt.name, 'PBAFN_gen_epoch_%03d.pth' % (epoch+1)))
+
+    if epoch > opt.niter:
+        model.module.update_learning_rate_warp(optimizer_warp)
+        model.module.update_learning_rate(optimizer_gen)

VITON-Extends-Train/util/__init__.py

@@ -0,0 +1 @@
+# util_init

VITON-Extends-Train/util/image_pool.py

@@ -0,0 +1,31 @@
+import random
+import torch
+from torch.autograd import Variable
+class ImagePool():
+    def __init__(self, pool_size):
+        self.pool_size = pool_size
+        if self.pool_size > 0:
+            self.num_imgs = 0
+            self.images = []
+
+    def query(self, images):
+        if self.pool_size == 0:
+            return images
+        return_images = []
+        for image in images.data:
+            image = torch.unsqueeze(image, 0)
+            if self.num_imgs < self.pool_size:
+                self.num_imgs = self.num_imgs + 1
+                self.images.append(image)
+                return_images.append(image)
+            else:
+                p = random.uniform(0, 1)
+                if p > 0.5:
+                    random_id = random.randint(0, self.pool_size-1)
+                    tmp = self.images[random_id].clone()
+                    self.images[random_id] = image
+                    return_images.append(tmp)
+                else:
+                    return_images.append(image)
+        return_images = Variable(torch.cat(return_images, 0))
+        return return_images

VITON-Extends-Train/util/util.py

@@ -0,0 +1,106 @@
+from __future__ import print_function
+
+import torch
+import numpy as np
+from PIL import Image
+import numpy as np
+import os
+
+# Converts a Tensor into a Numpy array
+# |imtype|: the desired type of the converted numpy array
+def tensor2im(image_tensor, imtype=np.uint8, normalize=True):
+    if isinstance(image_tensor, list):
+        image_numpy = []
+        for i in range(len(image_tensor)):
+            image_numpy.append(tensor2im(image_tensor[i], imtype, normalize))
+        return image_numpy
+    image_numpy = image_tensor.cpu().float().numpy()
+    #if normalize:
+    #    image_numpy = (np.transpose(image_numpy, (1, 2, 0)) + 1) / 2.0 * 255.0
+    #else:
+    #    image_numpy = np.transpose(image_numpy, (1, 2, 0)) * 255.0
+    image_numpy = (image_numpy + 1) / 2.0
+    image_numpy = np.clip(image_numpy, 0, 1)
+    if image_numpy.shape[2] == 1 or image_numpy.shape[2] > 3:        
+        image_numpy = image_numpy[:,:,0]
+
+    return image_numpy
+
+# Converts a one-hot tensor into a colorful label map
+def tensor2label(label_tensor, n_label, imtype=np.uint8):
+    if n_label == 0:
+        return tensor2im(label_tensor, imtype)
+    label_tensor = label_tensor.cpu().float()    
+    if label_tensor.size()[0] > 1:
+        label_tensor = label_tensor.max(0, keepdim=True)[1]
+    label_tensor = Colorize(n_label)(label_tensor)
+    #label_numpy = np.transpose(label_tensor.numpy(), (1, 2, 0))
+    label_numpy = label_tensor.numpy()
+    label_numpy = label_numpy / 255.0
+
+    return label_numpy
+
+def save_image(image_numpy, image_path):
+    image_pil = Image.fromarray(image_numpy)
+    image_pil.save(image_path)
+
+def mkdirs(paths):
+    if isinstance(paths, list) and not isinstance(paths, str):
+        for path in paths:
+            mkdir(path)
+    else:
+        mkdir(paths)
+
+def mkdir(path):
+    if not os.path.exists(path):
+        os.makedirs(path)
+
+###############################################################################
+# Code from
+# https://github.com/ycszen/pytorch-seg/blob/master/transform.py
+# Modified so it complies with the Citscape label map colors
+###############################################################################
+def uint82bin(n, count=8):
+    """returns the binary of integer n, count refers to amount of bits"""
+    return ''.join([str((n >> y) & 1) for y in range(count-1, -1, -1)])
+
+def labelcolormap(N):
+    if N == 35: # cityscape
+        cmap = np.array([(  0,  0,  0), (  0,  0,  0), (  0,  0,  0), (  0,  0,  0), (  0,  0,  0), (111, 74,  0), ( 81,  0, 81),
+                     (128, 64,128), (244, 35,232), (250,170,160), (230,150,140), ( 70, 70, 70), (102,102,156), (190,153,153),
+                     (180,165,180), (150,100,100), (150,120, 90), (153,153,153), (153,153,153), (250,170, 30), (220,220,  0),
+                     (107,142, 35), (152,251,152), ( 70,130,180), (220, 20, 60), (255,  0,  0), (  0,  0,142), (  0,  0, 70),
+                     (  0, 60,100), (  0,  0, 90), (  0,  0,110), (  0, 80,100), (  0,  0,230), (119, 11, 32), (  0,  0,142)], 
+                     dtype=np.uint8)
+    else:
+        cmap = np.zeros((N, 3), dtype=np.uint8)
+        for i in range(N):
+            r, g, b = 0, 0, 0
+            id = i
+            for j in range(7):
+                str_id = uint82bin(id)
+                r = r ^ (np.uint8(str_id[-1]) << (7-j))
+                g = g ^ (np.uint8(str_id[-2]) << (7-j))
+                b = b ^ (np.uint8(str_id[-3]) << (7-j))
+                id = id >> 3
+            cmap[i, 0] = r
+            cmap[i, 1] = g
+            cmap[i, 2] = b
+    return cmap
+
+class Colorize(object):
+    def __init__(self, n=35):
+        self.cmap = labelcolormap(n)
+        self.cmap = torch.from_numpy(self.cmap[:n])
+
+    def __call__(self, gray_image):
+        size = gray_image.size()
+        color_image = torch.ByteTensor(3, size[1], size[2]).fill_(0)
+
+        for label in range(0, len(self.cmap)):
+            mask = (label == gray_image[0]).cpu()
+            color_image[0][mask] = self.cmap[label][0]
+            color_image[1][mask] = self.cmap[label][1]
+            color_image[2][mask] = self.cmap[label][2]
+
+        return color_image

VITON-Extends_test/.gitignore

@@ -0,0 +1,27 @@
+# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
+
+# dependencies
+/node_modules
+
+# next.js
+/.next/
+/out/
+
+# production
+/build
+
+# debug
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+.pnpm-debug.log*
+
+# env files
+.env*
+
+# vercel
+.vercel
+
+# typescript
+*.tsbuildinfo
+next-env.d.ts

VITON-Extends_test/API.py

@@ -0,0 +1,312 @@
+import cv2
+import torch
+import numpy as np
+from torchvision import transforms
+from PIL import Image
+import shutil
+import os
+import uuid
+from fastapi import FastAPI, File, UploadFile
+from fastapi.responses import FileResponse
+
+# Giả định rằng file u2net.py chứa class U2NET và file u2net.pth 
+# nằm cùng thư mục với main.py hoặc trong PYTHONPATH.
+# Ví dụ: from your_project.u2net import U2NET
+# Nếu u2net.py là file định nghĩa class, bạn có thể import trực tiếp:
+try:
+    from u2net import U2NET  # Model definition
+except ImportError:
+    print("Lỗi: Không tìm thấy file u2net.py định nghĩa class U2NET.")
+    print("Hãy đảm bảo file u2net.py (chứa class U2NET) nằm trong cùng thư mục hoặc PYTHONPATH.")
+    exit()
+
+
+# --- Khởi tạo FastAPI app ---
+app = FastAPI(title="VITON-Extends API")
+
+# --- Cấu hình và tải mô hình U2NET ---
+# Thực hiện một lần khi ứng dụng khởi động
+U2NET_MODEL = None
+_API_SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+U2NET_MODEL_PATH = os.path.join(_API_SCRIPT_DIR, 'checkpoints', 'u2net.pth') 
+
+def load_u2net_model():
+    global U2NET_MODEL
+    if not os.path.exists(U2NET_MODEL_PATH):
+        print(f"Lỗi: Không tìm thấy file trọng số U2NET tại '{U2NET_MODEL_PATH}'.")
+        print("Hãy đảm bảo file u2net.pth nằm đúng vị trí.")
+        # Không exit() ở đây để FastAPI vẫn có thể khởi động và báo lỗi qua API nếu cần
+        # Hoặc bạn có thể quyết định exit() nếu U2NET là bắt buộc.
+        return False
+
+    try:
+        U2NET_MODEL = U2NET(3, 1) # 3 kênh đầu vào (RGB), 1 kênh đầu ra (mask)
+        # Sử dụng torch.device để đảm bảo tương thích CPU/GPU
+        device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+        U2NET_MODEL.load_state_dict(torch.load(U2NET_MODEL_PATH, map_location=device))
+        U2NET_MODEL.to(device)
+        U2NET_MODEL.eval()
+        print(f"Đã tải thành công mô hình U2NET lên {device}.")
+        return True
+    except Exception as e:
+        print(f"Lỗi khi tải mô hình U2NET: {e}")
+        U2NET_MODEL = None # Đảm bảo model là None nếu tải lỗi
+        return False
+
+# Gọi hàm tải model khi ứng dụng khởi động
+# FastAPI sẽ chạy hàm này trong sự kiện startup nếu bạn dùng @app.on_event("startup")
+# Tuy nhiên, để đơn giản, ta gọi trực tiếp. Nếu có lỗi, các endpoint sẽ kiểm tra U2NET_MODEL.
+MODEL_LOADED_SUCCESSFULLY = load_u2net_model()
+
+
+# --- Các hàm xử lý ảnh với U2NET (tương tự unet.py) ---
+def _preprocess_for_u2net(pil_image: Image.Image) -> torch.Tensor:
+    """Tiền xử lý ảnh PIL cho đầu vào U2NET."""
+    transform = transforms.Compose([
+        transforms.Resize((256, 192)), # (H, W) theo convention của U2NET trong unet.py
+        transforms.ToTensor(),
+        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
+    ])
+    return transform(pil_image).unsqueeze(0)
+
+def generate_person_mask_from_image(
+    image_path: str, 
+    output_mask_path: str,
+    device: torch.device
+) -> str:
+    """
+    Tạo mặt nạ cho người từ ảnh đầu vào bằng U2NET.
+    Mặt nạ được resize về kích thước ảnh gốc và lưu dưới dạng ảnh grayscale.
+    """
+    if U2NET_MODEL is None:
+        raise RuntimeError("Mô hình U2NET chưa được tải thành công.")
+
+    pil_image = Image.open(image_path).convert('RGB')
+    original_w, original_h = pil_image.size
+    
+    input_tensor = _preprocess_for_u2net(pil_image)
+    input_tensor = input_tensor.to(device) # Chuyển tensor sang device của model
+    
+    with torch.no_grad():
+        # U2NET thường trả về nhiều output ở các scale khác nhau, d1 là output chính
+        d1, *_ = U2NET_MODEL(input_tensor) 
+        
+        pred = d1[:,0,:,:] # Lấy mask từ output, shape: (1, H_u2net, W_u2net)
+        pred = pred.squeeze().cpu().numpy() # Chuyển về numpy array trên CPU, shape: (H_u2net, W_u2net)
+        
+        # Chuẩn hóa giá trị của mask về khoảng [0, 1]
+        pred_min = pred.min()
+        pred_max = pred.max()
+        if pred_max - pred_min > 1e-8: # Tránh chia cho 0
+            pred = (pred - pred_min) / (pred_max - pred_min)
+        else:
+            pred = np.zeros_like(pred) # Nếu ảnh đầu vào đồng màu, mask có thể là 0
+            
+        # Resize mask về kích thước ảnh gốc
+        # cv2.resize yêu cầu dsize là (width, height)
+        mask_resized = cv2.resize(pred, (original_w, original_h), interpolation=cv2.INTER_LINEAR)
+        
+        # Lưu mask dưới dạng ảnh grayscale (giá trị 0-255)
+        cv2.imwrite(output_mask_path, (mask_resized * 255).astype(np.uint8))
+    return output_mask_path
+
+def apply_mask_and_prepare_person_image(
+    original_image_path: str,
+    person_mask_path: str, # Đường dẫn đến file mask grayscale (0-255)
+    output_image_path: str,
+    target_size: tuple = (192, 256) # (W, H) cho ảnh output cuối cùng của người
+) -> str:
+    """
+    Áp dụng mặt nạ lên ảnh gốc (nền trắng) và resize về kích thước mục tiêu.
+    """
+    original_bgr = cv2.imread(original_image_path)
+    if original_bgr is None:
+        raise FileNotFoundError(f"Không tìm thấy ảnh gốc: {original_image_path}")
+    original_rgb = cv2.cvtColor(original_bgr, cv2.COLOR_BGR2RGB)
+    
+    mask_gray = cv2.imread(person_mask_path, cv2.IMREAD_GRAYSCALE)
+    if mask_gray is None:
+        raise FileNotFoundError(f"Không tìm thấy ảnh mặt nạ: {person_mask_path}")
+
+    # Đảm bảo mask có cùng kích thước với ảnh gốc
+    if mask_gray.shape[:2] != original_rgb.shape[:2]:
+        mask_gray = cv2.resize(mask_gray, (original_rgb.shape[1], original_rgb.shape[0]), 
+                               interpolation=cv2.INTER_LINEAR)
+
+    # Chuẩn hóa mask về khoảng [0, 1]
+    mask_float = mask_gray / 255.0
+    # Mở rộng mask thành 3 kênh để áp dụng cho ảnh RGB
+    mask_3channel = np.repeat(np.expand_dims(mask_float, axis=2), 3, axis=2)
+    
+    # Tạo ảnh nền trắng
+    white_background_rgb = np.full_like(original_rgb, 255, dtype=np.uint8)
+    
+    # Áp dụng công thức: result = foreground * mask + background * (1 - mask)
+    composited_rgb = (original_rgb.astype(float) * mask_3channel + \
+                      white_background_rgb.astype(float) * (1 - mask_3channel))
+    composited_uint8 = np.clip(composited_rgb, 0, 255).astype(np.uint8)
+    
+    # Resize ảnh đã xử lý về kích thước mục tiêu (W, H)
+    # cv2.resize yêu cầu dsize là (width, height)
+    resized_image_rgb = cv2.resize(composited_uint8, target_size, interpolation=cv2.INTER_AREA)
+        
+    # Chuyển lại BGR để lưu bằng OpenCV
+    output_bgr = cv2.cvtColor(resized_image_rgb, cv2.COLOR_RGB2BGR)
+    cv2.imwrite(output_image_path, output_bgr)
+    return output_image_path
+
+# --- Placeholder cho mô hình VITON-Extends ---
+def run_viton_try_on_model(
+    person_image_path: str,      # Ảnh người đã xử lý (nền trắng, resized)
+    clothing_image_path: str,    # Ảnh trang phục
+    person_mask_path: str,       # Mặt nạ người (có thể dùng làm "edge")
+    output_dir: str
+) -> str:
+    """
+    Hàm giả lập việc gọi mô hình VITON-Extends.
+    Trong thực tế, bạn sẽ thay thế phần này bằng code gọi mô hình của bạn.
+    """
+    print(f"Gọi mô hình VITON (giả lập) với:")
+    print(f"  - Ảnh người: {person_image_path}")
+    print(f"  - Ảnh trang phục: {clothing_image_path}")
+    print(f"  - Mặt nạ người ('edge'): {person_mask_path}")
+
+    # Tạo một file output giả lập
+    dummy_output_name = f"viton_result_{uuid.uuid4().hex}.png"
+    dummy_output_path = os.path.join(output_dir, dummy_output_name)
+    
+    # Ví dụ: copy ảnh người làm kết quả giả lập
+    if os.path.exists(person_image_path):
+        shutil.copy(person_image_path, dummy_output_path)
+        print(f"Mô hình VITON (giả lập) đã lưu kết quả tại: {dummy_output_path}")
+        return dummy_output_path
+    else:
+        # Tạo ảnh trống nếu không có ảnh người
+        error_img = np.zeros((256, 192, 3), dtype=np.uint8)
+        cv2.putText(error_img, "VITON Error", (10,128), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0,0,255),1)
+        cv2.imwrite(dummy_output_path, error_img)
+        print(f"Lỗi: Không tìm thấy ảnh người để tạo output giả lập. Đã tạo ảnh lỗi.")
+        return dummy_output_path
+
+
+# --- Thiết lập thư mục tạm ---
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+TEMP_DIR = os.path.join(BASE_DIR, "temp_files_viton_api")
+os.makedirs(TEMP_DIR, exist_ok=True)
+
+# Thư mục cho các file input gốc
+UPLOADED_FILES_DIR = os.path.join(TEMP_DIR, "uploads")
+os.makedirs(UPLOADED_FILES_DIR, exist_ok=True)
+
+# Thư mục cho output của U2NET (ảnh người đã xử lý, mặt nạ người)
+UNET_OUTPUT_DIR = os.path.join(TEMP_DIR, "unet_outputs")
+os.makedirs(UNET_OUTPUT_DIR, exist_ok=True)
+
+# Thư mục cho output cuối cùng của VITON
+VITON_OUTPUT_DIR = os.path.join(TEMP_DIR, "viton_results")
+os.makedirs(VITON_OUTPUT_DIR, exist_ok=True)
+
+
+# --- API Endpoint ---
+@app.post("/virtual-try-on/", 
+          summary="Thực hiện thử đồ ảo",
+          description="Tải lên ảnh người và ảnh trang phục. API sẽ trả về ảnh người mặc trang phục đó.")
+async def virtual_try_on_endpoint(
+    person_image: UploadFile = File(..., description="Ảnh người dùng (định dạng JPG, PNG)."),
+    clothing_image: UploadFile = File(..., description="Ảnh trang phục (định dạng JPG, PNG).")
+):
+    if not MODEL_LOADED_SUCCESSFULLY or U2NET_MODEL is None:
+        return {"error": "Mô hình U2NET chưa sẵn sàng hoặc tải lỗi. Vui lòng kiểm tra console server."}
+
+    request_id = uuid.uuid4().hex
+    
+    # --- 1. Lưu ảnh tải lên ---
+    person_image_name = f"{request_id}_person{os.path.splitext(person_image.filename)[1]}"
+    clothing_image_name = f"{request_id}_clothing{os.path.splitext(clothing_image.filename)[1]}"
+    
+    original_person_image_path = os.path.join(UPLOADED_FILES_DIR, person_image_name)
+    original_clothing_image_path = os.path.join(UPLOADED_FILES_DIR, clothing_image_name)
+
+    try:
+        with open(original_person_image_path, "wb") as buffer:
+            shutil.copyfileobj(person_image.file, buffer)
+        with open(original_clothing_image_path, "wb") as buffer:
+            shutil.copyfileobj(clothing_image.file, buffer)
+    except Exception as e:
+        return {"error": f"Lỗi khi lưu file tải lên: {e}"}
+    finally:
+        person_image.file.close()
+        clothing_image.file.close()
+
+    # --- 2. Xử lý ảnh người bằng U2NET ---
+    # Đường dẫn cho mặt nạ người (person mask)
+    person_mask_filename = f"{request_id}_person_mask.png"
+    generated_person_mask_path = os.path.join(UNET_OUTPUT_DIR, person_mask_filename)
+
+    # Đường dẫn cho ảnh người đã xử lý (nền trắng, resized) - đây sẽ là "img" cho VITON
+    # Kích thước (192, 256) WxH như trong unet.py gốc
+    processed_person_image_filename = f"{request_id}_person_processed.png"
+    processed_person_image_path = os.path.join(UNET_OUTPUT_DIR, processed_person_image_filename)
+    
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+    try:
+        print(f"[{request_id}] Bắt đầu tạo mặt nạ cho: {original_person_image_path}")
+        actual_person_mask_path = generate_person_mask_from_image(
+            original_person_image_path, 
+            generated_person_mask_path,
+            device
+        )
+        print(f"[{request_id}] Đã tạo mặt nạ người tại: {actual_person_mask_path}")
+
+        print(f"[{request_id}] Bắt đầu xử lý ảnh người: {original_person_image_path}")
+        # "img" cho VITON (192W x 256H, nền trắng)
+        actual_processed_person_image_path = apply_mask_and_prepare_person_image(
+            original_image_path=original_person_image_path,
+            person_mask_path=actual_person_mask_path,
+            output_image_path=processed_person_image_path,
+            target_size=(192, 256) # (W, H)
+        )
+        print(f"[{request_id}] Đã xử lý ảnh người tại: {actual_processed_person_image_path}")
+
+    except FileNotFoundError as e:
+        return {"error": f"Lỗi file trong quá trình xử lý U2NET: {e}"}
+    except RuntimeError as e: # Bắt lỗi Runtime từ U2NET (ví dụ model chưa tải)
+        return {"error": f"Lỗi Runtime U2NET: {e}"}
+    except Exception as e:
+        return {"error": f"Lỗi không xác định trong quá trình xử lý U2NET: {e}"}
+
+    # --- 3. Gọi mô hình VITON-Extends (Placeholder) ---
+    # Đầu vào cho mô hình VITON:
+    # - img: actual_processed_person_image_path (ảnh người 192x256, nền trắng)
+    # - clothes: original_clothing_image_path (ảnh trang phục gốc)
+    # - edge: actual_person_mask_path (mặt nạ người, kích thước gốc)
+    try:
+        print(f"[{request_id}] Bắt đầu gọi mô hình VITON (giả lập)...")
+        final_try_on_image_path = run_viton_try_on_model(
+            person_image_path=actual_processed_person_image_path,
+            clothing_image_path=original_clothing_image_path,
+            person_mask_path=actual_person_mask_path, # "edge" là mặt nạ người
+            output_dir=VITON_OUTPUT_DIR
+        )
+        print(f"[{request_id}] Mô hình VITON (giả lập) hoàn tất. Kết quả: {final_try_on_image_path}")
+
+        if not os.path.exists(final_try_on_image_path):
+            return {"error": "Mô hình VITON không tạo ra file output."}
+        
+        # Trả về file ảnh kết quả
+        return FileResponse(final_try_on_image_path, media_type="image/png")
+
+    except Exception as e:
+        # Cân nhắc dọn dẹp file tạm ở đây nếu cần
+        return {"error": f"Lỗi trong quá trình chạy mô hình VITON: {e}"}
+
+# --- Chạy FastAPI app (ví dụ với uvicorn) ---
+# Để chạy: mở terminal, cd vào thư mục chứa file này và chạy:
+# uvicorn main:app --reload
+# (main là tên file .py, app là tên biến FastAPI instance)
+
+if __name__ == "__main__":
+    import uvicorn
+    print("Để chạy API, sử dụng lệnh: uvicorn main:app --reload --host 0.0.0.0 --port 8000")
+    uvicorn.run(app, host="0.0.0.0", port=8000) # B�� comment để chạy trực tiếp khi thực thi file

VITON-Extends_test/components.json

@@ -0,0 +1,21 @@
+{
+  "$schema": "https://ui.shadcn.com/schema.json",
+  "style": "default",
+  "rsc": true,
+  "tsx": true,
+  "tailwind": {
+    "config": "tailwind.config.ts",
+    "css": "app/globals.css",
+    "baseColor": "neutral",
+    "cssVariables": true,
+    "prefix": ""
+  },
+  "aliases": {
+    "components": "@/components",
+    "utils": "@/lib/utils",
+    "ui": "@/components/ui",
+    "lib": "@/lib",
+    "hooks": "@/hooks"
+  },
+  "iconLibrary": "lucide"
+}

VITON-Extends_test/demo.txt

@@ -0,0 +1 @@
+000129_0.jpg 007365_1.jpg

VITON-Extends_test/demo1.txt

@@ -0,0 +1,2032 @@
+000001_0.jpg 001744_1.jpg
+000010_0.jpg 004325_1.jpg
+000020_0.jpg 002022_1.jpg
+000028_0.jpg 014652_1.jpg
+000038_0.jpg 010143_1.jpg
+000048_0.jpg 010608_1.jpg
+000057_0.jpg 012578_1.jpg
+000066_0.jpg 009595_1.jpg
+000074_0.jpg 015392_1.jpg
+000082_0.jpg 003291_1.jpg
+000097_0.jpg 019522_1.jpg
+000109_0.jpg 018778_1.jpg
+000118_0.jpg 005533_1.jpg
+000129_0.jpg 007365_1.jpg
+000143_0.jpg 016246_1.jpg
+000154_0.jpg 003898_1.jpg
+000164_0.jpg 003514_1.jpg
+000174_0.jpg 016866_1.jpg
+000183_0.jpg 019332_1.jpg
+000192_0.jpg 007692_1.jpg
+000200_0.jpg 015272_1.jpg
+000209_0.jpg 013780_1.jpg
+000220_0.jpg 001360_1.jpg
+000228_0.jpg 019540_1.jpg
+000240_0.jpg 018746_1.jpg
+000248_0.jpg 001583_1.jpg
+000258_0.jpg 019037_1.jpg
+000266_0.jpg 015836_1.jpg
+000274_0.jpg 008560_1.jpg
+000284_0.jpg 019552_1.jpg
+000293_0.jpg 007415_1.jpg
+000303_0.jpg 013245_1.jpg
+000312_0.jpg 007484_1.jpg
+000320_0.jpg 019029_1.jpg
+000330_0.jpg 005053_1.jpg
+000339_0.jpg 001879_1.jpg
+000347_0.jpg 016367_1.jpg
+000356_0.jpg 014701_1.jpg
+000370_0.jpg 002397_1.jpg
+000378_0.jpg 005666_1.jpg
+000386_0.jpg 015308_1.jpg
+000395_0.jpg 011689_1.jpg
+000404_0.jpg 004922_1.jpg
+000417_0.jpg 008406_1.jpg
+000426_0.jpg 014794_1.jpg
+000437_0.jpg 000846_1.jpg
+000445_0.jpg 008645_1.jpg
+000456_0.jpg 015759_1.jpg
+000466_0.jpg 000514_1.jpg
+000477_0.jpg 006976_1.jpg
+000488_0.jpg 007986_1.jpg
+000501_0.jpg 016300_1.jpg
+000514_0.jpg 012652_1.jpg
+000523_0.jpg 017868_1.jpg
+000532_0.jpg 013214_1.jpg
+000542_0.jpg 014149_1.jpg
+000560_0.jpg 006640_1.jpg
+000568_0.jpg 004342_1.jpg
+000576_0.jpg 001192_1.jpg
+000585_0.jpg 008471_1.jpg
+000593_0.jpg 003998_1.jpg
+000602_0.jpg 012860_1.jpg
+000610_0.jpg 014979_1.jpg
+000619_0.jpg 008744_1.jpg
+000629_0.jpg 001144_1.jpg
+000639_0.jpg 008420_1.jpg
+000651_0.jpg 003422_1.jpg
+000659_0.jpg 015362_1.jpg
+000668_0.jpg 008959_1.jpg
+000676_0.jpg 010105_1.jpg
+000685_0.jpg 011944_1.jpg
+000696_0.jpg 012605_1.jpg
+000706_0.jpg 016474_1.jpg
+000716_0.jpg 006808_1.jpg
+000724_0.jpg 007243_1.jpg
+000734_0.jpg 014888_1.jpg
+000742_0.jpg 009390_1.jpg
+000750_0.jpg 013654_1.jpg
+000760_0.jpg 005368_1.jpg
+000768_0.jpg 017886_1.jpg
+000776_0.jpg 008506_1.jpg
+000786_0.jpg 007957_1.jpg
+000795_0.jpg 006859_1.jpg
+000803_0.jpg 005203_1.jpg
+000812_0.jpg 003821_1.jpg
+000827_0.jpg 002297_1.jpg
+000837_0.jpg 004710_1.jpg
+000846_0.jpg 001606_1.jpg
+000855_0.jpg 011816_1.jpg
+000867_0.jpg 002111_1.jpg
+000877_0.jpg 010543_1.jpg
+000889_0.jpg 004080_1.jpg
+000898_0.jpg 011173_1.jpg
+000907_0.jpg 004123_1.jpg
+000915_0.jpg 016049_1.jpg
+000924_0.jpg 007286_1.jpg
+000934_0.jpg 017466_1.jpg
+000943_0.jpg 010463_1.jpg
+000957_0.jpg 012322_1.jpg
+000968_0.jpg 005328_1.jpg
+000979_0.jpg 014765_1.jpg
+000988_0.jpg 016059_1.jpg
+000997_0.jpg 019224_1.jpg
+001009_0.jpg 000889_1.jpg
+001017_0.jpg 010744_1.jpg
+001028_0.jpg 004844_1.jpg
+001038_0.jpg 003721_1.jpg
+001048_0.jpg 002076_1.jpg
+001056_0.jpg 005396_1.jpg
+001064_0.jpg 017438_1.jpg
+001073_0.jpg 000724_1.jpg
+001083_0.jpg 007609_1.jpg
+001092_0.jpg 000154_1.jpg
+001101_0.jpg 018962_1.jpg
+001109_0.jpg 016951_1.jpg
+001118_0.jpg 002874_1.jpg
+001126_0.jpg 011042_1.jpg
+001136_0.jpg 019045_1.jpg
+001144_0.jpg 016172_1.jpg
+001153_0.jpg 018210_1.jpg
+001162_0.jpg 019009_1.jpg
+001173_0.jpg 007505_1.jpg
+001181_0.jpg 002103_1.jpg
+001192_0.jpg 017002_1.jpg
+001203_0.jpg 009236_1.jpg
+001211_0.jpg 014192_1.jpg
+001219_0.jpg 009995_1.jpg
+001228_0.jpg 003731_1.jpg
+001236_0.jpg 007149_1.jpg
+001245_0.jpg 010891_1.jpg
+001255_0.jpg 017091_1.jpg
+001269_0.jpg 014262_1.jpg
+001283_0.jpg 002137_1.jpg
+001292_0.jpg 013047_1.jpg
+001301_0.jpg 003813_1.jpg
+001310_0.jpg 014854_1.jpg
+001320_0.jpg 003208_1.jpg
+001328_0.jpg 011615_1.jpg
+001337_0.jpg 012174_1.jpg
+001349_0.jpg 008241_1.jpg
+001360_0.jpg 008451_1.jpg
+001369_0.jpg 019279_1.jpg
+001378_0.jpg 000466_1.jpg
+001387_0.jpg 015325_1.jpg
+001399_0.jpg 005711_1.jpg
+001408_0.jpg 002980_1.jpg
+001419_0.jpg 010337_1.jpg
+001428_0.jpg 007617_1.jpg
+001437_0.jpg 001476_1.jpg
+001448_0.jpg 016067_1.jpg
+001457_0.jpg 008804_1.jpg
+001467_0.jpg 017235_1.jpg
+001476_0.jpg 010281_1.jpg
+001485_0.jpg 018420_1.jpg
+001494_0.jpg 008928_1.jpg
+001502_0.jpg 015150_1.jpg
+001512_0.jpg 018031_1.jpg
+001520_0.jpg 012395_1.jpg
+001528_0.jpg 015688_1.jpg
+001537_0.jpg 001825_1.jpg
+001547_0.jpg 003357_1.jpg
+001559_0.jpg 011190_1.jpg
+001567_0.jpg 001567_1.jpg
+001575_0.jpg 018544_1.jpg
+001583_0.jpg 019087_1.jpg
+001594_0.jpg 013527_1.jpg
+001606_0.jpg 010115_1.jpg
+001614_0.jpg 005975_1.jpg
+001623_0.jpg 010300_1.jpg
+001635_0.jpg 019573_1.jpg
+001645_0.jpg 009342_1.jpg
+001655_0.jpg 000576_1.jpg
+001664_0.jpg 004061_1.jpg
+001673_0.jpg 008863_1.jpg
+001683_0.jpg 008206_1.jpg
+001695_0.jpg 017175_1.jpg
+001706_0.jpg 010735_1.jpg
+001715_0.jpg 006581_1.jpg
+001725_0.jpg 002892_1.jpg
+001735_0.jpg 001645_1.jpg
+001744_0.jpg 001328_1.jpg
+001756_0.jpg 002999_1.jpg
+001765_0.jpg 006834_1.jpg
+001776_0.jpg 007899_1.jpg
+001789_0.jpg 011288_1.jpg
+001798_0.jpg 001735_1.jpg
+001809_0.jpg 010995_1.jpg
+001817_0.jpg 003777_1.jpg
+001825_0.jpg 017945_1.jpg
+001834_0.jpg 005044_1.jpg
+001845_0.jpg 000395_1.jpg
+001858_0.jpg 019402_1.jpg
+001868_0.jpg 011270_1.jpg
+001879_0.jpg 004727_1.jpg
+001891_0.jpg 018348_1.jpg
+001900_0.jpg 011544_1.jpg
+001908_0.jpg 011515_1.jpg
+001919_0.jpg 001211_1.jpg
+001928_0.jpg 013155_1.jpg
+001937_0.jpg 005887_1.jpg
+001947_0.jpg 002990_1.jpg
+001957_0.jpg 002749_1.jpg
+001966_0.jpg 007932_1.jpg
+001974_0.jpg 008101_1.jpg
+001983_0.jpg 004423_1.jpg
+001991_0.jpg 004981_1.jpg
+002000_0.jpg 016628_1.jpg
+002011_0.jpg 005440_1.jpg
+002022_0.jpg 017204_1.jpg
+002031_0.jpg 008967_1.jpg
+002039_0.jpg 018769_1.jpg
+002049_0.jpg 003124_1.jpg
+002059_0.jpg 008092_1.jpg
+002068_0.jpg 010415_1.jpg
+002076_0.jpg 000716_1.jpg
+002085_0.jpg 001236_1.jpg
+002093_0.jpg 018971_1.jpg
+002103_0.jpg 017070_1.jpg
+002111_0.jpg 017012_1.jpg
+002119_0.jpg 016445_1.jpg
+002128_0.jpg 005360_1.jpg
+002137_0.jpg 015579_1.jpg
+002147_0.jpg 005603_1.jpg
+002156_0.jpg 018431_1.jpg
+002169_0.jpg 009094_1.jpg
+002180_0.jpg 019066_1.jpg
+002191_0.jpg 009215_1.jpg
+002200_0.jpg 008632_1.jpg
+002208_0.jpg 009435_1.jpg
+002217_0.jpg 002119_1.jpg
+002226_0.jpg 016145_1.jpg
+002236_0.jpg 006213_1.jpg
+002248_0.jpg 012338_1.jpg
+002259_0.jpg 013391_1.jpg
+002268_0.jpg 000760_1.jpg
+002276_0.jpg 003338_1.jpg
+002287_0.jpg 018569_1.jpg
+002297_0.jpg 013883_1.jpg
+002307_0.jpg 014416_1.jpg
+002317_0.jpg 017243_1.jpg
+002327_0.jpg 015724_1.jpg
+002337_0.jpg 002439_1.jpg
+002345_0.jpg 015607_1.jpg
+002353_0.jpg 016653_1.jpg
+002362_0.jpg 018401_1.jpg
+002371_0.jpg 005877_1.jpg
+002379_0.jpg 011240_1.jpg
+002388_0.jpg 005081_1.jpg
+002397_0.jpg 009496_1.jpg
+002405_0.jpg 018496_1.jpg
+002413_0.jpg 008023_1.jpg
+002422_0.jpg 015125_1.jpg
+002431_0.jpg 007797_1.jpg
+002439_0.jpg 004185_1.jpg
+002447_0.jpg 000240_1.jpg
+002455_0.jpg 011891_1.jpg
+002464_0.jpg 010851_1.jpg
+002474_0.jpg 004268_1.jpg
+002486_0.jpg 017348_1.jpg
+002494_0.jpg 013836_1.jpg
+002502_0.jpg 004333_1.jpg
+002511_0.jpg 000020_1.jpg
+002523_0.jpg 009114_1.jpg
+002533_0.jpg 019340_1.jpg
+002545_0.jpg 004006_1.jpg
+002553_0.jpg 012763_1.jpg
+002561_0.jpg 012644_1.jpg
+002575_0.jpg 012996_1.jpg
+002589_0.jpg 013891_1.jpg
+002599_0.jpg 005648_1.jpg
+002610_0.jpg 015465_1.jpg
+002620_0.jpg 003749_1.jpg
+002628_0.jpg 016739_1.jpg
+002639_0.jpg 000143_1.jpg
+002651_0.jpg 016636_1.jpg
+002659_0.jpg 003935_1.jpg
+002670_0.jpg 010710_1.jpg
+002681_0.jpg 000312_1.jpg
+002691_0.jpg 015256_1.jpg
+002699_0.jpg 001118_1.jpg
+002712_0.jpg 013583_1.jpg
+002720_0.jpg 019514_1.jpg
+002728_0.jpg 001991_1.jpg
+002739_0.jpg 005952_1.jpg
+002749_0.jpg 011523_1.jpg
+002758_0.jpg 012256_1.jpg
+002769_0.jpg 010806_1.jpg
+002778_0.jpg 001512_1.jpg
+002787_0.jpg 002787_1.jpg
+002795_0.jpg 018138_1.jpg
+002803_0.jpg 016238_1.jpg
+002812_0.jpg 004497_1.jpg
+002820_0.jpg 011761_1.jpg
+002828_0.jpg 000968_1.jpg
+002839_0.jpg 009178_1.jpg
+002852_0.jpg 007261_1.jpg
+002865_0.jpg 004167_1.jpg
+002874_0.jpg 008429_1.jpg
+002883_0.jpg 009141_1.jpg
+002892_0.jpg 016290_1.jpg
+002901_0.jpg 015627_1.jpg
+002911_0.jpg 013355_1.jpg
+002922_0.jpg 012975_1.jpg
+002930_0.jpg 016002_1.jpg
+002942_0.jpg 015371_1.jpg
+002952_0.jpg 011381_1.jpg
+002962_0.jpg 012553_1.jpg
+002970_0.jpg 016593_1.jpg
+002980_0.jpg 004366_1.jpg
+002990_0.jpg 003684_1.jpg
+002999_0.jpg 018393_1.jpg
+003008_0.jpg 007455_1.jpg
+003016_0.jpg 012811_1.jpg
+003024_0.jpg 001245_1.jpg
+003032_0.jpg 005797_1.jpg
+003041_0.jpg 001673_1.jpg
+003049_0.jpg 008822_1.jpg
+003060_0.jpg 002720_1.jpg
+003069_0.jpg 013680_1.jpg
+003077_0.jpg 000639_1.jpg
+003086_0.jpg 006057_1.jpg
+003094_0.jpg 018452_1.jpg
+003107_0.jpg 002795_1.jpg
+003115_0.jpg 007772_1.jpg
+003124_0.jpg 010591_1.jpg
+003133_0.jpg 010125_1.jpg
+003142_0.jpg 011068_1.jpg
+003150_0.jpg 011736_1.jpg
+003158_0.jpg 012350_1.jpg
+003167_0.jpg 006606_1.jpg
+003179_0.jpg 010937_1.jpg
+003187_0.jpg 011212_1.jpg
+003195_0.jpg 009282_1.jpg
+003208_0.jpg 001255_1.jpg
+003218_0.jpg 016541_1.jpg
+003226_0.jpg 010177_1.jpg
+003236_0.jpg 005251_1.jpg
+003250_0.jpg 017410_1.jpg
+003259_0.jpg 002639_1.jpg
+003270_0.jpg 017796_1.jpg
+003280_0.jpg 017526_1.jpg
+003291_0.jpg 011708_1.jpg
+003303_0.jpg 003491_1.jpg
+003311_0.jpg 013827_1.jpg
+003319_0.jpg 015192_1.jpg
+003328_0.jpg 012273_1.jpg
+003338_0.jpg 010567_1.jpg
+003349_0.jpg 001101_1.jpg
+003357_0.jpg 013374_1.jpg
+003367_0.jpg 002353_1.jpg
+003376_0.jpg 014006_1.jpg
+003386_0.jpg 018479_1.jpg
+003395_0.jpg 010726_1.jpg
+003404_0.jpg 015844_1.jpg
+003414_0.jpg 000855_1.jpg
+003422_0.jpg 000456_1.jpg
+003434_0.jpg 010718_1.jpg
+003443_0.jpg 003945_1.jpg
+003451_0.jpg 011336_1.jpg
+003461_0.jpg 004814_1.jpg
+003472_0.jpg 006470_1.jpg
+003481_0.jpg 016726_1.jpg
+003491_0.jpg 017298_1.jpg
+003501_0.jpg 010270_1.jpg
+003514_0.jpg 018608_1.jpg
+003526_0.jpg 001858_1.jpg
+003535_0.jpg 009852_1.jpg
+003545_0.jpg 002085_1.jpg
+003555_0.jpg 013564_1.jpg
+003565_0.jpg 005525_1.jpg
+003578_0.jpg 013007_1.jpg
+003591_0.jpg 005720_1.jpg
+003600_0.jpg 015938_1.jpg
+003611_0.jpg 013715_1.jpg
+003621_0.jpg 000274_1.jpg
+003632_0.jpg 000585_1.jpg
+003641_0.jpg 014876_1.jpg
+003649_0.jpg 019140_1.jpg
+003658_0.jpg 016465_1.jpg
+003668_0.jpg 010234_1.jpg
+003676_0.jpg 007601_1.jpg
+003684_0.jpg 006381_1.jpg
+003693_0.jpg 015590_1.jpg
+003703_0.jpg 011883_1.jpg
+003712_0.jpg 014621_1.jpg
+003721_0.jpg 001126_1.jpg
+003731_0.jpg 015715_1.jpg
+003739_0.jpg 004804_1.jpg
+003749_0.jpg 014140_1.jpg
+003760_0.jpg 008397_1.jpg
+003768_0.jpg 015697_1.jpg
+003777_0.jpg 000082_1.jpg
+003787_0.jpg 001966_1.jpg
+003795_0.jpg 003414_1.jpg
+003803_0.jpg 011916_1.jpg
+003813_0.jpg 014612_1.jpg
+003821_0.jpg 014292_1.jpg
+003833_0.jpg 008326_1.jpg
+003842_0.jpg 012219_1.jpg
+003852_0.jpg 011466_1.jpg
+003861_0.jpg 011962_1.jpg
+003874_0.jpg 014349_1.jpg
+003882_0.jpg 017583_1.jpg
+003890_0.jpg 018921_1.jpg
+003898_0.jpg 004196_1.jpg
+003915_0.jpg 013688_1.jpg
+003925_0.jpg 004397_1.jpg
+003935_0.jpg 012889_1.jpg
+003945_0.jpg 000898_1.jpg
+003953_0.jpg 002379_1.jpg
+003963_0.jpg 008160_1.jpg
+003972_0.jpg 012694_1.jpg
+003981_0.jpg 008307_1.jpg
+003990_0.jpg 004636_1.jpg
+003998_0.jpg 007405_1.jpg
+004006_0.jpg 001725_1.jpg
+004015_0.jpg 015785_1.jpg
+004023_0.jpg 000488_1.jpg
+004033_0.jpg 010583_1.jpg
+004042_0.jpg 004580_1.jpg
+004051_0.jpg 000028_1.jpg
+004061_0.jpg 012531_1.jpg
+004071_0.jpg 012838_1.jpg
+004080_0.jpg 012006_1.jpg
+004091_0.jpg 002769_1.jpg
+004099_0.jpg 000320_1.jpg
+004107_0.jpg 005317_1.jpg
+004115_0.jpg 009949_1.jpg
+004123_0.jpg 008196_1.jpg
+004131_0.jpg 013199_1.jpg
+004139_0.jpg 017814_1.jpg
+004148_0.jpg 017555_1.jpg
+004158_0.jpg 017130_1.jpg
+004167_0.jpg 005388_1.jpg
+004177_0.jpg 015133_1.jpg
+004185_0.jpg 000501_1.jpg
+004196_0.jpg 004158_1.jpg
+004210_0.jpg 008663_1.jpg
+004220_0.jpg 014332_1.jpg
+004234_0.jpg 009766_1.jpg
+004243_0.jpg 010454_1.jpg
+004252_0.jpg 004553_1.jpg
+004260_0.jpg 013899_1.jpg
+004268_0.jpg 017474_1.jpg
+004277_0.jpg 017545_1.jpg
+004285_0.jpg 008110_1.jpg
+004294_0.jpg 015560_1.jpg
+004304_0.jpg 009689_1.jpg
+004314_0.jpg 017896_1.jpg
+004325_0.jpg 003600_1.jpg
+004333_0.jpg 007579_1.jpg
+004342_0.jpg 018460_1.jpg
+004357_0.jpg 001559_1.jpg
+004366_0.jpg 002812_1.jpg
+004378_0.jpg 008367_1.jpg
+004387_0.jpg 010244_1.jpg
+004397_0.jpg 008672_1.jpg
+004415_0.jpg 002000_1.jpg
+004423_0.jpg 011034_1.jpg
+004431_0.jpg 001181_1.jpg
+004441_0.jpg 009545_1.jpg
+004451_0.jpg 007789_1.jpg
+004462_0.jpg 004015_1.jpg
+004470_0.jpg 008900_1.jpg
+004478_0.jpg 011015_1.jpg
+004487_0.jpg 003349_1.jpg
+004497_0.jpg 015209_1.jpg
+004508_0.jpg 009709_1.jpg
+004516_0.jpg 001974_1.jpg
+004529_0.jpg 005995_1.jpg
+004537_0.jpg 019429_1.jpg
+004545_0.jpg 014396_1.jpg
+004553_0.jpg 017400_1.jpg
+004561_0.jpg 019174_1.jpg
+004572_0.jpg 002180_1.jpg
+004580_0.jpg 019252_1.jpg
+004590_0.jpg 011833_1.jpg
+004598_0.jpg 014939_1.jpg
+004609_0.jpg 013698_1.jpg
+004620_0.jpg 002464_1.jpg
+004628_0.jpg 011825_1.jpg
+004636_0.jpg 013806_1.jpg
+004646_0.jpg 001109_1.jpg
+004657_0.jpg 000258_1.jpg
+004666_0.jpg 002628_1.jpg
+004674_0.jpg 007732_1.jpg
+004683_0.jpg 012330_1.jpg
+004691_0.jpg 019287_1.jpg
+004702_0.jpg 010869_1.jpg
+004710_0.jpg 005022_1.jpg
+004718_0.jpg 017496_1.jpg
+004727_0.jpg 008771_1.jpg
+004737_0.jpg 000248_1.jpg
+004745_0.jpg 014591_1.jpg
+004758_0.jpg 001715_1.jpg
+004766_0.jpg 004628_1.jpg
+004774_0.jpg 005120_1.jpg
+004785_0.jpg 000445_1.jpg
+004795_0.jpg 005262_1.jpg
+004804_0.jpg 013907_1.jpg
+004814_0.jpg 002268_1.jpg
+004823_0.jpg 000183_1.jpg
+004833_0.jpg 014014_1.jpg
+004844_0.jpg 015497_1.jpg
+004854_0.jpg 018047_1.jpg
+004867_0.jpg 016777_1.jpg
+004878_0.jpg 013338_1.jpg
+004888_0.jpg 006429_1.jpg
+004896_0.jpg 015803_1.jpg
+004904_0.jpg 012072_1.jpg
+004912_0.jpg 009605_1.jpg
+004922_0.jpg 000934_1.jpg
+004933_0.jpg 010381_1.jpg
+004941_0.jpg 016533_1.jpg
+004949_0.jpg 004451_1.jpg
+004957_0.jpg 006959_1.jpg
+004965_0.jpg 018532_1.jpg
+004981_0.jpg 002820_1.jpg
+004989_0.jpg 010261_1.jpg
+004997_0.jpg 004933_1.jpg
+005006_0.jpg 004415_1.jpg
+005014_0.jpg 008891_1.jpg
+005022_0.jpg 009780_1.jpg
+005031_0.jpg 003218_1.jpg
+005044_0.jpg 012944_1.jpg
+005053_0.jpg 012127_1.jpg
+005062_0.jpg 015767_1.jpg
+005072_0.jpg 018826_1.jpg
+005081_0.jpg 013410_1.jpg
+005091_0.jpg 012404_1.jpg
+005101_0.jpg 007304_1.jpg
+005110_0.jpg 005349_1.jpg
+005120_0.jpg 003842_1.jpg
+005131_0.jpg 007473_1.jpg
+005145_0.jpg 003693_1.jpg
+005153_0.jpg 006658_1.jpg
+005166_0.jpg 007446_1.jpg
+005175_0.jpg 007434_1.jpg
+005186_0.jpg 013948_1.jpg
+005195_0.jpg 002561_1.jpg
+005203_0.jpg 016888_1.jpg
+005213_0.jpg 015264_1.jpg
+005222_0.jpg 007065_1.jpg
+005231_0.jpg 002431_1.jpg
+005241_0.jpg 006789_1.jpg
+005251_0.jpg 014314_1.jpg
+005262_0.jpg 018192_1.jpg
+005271_0.jpg 011954_1.jpg
+005285_0.jpg 006285_1.jpg
+005298_0.jpg 015280_1.jpg
+005306_0.jpg 018681_1.jpg
+005317_0.jpg 011436_1.jpg
+005328_0.jpg 000997_1.jpg
+005336_0.jpg 000404_1.jpg
+005349_0.jpg 006717_1.jpg
+005360_0.jpg 010967_1.jpg
+005368_0.jpg 005379_1.jpg
+005379_0.jpg 016962_1.jpg
+005388_0.jpg 006137_1.jpg
+005396_0.jpg 012545_1.jpg
+005404_0.jpg 013572_1.jpg
+005413_0.jpg 005413_1.jpg
+005422_0.jpg 018470_1.jpg
+005430_0.jpg 004537_1.jpg
+005440_0.jpg 015825_1.jpg
+005449_0.jpg 017904_1.jpg
+005457_0.jpg 017315_1.jpg
+005470_0.jpg 010599_1.jpg
+005480_0.jpg 000988_1.jpg
+005489_0.jpg 007518_1.jpg
+005501_0.jpg 008784_1.jpg
+005510_0.jpg 004294_1.jpg
+005525_0.jpg 006339_1.jpg
+005533_0.jpg 016662_1.jpg
+005542_0.jpg 007345_1.jpg
+005552_0.jpg 012505_1.jpg
+005562_0.jpg 007864_1.jpg
+005570_0.jpg 010481_1.jpg
+005578_0.jpg 019454_1.jpg
+005586_0.jpg 019494_1.jpg
+005594_0.jpg 006016_1.jpg
+005603_0.jpg 017667_1.jpg
+005614_0.jpg 019110_1.jpg
+005622_0.jpg 010947_1.jpg
+005631_0.jpg 019384_1.jpg
+005648_0.jpg 018946_1.jpg
+005657_0.jpg 003443_1.jpg
+005666_0.jpg 016281_1.jpg
+005675_0.jpg 001301_1.jpg
+005683_0.jpg 012099_1.jpg
+005691_0.jpg 011355_1.jpg
+005702_0.jpg 001798_1.jpg
+005711_0.jpg 010096_1.jpg
+005720_0.jpg 009758_1.jpg
+005728_0.jpg 014114_1.jpg
+005737_0.jpg 012063_1.jpg
+005747_0.jpg 004529_1.jpg
+005755_0.jpg 014370_1.jpg
+005763_0.jpg 007834_1.jpg
+005771_0.jpg 018069_1.jpg
+005784_0.jpg 018700_1.jpg
+005797_0.jpg 015881_1.jpg
+005809_0.jpg 010371_1.jpg
+005820_0.jpg 016899_1.jpg
+005828_0.jpg 002049_1.jpg
+005837_0.jpg 016183_1.jpg
+005846_0.jpg 008006_1.jpg
+005857_0.jpg 010628_1.jpg
+005866_0.jpg 013469_1.jpg
+005877_0.jpg 010021_1.jpg
+005887_0.jpg 013593_1.jpg
+005898_0.jpg 000057_1.jpg
+005908_0.jpg 000867_1.jpg
+005920_0.jpg 013327_1.jpg
+005929_0.jpg 011401_1.jpg
+005940_0.jpg 000593_1.jpg
+005952_0.jpg 014201_1.jpg
+005963_0.jpg 009922_1.jpg
+005975_0.jpg 010431_1.jpg
+005984_0.jpg 007710_1.jpg
+005995_0.jpg 001083_1.jpg
+006004_0.jpg 018954_1.jpg
+006016_0.jpg 010691_1.jpg
+006026_0.jpg 003641_1.jpg
+006036_0.jpg 000750_1.jpg
+006045_0.jpg 008681_1.jpg
+006057_0.jpg 010910_1.jpg
+006065_0.jpg 011415_1.jpg
+006073_0.jpg 010840_1.jpg
+006081_0.jpg 008908_1.jpg
+006090_0.jpg 007997_1.jpg
+006099_0.jpg 015900_1.jpg
+006110_0.jpg 009034_1.jpg
+006118_0.jpg 015861_1.jpg
+006129_0.jpg 006165_1.jpg
+006137_0.jpg 008379_1.jpg
+006145_0.jpg 016379_1.jpg
+006155_0.jpg 016878_1.jpg
+006165_0.jpg 010040_1.jpg
+006173_0.jpg 001776_1.jpg
+006186_0.jpg 007891_1.jpg
+006194_0.jpg 015969_1.jpg
+006203_0.jpg 005820_1.jpg
+006213_0.jpg 014900_1.jpg
+006224_0.jpg 016748_1.jpg
+006232_0.jpg 010636_1.jpg
+006241_0.jpg 018327_1.jpg
+006250_0.jpg 013097_1.jpg
+006260_0.jpg 007103_1.jpg
+006268_0.jpg 007073_1.jpg
+006276_0.jpg 011128_1.jpg
+006285_0.jpg 019319_1.jpg
+006296_0.jpg 002952_1.jpg
+006304_0.jpg 002371_1.jpg
+006313_0.jpg 014553_1.jpg
+006321_0.jpg 014489_1.jpg
+006329_0.jpg 005866_1.jpg
+006339_0.jpg 019368_1.jpg
+006347_0.jpg 006402_1.jpg
+006358_0.jpg 002422_1.jpg
+006371_0.jpg 011842_1.jpg
+006381_0.jpg 019446_1.jpg
+006393_0.jpg 012015_1.jpg
+006402_0.jpg 013382_1.jpg
+006410_0.jpg 000038_1.jpg
+006419_0.jpg 014959_1.jpg
+006429_0.jpg 018837_1.jpg
+006440_0.jpg 017750_1.jpg
+006452_0.jpg 003259_1.jpg
+006462_0.jpg 018009_1.jpg
+006470_0.jpg 013309_1.jpg
+006478_0.jpg 014712_1.jpg
+006486_0.jpg 000228_1.jpg
+006494_0.jpg 005614_1.jpg
+006502_0.jpg 010535_1.jpg
+006512_0.jpg 007741_1.jpg
+006523_0.jpg 015990_1.jpg
+006535_0.jpg 011231_1.jpg
+006545_0.jpg 016584_1.jpg
+006555_0.jpg 015105_1.jpg
+006563_0.jpg 001494_1.jpg
+006571_0.jpg 007376_1.jpg
+006581_0.jpg 003404_1.jpg
+006589_0.jpg 008346_1.jpg
+006597_0.jpg 008014_1.jpg
+006606_0.jpg 002511_1.jpg
+006620_0.jpg 017196_1.jpg
+006628_0.jpg 009084_1.jpg
+006640_0.jpg 014086_1.jpg
+006649_0.jpg 004508_1.jpg
+006658_0.jpg 014131_1.jpg
+006670_0.jpg 000979_1.jpg
+006678_0.jpg 002523_1.jpg
+006688_0.jpg 011988_1.jpg
+006697_0.jpg 018200_1.jpg
+006709_0.jpg 017840_1.jpg
+006717_0.jpg 018524_1.jpg
+006728_0.jpg 013418_1.jpg
+006738_0.jpg 011457_1.jpg
+006748_0.jpg 016031_1.jpg
+006757_0.jpg 001520_1.jpg
+006768_0.jpg 008172_1.jpg
+006776_0.jpg 000651_1.jpg
+006789_0.jpg 017110_1.jpg
+006799_0.jpg 001292_1.jpg
+006808_0.jpg 002128_1.jpg
+006817_0.jpg 004357_1.jpg
+006825_0.jpg 012245_1.jpg
+006834_0.jpg 014324_1.jpg
+006842_0.jpg 009635_1.jpg
+006850_0.jpg 012166_1.jpg
+006859_0.jpg 003086_1.jpg
+006868_0.jpg 010859_1.jpg
+006881_0.jpg 004646_1.jpg
+006889_0.jpg 014507_1.jpg
+006897_0.jpg 012849_1.jpg
+006908_0.jpg 006535_1.jpg
+006916_0.jpg 000696_1.jpg
+006928_0.jpg 017290_1.jpg
+006937_0.jpg 008276_1.jpg
+006945_0.jpg 009197_1.jpg
+006959_0.jpg 013706_1.jpg
+006968_0.jpg 015908_1.jpg
+006976_0.jpg 018929_1.jpg
+006984_0.jpg 005631_1.jpg
+006992_0.jpg 000837_1.jpg
+007003_0.jpg 010168_1.jpg
+007013_0.jpg 006984_1.jpg
+007021_0.jpg 006321_1.jpg
+007029_0.jpg 007808_1.jpg
+007037_0.jpg 011278_1.jpg
+007045_0.jpg 008496_1.jpg
+007056_0.jpg 016943_1.jpg
+007065_0.jpg 015381_1.jpg
+007073_0.jpg 007013_1.jpg
+007086_0.jpg 017264_1.jpg
+007094_0.jpg 004210_1.jpg
+007103_0.jpg 011585_1.jpg
+007113_0.jpg 016992_1.jpg
+007121_0.jpg 009263_1.jpg
+007129_0.jpg 000220_1.jpg
+007138_0.jpg 017428_1.jpg
+007149_0.jpg 010816_1.jpg
+007159_0.jpg 018227_1.jpg
+007168_0.jpg 002589_1.jpg
+007180_0.jpg 011300_1.jpg
+007188_0.jpg 000943_1.jpg
+007199_0.jpg 016358_1.jpg
+007212_0.jpg 007094_1.jpg
+007221_0.jpg 002962_1.jpg
+007232_0.jpg 005570_1.jpg
+007243_0.jpg 004888_1.jpg
+007252_0.jpg 003803_1.jpg
+007261_0.jpg 006850_1.jpg
+007269_0.jpg 017639_1.jpg
+007278_0.jpg 001369_1.jpg
+007286_0.jpg 009131_1.jpg
+007294_0.jpg 004774_1.jpg
+007304_0.jpg 003395_1.jpg
+007313_0.jpg 014184_1.jpg
+007324_0.jpg 008847_1.jpg
+007336_0.jpg 001537_1.jpg
+007345_0.jpg 015979_1.jpg
+007357_0.jpg 019561_1.jpg
+007365_0.jpg 005828_1.jpg
+007376_0.jpg 010078_1.jpg
+007388_0.jpg 006945_1.jpg
+007397_0.jpg 012236_1.jpg
+007405_0.jpg 015732_1.jpg
+007415_0.jpg 009426_1.jpg
+007423_0.jpg 012879_1.jpg
+007434_0.jpg 012597_1.jpg
+007446_0.jpg 015317_1.jpg
+007455_0.jpg 009274_1.jpg
+007463_0.jpg 003016_1.jpg
+007473_0.jpg 013725_1.jpg
+007484_0.jpg 003501_1.jpg
+007495_0.jpg 005908_1.jpg
+007505_0.jpg 011970_1.jpg
+007518_0.jpg 005784_1.jpg
+007526_0.jpg 015550_1.jpg
+007536_0.jpg 015853_1.jpg
+007549_0.jpg 015420_1.jpg
+007561_0.jpg 013036_1.jpg
+007570_0.jpg 005306_1.jpg
+007579_0.jpg 006628_1.jpg
+007592_0.jpg 001623_1.jpg
+007601_0.jpg 014463_1.jpg
+007609_0.jpg 009525_1.jpg
+007617_0.jpg 015085_1.jpg
+007628_0.jpg 000074_1.jpg
+007639_0.jpg 014477_1.jpg
+007648_0.jpg 004099_1.jpg
+007656_0.jpg 008138_1.jpg
+007664_0.jpg 002217_1.jpg
+007672_0.jpg 016550_1.jpg
+007681_0.jpg 004833_1.jpg
+007692_0.jpg 003852_1.jpg
+007702_0.jpg 015291_1.jpg
+007710_0.jpg 011050_1.jpg
+007719_0.jpg 005963_1.jpg
+007732_0.jpg 008715_1.jpg
+007741_0.jpg 019302_1.jpg
+007750_0.jpg 018690_1.jpg
+007762_0.jpg 006597_1.jpg
+007772_0.jpg 002691_1.jpg
+007781_0.jpg 002942_1.jpg
+007789_0.jpg 017370_1.jpg
+007797_0.jpg 006916_1.jpg
+007808_0.jpg 014844_1.jpg
+007817_0.jpg 015916_1.jpg
+007826_0.jpg 004766_1.jpg
+007834_0.jpg 011447_1.jpg
+007848_0.jpg 008051_1.jpg
+007856_0.jpg 000129_1.jpg
+007864_0.jpg 001017_1.jpg
+007874_0.jpg 004033_1.jpg
+007882_0.jpg 003890_1.jpg
+007891_0.jpg 008696_1.jpg
+007899_0.jpg 002317_1.jpg
+007914_0.jpg 019130_1.jpg
+007923_0.jpg 000417_1.jpg
+007932_0.jpg 011670_1.jpg
+007940_0.jpg 004441_1.jpg
+007949_0.jpg 018018_1.jpg
+007957_0.jpg 002599_1.jpg
+007966_0.jpg 017761_1.jpg
+007974_0.jpg 000523_1.jpg
+007986_0.jpg 011560_1.jpg
+007997_0.jpg 007592_1.jpg
+008006_0.jpg 004718_1.jpg
+008014_0.jpg 015006_1.jpg
+008023_0.jpg 000803_1.jpg
+008032_0.jpg 003167_1.jpg
+008041_0.jpg 006992_1.jpg
+008051_0.jpg 006697_1.jpg
+008062_0.jpg 009008_1.jpg
+008071_0.jpg 014805_1.jpg
+008080_0.jpg 003578_1.jpg
+008092_0.jpg 007113_1.jpg
+008101_0.jpg 011596_1.jpg
+008110_0.jpg 007628_1.jpg
+008118_0.jpg 005231_1.jpg
+008126_0.jpg 014816_1.jpg
+008138_0.jpg 000266_1.jpg
+008151_0.jpg 011392_1.jpg
+008160_0.jpg 013127_1.jpg
+008172_0.jpg 015026_1.jpg
+008180_0.jpg 009482_1.jpg
+008188_0.jpg 008938_1.jpg
+008196_0.jpg 004737_1.jpg
+008206_0.jpg 002865_1.jpg
+008214_0.jpg 018902_1.jpg
+008224_0.jpg 012626_1.jpg
+008233_0.jpg 002620_1.jpg
+008241_0.jpg 007826_1.jpg
+008250_0.jpg 002486_1.jpg
+008258_0.jpg 003158_1.jpg
+008266_0.jpg 015571_1.jpg
+008276_0.jpg 009418_1.jpg
+008285_0.jpg 004965_1.jpg
+008295_0.jpg 017678_1.jpg
+008307_0.jpg 001428_1.jpg
+008317_0.jpg 011577_1.jpg
+008326_0.jpg 006881_1.jpg
+008334_0.jpg 014863_1.jpg
+008346_0.jpg 014341_1.jpg
+008354_0.jpg 007914_1.jpg
+008367_0.jpg 004904_1.jpg
+008379_0.jpg 004957_1.jpg
+008389_0.jpg 004878_1.jpg
+008397_0.jpg 016786_1.jpg
+008406_0.jpg 015428_1.jpg
+008420_0.jpg 001448_1.jpg
+008429_0.jpg 005747_1.jpg
+008443_0.jpg 011087_1.jpg
+008451_0.jpg 000619_1.jpg
+008462_0.jpg 008224_1.jpg
+008471_0.jpg 012743_1.jpg
+008479_0.jpg 006129_1.jpg
+008487_0.jpg 001378_1.jpg
+008496_0.jpg 015141_1.jpg
+008506_0.jpg 006110_1.jpg
+008515_0.jpg 017630_1.jpg
+008523_0.jpg 002236_1.jpg
+008533_0.jpg 017457_1.jpg
+008542_0.jpg 010620_1.jpg
+008551_0.jpg 016799_1.jpg
+008560_0.jpg 016317_1.jpg
+008570_0.jpg 007648_1.jpg
+008580_0.jpg 018219_1.jpg
+008590_0.jpg 003179_1.jpg
+008598_0.jpg 010527_1.jpg
+008608_0.jpg 016716_1.jpg
+008616_0.jpg 010206_1.jpg
+008624_0.jpg 007664_1.jpg
+008632_0.jpg 019411_1.jpg
+008645_0.jpg 014434_1.jpg
+008653_0.jpg 018710_1.jpg
+008663_0.jpg 007397_1.jpg
+008672_0.jpg 010662_1.jpg
+008681_0.jpg 005552_1.jpg
+008696_0.jpg 014302_1.jpg
+008706_0.jpg 011097_1.jpg
+008715_0.jpg 001437_1.jpg
+008725_0.jpg 004304_1.jpg
+008736_0.jpg 012734_1.jpg
+008744_0.jpg 018796_1.jpg
+008753_0.jpg 003472_1.jpg
+008763_0.jpg 007856_1.jpg
+008771_0.jpg 005186_1.jpg
+008784_0.jpg 006329_1.jpg
+008793_0.jpg 014240_1.jpg
+008804_0.jpg 013490_1.jpg
+008813_0.jpg 011347_1.jpg
+008822_0.jpg 002553_1.jpg
+008830_0.jpg 017118_1.jpg
+008839_0.jpg 013989_1.jpg
+008847_0.jpg 012754_1.jpg
+008855_0.jpg 005241_1.jpg
+008863_0.jpg 018848_1.jpg
+008871_0.jpg 006738_1.jpg
+008881_0.jpg 002739_1.jpg
+008891_0.jpg 015816_1.jpg
+008900_0.jpg 019376_1.jpg
+008908_0.jpg 009975_1.jpg
+008919_0.jpg 011798_1.jpg
+008928_0.jpg 001337_1.jpg
+008938_0.jpg 009074_1.jpg
+008949_0.jpg 002039_1.jpg
+008959_0.jpg 002681_1.jpg
+008967_0.jpg 012033_1.jpg
+008976_0.jpg 006440_1.jpg
+008986_0.jpg 015524_1.jpg
+008997_0.jpg 003226_1.jpg
+009008_0.jpg 004691_1.jpg
+009016_0.jpg 013855_1.jpg
+009024_0.jpg 014379_1.jpg
+009034_0.jpg 012385_1.jpg
+009042_0.jpg 000685_1.jpg
+009054_0.jpg 015403_1.jpg
+009064_0.jpg 017449_1.jpg
+009074_0.jpg 018112_1.jpg
+009084_0.jpg 014220_1.jpg
+009094_0.jpg 014076_1.jpg
+009106_0.jpg 016039_1.jpg
+009114_0.jpg 010653_1.jpg
+009123_0.jpg 001756_1.jpg
+009131_0.jpg 003953_1.jpg
+009141_0.jpg 012917_1.jpg
+009149_0.jpg 015476_1.jpg
+009159_0.jpg 010762_1.jpg
+009169_0.jpg 017648_1.jpg
+009178_0.jpg 008919_1.jpg
+009189_0.jpg 007463_1.jpg
+009197_0.jpg 006065_1.jpg
+009205_0.jpg 014537_1.jpg
+009215_0.jpg 007252_1.jpg
+009228_0.jpg 007212_1.jpg
+009236_0.jpg 017622_1.jpg
+009246_0.jpg 007232_1.jpg
+009254_0.jpg 010918_1.jpg
+009263_0.jpg 016094_1.jpg
+009274_0.jpg 007221_1.jpg
+009282_0.jpg 005691_1.jpg
+009291_0.jpg 002345_1.jpg
+009300_0.jpg 009300_1.jpg
+009312_0.jpg 014629_1.jpg
+009323_0.jpg 010133_1.jpg
+009332_0.jpg 016697_1.jpg
+009342_0.jpg 016262_1.jpg
+009356_0.jpg 011568_1.jpg
+009365_0.jpg 003115_1.jpg
+009374_0.jpg 008542_1.jpg
+009382_0.jpg 010789_1.jpg
+009390_0.jpg 013743_1.jpg
+009399_0.jpg 009374_1.jpg
+009409_0.jpg 011106_1.jpg
+009418_0.jpg 013620_1.jpg
+009426_0.jpg 006817_1.jpg
+009435_0.jpg 012702_1.jpg
+009446_0.jpg 002575_1.jpg
+009454_0.jpg 017730_1.jpg
+009462_0.jpg 016831_1.jpg
+009474_0.jpg 006194_1.jpg
+009482_0.jpg 007086_1.jpg
+009496_0.jpg 001064_1.jpg
+009505_0.jpg 011004_1.jpg
+009515_0.jpg 014968_1.jpg
+009525_0.jpg 002259_1.jpg
+009537_0.jpg 003545_1.jpg
+009545_0.jpg 002147_1.jpg
+009561_0.jpg 003833_1.jpg
+009571_0.jpg 007966_1.jpg
+009586_0.jpg 017877_1.jpg
+009595_0.jpg 007003_1.jpg
+009605_0.jpg 016220_1.jpg
+009619_0.jpg 017306_1.jpg
+009627_0.jpg 010644_1.jpg
+009635_0.jpg 008295_1.jpg
+009643_0.jpg 018318_1.jpg
+009651_0.jpg 013173_1.jpg
+009660_0.jpg 010445_1.jpg
+009668_0.jpg 002068_1.jpg
+009679_0.jpg 003187_1.jpg
+009689_0.jpg 011058_1.jpg
+009699_0.jpg 005657_1.jpg
+009709_0.jpg 009882_1.jpg
+009722_0.jpg 009228_1.jpg
+009730_0.jpg 015794_1.jpg
+009741_0.jpg 009399_1.jpg
+009758_0.jpg 013555_1.jpg
+009766_0.jpg 013265_1.jpg
+009780_0.jpg 013863_1.jpg
+009790_0.jpg 001283_1.jpg
+009799_0.jpg 018755_1.jpg
+009809_0.jpg 006393_1.jpg
+009822_0.jpg 009903_1.jpg
+009832_0.jpg 004148_1.jpg
+009843_0.jpg 018561_1.jpg
+009852_0.jpg 018059_1.jpg
+009860_0.jpg 010575_1.jpg
+009872_0.jpg 008266_1.jpg
+009882_0.jpg 015615_1.jpg
+009894_0.jpg 006250_1.jpg
+009903_0.jpg 014232_1.jpg
+009912_0.jpg 015707_1.jpg
+009922_0.jpg 016812_1.jpg
+009932_0.jpg 007672_1.jpg
+009941_0.jpg 012785_1.jpg
+009949_0.jpg 000924_1.jpg
+009959_0.jpg 009016_1.jpg
+009967_0.jpg 008976_1.jpg
+009975_0.jpg 017688_1.jpg
+009984_0.jpg 016426_1.jpg
+009995_0.jpg 003376_1.jpg
+010003_0.jpg 015637_1.jpg
+010011_0.jpg 014498_1.jpg
+010021_0.jpg 018236_1.jpg
+010031_0.jpg 016112_1.jpg
+010040_0.jpg 001957_1.jpg
+010049_0.jpg 015181_1.jpg
+010057_0.jpg 017860_1.jpg
+010067_0.jpg 015173_1.jpg
+010078_0.jpg 008706_1.jpg
+010088_0.jpg 009323_1.jpg
+010096_0.jpg 019096_1.jpg
+010105_0.jpg 001983_1.jpg
+010115_0.jpg 013165_1.jpg
+010125_0.jpg 001947_1.jpg
+010133_0.jpg 004785_1.jpg
+010143_0.jpg 010225_1.jpg
+010152_0.jpg 000610_1.jpg
+010160_0.jpg 004023_1.jpg
+010168_0.jpg 019001_1.jpg
+010177_0.jpg 006478_1.jpg
+010185_0.jpg 007336_1.jpg
+010195_0.jpg 017831_1.jpg
+010206_0.jpg 003712_1.jpg
+010215_0.jpg 015036_1.jpg
+010225_0.jpg 003972_1.jpg
+010234_0.jpg 001891_1.jpg
+010244_0.jpg 001387_1.jpg
+010253_0.jpg 014736_1.jpg
+010261_0.jpg 013923_1.jpg
+010270_0.jpg 006728_1.jpg
+010281_0.jpg 004896_1.jpg
+010289_0.jpg 011076_1.jpg
+010300_0.jpg 012303_1.jpg
+010308_0.jpg 001092_1.jpg
+010318_0.jpg 012089_1.jpg
+010329_0.jpg 006452_1.jpg
+010337_0.jpg 018263_1.jpg
+010346_0.jpg 016191_1.jpg
+010357_0.jpg 017145_1.jpg
+010371_0.jpg 010515_1.jpg
+010381_0.jpg 006709_1.jpg
+010392_0.jpg 013319_1.jpg
+010404_0.jpg 000659_1.jpg
+010415_0.jpg 016562_1.jpg
+010431_0.jpg 016254_1.jpg
+010445_0.jpg 014744_1.jpg
+010454_0.jpg 017722_1.jpg
+010463_0.jpg 003795_1.jpg
+010473_0.jpg 013753_1.jpg
+010481_0.jpg 009409_1.jpg
+010493_0.jpg 015230_1.jpg
+010503_0.jpg 017701_1.jpg
+010515_0.jpg 002930_1.jpg
+010527_0.jpg 008986_1.jpg
+010535_0.jpg 000827_1.jpg
+010543_0.jpg 008354_1.jpg
+010551_0.jpg 015069_1.jpg
+010559_0.jpg 012514_1.jpg
+010567_0.jpg 012681_1.jpg
+010575_0.jpg 017710_1.jpg
+010583_0.jpg 002852_1.jpg
+010591_0.jpg 006825_1.jpg
+010599_0.jpg 016154_1.jpg
+010608_0.jpg 015450_1.jpg
+010620_0.jpg 009064_1.jpg
+010628_0.jpg 002922_1.jpg
+010636_0.jpg 004131_1.jpg
+010644_0.jpg 007021_1.jpg
+010653_0.jpg 019438_1.jpg
+010662_0.jpg 003535_1.jpg
+010670_0.jpg 003060_1.jpg
+010683_0.jpg 001349_1.jpg
+010691_0.jpg 003874_1.jpg
+010699_0.jpg 017167_1.jpg
+010710_0.jpg 018441_1.jpg
+010718_0.jpg 011425_1.jpg
+010726_0.jpg 001038_1.jpg
+010735_0.jpg 007536_1.jpg
+010744_0.jpg 000676_1.jpg
+010753_0.jpg 011485_1.jpg
+010762_0.jpg 002200_1.jpg
+010770_0.jpg 007495_1.jpg
+010778_0.jpg 006462_1.jpg
+010789_0.jpg 016086_1.jpg
+010797_0.jpg 013298_1.jpg
+010806_0.jpg 015869_1.jpg
+010816_0.jpg 009832_1.jpg
+010830_0.jpg 013734_1.jpg
+010840_0.jpg 010011_1.jpg
+010851_0.jpg 009189_1.jpg
+010859_0.jpg 004997_1.jpg
+010869_0.jpg 004572_1.jpg
+010882_0.jpg 012898_1.jpg
+010891_0.jpg 011680_1.jpg
+010900_0.jpg 001919_1.jpg
+010910_0.jpg 006186_1.jpg
+010918_0.jpg 010346_1.jpg
+010929_0.jpg 007199_1.jpg
+010937_0.jpg 016388_1.jpg
+010947_0.jpg 017051_1.jpg
+010959_0.jpg 017273_1.jpg
+010967_0.jpg 012487_1.jpg
+010976_0.jpg 018980_1.jpg
+010984_0.jpg 018636_1.jpg
+010995_0.jpg 008126_1.jpg
+011004_0.jpg 014693_1.jpg
+011015_0.jpg 008080_1.jpg
+011023_0.jpg 002413_1.jpg
+011034_0.jpg 018807_1.jpg
+011042_0.jpg 007029_1.jpg
+011050_0.jpg 012116_1.jpg
+011058_0.jpg 019204_1.jpg
+011068_0.jpg 007681_1.jpg
+011076_0.jpg 000293_1.jpg
+011087_0.jpg 012265_1.jpg
+011097_0.jpg 019053_1.jpg
+011106_0.jpg 003668_1.jpg
+011120_0.jpg 014387_1.jpg
+011128_0.jpg 009159_1.jpg
+011137_0.jpg 003611_1.jpg
+011152_0.jpg 003676_1.jpg
+011164_0.jpg 018375_1.jpg
+011173_0.jpg 009106_1.jpg
+011181_0.jpg 005763_1.jpg
+011190_0.jpg 000370_1.jpg
+011203_0.jpg 001528_1.jpg
+011212_0.jpg 018737_1.jpg
+011221_0.jpg 005062_1.jpg
+011231_0.jpg 016021_1.jpg
+011240_0.jpg 008285_1.jpg
+011249_0.jpg 016612_1.jpg
+011258_0.jpg 012183_1.jpg
+011270_0.jpg 005510_1.jpg
+011278_0.jpg 014987_1.jpg
+011288_0.jpg 002651_1.jpg
+011300_0.jpg 006045_1.jpg
+011309_0.jpg 003981_1.jpg
+011318_0.jpg 006371_1.jpg
+011328_0.jpg 004091_1.jpg
+011336_0.jpg 009941_1.jpg
+011347_0.jpg 014360_1.jpg
+011355_0.jpg 004702_1.jpg
+011363_0.jpg 010195_1.jpg
+011372_0.jpg 008523_1.jpg
+011381_0.jpg 003077_1.jpg
+011392_0.jpg 018357_1.jpg
+011401_0.jpg 001056_1.jpg
+011415_0.jpg 016971_1.jpg
+011425_0.jpg 009799_1.jpg
+011436_0.jpg 009246_1.jpg
+011447_0.jpg 006502_1.jpg
+011457_0.jpg 005430_1.jpg
+011466_0.jpg 002447_1.jpg
+011475_0.jpg 015487_1.jpg
+011485_0.jpg 014666_1.jpg
+011495_0.jpg 009967_1.jpg
+011506_0.jpg 002839_1.jpg
+011515_0.jpg 006145_1.jpg
+011523_0.jpg 017990_1.jpg
+011536_0.jpg 010067_1.jpg
+011544_0.jpg 014280_1.jpg
+011552_0.jpg 017974_1.jpg
+011560_0.jpg 000734_1.jpg
+011568_0.jpg 012495_1.jpg
+011577_0.jpg 013601_1.jpg
+011585_0.jpg 018146_1.jpg
+011596_0.jpg 012149_1.jpg
+011604_0.jpg 002059_1.jpg
+011615_0.jpg 008736_1.jpg
+011623_0.jpg 004854_1.jpg
+011631_0.jpg 009332_1.jpg
+011641_0.jpg 003565_1.jpg
+011654_0.jpg 005898_1.jpg
+011662_0.jpg 000001_1.jpg
+011670_0.jpg 016484_1.jpg
+011680_0.jpg 015654_1.jpg
+011689_0.jpg 001655_1.jpg
+011699_0.jpg 006512_1.jpg
+011708_0.jpg 000768_1.jpg
+011716_0.jpg 001162_1.jpg
+011724_0.jpg 016495_1.jpg
+011736_0.jpg 012926_1.jpg
+011745_0.jpg 012202_1.jpg
+011761_0.jpg 006563_1.jpg
+011769_0.jpg 003133_1.jpg
+011781_0.jpg 002494_1.jpg
+011790_0.jpg 008997_1.jpg
+011798_0.jpg 012907_1.jpg
+011806_0.jpg 005622_1.jpg
+011816_0.jpg 014685_1.jpg
+011825_0.jpg 014582_1.jpg
+011833_0.jpg 008839_1.jpg
+011842_0.jpg 006670_1.jpg
+011850_0.jpg 015928_1.jpg
+011862_0.jpg 016839_1.jpg
+011872_0.jpg 000877_1.jpg
+011883_0.jpg 016644_1.jpg
+011891_0.jpg 010253_1.jpg
+011899_0.jpg 018488_1.jpg
+011908_0.jpg 011604_1.jpg
+011916_0.jpg 010057_1.jpg
+011924_0.jpg 000668_1.jpg
+011933_0.jpg 006410_1.jpg
+011944_0.jpg 011623_1.jpg
+011954_0.jpg 005195_1.jpg
+011962_0.jpg 004867_1.jpg
+011970_0.jpg 012616_1.jpg
+011980_0.jpg 009024_1.jpg
+011988_0.jpg 002610_1.jpg
+011996_0.jpg 012803_1.jpg
+012006_0.jpg 001457_1.jpg
+012015_0.jpg 018644_1.jpg
+012025_0.jpg 011790_1.jpg
+012033_0.jpg 006968_1.jpg
+012044_0.jpg 015095_1.jpg
+012054_0.jpg 007313_1.jpg
+012063_0.jpg 015516_1.jpg
+012072_0.jpg 006486_1.jpg
+012081_0.jpg 018590_1.jpg
+012089_0.jpg 013147_1.jpg
+012099_0.jpg 006224_1.jpg
+012107_0.jpg 001467_1.jpg
+012116_0.jpg 009454_1.jpg
+012127_0.jpg 005213_1.jpg
+012137_0.jpg 001269_1.jpg
+012149_0.jpg 010830_1.jpg
+012158_0.jpg 013510_1.jpg
+012166_0.jpg 018729_1.jpg
+012174_0.jpg 000957_1.jpg
+012183_0.jpg 018291_1.jpg
+012193_0.jpg 011249_1.jpg
+012202_0.jpg 003882_1.jpg
+012219_0.jpg 004277_1.jpg
+012228_0.jpg 006555_1.jpg
+012236_0.jpg 015045_1.jpg
+012245_0.jpg 008258_1.jpg
+012256_0.jpg 017099_1.jpg
+012265_0.jpg 009462_1.jpg
+012273_0.jpg 004516_1.jpg
+012282_0.jpg 008233_1.jpg
+012291_0.jpg 001009_1.jpg
+012303_0.jpg 018876_1.jpg
+012311_0.jpg 001845_1.jpg
+012322_0.jpg 013060_1.jpg
+012330_0.jpg 015645_1.jpg
+012338_0.jpg 000812_1.jpg
+012350_0.jpg 011023_1.jpg
+012359_0.jpg 013117_1.jpg
+012369_0.jpg 009474_1.jpg
+012377_0.jpg 017227_1.jpg
+012385_0.jpg 005110_1.jpg
+012395_0.jpg 015662_1.jpg
+012404_0.jpg 000174_1.jpg
+012413_0.jpg 007949_1.jpg
+012422_0.jpg 009042_1.jpg
+012430_0.jpg 006620_1.jpg
+012440_0.jpg 009446_1.jpg
+012451_0.jpg 007159_1.jpg
+012460_0.jpg 012025_1.jpg
+012469_0.jpg 015334_1.jpg
+012479_0.jpg 017021_1.jpg
+012487_0.jpg 014055_1.jpg
+012495_0.jpg 002156_1.jpg
+012505_0.jpg 002911_1.jpg
+012514_0.jpg 004285_1.jpg
+012522_0.jpg 015740_1.jpg
+012531_0.jpg 005702_1.jpg
+012545_0.jpg 005755_1.jpg
+012553_0.jpg 016415_1.jpg
+012564_0.jpg 013931_1.jpg
+012578_0.jpg 014252_1.jpg
+012587_0.jpg 016687_1.jpg
+012597_0.jpg 016309_1.jpg
+012605_0.jpg 004561_1.jpg
+012616_0.jpg 009790_1.jpg
+012626_0.jpg 000209_1.jpg
+012636_0.jpg 004666_1.jpg
+012644_0.jpg 017922_1.jpg
+012652_0.jpg 002545_1.jpg
+012660_0.jpg 017957_1.jpg
+012669_0.jpg 005846_1.jpg
+012681_0.jpg 015955_1.jpg
+012694_0.jpg 001683_1.jpg
+012702_0.jpg 015671_1.jpg
+012712_0.jpg 005457_1.jpg
+012725_0.jpg 019243_1.jpg
+012734_0.jpg 008041_1.jpg
+012743_0.jpg 001928_1.jpg
+012754_0.jpg 003142_1.jpg
+012763_0.jpg 006776_1.jpg
+012773_0.jpg 009679_1.jpg
+012785_0.jpg 015412_1.jpg
+012795_0.jpg 018337_1.jpg
+012803_0.jpg 013997_1.jpg
+012811_0.jpg 001834_1.jpg
+012822_0.jpg 013284_1.jpg
+012830_0.jpg 008479_1.jpg
+012838_0.jpg 015889_1.jpg
+012849_0.jpg 015439_1.jpg
+012860_0.jpg 012107_1.jpg
+012868_0.jpg 003250_1.jpg
+012879_0.jpg 017282_1.jpg
+012889_0.jpg 000795_1.jpg
+012898_0.jpg 002758_1.jpg
+012907_0.jpg 012987_1.jpg
+012917_0.jpg 016102_1.jpg
+012926_0.jpg 016328_1.jpg
+012934_0.jpg 010551_1.jpg
+012944_0.jpg 016921_1.jpg
+012953_0.jpg 001310_1.jpg
+012964_0.jpg 006203_1.jpg
+012975_0.jpg 007423_1.jpg
+012987_0.jpg 015200_1.jpg
+012996_0.jpg 012669_1.jpg
+013007_0.jpg 014920_1.jpg
+013019_0.jpg 003069_1.jpg
+013028_0.jpg 000164_1.jpg
+013036_0.jpg 008598_1.jpg
+013047_0.jpg 018507_1.jpg
+013060_0.jpg 009741_1.jpg
+013068_0.jpg 012081_1.jpg
+013076_0.jpg 011654_1.jpg
+013084_0.jpg 012830_1.jpg
+013097_0.jpg 002307_1.jpg
+013106_0.jpg 000542_1.jpg
+013117_0.jpg 014755_1.jpg
+013127_0.jpg 008763_1.jpg
+013139_0.jpg 009809_1.jpg
+013147_0.jpg 008462_1.jpg
+013155_0.jpg 013789_1.jpg
+013165_0.jpg 007526_1.jpg
+013173_0.jpg 010404_1.jpg
+013181_0.jpg 005222_1.jpg
+013190_0.jpg 014908_1.jpg
+013199_0.jpg 019486_1.jpg
+013214_0.jpg 017770_1.jpg
+013224_0.jpg 004590_1.jpg
+013233_0.jpg 007357_1.jpg
+013245_0.jpg 005562_1.jpg
+013256_0.jpg 012773_1.jpg
+013265_0.jpg 018039_1.jpg
+013273_0.jpg 017062_1.jpg
+013284_0.jpg 002474_1.jpg
+013298_0.jpg 002208_1.jpg
+013309_0.jpg 002031_1.jpg
+013319_0.jpg 009169_1.jpg
+013327_0.jpg 006036_1.jpg
+013338_0.jpg 012311_1.jpg
+013355_0.jpg 018626_1.jpg
+013365_0.jpg 014272_1.jpg
+013374_0.jpg 014035_1.jpg
+013382_0.jpg 016515_1.jpg
+013391_0.jpg 004758_1.jpg
+013400_0.jpg 002093_1.jpg
+013410_0.jpg 004462_1.jpg
+013418_0.jpg 000284_1.jpg
+013428_0.jpg 008188_1.jpg
+013437_0.jpg 006260_1.jpg
+013447_0.jpg 007188_1.jpg
+013456_0.jpg 017563_1.jpg
+013469_0.jpg 009984_1.jpg
+013478_0.jpg 005166_1.jpg
+013490_0.jpg 009205_1.jpg
+013502_0.jpg 008032_1.jpg
+013510_0.jpg 005153_1.jpg
+013518_0.jpg 000200_1.jpg
+013527_0.jpg 013478_1.jpg
+013539_0.jpg 012469_1.jpg
+013547_0.jpg 017779_1.jpg
+013555_0.jpg 019505_1.jpg
+013564_0.jpg 016271_1.jpg
+013572_0.jpg 014406_1.jpg
+013583_0.jpg 006296_1.jpg
+013593_0.jpg 009959_1.jpg
+013601_0.jpg 013968_1.jpg
+013611_0.jpg 004051_1.jpg
+013620_0.jpg 010160_1.jpg
+013634_0.jpg 009571_1.jpg
+013642_0.jpg 019475_1.jpg
+013654_0.jpg 011850_1.jpg
+013665_0.jpg 015352_1.jpg
+013680_0.jpg 018515_1.jpg
+013688_0.jpg 012137_1.jpg
+013698_0.jpg 015015_1.jpg
+013706_0.jpg 014834_1.jpg
+013715_0.jpg 019393_1.jpg
+013725_0.jpg 005920_1.jpg
+013734_0.jpg 007974_1.jpg
+013743_0.jpg 018411_1.jpg
+013753_0.jpg 008443_1.jpg
+013764_0.jpg 004431_1.jpg
+013772_0.jpg 000915_1.jpg
+013780_0.jpg 006026_1.jpg
+013789_0.jpg 005586_1.jpg
+013798_0.jpg 009505_1.jpg
+013806_0.jpg 019310_1.jpg
+013816_0.jpg 018671_1.jpg
+013827_0.jpg 010683_1.jpg
+013836_0.jpg 007129_1.jpg
+013845_0.jpg 019183_1.jpg
+013855_0.jpg 009149_1.jpg
+013863_0.jpg 005984_1.jpg
+013875_0.jpg 003367_1.jpg
+013883_0.jpg 005298_1.jpg
+013891_0.jpg 005336_1.jpg
+013899_0.jpg 003311_1.jpg
+013907_0.jpg 005480_1.jpg
+013915_0.jpg 014574_1.jpg
+013923_0.jpg 013981_1.jpg
+013931_0.jpg 001408_1.jpg
+013939_0.jpg 010900_1.jpg
+013948_0.jpg 012193_1.jpg
+013959_0.jpg 003008_1.jpg
+013968_0.jpg 003041_1.jpg
+013981_0.jpg 003632_1.jpg
+013989_0.jpg 003303_1.jpg
+013997_0.jpg 001485_1.jpg
+014006_0.jpg 005131_1.jpg
+014014_0.jpg 005837_1.jpg
+014025_0.jpg 001547_1.jpg
+014035_0.jpg 005271_1.jpg
+014046_0.jpg 014106_1.jpg
+014055_0.jpg 011120_1.jpg
+014066_0.jpg 019119_1.jpg
+014076_0.jpg 008062_1.jpg
+014086_0.jpg 016765_1.jpg
+014096_0.jpg 010289_1.jpg
+014106_0.jpg 003195_1.jpg
+014114_0.jpg 000706_1.jpg
+014123_0.jpg 016757_1.jpg
+014131_0.jpg 015507_1.jpg
+014140_0.jpg 005489_1.jpg
+014149_0.jpg 012934_1.jpg
+014159_0.jpg 012359_1.jpg
+014167_0.jpg 009860_1.jpg
+014176_0.jpg 011769_1.jpg
+014184_0.jpg 004260_1.jpg
+014192_0.jpg 018167_1.jpg
+014201_0.jpg 012451_1.jpg
+014209_0.jpg 003526_1.jpg
+014220_0.jpg 013028_1.jpg
+014232_0.jpg 005006_1.jpg
+014240_0.jpg 004598_1.jpg
+014252_0.jpg 011806_1.jpg
+014262_0.jpg 014176_1.jpg
+014272_0.jpg 008071_1.jpg
+014280_0.jpg 007817_1.jpg
+014292_0.jpg 013634_1.jpg
+014302_0.jpg 007719_1.jpg
+014314_0.jpg 013764_1.jpg
+014324_0.jpg 000532_1.jpg
+014332_0.jpg 012587_1.jpg
+014341_0.jpg 016397_1.jpg
+014349_0.jpg 018300_1.jpg
+014360_0.jpg 008118_1.jpg
+014370_0.jpg 000118_1.jpg
+014379_0.jpg 006173_1.jpg
+014387_0.jpg 002287_1.jpg
+014396_0.jpg 002405_1.jpg
+014406_0.jpg 011181_1.jpg
+014416_0.jpg 002388_1.jpg
+014426_0.jpg 003461_1.jpg
+014434_0.jpg 001937_1.jpg
+014443_0.jpg 019465_1.jpg
+014452_0.jpg 017657_1.jpg
+014463_0.jpg 001664_1.jpg
+014477_0.jpg 010984_1.jpg
+014489_0.jpg 014046_1.jpg
+014498_0.jpg 017932_1.jpg
+014507_0.jpg 003451_1.jpg
+014518_0.jpg 016338_1.jpg
+014528_0.jpg 008753_1.jpg
+014537_0.jpg 012660_1.jpg
+014553_0.jpg 017323_1.jpg
+014564_0.jpg 000568_1.jpg
+014574_0.jpg 013106_1.jpg
+014582_0.jpg 018894_1.jpg
+014591_0.jpg 013502_1.jpg
+014604_0.jpg 012712_1.jpg
+014612_0.jpg 005737_1.jpg
+014621_0.jpg 017041_1.jpg
+014629_0.jpg 019420_1.jpg
+014639_0.jpg 001868_1.jpg
+014652_0.jpg 016435_1.jpg
+014666_0.jpg 005285_1.jpg
+014675_0.jpg 004795_1.jpg
+014685_0.jpg 003434_1.jpg
+014693_0.jpg 013611_1.jpg
+014701_0.jpg 006589_1.jpg
+014712_0.jpg 011309_1.jpg
+014720_0.jpg 009586_1.jpg
+014728_0.jpg 015220_1.jpg
+014736_0.jpg 011137_1.jpg
+014744_0.jpg 007570_1.jpg
+014755_0.jpg 007056_1.jpg
+014765_0.jpg 012044_1.jpg
+014774_0.jpg 018254_1.jpg
+014785_0.jpg 000786_1.jpg
+014794_0.jpg 011372_1.jpg
+014805_0.jpg 001695_1.jpg
+014816_0.jpg 015598_1.jpg
+014825_0.jpg 002712_1.jpg
+014834_0.jpg 014452_1.jpg
+014844_0.jpg 011908_1.jpg
+014854_0.jpg 018129_1.jpg
+014863_0.jpg 017153_1.jpg
+014876_0.jpg 010976_1.jpg
+014888_0.jpg 016929_1.jpg
+014900_0.jpg 009365_1.jpg
+014908_0.jpg 012282_1.jpg
+014920_0.jpg 008389_1.jpg
+014930_0.jpg 012460_1.jpg
+014939_0.jpg 011631_1.jpg
+014950_0.jpg 013273_1.jpg
+014959_0.jpg 003768_1.jpg
+014968_0.jpg 002248_1.jpg
+014979_0.jpg 005675_1.jpg
+014987_0.jpg 013365_1.jpg
+014995_0.jpg 006688_1.jpg
+015006_0.jpg 006268_1.jpg
+015015_0.jpg 017982_1.jpg
+015026_0.jpg 006241_1.jpg
+015036_0.jpg 014167_1.jpg
+015045_0.jpg 016981_1.jpg
+015060_0.jpg 009382_1.jpg
+015069_0.jpg 005501_1.jpg
+015077_0.jpg 014518_1.jpg
+015085_0.jpg 016130_1.jpg
+015095_0.jpg 001614_1.jpg
+015105_0.jpg 011862_1.jpg
+015114_0.jpg 002455_1.jpg
+015125_0.jpg 016707_1.jpg
+015133_0.jpg 014443_1.jpg
+015141_0.jpg 000339_1.jpg
+015150_0.jpg 014825_1.jpg
+015158_0.jpg 005771_1.jpg
+015173_0.jpg 005929_1.jpg
+015181_0.jpg 003150_1.jpg
+015192_0.jpg 004683_1.jpg
+015200_0.jpg 007388_1.jpg
+015209_0.jpg 009356_1.jpg
+015220_0.jpg 011699_1.jpg
+015230_0.jpg 004487_1.jpg
+015238_0.jpg 013224_1.jpg
+015247_0.jpg 004674_1.jpg
+015256_0.jpg 018817_1.jpg
+015264_0.jpg 007561_1.jpg
+015272_0.jpg 010959_1.jpg
+015280_0.jpg 013845_1.jpg
+015291_0.jpg 011506_1.jpg
+015299_0.jpg 010670_1.jpg
+015308_0.jpg 019018_1.jpg
+015317_0.jpg 010185_1.jpg
+015325_0.jpg 006155_1.jpg
+015334_0.jpg 005578_1.jpg
+015344_0.jpg 000742_1.jpg
+015352_0.jpg 002327_1.jpg
+015362_0.jpg 005072_1.jpg
+015371_0.jpg 009912_1.jpg
+015381_0.jpg 009822_1.jpg
+015392_0.jpg 001073_1.jpg
+015403_0.jpg 005014_1.jpg
+015412_0.jpg 015542_1.jpg
+015420_0.jpg 007037_1.jpg
+015428_0.jpg 018245_1.jpg
+015439_0.jpg 006748_1.jpg
+015450_0.jpg 006099_1.jpg
+015465_0.jpg 008580_1.jpg
+015476_0.jpg 000330_1.jpg
+015487_0.jpg 013076_1.jpg
+015497_0.jpg 012953_1.jpg
+015507_0.jpg 018652_1.jpg
+015516_0.jpg 012430_1.jpg
+015524_0.jpg 014159_1.jpg
+015542_0.jpg 019531_1.jpg
+015550_0.jpg 013875_1.jpg
+015560_0.jpg 012422_1.jpg
+015571_0.jpg 018618_1.jpg
+015579_0.jpg 005031_1.jpg
+015590_0.jpg 003963_1.jpg
+015598_0.jpg 018159_1.jpg
+015607_0.jpg 005422_1.jpg
+015615_0.jpg 010699_1.jpg
+015627_0.jpg 018884_1.jpg
+015637_0.jpg 012522_1.jpg
+015645_0.jpg 017536_1.jpg
+015654_0.jpg 009843_1.jpg
+015662_0.jpg 002011_1.jpg
+015671_0.jpg 011152_1.jpg
+015680_0.jpg 005449_1.jpg
+015688_0.jpg 001419_1.jpg
+015697_0.jpg 004314_1.jpg
+015707_0.jpg 018121_1.jpg
+015715_0.jpg 013084_1.jpg
+015724_0.jpg 006313_1.jpg
+015732_0.jpg 013816_1.jpg
+015740_0.jpg 014995_1.jpg
+015748_0.jpg 001502_1.jpg
+015759_0.jpg 003649_1.jpg
+015767_0.jpg 000437_1.jpg
+015776_0.jpg 009651_1.jpg
+015785_0.jpg 005470_1.jpg
+015794_0.jpg 009123_1.jpg
+015803_0.jpg 005145_1.jpg
+015816_0.jpg 004115_1.jpg
+015825_0.jpg 008871_1.jpg
+015836_0.jpg 006118_1.jpg
+015844_0.jpg 007294_1.jpg
+015853_0.jpg 005101_1.jpg
+015861_0.jpg 017592_1.jpg
+015869_0.jpg 011724_1.jpg
+015881_0.jpg 008180_1.jpg
+015889_0.jpg 009699_1.jpg
+015900_0.jpg 017079_1.jpg
+015908_0.jpg 008533_1.jpg
+015916_0.jpg 002533_1.jpg
+015928_0.jpg 017418_1.jpg
+015938_0.jpg 007874_1.jpg
+015946_0.jpg 014426_1.jpg
+015955_0.jpg 018662_1.jpg
+015969_0.jpg 009561_1.jpg
+015979_0.jpg 007848_1.jpg
+015990_0.jpg 010882_1.jpg
+016002_0.jpg 006358_1.jpg
+016013_0.jpg 014528_1.jpg
+016021_0.jpg 003621_1.jpg
+016031_0.jpg 002883_1.jpg
+016039_0.jpg 009894_1.jpg
+016049_0.jpg 004252_1.jpg
+016059_0.jpg 012291_1.jpg
+016067_0.jpg 006523_1.jpg
+016075_0.jpg 007121_1.jpg
+016086_0.jpg 016505_1.jpg
+016094_0.jpg 004378_1.jpg
+016102_0.jpg 011716_1.jpg
+016112_0.jpg 000560_1.jpg
+016121_0.jpg 004478_1.jpg
+016130_0.jpg 002803_1.jpg
+016145_0.jpg 016455_1.jpg
+016154_0.jpg 008949_1.jpg
+016163_0.jpg 002276_1.jpg
+016172_0.jpg 016163_1.jpg
+016183_0.jpg 005728_1.jpg
+016191_0.jpg 011536_1.jpg
+016206_0.jpg 015344_1.jpg
+016220_0.jpg 002670_1.jpg
+016230_0.jpg 002226_1.jpg
+016238_0.jpg 008855_1.jpg
+016246_0.jpg 003481_1.jpg
+016254_0.jpg 015060_1.jpg
+016262_0.jpg 007138_1.jpg
+016271_0.jpg 017390_1.jpg
+016281_0.jpg 018598_1.jpg
+016290_0.jpg 015680_1.jpg
+016300_0.jpg 009627_1.jpg
+016309_0.jpg 015238_1.jpg
+016317_0.jpg 004107_1.jpg
+016328_0.jpg 015776_1.jpg
+016338_0.jpg 009668_1.jpg
+016349_0.jpg 008250_1.jpg
+016358_0.jpg 006889_1.jpg
+016367_0.jpg 008813_1.jpg
+016379_0.jpg 003107_1.jpg
+016388_0.jpg 014785_1.jpg
+016397_0.jpg 002728_1.jpg
+016405_0.jpg 000356_1.jpg
+016415_0.jpg 014096_1.jpg
+016426_0.jpg 016230_1.jpg
+016435_0.jpg 005175_1.jpg
+016445_0.jpg 010770_1.jpg
+016455_0.jpg 013518_1.jpg
+016465_0.jpg 012158_1.jpg
+016474_0.jpg 017613_1.jpg
+016484_0.jpg 019166_1.jpg
+016495_0.jpg 009722_1.jpg
+016505_0.jpg 018858_1.jpg
+016515_0.jpg 009515_1.jpg
+016524_0.jpg 009537_1.jpg
+016533_0.jpg 006276_1.jpg
+016541_0.jpg 016853_1.jpg
+016550_0.jpg 013772_1.jpg
+016562_0.jpg 019154_1.jpg
+016571_0.jpg 017514_1.jpg
+016584_0.jpg 013447_1.jpg
+016593_0.jpg 018309_1.jpg
+016602_0.jpg 010088_1.jpg
+016612_0.jpg 003658_1.jpg
+016620_0.jpg 003760_1.jpg
+016628_0.jpg 007750_1.jpg
+016636_0.jpg 004470_1.jpg
+016644_0.jpg 015158_1.jpg
+016653_0.jpg 008725_1.jpg
+016662_0.jpg 010357_1.jpg
+016676_0.jpg 016013_1.jpg
+016687_0.jpg 014025_1.jpg
+016697_0.jpg 008487_1.jpg
+016707_0.jpg 003094_1.jpg
+016716_0.jpg 014066_1.jpg
+016726_0.jpg 011164_1.jpg
+016739_0.jpg 017805_1.jpg
+016748_0.jpg 012822_1.jpg
+016757_0.jpg 009730_1.jpg
+016765_0.jpg 007180_1.jpg
+016777_0.jpg 000066_1.jpg
+016786_0.jpg 017340_1.jpg
+016799_0.jpg 007656_1.jpg
+016812_0.jpg 003032_1.jpg
+016820_0.jpg 000776_1.jpg
+016831_0.jpg 007702_1.jpg
+016839_0.jpg 004609_1.jpg
+016853_0.jpg 003386_1.jpg
+016866_0.jpg 010778_1.jpg
+016878_0.jpg 012479_1.jpg
+016888_0.jpg 003703_1.jpg
+016899_0.jpg 002778_1.jpg
+016908_0.jpg 018867_1.jpg
+016921_0.jpg 004177_1.jpg
+016929_0.jpg 005683_1.jpg
+016943_0.jpg 000109_1.jpg
+016951_0.jpg 006928_1.jpg
+016962_0.jpg 014675_1.jpg
+016971_0.jpg 007940_1.jpg
+016981_0.jpg 019270_1.jpg
+016992_0.jpg 013547_1.jpg
+017002_0.jpg 013665_1.jpg
+017012_0.jpg 008881_1.jpg
+017021_0.jpg 000048_1.jpg
+017030_0.jpg 004139_1.jpg
+017041_0.jpg 003236_1.jpg
+017051_0.jpg 001136_1.jpg
+017062_0.jpg 001320_1.jpg
+017070_0.jpg 016121_1.jpg
+017079_0.jpg 014728_1.jpg
+017091_0.jpg 010215_1.jpg
+017099_0.jpg 004941_1.jpg
+017110_0.jpg 018183_1.jpg
+017118_0.jpg 001048_1.jpg
+017130_0.jpg 002901_1.jpg
+017145_0.jpg 008793_1.jpg
+017153_0.jpg 015114_1.jpg
+017167_0.jpg 007168_1.jpg
+017175_0.jpg 014639_1.jpg
+017188_0.jpg 001706_1.jpg
+017196_0.jpg 010308_1.jpg
+017204_0.jpg 016349_1.jpg
+017213_0.jpg 002362_1.jpg
+017227_0.jpg 001219_1.jpg
+017235_0.jpg 010559_1.jpg
+017243_0.jpg 003024_1.jpg
+017254_0.jpg 003591_1.jpg
+017264_0.jpg 017358_1.jpg
+017273_0.jpg 004042_1.jpg
+017282_0.jpg 012377_1.jpg
+017290_0.jpg 007762_1.jpg
+017298_0.jpg 015247_1.jpg
+017306_0.jpg 018787_1.jpg
+017315_0.jpg 010503_1.jpg
+017323_0.jpg 000602_1.jpg
+017332_0.jpg 001635_1.jpg
+017340_0.jpg 006842_1.jpg
+017348_0.jpg 017482_1.jpg
+017358_0.jpg 012440_1.jpg
+017370_0.jpg 019215_1.jpg
+017382_0.jpg 019590_1.jpg
+017390_0.jpg 003990_1.jpg
+017400_0.jpg 008334_1.jpg
+017410_0.jpg 017213_1.jpg
+017418_0.jpg 010392_1.jpg
+017428_0.jpg 018991_1.jpg
+017438_0.jpg 001817_1.jpg
+017449_0.jpg 014950_1.jpg
+017457_0.jpg 006649_1.jpg
+017466_0.jpg 013437_1.jpg
+017474_0.jpg 016602_1.jpg
+017482_0.jpg 007269_1.jpg
+017496_0.jpg 011495_1.jpg
+017505_0.jpg 000386_1.jpg
+017514_0.jpg 013190_1.jpg
+017526_0.jpg 004387_1.jpg
+017536_0.jpg 003328_1.jpg
+017545_0.jpg 006799_1.jpg
+017555_0.jpg 012413_1.jpg
+017563_0.jpg 008515_1.jpg
+017575_0.jpg 010152_1.jpg
+017583_0.jpg 011328_1.jpg
+017592_0.jpg 018910_1.jpg
+017600_0.jpg 018718_1.jpg
+017613_0.jpg 000378_1.jpg
+017622_0.jpg 019193_1.jpg
+017630_0.jpg 018280_1.jpg
+017639_0.jpg 013181_1.jpg
+017648_0.jpg 011363_1.jpg
+017657_0.jpg 001173_1.jpg
+017667_0.jpg 004243_1.jpg
+017678_0.jpg 013959_1.jpg
+017688_0.jpg 016908_1.jpg
+017701_0.jpg 013539_1.jpg
+017710_0.jpg 013456_1.jpg
+017722_0.jpg 004234_1.jpg
+017730_0.jpg 001203_1.jpg
+017740_0.jpg 013400_1.jpg
+017750_0.jpg 011781_1.jpg
+017761_0.jpg 011258_1.jpg
+017770_0.jpg 006908_1.jpg
+017779_0.jpg 009660_1.jpg
+017788_0.jpg 002191_1.jpg
+017796_0.jpg 006757_1.jpg
+017805_0.jpg 005857_1.jpg
+017814_0.jpg 011641_1.jpg
+017823_0.jpg 007923_1.jpg
+017831_0.jpg 004949_1.jpg
+017840_0.jpg 018580_1.jpg
+017852_0.jpg 017999_1.jpg
+017860_0.jpg 008653_1.jpg
+017868_0.jpg 011980_1.jpg
+017877_0.jpg 017382_1.jpg
+017886_0.jpg 011899_1.jpg
+017896_0.jpg 002169_1.jpg
+017904_0.jpg 010318_1.jpg
+017914_0.jpg 017740_1.jpg
+017922_0.jpg 011221_1.jpg
+017932_0.jpg 004989_1.jpg
+017945_0.jpg 003915_1.jpg
+017957_0.jpg 001789_1.jpg
+017965_0.jpg 003925_1.jpg
+017974_0.jpg 002337_1.jpg
+017982_0.jpg 008624_1.jpg
+017990_0.jpg 004220_1.jpg
+017999_0.jpg 001594_1.jpg
+018009_0.jpg 006004_1.jpg
+018018_0.jpg 019350_1.jpg
+018031_0.jpg 018552_1.jpg
+018039_0.jpg 010031_1.jpg
+018047_0.jpg 013256_1.jpg
+018059_0.jpg 001809_1.jpg
+018069_0.jpg 006868_1.jpg
+018080_0.jpg 000303_1.jpg
+018089_0.jpg 007882_1.jpg
+018102_0.jpg 016676_1.jpg
+018112_0.jpg 009619_1.jpg
+018121_0.jpg 017965_1.jpg
+018129_0.jpg 010049_1.jpg
+018138_0.jpg 018938_1.jpg
+018146_0.jpg 014209_1.jpg
+018159_0.jpg 007549_1.jpg
+018167_0.jpg 009054_1.jpg
+018175_0.jpg 008214_1.jpg
+018183_0.jpg 003319_1.jpg
+018192_0.jpg 016206_1.jpg
+018200_0.jpg 017914_1.jpg
+018210_0.jpg 016820_1.jpg
+018219_0.jpg 007781_1.jpg
+018227_0.jpg 006545_1.jpg
+018236_0.jpg 001153_1.jpg
+018245_0.jpg 000426_1.jpg
+018254_0.jpg 014123_1.jpg
+018263_0.jpg 006678_1.jpg
+018271_0.jpg 017254_1.jpg
+018280_0.jpg 001900_1.jpg
+018291_0.jpg 019234_1.jpg
+018300_0.jpg 012636_1.jpg
+018309_0.jpg 001908_1.jpg
+018318_0.jpg 017188_1.jpg
+018327_0.jpg 009291_1.jpg
+018337_0.jpg 009932_1.jpg
+018348_0.jpg 003049_1.jpg
+018357_0.jpg 003280_1.jpg
+018366_0.jpg 000010_1.jpg
+018375_0.jpg 015946_1.jpg
+018393_0.jpg 002699_1.jpg
+018401_0.jpg 002502_1.jpg
+018411_0.jpg 004620_1.jpg
+018420_0.jpg 002828_1.jpg
+018431_0.jpg 016524_1.jpg
+018441_0.jpg 005091_1.jpg
+018452_0.jpg 015299_1.jpg
+018460_0.jpg 011996_1.jpg
+018470_0.jpg 006937_1.jpg
+018479_0.jpg 003861_1.jpg
+018488_0.jpg 015748_1.jpg
+018496_0.jpg 005940_1.jpg
+018507_0.jpg 001765_1.jpg
+018515_0.jpg 013798_1.jpg
+018524_0.jpg 017332_1.jpg
+018532_0.jpg 005404_1.jpg
+018544_0.jpg 010797_1.jpg
+018552_0.jpg 006419_1.jpg
+018561_0.jpg 019078_1.jpg
+018569_0.jpg 014564_1.jpg
+018580_0.jpg 008830_1.jpg
+018590_0.jpg 016571_1.jpg
+018598_0.jpg 011745_1.jpg
+018608_0.jpg 000347_1.jpg
+018618_0.jpg 003739_1.jpg
+018626_0.jpg 011662_1.jpg
+018636_0.jpg 001399_1.jpg
+018644_0.jpg 004912_1.jpg
+018652_0.jpg 017600_1.jpg
+018662_0.jpg 018175_1.jpg
+018671_0.jpg 013939_1.jpg
+018681_0.jpg 006768_1.jpg
+018690_0.jpg 014604_1.jpg
+018700_0.jpg 009643_1.jpg
+018710_0.jpg 005542_1.jpg
+018718_0.jpg 003555_1.jpg
+018729_0.jpg 006073_1.jpg
+018737_0.jpg 014720_1.jpg
+018746_0.jpg 017030_1.jpg
+018755_0.jpg 017505_1.jpg
+018769_0.jpg 003270_1.jpg
+018778_0.jpg 007045_1.jpg
+018787_0.jpg 004823_1.jpg
+018796_0.jpg 007278_1.jpg
+018807_0.jpg 002659_1.jpg
+018817_0.jpg 008551_1.jpg
+018826_0.jpg 011318_1.jpg
+018837_0.jpg 016620_1.jpg
+018848_0.jpg 011933_1.jpg
+018858_0.jpg 019360_1.jpg
+018867_0.jpg 004545_1.jpg
+018876_0.jpg 000192_1.jpg
+018884_0.jpg 005809_1.jpg
+018894_0.jpg 012369_1.jpg
+018902_0.jpg 019581_1.jpg
+018910_0.jpg 004745_1.jpg
+018921_0.jpg 013233_1.jpg
+018929_0.jpg 008570_1.jpg
+018938_0.jpg 012564_1.jpg
+018946_0.jpg 013915_1.jpg
+018954_0.jpg 011872_1.jpg
+018962_0.jpg 014930_1.jpg
+018971_0.jpg 017823_1.jpg
+018980_0.jpg 018366_1.jpg
+018991_0.jpg 006897_1.jpg
+019001_0.jpg 010473_1.jpg
+019009_0.jpg 011924_1.jpg
+019018_0.jpg 001575_1.jpg
+019029_0.jpg 002970_1.jpg
+019037_0.jpg 000477_1.jpg
+019045_0.jpg 018080_1.jpg
+019053_0.jpg 008616_1.jpg
+019066_0.jpg 017852_1.jpg
+019078_0.jpg 007639_1.jpg
+019087_0.jpg 000907_1.jpg
+019096_0.jpg 009312_1.jpg
+019110_0.jpg 004657_1.jpg
+019119_0.jpg 001028_1.jpg
+019130_0.jpg 006232_1.jpg
+019140_0.jpg 011203_1.jpg
+019154_0.jpg 012795_1.jpg
+019166_0.jpg 013068_1.jpg
+019174_0.jpg 000097_1.jpg
+019183_0.jpg 009872_1.jpg
+019193_0.jpg 013428_1.jpg
+019204_0.jpg 016075_1.jpg
+019215_0.jpg 004071_1.jpg
+019224_0.jpg 011475_1.jpg
+019234_0.jpg 013642_1.jpg
+019243_0.jpg 018271_1.jpg
+019252_0.jpg 011552_1.jpg
+019262_0.jpg 005594_1.jpg
+019270_0.jpg 016405_1.jpg
+019279_0.jpg 010329_1.jpg
+019287_0.jpg 010493_1.jpg
+019302_0.jpg 018089_1.jpg
+019310_0.jpg 019262_1.jpg
+019319_0.jpg 017788_1.jpg
+019332_0.jpg 014774_1.jpg
+019340_0.jpg 009254_1.jpg
+019350_0.jpg 012725_1.jpg
+019360_0.jpg 008317_1.jpg
+019368_0.jpg 000629_1.jpg
+019376_0.jpg 017575_1.jpg
+019384_0.jpg 007324_1.jpg
+019393_0.jpg 013139_1.jpg
+019402_0.jpg 012868_1.jpg
+019411_0.jpg 001228_1.jpg
+019420_0.jpg 006347_1.jpg
+019429_0.jpg 006494_1.jpg
+019438_0.jpg 008590_1.jpg
+019446_0.jpg 006571_1.jpg
+019454_0.jpg 012228_1.jpg
+019465_0.jpg 010003_1.jpg
+019475_0.jpg 006304_1.jpg
+019486_0.jpg 013019_1.jpg
+019494_0.jpg 010929_1.jpg
+019505_0.jpg 010753_1.jpg
+019514_0.jpg 012054_1.jpg
+019522_0.jpg 018102_1.jpg
+019531_0.jpg 015077_1.jpg
+019540_0.jpg 008151_1.jpg
+019552_0.jpg 003787_1.jpg
+019561_0.jpg 006090_1.jpg
+019573_0.jpg 008608_1.jpg
+019581_0.jpg 006081_1.jpg
+019590_0.jpg 012964_1.jpg

VITON-Extends_test/next.config.mjs

@@ -0,0 +1,14 @@
+/** @type {import('next').NextConfig} */
+const nextConfig = {
+  eslint: {
+    ignoreDuringBuilds: true,
+  },
+  typescript: {
+    ignoreBuildErrors: true,
+  },
+  images: {
+    unoptimized: true,
+  },
+}
+
+export default nextConfig

VITON-Extends_test/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "my-v0-project",
+  "version": "0.1.0",
+  "private": true,
+  "scripts": {
+    "dev": "next dev",
+    "build": "next build",
+    "start": "next start",
+    "lint": "next lint"
+  },
+  "dependencies": {
+    "@emotion/is-prop-valid": "latest",
+    "@hookform/resolvers": "^3.9.1",
+    "@radix-ui/react-accordion": "1.2.2",
+    "@radix-ui/react-alert-dialog": "1.1.4",
+    "@radix-ui/react-aspect-ratio": "1.1.1",
+    "@radix-ui/react-avatar": "1.1.2",
+    "@radix-ui/react-checkbox": "1.1.3",
+    "@radix-ui/react-collapsible": "1.1.2",
+    "@radix-ui/react-context-menu": "2.2.4",
+    "@radix-ui/react-dialog": "1.1.4",
+    "@radix-ui/react-dropdown-menu": "2.1.4",
+    "@radix-ui/react-hover-card": "1.1.4",
+    "@radix-ui/react-label": "2.1.1",
+    "@radix-ui/react-menubar": "1.1.4",
+    "@radix-ui/react-navigation-menu": "1.2.3",
+    "@radix-ui/react-popover": "1.1.4",
+    "@radix-ui/react-progress": "1.1.1",
+    "@radix-ui/react-radio-group": "1.2.2",
+    "@radix-ui/react-scroll-area": "1.2.2",
+    "@radix-ui/react-select": "2.1.4",
+    "@radix-ui/react-separator": "1.1.1",
+    "@radix-ui/react-slider": "1.2.2",
+    "@radix-ui/react-slot": "1.1.1",
+    "@radix-ui/react-switch": "1.1.2",
+    "@radix-ui/react-tabs": "1.1.2",
+    "@radix-ui/react-toast": "1.2.4",
+    "@radix-ui/react-toggle": "1.1.1",
+    "@radix-ui/react-toggle-group": "1.1.1",
+    "@radix-ui/react-tooltip": "1.1.6",
+    "autoprefixer": "^10.4.20",
+    "class-variance-authority": "^0.7.1",
+    "clsx": "^2.1.1",
+    "cmdk": "1.0.4",
+    "date-fns": "4.1.0",
+    "embla-carousel-react": "8.5.1",
+    "framer-motion": "latest",
+    "input-otp": "1.4.1",
+    "lucide-react": "^0.454.0",
+    "next": "15.2.4",
+    "next-themes": "^0.4.4",
+    "react": "^19",
+    "react-day-picker": "8.10.1",
+    "react-dom": "^19",
+    "react-hook-form": "^7.54.1",
+    "react-resizable-panels": "^2.1.7",
+    "recharts": "2.15.0",
+    "sonner": "^1.7.1",
+    "tailwind-merge": "^2.5.5",
+    "tailwindcss-animate": "^1.0.7",
+    "vaul": "^0.9.6",
+    "zod": "^3.24.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22",
+    "@types/react": "^19",
+    "@types/react-dom": "^19",
+    "postcss": "^8",
+    "tailwindcss": "^3.4.17",
+    "typescript": "^5"
+  }
+}

VITON-Extends_test/pnpm-lock.yaml

@@ -0,0 +1,5 @@
+lockfileVersion: '9.0'
+
+settings:
+  autoInstallPeers: true
+  excludeLinksFromLockfile: false

VITON-Extends_test/postcss.config.mjs

@@ -0,0 +1,8 @@
+/** @type {import('postcss-load-config').Config} */
+const config = {
+  plugins: {
+    tailwindcss: {},
+  },
+};
+
+export default config;

VITON-Extends_test/tailwind.config.ts

@@ -0,0 +1,94 @@
+import type { Config } from "tailwindcss"
+
+const config = {
+  darkMode: ["class"],
+  content: [
+    "./pages/**/*.{ts,tsx}",
+    "./components/**/*.{ts,tsx}",
+    "./app/**/*.{ts,tsx}",
+    "./src/**/*.{ts,tsx}",
+    "*.{js,ts,jsx,tsx,mdx}",
+  ],
+  prefix: "",
+  theme: {
+    container: {
+      center: true,
+      padding: "2rem",
+      screens: {
+        "2xl": "1400px",
+      },
+    },
+    extend: {
+      colors: {
+        border: "hsl(var(--border))",
+        input: "hsl(var(--input))",
+        ring: "hsl(var(--ring))",
+        background: "hsl(var(--background))",
+        foreground: "hsl(var(--foreground))",
+        primary: {
+          DEFAULT: "hsl(var(--primary))",
+          foreground: "hsl(var(--primary-foreground))",
+        },
+        secondary: {
+          DEFAULT: "hsl(var(--secondary))",
+          foreground: "hsl(var(--secondary-foreground))",
+        },
+        destructive: {
+          DEFAULT: "hsl(var(--destructive))",
+          foreground: "hsl(var(--destructive-foreground))",
+        },
+        muted: {
+          DEFAULT: "hsl(var(--muted))",
+          foreground: "hsl(var(--muted-foreground))",
+        },
+        accent: {
+          DEFAULT: "hsl(var(--accent))",
+          foreground: "hsl(var(--accent-foreground))",
+        },
+        popover: {
+          DEFAULT: "hsl(var(--popover))",
+          foreground: "hsl(var(--popover-foreground))",
+        },
+        card: {
+          DEFAULT: "hsl(var(--card))",
+          foreground: "hsl(var(--card-foreground))",
+        },
+        purple: {
+          50: "#f5f3ff",
+          100: "#ede9fe",
+          200: "#ddd6fe",
+          300: "#c4b5fd",
+          400: "#a78bfa",
+          500: "#8b5cf6",
+          600: "#7c3aed",
+          700: "#6d28d9",
+          800: "#5b21b6",
+          900: "#4c1d95",
+          950: "#2e1065",
+        },
+      },
+      borderRadius: {
+        lg: "var(--radius)",
+        md: "calc(var(--radius) - 2px)",
+        sm: "calc(var(--radius) - 4px)",
+      },
+      keyframes: {
+        "accordion-down": {
+          from: { height: "0" },
+          to: { height: "var(--radix-accordion-content-height)" },
+        },
+        "accordion-up": {
+          from: { height: "var(--radix-accordion-content-height)" },
+          to: { height: "0" },
+        },
+      },
+      animation: {
+        "accordion-down": "accordion-down 0.2s ease-out",
+        "accordion-up": "accordion-up 0.2s ease-out",
+      },
+    },
+  },
+  plugins: [require("tailwindcss-animate")],
+} satisfies Config
+
+export default config

VITON-Extends_test/test.py

@@ -0,0 +1,84 @@
+import time
+from options.test_options import TestOptions
+from data.data_loader_test import CreateDataLoader
+from models.networks import ResUnetGenerator, load_checkpoint
+from models.afwm import AFWM
+import torch.nn as nn
+import os
+import numpy as np
+import torch
+import cv2
+import torch.nn.functional as F
+if __name__ == '__main__':
+    opt = TestOptions().parse()
+
+    start_epoch, epoch_iter = 1, 0
+
+    data_loader = CreateDataLoader(opt)
+    dataset = data_loader.load_data()
+    dataset_size = len(data_loader)
+    print(dataset_size)
+
+    warp_model = AFWM(opt, 3)
+    print(warp_model)
+    warp_model.eval()
+    warp_model.cuda()
+    load_checkpoint(warp_model, opt.warp_checkpoint)
+
+    gen_model = ResUnetGenerator(7, 4, 5, ngf=64, norm_layer=nn.BatchNorm2d)
+    print(gen_model)
+    gen_model.eval()
+    gen_model.cuda()
+    load_checkpoint(gen_model, opt.gen_checkpoint)
+
+    total_steps = (start_epoch-1) * dataset_size + epoch_iter
+    step = 0
+    step_per_batch = dataset_size / opt.batchSize
+
+    for epoch in range(1,2):
+
+        for i, data in enumerate(dataset, start=epoch_iter):
+            iter_start_time = time.time()
+            total_steps += opt.batchSize
+            epoch_iter += opt.batchSize
+
+            real_image = data['image']
+            clothes = data['clothes']
+            ##edge is extracted from the clothes image with the built-in function in python
+            edge = data['edge']
+            edge = torch.FloatTensor((edge.detach().numpy() > 0.5).astype(int))
+            clothes = clothes * edge        
+
+            flow_out = warp_model(real_image.cuda(), clothes.cuda())
+            warped_cloth, last_flow, = flow_out
+            warped_edge = F.grid_sample(edge.cuda(), last_flow.permute(0, 2, 3, 1),
+                            mode='bilinear', padding_mode='zeros')
+
+            gen_inputs = torch.cat([real_image.cuda(), warped_cloth, warped_edge], 1)
+            gen_outputs = gen_model(gen_inputs)
+            p_rendered, m_composite = torch.split(gen_outputs, [3, 1], 1)
+            p_rendered = torch.tanh(p_rendered)
+            m_composite = torch.sigmoid(m_composite)
+            m_composite = m_composite * warped_edge
+            p_tryon = warped_cloth * m_composite + p_rendered * (1 - m_composite)
+
+            path = 'results/' + opt.name
+            os.makedirs(path, exist_ok=True)
+            sub_path = path + '/VITON-Extends'
+            os.makedirs(sub_path,exist_ok=True)
+
+            if step % 1 == 0:
+                a = real_image.float().cuda()
+                b= clothes.cuda()
+                c = p_tryon
+                combine = torch.cat([a[0],b[0],c[0]], 2).squeeze()
+                cv_img=(combine.permute(1,2,0).detach().cpu().numpy()+1)/2
+                rgb=(cv_img*255).astype(np.uint8)
+                bgr=cv2.cvtColor(rgb,cv2.COLOR_RGB2BGR)
+                cv2.imwrite(sub_path+'/'+str(step)+'.jpg',bgr)
+
+            step += 1
+            if epoch_iter >= dataset_size:
+                break
+
+

VITON-Extends_test/test.sh

@@ -0,0 +1 @@
+python test.py --name demo --resize_or_crop None --batchSize 1 --gpu_ids 0

VITON-Extends_test/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "target": "ES6",
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "preserve",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "paths": {
+      "@/*": ["./*"]
+    }
+  },
+  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
+  "exclude": ["node_modules"]
+}

VITON-Extends_test/u2net.py

@@ -0,0 +1,525 @@
+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))
+
+        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))
+
+        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))
+
+        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))
+
+        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))
+
+        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))
+
+        return F.sigmoid(d0), F.sigmoid(d1), F.sigmoid(d2), F.sigmoid(d3), F.sigmoid(d4), F.sigmoid(d5), F.sigmoid(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 F.sigmoid(d0), F.sigmoid(d1), F.sigmoid(d2), F.sigmoid(d3), F.sigmoid(d4), F.sigmoid(d5), F.sigmoid(d6)

VITON-Extends_test/unet.py

@@ -0,0 +1,49 @@
+import cv2
+import torch
+import numpy as np
+from torchvision import transforms
+from PIL import Image
+from u2net import U2NET  
+
+# Load U2NET model
+model = U2NET(3, 1)
+model_path = 'checkpoints/u2net.pth' 
+model.load_state_dict(torch.load(model_path, map_location='cpu'))
+model.eval()
+
+# Tiền xử lý ảnh
+def preprocess(img):
+    transform = transforms.Compose([
+        transforms.Resize((192, 256)),
+        transforms.ToTensor(),
+        transforms.Normalize([0.485, 0.456, 0.406],
+                             [0.229, 0.224, 0.225])])
+    return transform(img).unsqueeze(0)
+
+# Tạo mặt nạ từ ảnh đầu vào
+def get_mask(image_path):
+    image = Image.open(image_path).convert('RGB')
+    input_tensor = preprocess(image)
+    with torch.no_grad():
+        d1, *_ = model(input_tensor)
+        pred = d1[0][0].numpy()
+        pred = (pred - pred.min()) / (pred.max() - pred.min())
+        mask = cv2.resize(pred, image.size)
+        return np.expand_dims(mask, axis=2)
+
+# Áp dụng mặt nạ và đổi nền thành trắng
+def apply_mask(img_path, output_path='output_2.png'):
+    original = cv2.imread(img_path)
+    original_rgb = cv2.cvtColor(original, cv2.COLOR_BGR2RGB)
+    mask = get_mask(img_path)
+    mask = cv2.resize(mask, (original.shape[1], original.shape[0]))
+    mask = np.expand_dims(mask, axis=2)
+    mask = np.repeat(mask, 3, axis=2)
+    result = (original_rgb * mask + 255 * (1 - mask)).astype(np.uint8)
+    result_bgr = cv2.cvtColor(result, cv2.COLOR_RGB2BGR)
+    result_bgr = cv2.resize(result_bgr, (192, 256))    
+    cv2.imwrite(output_path, result_bgr)
+    print(f"[✔] Đã lưu ảnh tại: {output_path}")
+
+# === CHẠY THỬ ===
+apply_mask('test_2.jpg')  # ⚠️ Thay bằng ảnh thật của bạn