libcom 0.1.8__py3-none-any.whl

libcom/fopa_heat_map/source/data/OBdataset.py

@@ -0,0 +1,292 @@
+# -*- coding: utf-8 -*-
+import json
+import os
+import torch
+import numpy as np
+
+from PIL import Image
+from torch.utils.data import DataLoader, Dataset
+from torchvision import transforms
+from libcom.fopa_heat_map.source.data.all_transforms import Compose, JointResize
+
+
+class CPDataset(Dataset):
+    def __init__(self, file, bg_dir, fg_dir, mask_dir, in_size, datatype='train'):
+        """
+        initialize dataset
+
+        Args:
+            file(str): file with training/test data information
+            bg_dir(str): folder with background images
+            fg_dir(str): folder with foreground images
+            mask_dir(str): folder with mask images
+            in_size(int): input size of network
+            datatype(str): "train" or "test"
+        """
+    
+        self.datatype = datatype
+        self.data = _collect_info(file, bg_dir, fg_dir, mask_dir, datatype)
+        self.insize = in_size
+
+        self.train_triple_transform = Compose([JointResize(in_size)])
+        self.train_img_transform = transforms.Compose(
+            [
+                transforms.ToTensor(),
+                transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),  # 处理的是Tensor
+            ]
+        )
+        self.train_mask_transform = transforms.ToTensor()
+
+        self.transforms_flip = transforms.Compose([
+            transforms.RandomHorizontalFlip(p=1)
+        ])
+
+    def __len__(self):
+        return len(self.data)
+    
+    def __getitem__(self, index):
+        """
+        load each item
+        return:
+            i: the image index,
+            bg_t:(1 * 3 * in_size * in_size) background image,
+            mask_t:(1 * 1 * in_size * in_size) scaled foreground mask
+            fg_t:(1 * 3 * in_size * in_size) scaled foreground image
+            target_t: (1 * in_size * in_size) pixel-wise binary labels
+            labels_num: (int) the number of annotated pixels
+        """
+        i, _, bg_path, fg_path, mask_path, scale, pos_label, neg_label, fg_path_2, mask_path_2, w, h = self.data[index]
+                
+        fg_name =  fg_path.split('/')[-1][:-4]
+        ## save_name: fg_bg_w_h_scale.jpg
+        save_name = fg_name + '_' + str(scale) + '.jpg'
+
+        bg_img = Image.open(bg_path)
+        fg_img = Image.open(fg_path)
+        mask = Image.open(mask_path)
+        if len(bg_img.split()) != 3: 
+            bg_img = bg_img.convert("RGB")
+        if len(fg_img.split()) == 3:
+            fg_img = fg_img.convert("RGB")
+        if len(mask.split()) == 3:
+            mask = mask.convert("L")
+
+        is_flip = False
+        if self.datatype == 'train' and np.random.uniform() < 0.5:
+            is_flip = True
+
+        # make composite images which are used in feature mimicking 
+        fg_tocp = Image.open(fg_path_2).convert("RGB")
+        mask_tocp = Image.open(mask_path_2).convert("L")
+        composite_list = []
+        for pos in pos_label:
+            x_, y_ = pos
+            x = int(x_ - w / 2)
+            y = int(y_ - h / 2)
+            composite_list.append(make_composite(fg_tocp, mask_tocp, bg_img, [x, y, w, h], is_flip))
+
+        for pos in neg_label:
+            x_, y_ = pos
+            x = int(x_ - w / 2)
+            y = int(y_ - h / 2) 
+            composite_list.append(make_composite(fg_tocp, mask_tocp, bg_img, [x, y, w, h], is_flip))
+
+        composite_list_ = torch.stack(composite_list, dim=0)
+        composite_cat = torch.zeros(50 - len(composite_list), 4, 256, 256)
+        composite_list = torch.cat((composite_list_, composite_cat), dim=0)
+
+        # positive pixels are 1, negative pixels are 0, other pixels are 255
+        # feature_pos: record the positions of annotated pixels
+        target, feature_pos = _obtain_target(bg_img.size[0], bg_img.size[1], self.insize, pos_label, neg_label, is_flip)
+        for i in range(50 - len(feature_pos)):
+            feature_pos.append((0, 0)) # pad the length to 50
+        feature_pos = torch.Tensor(feature_pos)
+        
+        # resize the foreground/background to 256, convert them to tensors
+        bg_t, fg_t, mask_t = self.train_triple_transform(bg_img, fg_img, mask)
+        mask_t = self.train_mask_transform(mask_t)
+        fg_t = self.train_img_transform(fg_t)
+        bg_t = self.train_img_transform(bg_t)
+
+        if is_flip == True:
+            fg_t = self.transforms_flip(fg_t)
+            bg_t = self.transforms_flip(bg_t)
+            mask_t = self.transforms_flip(mask_t)
+
+        # tensor is normalized to [0,1]，map back to [0, 255] for ease of computation
+        target_t = self.train_mask_transform(target) * 255
+        labels_num = (target_t != 255).sum()
+
+        return i, bg_t, mask_t, fg_t, target_t.squeeze(), labels_num, composite_list, feature_pos, w, h, save_name
+    
+
+def _obtain_target(original_width, original_height, in_size, pos_label, neg_label, isflip=False):
+    """
+    put 0, 1 labels on a 256x256 score map
+    Args:
+        original_width(int): width of original background
+        original_height(int): height of original background
+        in_size(int): input size of network
+        pos_label(list): positive pixels in original background
+        neg_label(list): negative pixels in original background
+    return:
+        target_r: score map with ground-truth labels
+    """
+    target = np.uint8(np.ones((in_size, in_size)) * 255)
+    feature_pos = []
+    for pos in pos_label:
+        x, y = pos
+        x_new = int(x * in_size / original_width) 
+        y_new = int(y * in_size / original_height)
+        target[y_new, x_new] = 1.
+        if isflip:
+            x_new = 256 - x_new
+        feature_pos.append((x_new, y_new))
+    for pos in neg_label:
+        x, y = pos
+        x_new = int(x * in_size / original_width)
+        y_new = int(y * in_size / original_height)
+        target[y_new, x_new] = 0.
+        if isflip:
+            x_new = 256 - x_new
+        feature_pos.append((x_new, y_new))
+    target_r = Image.fromarray(target)
+    if isflip:
+        target_r = transforms.RandomHorizontalFlip(p=1)(target_r)
+    return target_r, feature_pos
+
+
+def _collect_info(json_file, bg_dir, fg_dir, mask_dir, datatype='train'):
+    """
+    load json file and return required information
+    Args:
+        json_file(str): json file with train/test information 
+        bg_dir(str): folder with background images
+        fg_dir(str): folder with foreground images
+        mask_dir(str): folder with foreground masks
+        datatype(str): "train" or "test"
+    return:
+        index(int): the sample index
+        background image path, foreground image path, foreground mask image
+        foreground scale, the locations of positive/negative pixels
+    """
+    f_json = json.load(open(json_file, 'r'))
+    return [
+        (
+            index,                                      
+            row['scID'].rjust(12,'0'),
+            os.path.join(bg_dir, "%012d.jpg" % int(row['scID'])),  # background image path
+            os.path.join(fg_dir, "{}/{}_{}_{}_{}.jpg".format(datatype, int(row['annID']), int(row['scID']), # scaled foreground image path
+                                                             int(row['newWidth']), int(row['newHeight']))),
+          
+            os.path.join(mask_dir, "{}/{}_{}_{}_{}.jpg".format(datatype, int(row['annID']), int(row['scID']), # scaled foreground mask path
+                                                               int(row['newWidth']), int(row['newHeight']))),
+            row['scale'],
+            row['pos_label'], row['neg_label'],
+            os.path.join(fg_dir, "foreground/{}.jpg".format(int(row['annID']))), # original foreground image path
+            os.path.join(fg_dir, "foreground/mask_{}.jpg".format(int(row['annID']))), # original foreground mask path
+            int(row['newWidth']), int(row['newHeight']) # scaled foreground width and height
+        )
+        for index, row in enumerate(f_json)
+    ]
+
+
+def _to_center(bbox):
+    """conver bbox to center pixel"""
+    x, y, width, height = bbox
+    return x + width // 2, y + height // 2
+
+
+def create_loader(table_path, bg_dir, fg_dir, mask_dir, in_size, datatype, batch_size, num_workers, shuffle):
+    dset = CPDataset(table_path, bg_dir, fg_dir, mask_dir, in_size, datatype)
+    data_loader = DataLoader(dset, batch_size=batch_size, num_workers=num_workers, shuffle=shuffle)
+
+    return data_loader
+
+
+def make_composite(fg_img, mask_img, bg_img, pos, isflip=False):
+    x, y, w, h = pos
+    bg_h = bg_img.height
+    bg_w = bg_img.width
+    # resize foreground to expected size [h, w]
+    fg_transform = transforms.Compose([ 
+        transforms.Resize((h, w)),
+        transforms.ToTensor(),
+    ])
+    top = max(y, 0)
+    bottom = min(y + h, bg_h)
+    left = max(x, 0)
+    right = min(x + w, bg_w)
+    fg_img_ = fg_transform(fg_img)
+    mask_img_ = fg_transform(mask_img)
+    fg_img = torch.zeros(3, bg_h, bg_w)
+    mask_img = torch.zeros(3, bg_h, bg_w)
+    fg_img[:, top:bottom, left:right] = fg_img_[:, top - y:bottom - y, left - x:right - x]
+    mask_img[:, top:bottom, left:right] = mask_img_[:, top - y:bottom - y, left - x:right - x]
+    bg_img = transforms.ToTensor()(bg_img)
+    blended = fg_img * mask_img + bg_img * (1 - mask_img)
+    com_pic = transforms.ToPILImage()(blended).convert('RGB')
+    if isflip == False:
+        com_pic = transforms.Compose(
+            [
+                transforms.Resize((256, 256)),
+                transforms.ToTensor()
+            ]
+        )(com_pic)
+        mask_img = transforms.ToPILImage()(mask_img).convert('L')
+        mask_img = transforms.Compose(
+            [
+                transforms.Resize((256, 256)),
+                transforms.ToTensor()
+            ]
+        )(mask_img)
+        com_pic = torch.cat((com_pic, mask_img), dim=0)
+    else:
+        com_pic = transforms.Compose(
+            [
+                transforms.Resize((256, 256)),
+                transforms.RandomHorizontalFlip(p=1),
+                transforms.ToTensor()
+            ]
+        )(com_pic)
+        mask_img = transforms.ToPILImage()(mask_img).convert('L')
+        mask_img = transforms.Compose(
+            [
+                transforms.Resize((256, 256)),
+                transforms.RandomHorizontalFlip(p=1),
+                transforms.ToTensor()
+            ]
+        )(mask_img)
+        com_pic = torch.cat((com_pic, mask_img), dim=0)
+    return com_pic
+
+def make_composite_PIL(fg_img, mask_img, bg_img, pos, return_mask=False):
+    x, y, w, h = pos
+    bg_h = bg_img.height
+    bg_w = bg_img.width
+  
+    top = max(y, 0)
+    bottom = min(y + h, bg_h)
+    left = max(x, 0)
+    right = min(x + w, bg_w)
+    fg_img_ = fg_img.resize((w,h))
+    mask_img_ = mask_img.resize((w,h))
+    
+    fg_img_ = np.array(fg_img_)
+    mask_img_ = np.array(mask_img_, dtype=np.float64)/255
+    bg_img = np.array(bg_img)
+    
+    fg_img = np.zeros((bg_h, bg_w, 3), dtype=np.uint8) 
+    mask_img  = np.zeros((bg_h, bg_w, 3), dtype=np.float64) 
+    
+    fg_img[top:bottom, left:right, :] = fg_img_[top - y:bottom - y, left - x:right - x, :]
+    mask_img[top:bottom, left:right, :] = mask_img_[top - y:bottom - y, left - x:right - x, :]
+    composite_img = fg_img * mask_img + bg_img * (1 - mask_img)
+    
+    
+    composite_img = Image.fromarray(composite_img.astype(np.uint8))
+    if return_mask==False:
+        return composite_img
+    else:
+        composite_msk = Image.fromarray((mask_img*255).astype(np.uint8))
+        return composite_img, composite_msk

libcom/fopa_heat_map/source/data/all_transforms.py

@@ -0,0 +1,25 @@
+from PIL import Image
+
+class JointResize(object):
+    def __init__(self, size):
+        if isinstance(size, int):
+            self.size = (size, size)
+        elif isinstance(size, tuple):
+            self.size = size
+        else:
+            raise RuntimeError("size should be int or tuple")
+
+    def __call__(self, bg, fg, mask):
+        bg = bg.resize(self.size, Image.BILINEAR)
+        fg = fg.resize(self.size, Image.BILINEAR)
+        mask = mask.resize(self.size, Image.NEAREST)
+        return bg, fg, mask
+
+class Compose(object):
+    def __init__(self, transforms):
+        self.transforms = transforms
+
+    def __call__(self, bg, fg, mask):
+        for t in self.transforms:
+            bg, fg, mask = t(bg, fg, mask)
+        return bg, fg, mask

libcom/fopa_heat_map/source/network/BaseBlocks.py

@@ -0,0 +1,26 @@
+import torch.nn as nn
+
+
+class BasicConv2d(nn.Module):
+    def __init__(
+        self, in_planes, out_planes, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=False,
+    ):
+        super(BasicConv2d, self).__init__()
+
+        self.basicconv = nn.Sequential(
+            nn.Conv2d(
+                in_planes,
+                out_planes,
+                kernel_size=kernel_size,
+                stride=stride,
+                padding=padding,
+                dilation=dilation,
+                groups=groups,
+                bias=bias,
+            ),
+            nn.BatchNorm2d(out_planes),
+            nn.ReLU(inplace=True),
+        )
+
+    def forward(self, x):
+        return self.basicconv(x)

libcom/fopa_heat_map/source/network/DynamicModules.py

@@ -0,0 +1,43 @@
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class simpleDFN(nn.Module):
+    def __init__(self, in_xC, in_yC, out_C, kernel_size=3, down_factor=4):
+        """use nn.Unfold to realize dynamic convolution
+
+        Args:
+            in_xC (int): channel number of first input
+            in_yC (int): channel number of second input
+            out_C (int): channel number of output
+            kernel_size (int): the size of generated conv kernel
+            down_factor (int): reduce the model parameters when generating conv kernel
+        """
+        super(simpleDFN, self).__init__()
+        self.kernel_size = kernel_size
+        self.fuse = nn.Conv2d(in_xC, out_C, 3, 1, 1)
+        self.out_C = out_C
+        self.gernerate_kernel = nn.Sequential(
+            # nn.Conv2d(in_yC, in_yC, 3, 1, 1),
+            # DenseLayer(in_yC, in_yC, k=down_factor),
+            nn.Conv2d(in_yC, in_xC, 1),
+        )
+        self.unfold = nn.Unfold(kernel_size=3, dilation=1, padding=1, stride=1)
+        self.pool = nn.AdaptiveAvgPool2d(self.kernel_size)
+        self.in_planes = in_yC
+
+    def forward(self, x, y):  # x:bg y:fg
+        kernel = self.gernerate_kernel(self.pool(y))
+        batch_size, in_planes, height, width = x.size()
+        x = x.view(1, -1, height, width)
+        kernel = kernel.view(-1, 1, self.kernel_size, self.kernel_size)
+        if self.kernel_size == 3:
+            output = F.conv2d(x, kernel, bias=None, stride=1, padding=1, groups=self.in_planes * batch_size)
+        elif self.kernel_size == 1:
+            output = F.conv2d(x, kernel, bias=None, stride=1, padding=0, groups=self.in_planes * batch_size)
+        elif self.kernel_size == 5:
+            output = F.conv2d(x, kernel, bias=None, stride=1, padding=2, groups=self.in_planes * batch_size)
+        else:
+            output = F.conv2d(x, kernel, bias=None, stride=1, padding=3, groups=self.in_planes * batch_size)
+        output = output.view(batch_size, -1, height, width)
+        return self.fuse(output)

libcom/fopa_heat_map/source/network/ObPlaNet_simple.py

@@ -0,0 +1,112 @@
+import sys
+import torch
+import torch.nn as nn
+from torchvision import transforms
+
+sys.path.append("..")
+from ..backbone.ResNet import Backbone_ResNet18_in3, Backbone_ResNet18_in3_1
+from .BaseBlocks import BasicConv2d
+from .DynamicModules import simpleDFN
+from .tensor_ops import cus_sample, upsample_add
+
+class ObPlaNet_resnet18(nn.Module):
+    def __init__(self, pretrained=True, ks=3, scale=3, weight_path=None):
+        super(ObPlaNet_resnet18, self).__init__()
+        self.Eiters = 0
+        self.upsample_add = upsample_add
+        self.upsample = cus_sample
+        self.to_pil = transforms.ToPILImage()
+        self.scale = scale
+
+        self.add_mask = True
+
+        (
+            self.bg_encoder1,
+            self.bg_encoder2,
+            self.bg_encoder4,
+            self.bg_encoder8,
+            self.bg_encoder16,
+        ) = Backbone_ResNet18_in3(pretrained, weight_path)
+        
+        # freeze background encoder
+        for p in self.parameters():
+            p.requires_grad = False
+
+        (
+            self.fg_encoder1,
+            self.fg_encoder2,
+            self.fg_encoder4,
+            self.fg_encoder8,
+            self.fg_encoder16,
+            self.fg_encoder32,
+        ) = Backbone_ResNet18_in3_1(pretrained=pretrained)
+
+        if self.add_mask:
+            self.mask_conv = nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3, bias=False)
+
+        # dynamic conv
+        self.fg_trans16 = nn.Conv2d(512, 64, 1)
+        self.fg_trans8 = nn.Conv2d(256, 64, 1)
+        self.selfdc_16 = simpleDFN(64, 64, 512, ks, 4)
+        self.selfdc_8 = simpleDFN(64, 64, 512, ks, 4)
+
+        self.upconv16 = BasicConv2d(512, 256, kernel_size=3, stride=1, padding=1)
+        self.upconv8 = BasicConv2d(256, 128, kernel_size=3, stride=1, padding=1)
+        self.upconv4 = BasicConv2d(128, 64, kernel_size=3, stride=1, padding=1)
+        self.upconv2 = BasicConv2d(64, 64, kernel_size=3, stride=1, padding=1)
+        self.upconv1 = BasicConv2d(64, 64, kernel_size=3, stride=1, padding=1)
+
+        self.classifier = nn.Conv2d(512, 2, 1)
+
+    def forward(self, bg_in_data, fg_in_data, mask_in_data=None, mode='test'):
+        """
+        Args:
+            bg_in_data: (batch_size * 3 * H * W) background image
+            fg_in_data: (batch_size * 3 * H * W) scaled foreground image
+            mask_in_data: (batch_size * 1 * H * W) scaled foreground mask
+            mode: "train" or "test"
+        """
+        if ('train' == mode):
+            self.Eiters += 1
+            
+        # extract background and foreground features
+        black_mask = torch.zeros(mask_in_data.size()).to(mask_in_data.device)
+        bg_in_data_ = torch.cat([bg_in_data, black_mask], dim=1)
+        bg_in_data_1 = self.bg_encoder1(bg_in_data_)  # torch.Size([2, 64, 128, 128])
+        fg_cat_mask = torch.cat([fg_in_data, mask_in_data], dim=1)
+        fg_in_data_1 = self.fg_encoder1(fg_cat_mask)  # torch.Size([2, 64, 128, 128])
+  
+
+        bg_in_data_2 = self.bg_encoder2(bg_in_data_1)  # torch.Size([2, 64, 64, 64])
+        fg_in_data_2 = self.fg_encoder2(fg_in_data_1)  # torch.Size([2, 64, 128, 128])
+        bg_in_data_4 = self.bg_encoder4(bg_in_data_2)  # torch.Size([2, 128, 32, 32])
+        fg_in_data_4 = self.fg_encoder4(fg_in_data_2)  # torch.Size([2, 64, 64, 64])
+        del fg_in_data_1, fg_in_data_2
+
+        bg_in_data_8 = self.bg_encoder8(bg_in_data_4)  # torch.Size([2, 256, 16, 16])
+        fg_in_data_8 = self.fg_encoder8(fg_in_data_4)  # torch.Size([2, 128, 32, 32])
+        bg_in_data_16 = self.bg_encoder16(bg_in_data_8)  # torch.Size([2, 512, 8, 8])
+        fg_in_data_16 = self.fg_encoder16(fg_in_data_8)  # torch.Size([2, 256, 16, 16])
+        fg_in_data_32 = self.fg_encoder32(fg_in_data_16)  # torch.Size([2, 512, 8, 8])
+
+        in_data_8_aux = self.fg_trans8(fg_in_data_16)  # torch.Size([2, 64, 16, 16])
+        in_data_16_aux = self.fg_trans16(fg_in_data_32)  # torch.Size([2, 64, 8, 8])
+
+        # Unet decoder
+        bg_out_data_16 = bg_in_data_16  # torch.Size([2, 512, 8, 8])
+
+        bg_out_data_8 = self.upsample_add(self.upconv16(bg_out_data_16), bg_in_data_8)  # torch.Size([2, 256, 16, 16])
+        bg_out_data_4 = self.upsample_add(self.upconv8(bg_out_data_8), bg_in_data_4)  # torch.Size([2, 128, 32, 32])
+        bg_out_data_2 = self.upsample_add(self.upconv4(bg_out_data_4), bg_in_data_2)  # torch.Size([2, 64, 64, 64])
+        bg_out_data_1 = self.upsample_add(self.upconv2(bg_out_data_2), bg_in_data_1)  # torch.Size([2, 64, 128, 128])
+        del bg_out_data_2, bg_out_data_4, bg_out_data_8, bg_out_data_16
+
+        bg_out_data = self.upconv1(self.upsample(bg_out_data_1, scale_factor=2))  # torch.Size([2, 64, 256, 256])
+
+        # fuse foreground and background features using dynamic conv
+        fuse_out = self.upsample_add(self.selfdc_16(bg_out_data_1, in_data_8_aux), \
+                                     self.selfdc_8(bg_out_data, in_data_16_aux))  # torch.Size([2, 64, 256, 256])
+
+        out_data = self.classifier(fuse_out)  # torch.Size([2, 2, 256, 256])
+
+        return out_data, fuse_out

libcom/fopa_heat_map/source/network/__init__.py

@@ -0,0 +1 @@
+from .ObPlaNet_simple import *

libcom/fopa_heat_map/source/network/tensor_ops.py

@@ -0,0 +1,37 @@
+import torch
+import torch.nn.functional as F
+
+def cus_sample(feat, **kwargs):
+    assert len(kwargs.keys()) == 1 and list(kwargs.keys())[0] in ["size", "scale_factor"]
+    return F.interpolate(feat, mode="bilinear", align_corners=True,**kwargs)
+
+
+def upsample_add(*xs):
+    y = xs[-1]
+    for x in xs[:-1]:
+        y = y + F.interpolate(x, size=y.size()[2:], mode="bilinear", align_corners=False)
+    return y
+
+
+def upsample_cat(*xs):
+    y = xs[-1]
+    out = []
+    for x in xs[:-1]:
+        out.append(F.interpolate(x, size=y.size()[2:], mode="bilinear", align_corners=False))
+    return torch.cat([out, y], dim=1)
+
+
+def upsample_reduce(b, a):
+    _, C, _, _ = b.size()
+    N, _, H, W = a.size()
+
+    b = F.interpolate(b, size=(H, W), mode="bilinear", align_corners=False)
+    a = a.reshape(N, -1, C, H, W).mean(1)
+
+    return b + a
+
+
+def shuffle_channels(x, groups):
+    N, C, H, W = x.size()
+    x = x.reshape(N, groups, C // groups, H, W).permute(0, 2, 1, 3, 4)
+    return x.reshape(N, C, H, W)

libcom/fopa_heat_map/source/prepare_multi_fg_scales.py

@@ -0,0 +1,85 @@
+import os
+import csv
+import numpy as np
+from PIL import Image
+import cv2
+
+fg_scale_num = 16
+
+def fill_image_by_mask(image, mask, fill_pixel=0, thresh=127):
+    image = np.asarray(image).copy()
+    mask  = np.asarray(mask)
+    fill_img = (np.ones_like(image) * fill_pixel).astype(np.uint8)
+    image = np.where(mask > thresh, image, fill_img)
+    return Image.fromarray(image)
+
+def prepare_multi_fg_scales(cache_dir,fg_path,mask_path,bg_path,fg_scale_num):
+    os.makedirs(cache_dir, exist_ok=True)
+    fg_name   = os.path.splitext(os.path.basename(fg_path))[0]
+    bg_name   = os.path.splitext(os.path.basename(bg_path))[0]
+    fg_scales = list(range(1, fg_scale_num+1))
+    fg_scales = [i/(1+fg_scale_num+1) for i in fg_scales]
+    
+    scaled_fg_dir   = os.path.join(cache_dir, f'fg_{fg_scale_num}scales')
+    scaled_mask_dir = os.path.join(cache_dir, f'mask_{fg_scale_num}scales')    
+    csv_file = os.path.join(cache_dir, f'{fg_scale_num}scales.csv')
+    os.makedirs(scaled_fg_dir,   exist_ok=True)
+    os.makedirs(scaled_mask_dir, exist_ok=True)
+
+    file = open(csv_file, mode='w', newline='')
+    writer = csv.writer(file)
+    csv_head = ['fg_name', 'mask_name', 'bg_name', 'scale', 'newWidth', 'newHeight', 'pos_label', 'neg_label']
+    writer.writerow(csv_head)
+
+    bg_img = Image.open(bg_path).convert("RGB")  
+    bg_img_aspect = bg_img.height / bg_img.width
+    fg_tocp   = Image.open(fg_path).convert("RGB")
+    mask_tocp = Image.open(mask_path).convert("RGB")
+    fg_tocp   = fill_image_by_mask(fg_tocp, mask_tocp)
+    fg_tocp_aspect = fg_tocp.height / fg_tocp.width
+    
+    for fg_scale in fg_scales:
+        if fg_tocp_aspect > bg_img_aspect:
+            new_height = int(bg_img.height * fg_scale)
+            new_width  = int(new_height / fg_tocp.height * fg_tocp.width)
+        else:
+            new_width  = int(bg_img.width * fg_scale)
+            new_height = int(new_width / fg_tocp.width * fg_tocp.height)
+        
+        top    = int((bg_img.height - new_height) / 2)
+        bottom = top + new_height
+        left   = int((bg_img.width - new_width) / 2)
+        right  = left + new_width
+        
+        fg_img_ = np.asarray(fg_tocp.resize((new_width, new_height)))
+        mask_   = np.asarray(mask_tocp.resize((new_width, new_height)))
+        fg_img  = np.zeros((bg_img.height, bg_img.width, 3), dtype=np.uint8) 
+        mask    = np.zeros((bg_img.height, bg_img.width, 3), dtype=np.uint8) 
+        fg_img[top:bottom, left:right, :] = fg_img_
+        mask[top:bottom, left:right, :] = mask_
+        fg_img = Image.fromarray(fg_img.astype(np.uint8))
+        mask = Image.fromarray(mask.astype(np.uint8))
+        
+        basename = f'{fg_name}_{bg_name}_{new_width}_{new_height}.jpg'
+        fg_img_path = os.path.join(scaled_fg_dir, basename)
+        mask_path = os.path.join(scaled_mask_dir, basename)
+        fg_img.save(fg_img_path)
+        mask.save(mask_path)
+        writer.writerow([os.path.basename(fg_path), 
+                         os.path.basename(mask_path), 
+                         os.path.basename(bg_path), 
+                         fg_scale, new_width, new_height, 
+                         None, None])
+    file.close()  
+    csv_data = []
+    with open(csv_file, mode='r') as file:
+        reader = csv.DictReader(file)
+        for row in reader:
+            if row['pos_label']=="":
+                row['pos_label'] = [[0,0]]
+            if row['neg_label']=="":
+                row['neg_label'] = [[0,0]]
+            csv_data.append(row)
+    return scaled_fg_dir, scaled_mask_dir, csv_file
+
+

libcom/fos_score/__init__.py

@@ -0,0 +1,4 @@
+# change to your lib name
+from .fos_score_prediction import FOSScoreModel
+
+__all__ = ['FOSScoreModel']