libcom 0.1.8__py3-none-any.whl

libcom/shadow_generation/source/ldm/util.py

@@ -0,0 +1,199 @@
+import importlib
+
+import torch
+from torch import optim
+import numpy as np
+
+from inspect import isfunction
+from PIL import Image, ImageDraw, ImageFont
+
+
+def log_txt_as_img(wh, xc, size=10):
+    # wh a tuple of (width, height)
+    # xc a list of captions to plot
+    b = len(xc)
+    txts = list()
+    for bi in range(b):
+        txt = Image.new("RGB", wh, color="white")
+        draw = ImageDraw.Draw(txt)
+        font = ImageFont.truetype('font/DejaVuSans.ttf', size=size)
+        nc = int(40 * (wh[0] / 256))
+        lines = "\n".join(xc[bi][start:start + nc] for start in range(0, len(xc[bi]), nc))
+
+        try:
+            draw.text((0, 0), lines, fill="black", font=font)
+        except UnicodeEncodeError:
+            print("Cant encode string for logging. Skipping.")
+
+        txt = np.array(txt).transpose(2, 0, 1) / 127.5 - 1.0
+        txts.append(txt)
+    txts = np.stack(txts)
+    txts = torch.tensor(txts)
+    return txts
+
+
+def ismap(x):
+    if not isinstance(x, torch.Tensor):
+        return False
+    return (len(x.shape) == 4) and (x.shape[1] > 3)
+
+
+def isimage(x):
+    if not isinstance(x,torch.Tensor):
+        return False
+    return (len(x.shape) == 4) and (x.shape[1] == 3 or x.shape[1] == 1)
+
+
+def exists(x):
+    return x is not None
+
+
+def default(val, d):
+    if exists(val):
+        return val
+    return d() if isfunction(d) else d
+
+
+def mean_flat(tensor):
+    """
+    https://github.com/openai/guided-diffusion/blob/27c20a8fab9cb472df5d6bdd6c8d11c8f430b924/guided_diffusion/nn.py#L86
+    Take the mean over all non-batch dimensions.
+    """
+    return tensor.mean(dim=list(range(1, len(tensor.shape))))
+
+
+def count_params(model, verbose=False):
+    total_params = sum(p.numel() for p in model.parameters())
+    if verbose:
+        print(f"{model.__class__.__name__} has {total_params*1.e-6:.2f} M params.")
+    return total_params
+
+
+def instantiate_from_config(config):
+    if not "target" in config:
+        if config == '__is_first_stage__':
+            return None
+        elif config == "__is_unconditional__":
+            return None
+        raise KeyError("Expected key `target` to instantiate.")
+
+    return get_obj_from_str(config["target"])(**config.get("params", dict()))
+
+
+def get_obj_from_str(string, reload=False):
+    module, cls = string.rsplit(".", 1)
+
+    if reload:
+        module_imp = importlib.import_module(module)
+        importlib.reload(module_imp)
+    return getattr(importlib.import_module(module, package=None), cls)
+
+
+class AdamWwithEMAandWings(optim.Optimizer):
+    # credit to https://gist.github.com/crowsonkb/65f7265353f403714fce3b2595e0b298
+    def __init__(self, params, lr=1.e-3, betas=(0.9, 0.999), eps=1.e-8,  # TODO: check hyperparameters before using
+                 weight_decay=1.e-2, amsgrad=False, ema_decay=0.9999,   # ema decay to match previous code
+                 ema_power=1., param_names=()):
+        """AdamW that saves EMA versions of the parameters."""
+        if not 0.0 <= lr:
+            raise ValueError("Invalid learning rate: {}".format(lr))
+        if not 0.0 <= eps:
+            raise ValueError("Invalid epsilon value: {}".format(eps))
+        if not 0.0 <= betas[0] < 1.0:
+            raise ValueError("Invalid beta parameter at index 0: {}".format(betas[0]))
+        if not 0.0 <= betas[1] < 1.0:
+            raise ValueError("Invalid beta parameter at index 1: {}".format(betas[1]))
+        if not 0.0 <= weight_decay:
+            raise ValueError("Invalid weight_decay value: {}".format(weight_decay))
+        if not 0.0 <= ema_decay <= 1.0:
+            raise ValueError("Invalid ema_decay value: {}".format(ema_decay))
+        defaults = dict(lr=lr, betas=betas, eps=eps,
+                        weight_decay=weight_decay, amsgrad=amsgrad, ema_decay=ema_decay,
+                        ema_power=ema_power, param_names=param_names)
+        super().__init__(params, defaults)
+
+    def __setstate__(self, state):
+        super().__setstate__(state)
+        for group in self.param_groups:
+            group.setdefault('amsgrad', False)
+
+    @torch.no_grad()
+    def step(self, closure=None):
+        """Performs a single optimization step.
+        Args:
+            closure (callable, optional): A closure that reevaluates the model
+                and returns the loss.
+        """
+        loss = None
+        if closure is not None:
+            with torch.enable_grad():
+                loss = closure()
+
+        for group in self.param_groups:
+            params_with_grad = []
+            grads = []
+            exp_avgs = []
+            exp_avg_sqs = []
+            ema_params_with_grad = []
+            state_sums = []
+            max_exp_avg_sqs = []
+            state_steps = []
+            amsgrad = group['amsgrad']
+            beta1, beta2 = group['betas']
+            ema_decay = group['ema_decay']
+            ema_power = group['ema_power']
+
+            for p in group['params']:
+                if p.grad is None:
+                    continue
+                params_with_grad.append(p)
+                if p.grad.is_sparse:
+                    raise RuntimeError('AdamW does not support sparse gradients')
+                grads.append(p.grad)
+
+                state = self.state[p]
+
+                # State initialization
+                if len(state) == 0:
+                    state['step'] = 0
+                    # Exponential moving average of gradient values
+                    state['exp_avg'] = torch.zeros_like(p, memory_format=torch.preserve_format)
+                    # Exponential moving average of squared gradient values
+                    state['exp_avg_sq'] = torch.zeros_like(p, memory_format=torch.preserve_format)
+                    if amsgrad:
+                        # Maintains max of all exp. moving avg. of sq. grad. values
+                        state['max_exp_avg_sq'] = torch.zeros_like(p, memory_format=torch.preserve_format)
+                    # Exponential moving average of parameter values
+                    state['param_exp_avg'] = p.detach().float().clone()
+
+                exp_avgs.append(state['exp_avg'])
+                exp_avg_sqs.append(state['exp_avg_sq'])
+                ema_params_with_grad.append(state['param_exp_avg'])
+
+                if amsgrad:
+                    max_exp_avg_sqs.append(state['max_exp_avg_sq'])
+
+                # update the steps for each param group update
+                state['step'] += 1
+                # record the step after step update
+                state_steps.append(state['step'])
+
+            optim._functional.adamw(params_with_grad,
+                    grads,
+                    exp_avgs,
+                    exp_avg_sqs,
+                    max_exp_avg_sqs,
+                    state_steps,
+                    amsgrad=amsgrad,
+                    beta1=beta1,
+                    beta2=beta2,
+                    lr=group['lr'],
+                    weight_decay=group['weight_decay'],
+                    eps=group['eps'],
+                    maximize=False)
+
+            cur_ema_decay = min(ema_decay, 1 - state['step'] ** -ema_power)
+            for param, ema_param in zip(params_with_grad, ema_params_with_grad):
+                ema_param.mul_(cur_ema_decay).add_(param.float(), alpha=1 - cur_ema_decay)
+
+        return loss

libcom/utils/environment.py

@@ -0,0 +1,12 @@
+import torch
+
+def check_gpu_device(device):
+    assert torch.cuda.is_available(), 'Only GPU are supported'
+    if isinstance(device, (int, str)):
+        device = int(device)
+        assert 0 <= device < torch.cuda.device_count(), f'invalid device id: {device}'
+        device = torch.device(f'cuda:{device}')
+    if isinstance(device, torch.device):
+        return device
+    else:
+        raise Exception('invalid device type: type({})={}'.format(device, type(device)))

libcom/utils/model_download.py

@@ -0,0 +1,67 @@
+import os
+import shutil
+from tqdm import tqdm
+import zipfile
+
+hf_repo = 'BCMIZB/Libcom_pretrained_models'
+ms_repo = 'yujieouo/Libcom_pretrained_models'
+
+def download_pretrained_model(weight_path):
+    if os.path.exists(weight_path):
+        assert os.path.isfile(weight_path), weight_path
+        return weight_path
+    else:
+        weight_path= os.path.abspath(weight_path)
+        model_name = os.path.basename(weight_path)
+        save_dir   = os.path.dirname(weight_path)
+        download_file_from_network(model_name, save_dir)
+        print('Pretrained model has been stored to ', weight_path)
+        return weight_path
+    
+def download_entire_folder(folder_path):
+    if os.path.exists(folder_path):
+        assert os.path.isdir(folder_path), folder_path
+        assert len(os.listdir(folder_path)) > 1, f'{folder_path} is an empty folder'
+        return folder_path
+    else:
+        folder_path = os.path.abspath(folder_path) 
+        folder_name = os.path.basename(folder_path)
+        file_name   = folder_name + '.zip'
+        save_dir    = os.path.dirname(folder_path)
+        download_file_from_network(file_name, save_dir)
+        zip_file    = zipfile.ZipFile(os.path.join(save_dir, file_name))
+        zip_file.extractall(save_dir)
+        os.remove(os.path.join(save_dir, file_name))
+        print('Folder has been stored to ', folder_path)
+        return folder_path
+    
+def download_file_from_network(file_name, save_dir):
+    if not os.path.exists(save_dir):
+        os.makedirs(save_dir, exist_ok=True)
+    print('Try to download {} to {}'.format(file_name, save_dir))
+    try:
+        from huggingface_hub import hf_hub_download
+        file_path = hf_hub_download(repo_id=hf_repo, filename=file_name, cache_dir=save_dir, progress=True)
+
+    except Exception as e:
+        from modelscope.hub.file_download import model_file_download
+        file_path = model_file_download(model_id=ms_repo, 
+                                        file_path=file_name, 
+                                        cache_dir=save_dir, 
+                                        revision='master')
+    assert os.path.exists(file_path), 'Download {} failed, please try again'.format(file)
+    save_path = os.path.abspath(os.path.join(save_dir, file_name))
+    shutil.copyfile(os.path.abspath(file_path), save_path, follow_symlinks=True)
+    assert os.path.exists(save_path), 'Move file to {} failed, please try again'.format(save_path)
+    os.remove(os.path.realpath(file_path)) # delete the cache
+        
+if __name__ == '__main__':
+    file_list   = ['BargainNet.pth', 'SOPA.pth']
+    folder_list = ['openai-clip-vit-large-patch14'] 
+    for file in file_list:
+        weight_path = './pretrained_models/' + file
+        download_pretrained_model(weight_path)
+    
+    for folder in folder_list:
+        folder_path = './pretrained_models/' + folder
+        download_entire_folder(folder_path)

libcom/utils/process_image.py

@@ -0,0 +1,108 @@
+import os
+import cv2
+from PIL import Image
+import numpy as np
+
+def opencv_to_pil(input):
+    return Image.fromarray(cv2.cvtColor(input, cv2.COLOR_BGR2RGB))
+
+def pil_to_opencv(input):
+    return cv2.cvtColor(np.asarray(input), cv2.COLOR_RGB2BGR)
+
+def read_image_opencv(input):
+    if isinstance(input, str):
+        assert os.path.exists(input), input
+        input = cv2.imread(input, cv2.IMREAD_COLOR)        
+    elif isinstance(input, Image.Image):
+        input = pil_to_opencv(input)
+    return input
+
+def read_mask_opencv(input):
+    if isinstance(input, str):
+        assert os.path.exists(input), input
+        input = cv2.imread(input, cv2.IMREAD_GRAYSCALE)        
+    elif isinstance(input, Image.Image):
+        input = np.asarray(input)
+    return input
+
+def read_image_pil(input):
+    if isinstance(input, str):
+        assert os.path.exists(input), input
+        input = Image.open(input).convert('RGB')
+    elif isinstance(input, np.ndarray):
+        input = opencv_to_pil(input)
+    return input    
+
+def read_mask_pil(input):
+    if isinstance(input, str):
+        assert os.path.exists(input), input
+        input = Image.open(input).convert('L')
+    elif isinstance(input, np.ndarray):
+        input = Image.fromarray(input).convert('L')
+    return input
+
+def convert_mask_to_bbox(mask):
+    '''
+    mask: (h,w) or (h,w,1)
+    '''
+    if mask.ndim == 3:
+        mask = mask[...,0]
+    binmask = np.where(mask > 127)
+    x1 = int(np.min(binmask[1]))
+    x2 = int(np.max(binmask[1]))
+    y1 = int(np.min(binmask[0]))
+    y2 = int(np.max(binmask[0]))
+    return [x1, y1, x2+1, y2+1]
+
+def fill_image_pil(image, mask, fill_pixel=(0,0,0), thresh=127):
+    image = fill_image_opencv(image, mask, fill_pixel, thresh)
+    return Image.fromarray(image)
+
+def fill_image_opencv(image, mask, fill_pixel=(0,0,0), thresh=127):
+    image = np.asarray(image)
+    mask  = np.asarray(mask)
+    mask  = cv2.cvtColor(mask, cv2.COLOR_GRAY2BGR)
+    image[mask < thresh] = fill_pixel
+    return image
+
+def make_image_grid(img_list, text_list=None, resolution=(512,512), cols=None, border_color=255, border_width=5):
+    if cols == None:
+        cols = len(img_list)
+    assert len(img_list) % cols == 0, f'{len(img_list)} % {cols} != 0'
+    if isinstance(text_list, (list, tuple)):
+        text_list += [''] * max(0, len(img_list) - len(text_list))
+    rows = len(img_list) // cols
+    hor_border = (np.ones((resolution[0], border_width, 3), dtype=np.float32) * border_color).astype(np.uint8)
+    index = 0
+    grid_img = []
+    for i in range(rows):
+        row_img = []
+        for j in range(cols):
+            img = read_image_opencv(img_list[index])
+            img = cv2.resize(img, resolution)
+            if img.ndim == 2:
+                img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
+            if text_list and len(text_list[index]) > 0:
+                cv2.putText(img, text_list[index], (10,50), cv2.FONT_HERSHEY_COMPLEX, 1, (0,0,255), 2)
+            row_img.append(img)
+            if j < cols-1:
+                row_img.append(hor_border)
+            index += 1
+        row_img = np.concatenate(row_img, axis=1)
+        grid_img.append(row_img)
+        if i < rows-1:
+            ver_border = (np.ones((border_width, grid_img[-1].shape[1], 3), dtype=np.float32) * border_color).astype(np.uint8)
+            grid_img.append(ver_border)
+    grid_img = np.concatenate(grid_img, axis=0)
+    return grid_img
+
+def draw_bbox_on_image(input_img, bbox, color=(0,255,255), line_width=5):
+    img = read_image_opencv(input_img)
+    x1, y1, x2, y2 = bbox
+    h,w,_ = img.shape
+    x1 = max(x1, line_width)
+    y1 = max(y1, line_width)
+    x2 = min(x2, w-line_width)
+    y2 = min(y2, h-line_width)
+    img = cv2.rectangle(img, (x1,y1), (x2,y2), color, thickness=line_width)
+    return img

libcom-0.1.8.dist-info/METADATA

@@ -0,0 +1,157 @@
+Metadata-Version: 2.4
+Name: libcom
+Version: 0.1.8
+Summary: Image Composition Toolbox
+Home-page: https://github.com/bcmi/libcom
+Author: BCMI Lab
+Author-email: bernard-zhang@hotmail.com
+License: Apache License 2.0
+Keywords: computer vision,image composition
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: einops
+Requires-Dist: huggingface_hub==0.35.1
+Requires-Dist: imageio
+Requires-Dist: torch==2.6.0
+Requires-Dist: torchvision==0.21.0
+Requires-Dist: diffusers==0.34.0
+Requires-Dist: peft==0.17.1
+Requires-Dist: sentencepiece
+Requires-Dist: protobuf==6.32.1
+Requires-Dist: modelscope==1.30.0
+Requires-Dist: omegaconf==2.3.0
+Requires-Dist: opencv_python_headless
+Requires-Dist: pytorch_lightning==2.5.5
+Requires-Dist: transformers==4.44.2
+Requires-Dist: tqdm
+Requires-Dist: open_clip_torch==3.2.0
+Requires-Dist: taming-transformers-rom1504
+Requires-Dist: scikit-learn
+Requires-Dist: segment_anything
+Requires-Dist: clip
+Requires-Dist: pydantic==2.6.1
+Requires-Dist: lpips==0.1.4
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary
+
+<div align="center">
+</br>
+<img src="https://raw.githubusercontent.com/bcmi/libcom/main/resources/LOGO.png" width="200" />
+
+</div>
+
+<h1 align="center">libcom: everything about image composition</h1>
+
+</br>
+
+[![PyPI](https://img.shields.io/pypi/v/libcom)](https://pypi.org/project/libcom)
+[![Downloads](https://static.pepy.tech/badge/libcom)](https://pepy.tech/project/libcom)
+![visitors](https://visitor-badge.laobi.icu/badge?page_id=bcmi.libcom&left_color=2ea44f&right_color=green&left_text=visitors)
+[![Static Badge](https://img.shields.io/badge/Online_Workbench-yellow)](https://libcom.ustcnewly.com/)
+[![Static Badge](https://img.shields.io/badge/Dataset&Code_Resources-green)](https://github.com/bcmi/Awesome-Image-Composition)
+[![Static Badge](https://img.shields.io/badge/survey-arxiv%3A2106.14490-red)](https://arxiv.org/pdf/2106.14490.pdf)
+[![Static Badge](https://img.shields.io/github/stars/bcmi/libcom.svg?style=social)](https://github.com/bcmi/libcom/stargazers)
+
+---
+
+Welcome to scan the WeChat QR code to join the discussion group on image composition/compositing, object insertion/addition.
+<p align="center">
+<img width="150" height="150" alt="Image" src="https://github.com/user-attachments/assets/8572a7c4-0f62-4a5f-bc06-9a1d9fcb14e3" />
+</p>
+
+## Introduction
+**_libcom_ (the library of image composition) is an image composition toolbox.** The goal of [image composition](https://github.com/bcmi/Awesome-Image-Composition) ([object insertion](https://github.com/bcmi/Awesome-Object-Insertion)) is inserting one foreground into a background image to get a realistic composite image, by addressing the inconsistencies (appearance, geometry, and semantic inconsistency) between foreground and background. Generally speaking, image composition could be used to combine the visual elements from different images.
+<div align="center">
+</br>
+<img src="https://raw.githubusercontent.com/bcmi/libcom/main/resources/image_composition_task.gif" width="600" />
+</div>
+
+**_libcom_ covers a diversity of related tasks in the field of image composition**, including image blending, standard/painterly image harmonization, shadow generation, reflection generation, object placement, generative composition, quality evaluation, *etc*. For each task, we integrate one or two selected methods considering both efficiency and effectiveness. The selected methods will be continuously updated upon the emergence of better methods. 
+
+**The ultimate goal of this library is solving all the problems related to image composition with simple `import libcom`.** 
+Welcome to follow WeChat public account ["Newly AIGCer"](https://www.ustcnewly.com/blog.html) or Zhihu Column ["Newly CVer"](https://www.zhihu.com/column/c_1333918224900206592) to get the latest information about image composition! 
+
+**Welcome to recommend your self-developed models or models you have tested by opening an issue. If a model delivers outstanding and stable performance, we will consider integrating it into libcom.**
+
+**If you specialize in model inference acceleration, we welcome both voluntary and paid collaborations. Please contact us at ustcnewly@sjtu.edu.cn.**
+
+## Online Workbench
+
+We have built the [image composition workbench](https://libcom.ustcnewly.com/) based on our Libcom toolbox. The interface is as follows:
+
+<div align="center">
+</br>
+<img src="https://raw.githubusercontent.com/bcmi/libcom/main/resources/online_workbench.jpg" width="1000" />
+</div>
+
+[![]](https://github.com/user-attachments/assets/87416ec5-2461-42cb-9f2d-5030b1e1b5ec)
+
+## Main Functions
+
+- **get_composite_image** generates composite images using naive copy-and-paste followed by image blending (alpha blending or Poisson blending).
+- **OPAScoreModel** [[OPA]](https://github.com/bcmi/Object-Placement-Assessment-Dataset-OPA) evaluates the rationality of foreground object placement (location, scale) in a composite image.
+- **FOPAHeatMapModel** [[FOPA]](https://github.com/bcmi/FOPA-Fast-Object-Placement-Assessment) can predict the rationality scores for all locations/scales given a background-foreground pair, when placing the foreground with certain scale at certain location in the background. Based on the predicted rationality score map, the model can output the composite image with optimal location/scale.  
+- **color_transfer** adjusts the foreground color to match the background using traditional color transfer method.
+- **ImageHarmonizationModel** [[PCTNet]](https://github.com/rakutentech/PCT-Net-Image-Harmonization) [[LBM]](https://github.com/gojasper/LBM)  adjusts the foreground illumination to be compatible the background given photorealistic background and photorealistic foreground.
+- **PainterlyHarmonizationModel** [[PHDNet]](https://github.com/bcmi/PHDNet-Painterly-Image-Harmonization)  [[PHDiffusion]](https://github.com/bcmi/PHDiffusion-Painterly-Image-Harmonization) adjusts the foreground style to be compatible with the background given artistic background and photorealistic foreground.
+- **HarmonyScoreModel** [[BargainNet]](https://github.com/bcmi/BargainNet-Image-Harmonization) evaluates the harmony level between foreground and background in a composite image, that is, whether the illumination of foreground is harmonious with that of background. 
+- **InharmoniousLocalizationModel** [[MadisNet]](https://github.com/bcmi/MadisNet-Inharmonious-Region-Localization) localizes the inharmonious region in a synthetic image.
+- **FOSScoreModel** [[DiscoFOS]](https://github.com/bcmi/Foreground-Object-Search-Dataset-FOSD) evaluates the compatibility between foreground and background in a composite image in terms of geometry and semantics, that is, whether the geometric perspective of foreground matches that of background, and whether the semantic context of foreground in the background is reasonable.
+- **ShadowGenerationModel** [[GPSDiffusion]](https://github.com/bcmi/GPSDiffusion-Object-Shadow-Generation) generates plausible shadow for the inserted object in a composite image. 
+- **ReflectionGenerationModel** [[RGDiffusion]](https://github.com/bcmi/Object-Reflection-Generation-Dataset-DEROBA) generates plausible reflection for the inserted object in a composite image. 
+- **KontextBlendingHarmonizationModel** [[FluxKontext]](https://github.com/black-forest-labs/flux) is a generative image composition model which inserts foreground into the specified bounding box in the background. The pose and view of foreground stay unchanged. The "blending" mode does not adjust the foreground illumination, while the "harmonization" mode adjusts the foreground illumination to make the composite image harmonious. 
+- **OSInsertModel** [[OSInsert]](https://github.com/bcmi/OSInsert-Image-Composition) is a generative image composition model which inserts foreground into the specified bounding box in the background. The "conservative" mode has weak ability to adjust the pose and view of foreground according to the background. The "aggressive" mode has stronger ability to adjust the pose and view of foreground according to the background. You can also use foreground shape mask for controllable composition. 
+
+**For the detailed method descriptions, code examples, visualization results, and performance comments, please refer to our [[documents]](https://libcom.readthedocs.io/en/latest/).** If the model performance is not satisfactory, you can finetune the pretrained model on your own dataset using the source repository and replace the original model. 
+
+## Requirements
+
+The main branch is built on the Linux system with **Python 3.10** and **PyTorch>=2.6**. For other dependencies, please refer to [[requirements]](https://github.com/bcmi/libcom/blob/main/requirements.txt).
+
+## Get Started
+Please refer to [[Installation]](https://github.com/bcmi/libcom/blob/main/docs/get_started.md) for installation instructions and [[documents]](https://libcom.readthedocs.io/en/latest/) for user guidance.
+
+## Contributors
+- Institution: [Brain-like Computing and Machine Intelligence (BCMI) Lab](https://bcmi.sjtu.edu.cn/).
+- Project Initiator & Team Manager: [Li Niu](https://www.ustcnewly.com/index.html). 
+- Architect & Lead Developer: [Bo Zhang](https://bo-zhang-cs.github.io/), [Yujie Zhou](https://github.com/YujieOuO).
+- Module Developers: [Jiacheng Sui](https://github.com/charlessjc), [Bingjie Gao](https://github.com/WhynotHAHA), [Lingxiao Lu](https://github.com/pokaaa), [Xinhao Tao](https://github.com/taoxinhao13), [Junyan Cao](https://github.com/cjy-4), [Haonan Zhao](https://github.com/nononononno), [Jiaxuan Chen](https://github.com/csdahunzi), [Junqi You](https://github.com/dhmbb2).
+
+## License
+
+This project is released under the [Apache 2.0 license](https://github.com/bcmi/libcom/blob/main/LICENSE).
+
+## Bibtex
+
+If you use our toolbox, please cite our survey paper using the following BibTeX  [[arxiv](https://arxiv.org/pdf/2106.14490.pdf)]:
+
+```
+@article{niu2021making,
+  title={Making images real again: A comprehensive survey on deep image composition},
+  author={Niu, Li and Cong, Wenyan and Liu, Liu and Hong, Yan and Zhang, Bo and Liang, Jing and Zhang, Liqing},
+  journal={arXiv preprint arXiv:2106.14490},
+  year={2021}
+}
+```
+
+
+
+
+
+
+
+
+