Add files using upload-large-folder tool

external/Metric3D/training/mono/configs/__init__.py

@@ -0,0 +1 @@
+

external/Metric3D/training/mono/datasets/distributed_sampler.py

@@ -0,0 +1,275 @@
+import numpy as np
+import logging
+import torch.distributed as dist
+import math
+import os
+from mono.utils.comm import get_func, main_process
+from torch.utils.data import ConcatDataset, DataLoader
+import random
+import copy
+import torch
+import logging
+
+
+def build_dataset_n_sampler_with_cfg(cfg, phase):
+    # build data array, similar datasets are organized in the same group
+    datasets_array = build_data_array(cfg, phase)
+    # concatenate datasets with torch.utils.data.ConcatDataset methods
+    dataset_merge = concatenate_datasets(datasets_array)
+    # customerize sampler
+    custom_sampler = CustomerMultiDataSampler(cfg, dataset_merge, phase)
+    return dataset_merge, custom_sampler
+
+class CustomerMultiDataSampler(torch.utils.data.Sampler):
+    """
+    Customerize a sampler method.  During this process, the size of some datasets will be tailored or expanded. 
+    Such process aims to ensure each group has the same data size. 
+    e.g. dataset_list: [[A, B, C], [E, F], M], then group 'A,B,C' (Size(A) + Size(B) + Size(C)) has the same size 
+    as to group 'E,F' (Size(E) + Size(F)), so as to 'M'.
+    args:
+        @ cfg: configs for each dataset.
+        @ dataset_merge: merged multiple datasets with the torch.utils.data.ConcatDataset method.
+        @ phase: train/val/test phase.
+    """
+
+    def __init__(self, cfg, dataset_merge, phase):
+        self.cfg = cfg
+        self.world_size = int(os.environ['WORLD_SIZE'])
+        self.phase = phase
+        self.global_rank = cfg.dist_params.global_rank
+        self.dataset_merge = dataset_merge  
+        self.logger = logging.getLogger()
+        if main_process():
+            self.logger.info(f'Initilized CustomerMultiDataSampler for {phase}.')
+        self.random_seed = 136
+        self.random_seed_cp = 639
+
+    def __iter__(self):
+        self.create_samplers() 
+        self.logger.info("Sample list of {} in rank {} is: {}".format(self.phase, self.global_rank, ' '.join(map(str, self.sample_indices_array[-20: -10]))))
+        # subsample, each rank sample a subset for training.
+        rank_offset = self.each_gpu_size * self.global_rank
+        rank_indices = self.sample_indices_array[rank_offset : rank_offset + self.each_gpu_size]
+        
+        assert rank_indices.size == self.each_gpu_size
+        
+        for id in rank_indices:
+            yield id
+
+    def __len__(self):
+        return self.total_dist_size
+
+    def create_samplers(self):       
+        # sample idx for each dataset, idx value should not exceed the size of data, 
+        # i.e. 0 <= idx < len(data_size)
+        #self.samples_mat = []
+        self.indices_mat = []
+        # size expanded, idx cumulative aggregrated for calling
+        self.indices_expand_mat = []
+        
+        # max group size, each group may consists of multiple similar datasets
+        max_group_size = max([len(i) for i in self.dataset_merge.datasets])
+        
+        dataset_cumulative_sizes = [0] + self.dataset_merge.cumulative_sizes
+        
+        for gi, dataset_group in enumerate(self.dataset_merge.datasets):
+            # the merged dataset consists of multiple grouped datasets
+            samples_group = []
+            indices_expand_group = []
+            indices_group = []
+
+            # to ensure each group has the same size, group with less data has to duplicate its sample list for 'cp_times' times
+            cp_times = max_group_size / len(dataset_group)
+            
+            # adjust each group to ensure they have the same data size
+            group_cumulative_sizes = [0] + dataset_group.cumulative_sizes
+            expand_indices_sizes = (np.array(group_cumulative_sizes) * cp_times).astype(np.int)
+            expand_indices_sizes[-1] = max_group_size
+            # datasets in the same group have to expand its sample list
+            expand_indices_sizes = expand_indices_sizes[1:] - expand_indices_sizes[:-1]
+            
+            for di, dataset_i in enumerate(dataset_group.datasets):
+                # datasets residing in each group may have similar features
+                # samples indices list
+                dataset_i_ori_sample_list = self.dataset_merge.datasets[gi].datasets[di].sample_list
+                if self.phase == 'train':
+                    #sample_list_i = random.sample(dataset_i_ori_sample_list, len(dataset_i_ori_sample_list))
+                    sample_list_i = dataset_i_ori_sample_list
+                else:
+                    # no shuffle in val or test
+                    sample_list_i = dataset_i_ori_sample_list
+                #samples_group.append(sample_list_i)
+                          
+                # expand the sample list for each dataset
+                expand_size_i = expand_indices_sizes[di]
+                indices_expand_list = copy.deepcopy(sample_list_i)
+                
+                for i in range(int(cp_times)-1):
+                    #indices_expand_list += random.sample(sample_list_i, len(dataset_i))
+                    indices_expand_list += sample_list_i
+                random.seed(self.random_seed_cp)
+                indices_expand_list += random.sample(sample_list_i, len(dataset_i))[:expand_size_i % len(dataset_i)]
+                # adjust indices value
+                indices_expand_list = np.array(indices_expand_list) + dataset_cumulative_sizes[gi] + group_cumulative_sizes[di]
+                indices_list = np.array(sample_list_i) + dataset_cumulative_sizes[gi] + group_cumulative_sizes[di]
+
+                # the expanded sample list for dataset_i
+                indices_expand_group.append(indices_expand_list)
+                # the original sample list for the dataset_i
+                indices_group.append(indices_list)
+                
+                if main_process():
+                    self.logger.info(f'"{dataset_i.data_name}", {self.phase} set in group {gi}: ' + 
+                                     f'expand size {len(sample_list_i)} --->>>---, {expand_size_i}')
+
+            concat_group = np.concatenate(indices_expand_group)
+            # shuffle the grouped datasets samples, e.g. each group data is [a1, a2, a3, b1, b2, b3, b4, c1, c2], the shuffled one, maybe, is [a3, b1, b2, b3, b4, c1,...]
+            np.random.seed(self.random_seed)
+            if self.phase == 'train':
+                np.random.shuffle(concat_group)
+            self.indices_expand_mat.append(concat_group)
+            self.indices_mat.append(np.concatenate(indices_group))
+        
+        # create sample list
+        if "train" in self.phase:
+            # data groups are cross sorted, i.e. [A, B, C, A, B, C....]
+            self.sample_indices_array = np.array(self.indices_expand_mat).transpose(1, 0).reshape(-1)
+            self.total_indices_size = max_group_size * len(self.dataset_merge.datasets)
+        else:
+            self.sample_indices_array = np.concatenate(self.indices_mat[:])
+            self.total_indices_size = self.sample_indices_array.size
+        
+        self.total_sample_size = len(self.dataset_merge)
+        self.each_gpu_size = int(np.ceil(self.total_indices_size * 1.0 / self.world_size)) # ignore some residual samples
+        self.total_dist_size = self.each_gpu_size * self.world_size
+        # add extra samples to make it evenly divisible
+        diff_size = int(self.total_dist_size - self.total_indices_size)  # int(self.total_dist_size - self.total_sample_size)
+        if diff_size > 0:
+            self.sample_indices_array = np.append(self.sample_indices_array, self.sample_indices_array[:diff_size])
+        #if main_process():
+        self.logger.info(f'Expanded data size in merged dataset: {self.total_sample_size}, adjusted data size for distributed running: {self.total_dist_size}')
+        self.random_seed += 413
+        self.random_seed_cp += 377
+
+
+def build_data_array(cfg, phase):
+    """
+    Construct data repo with cfg. In cfg, there is a data name array, which encloses the name of each data. 
+    Each data name links to a data config file. With this config file, dataset can be constructed.
+    e.g. [['A', 'B', 'C'], ['E', 'F'], 'M']. Each letter indicates a dataset. 
+    """
+  
+    datasets_array = []
+    data_array_names_for_log = []
+    
+    dataname_array = cfg.data_array
+    for group_i in dataname_array:
+        dataset_group_i = []
+        data_group_i_names_for_log = []
+        if not isinstance(group_i, list):
+            group_i = [group_i, ]
+        for data_i in group_i:
+            if not isinstance(data_i, dict):
+                raise TypeError(f'data name must be a dict, but got {type(data_i)}')
+            # each data only can employ a single dataset config
+            assert len(data_i.values()) == 1
+            if list(data_i.values())[0] not in cfg:
+                raise RuntimeError(f'cannot find the data config for {data_i}')
+            
+            # dataset configure for data i
+            #data_i_cfg = cfg[data_i]
+            args = copy.deepcopy(cfg) #data_i_cfg.copy()
+            data_i_cfg_name = list(data_i.values())[0]
+            data_i_db_info_name = list(data_i.keys())[0]
+            data_i_db_info = cfg.db_info[data_i_db_info_name]
+
+            # Online evaluation using only metric datasets
+            # if phase == 'val' and 'exclude' in cfg.evaluation \
+            #     and data_i_db_info_name in cfg.evaluation.exclude:
+            #     continue
+
+            # dataset lib name
+            obj_name = cfg[data_i_cfg_name]['lib']
+            obj_path = os.path.dirname(__file__).split(os.getcwd() + '/')[-1].replace('/', '.') + '.' + obj_name 
+            obj_cls = get_func(obj_path)
+            if obj_cls is None:
+                raise KeyError(f'{obj_name} is not in .data')
+                             
+            dataset_i = obj_cls(
+                args[data_i_cfg_name], 
+                phase, 
+                db_info=data_i_db_info, 
+                **cfg.data_basic)
+            # if 'Taskonomy' not in data_i:
+            #     print('>>>>>>>>>>ditributed_sampler LN189', dataset_i.data_name, dataset_i.annotations['files'][0]['rgb'].split('/')[-1],
+            #       dataset_i.annotations['files'][1000]['rgb'].split('/')[-1], dataset_i.annotations['files'][3000]['rgb'].split('/')[-1])
+            # else:
+            #     print('>>>>>>>>>>ditributed_sampler LN189', dataset_i.data_name, dataset_i.annotations['files'][0]['meta_data'].split('/')[-1],
+            #       dataset_i.annotations['files'][1000]['meta_data'].split('/')[-1], dataset_i.annotations['files'][3000]['meta_data'].split('/')[-1])
+            dataset_group_i.append(dataset_i)
+            # get data name for log
+            data_group_i_names_for_log.append(data_i_db_info_name)
+
+        datasets_array.append(dataset_group_i)
+        data_array_names_for_log.append(data_group_i_names_for_log)
+
+    if main_process():
+        logger = logging.getLogger()
+        logger.info(f'{phase}: data array ({data_array_names_for_log}) has been constructed.')
+    return datasets_array
+            
+def concatenate_datasets(datasets_array):
+    """
+    Merge grouped datasets to a single one.
+    args:
+        @ dataset_list: the list of constructed dataset. 
+    """
+    #max_size = 0
+    dataset_merge = []                         
+    for group in datasets_array:
+        group_dataset = ConcatDataset(group)
+        group_size = len(group_dataset)
+        #max_size = max_size if group_size < max_size else group_size
+        dataset_merge.append(group_dataset)
+    return ConcatDataset(dataset_merge)
+
+
+def log_canonical_transfer_info(cfg):
+    logger = logging.getLogger()
+    data = []
+    canonical_focal_length = cfg.data_basic.canonical_space.focal_length
+    canonical_size = cfg.data_basic.canonical_space.img_size
+    for group_i in cfg.data_array:
+        if not isinstance(group_i, list):
+            group_i = [group_i, ]
+        for data_i in group_i:
+            if not isinstance(data_i, dict):
+                raise TypeError(f'data name must be a dict, but got {type(data_i)}')
+            assert len(data_i.values()) == 1
+            if list(data_i.values())[0] not in cfg:
+                raise RuntimeError(f'cannot find the data config for {data_i.values()}')
+            if list(data_i.values())[0] not in data:
+                data.append(list(data_i.values())[0])
+
+    logger.info('>>>>>>>>>>>>>>Some data transfer details during augmentation.>>>>>>>>>>>>>>')
+    for data_i in data:
+        data_i_cfg = cfg[data_i]
+        if type(data_i_cfg.original_focal_length) != tuple:
+            ori_focal = (data_i_cfg.original_focal_length, )
+        else:
+            ori_focal = data_i_cfg.original_focal_length
+        
+        log_str = '%s transfer details: \n' % data_i
+        for ori_f  in ori_focal:
+            # to canonical space
+            scalor = canonical_focal_length / ori_f
+            img_size = (data_i_cfg.original_size[0]*scalor,  data_i_cfg.original_size[1]*scalor)
+            log_str += 'To canonical space: focal length, %f -> %f; size, %s -> %s\n' %(ori_f, canonical_focal_length, data_i_cfg.original_size, img_size)
+            
+            # random resize in augmentaiton
+            resize_range = data_i_cfg.data.train.pipeline[1].ratio_range
+            resize_low = (img_size[0]*resize_range[0],  img_size[1]*resize_range[0])
+            resize_up = (img_size[0]*resize_range[1],  img_size[1]*resize_range[1])
+            log_str += 'Random resize bound: %s ~ %s; \n' %(resize_low, resize_up)
+        
+        logger.info(log_str)

external/Metric3D/training/mono/datasets/eth3d_dataset.py

@@ -0,0 +1,94 @@
+import os
+import json
+import torch
+import torchvision.transforms as transforms
+import os.path
+import numpy as np
+import cv2
+from torch.utils.data import Dataset
+import random
+from .__base_dataset__ import BaseDataset
+
+
+class ETH3DDataset(BaseDataset):
+    def __init__(self, cfg, phase, **kwargs):
+        super(ETH3DDataset, self).__init__(
+            cfg=cfg,
+            phase=phase,
+            **kwargs)
+        self.metric_scale = cfg.metric_scale
+    
+    def __getitem__(self, idx):
+        anno = self.annotations['files'][idx]
+        curr_rgb_path = os.path.join(self.data_root, anno['rgb_path'])
+        curr_depth_path = os.path.join(self.depth_root, anno['depth_path'])
+        meta_data = self.load_meta_data(anno)
+        ori_curr_intrinsic = [2000, 2000, 3024, 2016] #meta_data['cam_in']
+        
+        curr_rgb = cv2.imread(curr_rgb_path) # [r, g, b]
+        with open(curr_depth_path, 'r') as f:
+            imgfile = np.fromfile(f, np.float32)
+            curr_depth = imgfile.reshape((4032, 6048))
+            curr_depth[curr_depth>100] = 0
+        
+        #curr_rgb, curr_depth = self.load_rgb_depth(curr_rgb_path, curr_depth_path)
+        # curr_rgb = cv2.resize(curr_rgb, dsize=(3024, 2016), interpolation=cv2.INTER_LINEAR)
+        # curr_depth = cv2.resize(curr_depth, dsize=(3024, 2016), interpolation=cv2.INTER_LINEAR)
+        # ori_curr_intrinsic = [i//2 for i in ori_curr_intrinsic]
+        
+        ori_h, ori_w, _ = curr_rgb.shape
+        # create camera model
+        curr_cam_model = self.create_cam_model(curr_rgb.shape[0], curr_rgb.shape[1], ori_curr_intrinsic)
+        # load tmpl rgb info
+        # tmpl_annos = self.load_tmpl_annos(anno, curr_rgb, meta_data)
+        # tmpl_rgb = tmpl_annos['tmpl_rgb_list'] # list of reference rgbs
+
+        transform_paras = dict()
+        rgbs, depths, intrinsics, cam_models, _, other_labels, transform_paras = self.img_transforms(
+                                                                   images=[curr_rgb, ], 
+                                                                   labels=[curr_depth, ], 
+                                                                   intrinsics=[ori_curr_intrinsic,], 
+                                                                   cam_models=[curr_cam_model, ],
+                                                                   transform_paras=transform_paras)
+        # depth in original size
+        depth_out = self.clip_depth(curr_depth) * self.depth_range[1]
+
+        filename = os.path.basename(anno['rgb_path'])
+        curr_intrinsic_mat = self.intrinsics_list2mat(intrinsics[0])
+
+        pad = transform_paras['pad'] if 'pad' in transform_paras else [0,0,0,0]
+        scale_ratio = transform_paras['label_scale_factor'] if 'label_scale_factor' in transform_paras else 1.0
+        cam_models_stacks = [
+            torch.nn.functional.interpolate(cam_models[0][None, :, :, :], size=(cam_models[0].shape[1]//i, cam_models[0].shape[2]//i), mode='bilinear', align_corners=False).squeeze()
+            for i in [2, 4, 8, 16, 32] 
+            ]    
+        raw_rgb = torch.from_numpy(curr_rgb)
+        data = dict(input=rgbs[0],
+                    target=depth_out,
+                    intrinsic=curr_intrinsic_mat,
+                    filename=filename,
+                    dataset=self.data_name,
+                    cam_model=cam_models_stacks,
+                    ref_input=rgbs[1:],
+                    tmpl_flg=False,
+                    pad=pad,
+                    scale=scale_ratio,
+                    raw_rgb=raw_rgb,
+                    normal = np.zeros_like(curr_rgb.transpose((2,0,1))),
+                    #stereo_depth=torch.zeros_like(depth_out)
+                    ) 
+        return data
+    
+    def process_depth(self, depth):
+        depth[depth>65500] = 0
+        depth /= self.metric_scale
+        return depth
+
+
+
+if __name__ == '__main__':
+    from mmcv.utils import Config 
+    cfg = Config.fromfile('mono/configs/Apolloscape_DDAD/convnext_base.cascade.1m.sgd.mae.py')
+    dataset_i = NYUDataset(cfg['Apolloscape'], 'train', **cfg.data_basic)
+    print(dataset_i)
+    

external/Metric3D/training/mono/datasets/mapillary_psd_dataset.py

@@ -0,0 +1,35 @@
+import os
+import json
+import torch
+import torchvision.transforms as transforms
+import os.path
+import numpy as np
+import cv2
+from torch.utils.data import Dataset
+import random
+from .__base_dataset__ import BaseDataset
+import matplotlib.pyplot as plt
+
+class MapillaryPSDDataset(BaseDataset):
+    def __init__(self, cfg, phase, **kwargs):
+        super(MapillaryPSDDataset, self).__init__(
+            cfg=cfg,
+            phase=phase,
+            **kwargs)
+        self.metric_scale = cfg.metric_scale
+    
+    def process_depth(self, depth, rgb):
+        depth[depth>65500] = 0
+        depth /= self.metric_scale
+        h, w, _ = rgb.shape # to rgb size
+        depth_resize = cv2.resize(depth, (w, h), interpolation=cv2.INTER_NEAREST)
+        return depth_resize
+
+
+
+if __name__ == '__main__':
+    from mmcv.utils import Config 
+    cfg = Config.fromfile('mono/configs/Apolloscape_DDAD/convnext_base.cascade.1m.sgd.mae.py')
+    dataset_i = MapillaryDataset(cfg['Apolloscape'], 'train', **cfg.data_basic)
+    print(dataset_i)
+    

external/Metric3D/training/mono/utils/__init__.py

@@ -0,0 +1 @@
+

external/Metric3D/training/mono/utils/avg_meter.py

@@ -0,0 +1,561 @@
+import numpy as np
+import torch
+import torch.distributed as dist
+from .inverse_warp import pixel2cam, cam2pixel2
+import torch.nn.functional as F
+import matplotlib.pyplot as plt
+
+class AverageMeter(object):
+    """Computes and stores the average and current value"""
+    def __init__(self) -> None:
+        self.reset()
+
+    def reset(self) -> None:
+        self.val = np.longdouble(0.0)
+        self.avg = np.longdouble(0.0)
+        self.sum = np.longdouble(0.0)
+        self.count = np.longdouble(0.0)
+
+    def update(self, val, n: float = 1) -> None:
+        self.val = val
+        self.sum += val
+        self.count += n
+        self.avg = self.sum / (self.count + 1e-6)
+
+class MetricAverageMeter(AverageMeter):
+    """ 
+    An AverageMeter designed specifically for evaluating segmentation results.
+    """
+    def __init__(self, metrics: list) -> None:
+        """ Initialize object. """
+        # average meters for metrics
+        self.abs_rel = AverageMeter()
+        self.rmse = AverageMeter()
+        self.silog = AverageMeter()
+        self.delta1 = AverageMeter()
+        self.delta2 = AverageMeter()
+        self.delta3 = AverageMeter()
+
+        self.metrics = metrics
+
+        self.consistency = AverageMeter()
+        self.log10 = AverageMeter()
+        self.rmse_log = AverageMeter()
+        self.sq_rel = AverageMeter()
+
+        # normal
+        self.normal_mean = AverageMeter()
+        self.normal_rmse = AverageMeter()
+        self.normal_a1 = AverageMeter()
+        self.normal_a2 = AverageMeter()
+        
+        self.normal_median = AverageMeter()
+        self.normal_a3 = AverageMeter()
+        self.normal_a4 = AverageMeter()
+        self.normal_a5 = AverageMeter()
+
+
+    def update_metrics_cpu(self,
+        pred: torch.Tensor,
+        target: torch.Tensor,
+        mask: torch.Tensor,):
+        """
+        Update metrics on cpu
+        """
+
+        assert pred.shape == target.shape
+
+        if len(pred.shape) == 3:
+            pred = pred[:, None, :, :]
+            target = target[:, None, :, :]
+            mask = mask[:, None, :, :]
+        elif len(pred.shape) == 2:
+            pred = pred[None, None, :, :]
+            target = target[None, None, :, :]
+            mask = mask[None, None, :, :]
+
+
+        # Absolute relative error
+        abs_rel_sum, valid_pics = get_absrel_err(pred, target, mask)
+        abs_rel_sum = abs_rel_sum.numpy()
+        valid_pics = valid_pics.numpy()
+        self.abs_rel.update(abs_rel_sum, valid_pics)
+        
+        # squared relative error
+        sqrel_sum, _ = get_sqrel_err(pred, target, mask)
+        sqrel_sum = sqrel_sum.numpy()
+        self.sq_rel.update(sqrel_sum, valid_pics)
+
+        # root mean squared error
+        rmse_sum, _ = get_rmse_err(pred, target, mask)
+        rmse_sum = rmse_sum.numpy()
+        self.rmse.update(rmse_sum, valid_pics)
+        
+        # log root mean squared error
+        log_rmse_sum, _ = get_rmse_log_err(pred, target, mask)
+        log_rmse_sum = log_rmse_sum.numpy()
+        self.rmse.update(log_rmse_sum, valid_pics)
+        
+        # log10 error
+        log10_sum, _ = get_log10_err(pred, target, mask)
+        log10_sum = log10_sum.numpy()
+        self.rmse.update(log10_sum, valid_pics)
+
+        # scale-invariant root mean squared error in log space
+        silog_sum, _ = get_silog_err(pred, target, mask)
+        silog_sum = silog_sum.numpy()
+        self.silog.update(silog_sum, valid_pics)
+
+        # ratio error, delta1, ....
+        delta1_sum, delta2_sum, delta3_sum, _ = get_ratio_error(pred, target, mask)
+        delta1_sum = delta1_sum.numpy()
+        delta2_sum = delta2_sum.numpy()
+        delta3_sum = delta3_sum.numpy()
+
+        self.delta1.update(delta1_sum, valid_pics)
+        self.delta2.update(delta1_sum, valid_pics)
+        self.delta3.update(delta1_sum, valid_pics)
+        
+
+    def update_metrics_gpu(
+        self,
+        pred: torch.Tensor,
+        target: torch.Tensor,
+        mask: torch.Tensor,
+        is_distributed: bool,
+        pred_next: torch.tensor = None,
+        pose_f1_to_f2: torch.tensor = None,
+        intrinsic: torch.tensor = None):
+        """ 
+        Update metric on GPU. It supports distributed processing. If multiple machines are employed, please
+        set 'is_distributed' as True.
+        """
+        assert pred.shape == target.shape
+
+        if len(pred.shape) == 3:
+            pred = pred[:, None, :, :]
+            target = target[:, None, :, :]
+            mask = mask[:, None, :, :]
+        elif len(pred.shape) == 2:
+            pred = pred[None, None, :, :]
+            target = target[None, None, :, :]
+            mask = mask[None, None, :, :]
+
+
+        # Absolute relative error
+        abs_rel_sum, valid_pics = get_absrel_err(pred, target, mask)
+        if is_distributed:
+            dist.all_reduce(abs_rel_sum), dist.all_reduce(valid_pics)
+        abs_rel_sum = abs_rel_sum.cpu().numpy()
+        valid_pics = int(valid_pics)
+        self.abs_rel.update(abs_rel_sum, valid_pics)
+
+        # root mean squared error
+        rmse_sum, _ = get_rmse_err(pred, target, mask)
+        if is_distributed:
+            dist.all_reduce(rmse_sum)
+        rmse_sum = rmse_sum.cpu().numpy()
+        self.rmse.update(rmse_sum, valid_pics)
+        
+        # log root mean squared error
+        log_rmse_sum, _ = get_rmse_log_err(pred, target, mask)
+        if is_distributed:
+            dist.all_reduce(log_rmse_sum)
+        log_rmse_sum = log_rmse_sum.cpu().numpy()
+        self.rmse_log.update(log_rmse_sum, valid_pics)
+    
+        # log10 error
+        log10_sum, _ = get_log10_err(pred, target, mask)
+        if is_distributed:
+            dist.all_reduce(log10_sum)
+        log10_sum = log10_sum.cpu().numpy()
+        self.log10.update(log10_sum, valid_pics)
+
+        # scale-invariant root mean squared error in log space
+        silog_sum, _ = get_silog_err(pred, target, mask)
+        if is_distributed:
+            dist.all_reduce(silog_sum)
+        silog_sum = silog_sum.cpu().numpy()
+        self.silog.update(silog_sum, valid_pics)
+
+        # ratio error, delta1, ....
+        delta1_sum, delta2_sum, delta3_sum, _ = get_ratio_error(pred, target, mask)
+        if is_distributed:
+            dist.all_reduce(delta1_sum), dist.all_reduce(delta2_sum), dist.all_reduce(delta3_sum)
+        delta1_sum = delta1_sum.cpu().numpy()
+        delta2_sum = delta2_sum.cpu().numpy()
+        delta3_sum = delta3_sum.cpu().numpy()
+
+        self.delta1.update(delta1_sum, valid_pics)
+        self.delta2.update(delta2_sum, valid_pics)
+        self.delta3.update(delta3_sum, valid_pics)
+
+        # video consistency error
+        consistency_rel_sum, valid_warps = get_video_consistency_err(pred, pred_next, pose_f1_to_f2, intrinsic)
+        if is_distributed:
+            dist.all_reduce(consistency_rel_sum), dist.all_reduce(valid_warps)
+        consistency_rel_sum = consistency_rel_sum.cpu().numpy()
+        valid_warps = int(valid_warps)
+        self.consistency.update(consistency_rel_sum, valid_warps)
+
+    ## for surface normal
+    def update_normal_metrics_gpu(
+        self,
+        pred: torch.Tensor, # (B, 3, H, W)
+        target: torch.Tensor, # (B, 3, H, W)
+        mask: torch.Tensor, # (B, 1, H, W)
+        is_distributed: bool,
+        ):
+        """ 
+        Update metric on GPU. It supports distributed processing. If multiple machines are employed, please
+        set 'is_distributed' as True.
+        """
+        assert pred.shape == target.shape
+
+        valid_pics = torch.sum(mask, dtype=torch.float32) + 1e-6
+
+        if valid_pics < 10:
+            return
+
+        mean_error = rmse_error = a1_error = a2_error = dist_node_cnt = valid_pics
+        normal_error = torch.cosine_similarity(pred, target, dim=1)
+        normal_error = torch.clamp(normal_error, min=-1.0, max=1.0)
+        angle_error = torch.acos(normal_error) * 180.0 / torch.pi
+        angle_error = angle_error[:, None, :, :]
+        angle_error = angle_error[mask]
+        # Calculation error
+        mean_error = angle_error.sum() / valid_pics
+        rmse_error = torch.sqrt( torch.sum(torch.square(angle_error)) / valid_pics )
+        median_error = angle_error.median()
+        a1_error = 100.0 * (torch.sum(angle_error < 5) / valid_pics)
+        a2_error = 100.0 * (torch.sum(angle_error < 7.5) / valid_pics)
+        
+        a3_error = 100.0 * (torch.sum(angle_error < 11.25) / valid_pics)
+        a4_error = 100.0 * (torch.sum(angle_error < 22.5) / valid_pics)
+        a5_error = 100.0 * (torch.sum(angle_error < 30) / valid_pics)
+
+        # if valid_pics > 1e-5:
+        # If the current node gets data with valid normal
+        dist_node_cnt = (valid_pics - 1e-6) / valid_pics
+
+        if is_distributed:
+            dist.all_reduce(dist_node_cnt)
+            dist.all_reduce(mean_error)
+            dist.all_reduce(rmse_error)
+            dist.all_reduce(a1_error)
+            dist.all_reduce(a2_error)
+            
+            dist.all_reduce(a3_error)
+            dist.all_reduce(a4_error)
+            dist.all_reduce(a5_error)
+
+        dist_node_cnt = dist_node_cnt.cpu().numpy()
+        self.normal_mean.update(mean_error.cpu().numpy(), dist_node_cnt)
+        self.normal_rmse.update(rmse_error.cpu().numpy(), dist_node_cnt)
+        self.normal_a1.update(a1_error.cpu().numpy(), dist_node_cnt)
+        self.normal_a2.update(a2_error.cpu().numpy(), dist_node_cnt)
+
+        self.normal_median.update(median_error.cpu().numpy(), dist_node_cnt)
+        self.normal_a3.update(a3_error.cpu().numpy(), dist_node_cnt)
+        self.normal_a4.update(a4_error.cpu().numpy(), dist_node_cnt)
+        self.normal_a5.update(a5_error.cpu().numpy(), dist_node_cnt)
+
+
+    def get_metrics(self,):
+        """
+        """
+        metrics_dict = {}
+        for metric in self.metrics:
+            metrics_dict[metric] = self.__getattribute__(metric).avg
+        return metrics_dict
+
+
+    def get_metrics(self,):
+        """
+        """
+        metrics_dict = {}
+        for metric in self.metrics:
+            metrics_dict[metric] = self.__getattribute__(metric).avg
+        return metrics_dict
+
+
+def get_absrel_err(pred: torch.tensor, 
+                   target: torch.tensor, 
+                   mask: torch.tensor):
+    """
+    Computes absolute relative error.
+    Takes preprocessed depths (no nans, infs and non-positive values).
+    pred, target, and mask should be in the shape of [b, c, h, w]
+    """
+
+    assert len(pred.shape) == 4, len(target.shape) == 4
+    b, c, h, w = pred.shape
+    mask = mask.to(torch.float)
+    t_m = target * mask
+    p_m = pred * mask
+
+    #Mean Absolute Relative Error
+    rel = torch.abs(t_m - p_m) / (t_m + 1e-10) # compute errors
+    abs_rel_sum = torch.sum(rel.reshape((b, c, -1)), dim=2) # [b, c]
+    num = torch.sum(mask.reshape((b, c, -1)), dim=2) # [b, c]
+    abs_err = abs_rel_sum / (num + 1e-10) 
+    valid_pics = torch.sum(num > 0)
+    return torch.sum(abs_err), valid_pics
+
+def get_sqrel_err(pred: torch.tensor, 
+                   target: torch.tensor, 
+                   mask: torch.tensor):
+    """
+    Computes squared relative error.
+    Takes preprocessed depths (no nans, infs and non-positive values).
+    pred, target, and mask should be in the shape of [b, c, h, w]
+    """
+
+    assert len(pred.shape) == 4, len(target.shape) == 4
+    b, c, h, w = pred.shape
+    mask = mask.to(torch.float)
+    t_m = target * mask
+    p_m = pred * mask
+
+    #Mean Absolute Relative Error
+    sq_rel = torch.abs(t_m - p_m)**2 / (t_m + 1e-10) # compute errors
+    sq_rel_sum = torch.sum(sq_rel.reshape((b, c, -1)), dim=2) # [b, c]
+    num = torch.sum(mask.reshape((b, c, -1)), dim=2) # [b, c]
+    sqrel_err = sq_rel_sum / (num + 1e-10) 
+    valid_pics = torch.sum(num > 0)
+    return torch.sum(sqrel_err), valid_pics
+
+def get_log10_err(pred: torch.tensor, 
+                   target: torch.tensor, 
+                   mask: torch.tensor):
+    """
+    Computes log10 error.
+    Takes preprocessed depths (no nans, infs and non-positive values).
+    pred, target, and mask should be in the shape of [b, c, h, w]
+    """
+
+    assert len(pred.shape) == 4, len(target.shape) == 4
+    b, c, h, w = pred.shape
+    mask = mask.to(torch.float)
+    t_m = target * mask
+    p_m = pred * mask
+
+    diff_log = (torch.log10(p_m+1e-10) - torch.log10(t_m+1e-10)) * mask
+    log10_diff = torch.abs(diff_log) # compute errors
+    log10_sum = torch.sum(log10_diff.reshape((b, c, -1)), dim=2) # [b, c]
+    num = torch.sum(mask.reshape((b, c, -1)), dim=2) # [b, c]
+    abs_err = log10_sum / (num + 1e-10) 
+    valid_pics = torch.sum(num > 0)
+    return torch.sum(abs_err), valid_pics
+
+def get_rmse_err(pred: torch.tensor, 
+                 target: torch.tensor, 
+                 mask: torch.tensor):
+    """
+    Computes log root mean squared error.
+    Takes preprocessed depths (no nans, infs and non-positive values).
+    pred, target, and mask should be in the shape of [b, c, h, w]
+    """
+    assert len(pred.shape) == 4, len(target.shape) == 4
+    b, c, h, w = pred.shape
+    mask = mask.to(torch.float)
+    t_m = target * mask
+    p_m = pred * mask
+     
+    square = (t_m - p_m) ** 2
+    rmse_sum = torch.sum(square.reshape((b, c, -1)), dim=2) # [b, c]
+    num = torch.sum(mask.reshape((b, c, -1)), dim=2) # [b, c]
+    rmse = torch.sqrt(rmse_sum / (num + 1e-10))
+    valid_pics = torch.sum(num > 0)
+    return torch.sum(rmse), valid_pics 
+
+def get_rmse_log_err(pred: torch.tensor, 
+                 target: torch.tensor, 
+                 mask: torch.tensor):
+    """
+    Computes root mean squared error.
+    Takes preprocessed depths (no nans, infs and non-positive values).
+    pred, target, and mask should be in the shape of [b, c, h, w]
+    """
+    assert len(pred.shape) == 4, len(target.shape) == 4
+    b, c, h, w = pred.shape
+    mask = mask.to(torch.float)
+    t_m = target * mask
+    p_m = pred * mask
+     
+    diff_log = (torch.log(p_m+1e-10) - torch.log(t_m+1e-10)) * mask
+    square = diff_log ** 2
+    rmse_sum = torch.sum(square.reshape((b, c, -1)), dim=2) # [b, c]
+    num = torch.sum(mask.reshape((b, c, -1)), dim=2) # [b, c]
+    rmse = torch.sqrt(rmse_sum / (num + 1e-10))
+    valid_pics = torch.sum(num > 0)
+    return torch.sum(rmse), valid_pics 
+
+
+def get_silog_err(pred: torch.tensor, 
+                  target: torch.tensor, 
+                  mask: torch.tensor):
+    """
+    Computes scale invariant loss based on differences of logs of depth maps.
+    Takes preprocessed depths (no nans, infs and non-positive values).
+    pred, target, and mask should be in the shape of [b, c, h, w]
+    """
+    assert len(pred.shape) == 4, len(target.shape) == 4
+    b, c, h, w = pred.shape
+    mask = mask.to(torch.float)
+    t_m = target * mask
+    p_m = pred * mask
+    
+    diff_log = (torch.log(p_m+1e-10) - torch.log(t_m+1e-10)) * mask
+    diff_log_sum = torch.sum(diff_log.reshape((b, c, -1)), dim=2) # [b, c]
+    diff_log_square = diff_log ** 2
+    diff_log_square_sum = torch.sum(diff_log_square.reshape((b, c, -1)), dim=2) # [b, c]
+    num = torch.sum(mask.reshape((b, c, -1)), dim=2) # [b, c]
+    silog = torch.sqrt(diff_log_square_sum / (num + 1e-10) - (diff_log_sum / (num + 1e-10)) **2 )
+    valid_pics = torch.sum(num > 0)
+    if torch.isnan(torch.sum(silog)):
+        print('None in silog')
+    return torch.sum(silog), valid_pics
+    
+
+def get_ratio_error(pred: torch.tensor, 
+                    target: torch.tensor, 
+                    mask: torch.tensor):
+    """
+    Computes  the percentage of pixels for which the ratio of the two depth maps is less than a given threshold.
+    Takes preprocessed depths (no nans, infs and non-positive values).
+    pred, target, and mask should be in the shape of [b, c, h, w]
+    """    
+    assert len(pred.shape) == 4, len(target.shape) == 4
+    b, c, h, w = pred.shape
+    mask = mask.to(torch.float)
+    t_m = target * mask
+    p_m = pred
+
+    gt_pred = t_m / (p_m + 1e-10)
+    pred_gt = p_m / (t_m + 1e-10)
+    gt_pred = gt_pred.reshape((b, c, -1))
+    pred_gt = pred_gt.reshape((b, c, -1))
+    gt_pred_gt = torch.cat((gt_pred, pred_gt), axis=1)
+    ratio_max = torch.amax(gt_pred_gt, axis=1)
+
+    mask = mask.reshape((b, -1))
+    delta_1_sum = torch.sum((ratio_max < 1.25) * mask, dim=1) # [b, ]
+    delta_2_sum = torch.sum((ratio_max < 1.25**2) * mask, dim=1) # [b,]
+    delta_3_sum = torch.sum((ratio_max < 1.25**3) * mask, dim=1) # [b, ]
+    num = torch.sum(mask, dim=1) # [b, ]
+
+    delta_1 = delta_1_sum / (num + 1e-10)
+    delta_2 = delta_2_sum / (num + 1e-10)
+    delta_3 = delta_3_sum / (num + 1e-10)
+    valid_pics = torch.sum(num > 0)
+
+    return torch.sum(delta_1), torch.sum(delta_2), torch.sum(delta_3), valid_pics
+
+def unproj_pcd(
+    depth: torch.tensor,
+    intrinsic: torch.tensor
+    ):
+    depth = depth.squeeze(1)  # [B, H, W]
+    b, h, w = depth.size()
+    v = torch.arange(0, h).view(1, h, 1).expand(b, h, w).type_as(depth)  # [B, H, W]
+    u = torch.arange(0, w).view(1, 1, w).expand(b, h, w).type_as(depth)  # [B, H, W]
+    x = (u - intrinsic[:, 0, 2]) / intrinsic[:, 0, 0] * depth # [B, H, W]
+    y = (v - intrinsic[:, 1, 2]) / intrinsic[:, 0, 0] * depth # [B, H, W]
+    pcd = torch.stack([x, y, depth], dim=1)
+    return pcd
+
+def forward_warp(
+    depth: torch.tensor,
+    intrinsic: torch.tensor,
+    pose: torch.tensor,
+    ):
+    """
+    Warp the depth with the provided pose.
+    Args:
+        depth: depth map of the target image -- [B, 1, H, W]
+        intrinsic: camera intrinsic parameters -- [B, 3, 3]
+        pose: the camera pose -- [B, 4, 4]
+    """
+    B, _, H, W = depth.shape
+    pcd = unproj_pcd(depth.float(), intrinsic.float())
+    pcd = pcd.reshape(B, 3, -1)  # [B, 3, H*W]
+    rot, tr = pose[:, :3, :3], pose[:, :3, -1:]
+    proj_pcd = rot @ pcd + tr
+
+    img_coors = intrinsic @ proj_pcd
+
+    X = img_coors[:, 0, :]
+    Y = img_coors[:, 1, :]
+    Z = img_coors[:, 2, :].clamp(min=1e-3)
+
+    x_img_coor = (X/Z + 0.5).long()
+    y_img_coor = (Y/Z + 0.5).long()
+
+    X_mask = ((x_img_coor >=0) & (x_img_coor < W))
+    Y_mask = ((y_img_coor >=0) & (y_img_coor < H))
+    mask = X_mask & Y_mask
+
+    proj_depth = torch.zeros_like(Z).reshape(B, 1, H, W)
+    for i in range(B):
+        proj_depth[i, :, y_img_coor[i,...][mask[i,...]], x_img_coor[i,...][mask[i,...]]] = Z[i,...][mask[i,...]]
+    plt.imsave('warp2.png', proj_depth.squeeze().cpu().numpy(), cmap='rainbow')
+    return proj_depth
+
+
+def get_video_consistency_err(
+    pred_f1: torch.tensor, 
+    pred_f2: torch.tensor,
+    ego_pose_f1_to_f2: torch.tensor,
+    intrinsic: torch.tensor,
+    ):
+    """
+    Compute consistency error between consecutive frames.
+    """   
+    if pred_f2 is None or ego_pose_f1_to_f2 is None or intrinsic is None:
+        return torch.zeros_like(pred_f1).sum(), torch.zeros_like(pred_f1).sum()
+    ego_pose_f1_to_f2 = ego_pose_f1_to_f2.float()
+    pred_f2 = pred_f2.float()
+
+    pred_f1 = pred_f1[:, None, :, :] if pred_f1.ndim == 3 else pred_f1
+    pred_f2 = pred_f2[:, None, :, :] if pred_f2.ndim == 3 else pred_f2
+    pred_f1 = pred_f1[None, None, :, :] if pred_f1.ndim == 2 else pred_f1
+    pred_f2 = pred_f2[None, None, :, :] if pred_f2.ndim == 2 else pred_f2
+
+    B, _, H, W = pred_f1.shape
+    # Get projection matrix for tgt camera frame to source pixel frame
+    cam_coords = pixel2cam(pred_f1.squeeze(1).float(), intrinsic.inverse().float())  # [B,3,H,W]
+    #proj_depth_my = forward_warp(pred_f1, intrinsic,  ego_pose_f1_to_f2)
+    
+    proj_f1_to_f2 = intrinsic @ ego_pose_f1_to_f2[:, :3, :]  # [B, 3, 4]
+    rot, tr = proj_f1_to_f2[:, :, :3], proj_f1_to_f2[:, :, -1:]
+    f2_pixel_coords, warped_depth_f1_to_f2 = cam2pixel2(cam_coords, rot, tr, padding_mode="zeros")  # [B,H,W,2]
+
+    projected_depth = F.grid_sample(pred_f2, f2_pixel_coords, padding_mode="zeros", align_corners=False)
+    
+    mask_valid = (projected_depth > 1e-6) & (warped_depth_f1_to_f2 > 1e-6)
+   
+    # plt.imsave('f1.png', pred_f1.squeeze().cpu().numpy(), cmap='rainbow')
+    # plt.imsave('f2.png', pred_f2.squeeze().cpu().numpy(), cmap='rainbow')
+    # plt.imsave('warp.png', warped_depth_f1_to_f2.squeeze().cpu().numpy(), cmap='rainbow')
+    # plt.imsave('proj.png', projected_depth.squeeze().cpu().numpy(), cmap='rainbow')
+
+    consistency_rel_err, valid_pix = get_absrel_err(warped_depth_f1_to_f2, projected_depth, mask_valid)
+    return consistency_rel_err, valid_pix
+
+
+if __name__ == '__main__':
+    cfg = ['abs_rel', 'delta1']
+    dam = MetricAverageMeter(cfg)
+
+    pred_depth = np.random.random([2, 480, 640])
+    gt_depth = np.random.random([2, 480, 640]) - 0.5 #np.ones_like(pred_depth) * (-1) #
+    intrinsic = [[100, 100, 200, 200], [200, 200, 300, 300]]
+
+    pred = torch.from_numpy(pred_depth).cuda()
+    gt = torch.from_numpy(gt_depth).cuda()
+
+    mask = gt > 0
+    dam.update_metrics_gpu(pred, pred, mask, False)
+    eval_error = dam.get_metrics()
+    print(eval_error)

external/Metric3D/training/mono/utils/comm.py

@@ -0,0 +1,343 @@
+import importlib 
+import torch
+import torch.distributed as dist
+from .avg_meter import AverageMeter
+from collections import defaultdict, OrderedDict
+import os
+import socket
+from mmcv.utils import collect_env as collect_base_env
+try:
+    from mmcv.utils import get_git_hash
+except:
+    from mmengine import get_git_hash
+#import mono.mmseg as mmseg
+import mmseg
+import time
+import datetime
+import logging
+
+
+def main_process() -> bool:
+    return get_rank() == 0
+    #return not cfg.distributed or \
+    #       (cfg.distributed and cfg.local_rank == 0)
+
+def get_world_size() -> int:
+    if not dist.is_available():
+        return 1
+    if not dist.is_initialized():
+        return 1
+    return dist.get_world_size()
+
+def get_rank() -> int:
+    if not dist.is_available():
+        return 0
+    if not dist.is_initialized():
+        return 0
+    return dist.get_rank()
+
+def _find_free_port():
+    # refer to https://github.com/facebookresearch/detectron2/blob/main/detectron2/engine/launch.py # noqa: E501
+    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    # Binding to port 0 will cause the OS to find an available port for us
+    sock.bind(('', 0))
+    port = sock.getsockname()[1]
+    sock.close()
+    # NOTE: there is still a chance the port could be taken by other processes.
+    return port 
+
+def _is_free_port(port):
+    ips = socket.gethostbyname_ex(socket.gethostname())[-1]
+    ips.append('localhost')
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        return all(s.connect_ex((ip, port)) != 0 for ip in ips)
+
+
+def collect_env():
+    """Collect the information of the running environments."""
+    env_info = collect_base_env()
+    env_info['MMSegmentation'] = f'{mmseg.__version__}+{get_git_hash()[:7]}'
+
+    return env_info
+
+def init_env(launcher, cfg):
+    """Initialize distributed training environment.
+    If argument ``cfg.dist_params.dist_url`` is specified as 'env://', then the master port will be system
+    environment variable ``MASTER_PORT``. If ``MASTER_PORT`` is not in system
+    environment variable, then a default port ``29500`` will be used.
+    """
+    if launcher == 'slurm':
+        _init_dist_slurm(cfg)
+    elif launcher == 'ror':
+        _init_dist_ror(cfg)
+    elif launcher == 'None':
+        _init_none_dist(cfg)
+    elif launcher == 'pytorch':
+        _init_dist_pytorch(cfg)
+    else:
+        raise RuntimeError(f'{cfg.launcher} has not been supported!')
+
+def _init_none_dist(cfg):
+    cfg.dist_params.num_gpus_per_node = 1
+    cfg.dist_params.world_size = 1
+    cfg.dist_params.nnodes = 1
+    cfg.dist_params.node_rank = 0
+    cfg.dist_params.global_rank = 0
+    cfg.dist_params.local_rank = 0
+    os.environ["WORLD_SIZE"] = str(1)
+
+def _init_dist_ror(cfg):
+    from ac2.ror.comm import get_local_rank, get_world_rank, get_local_size, get_node_rank, get_world_size
+    cfg.dist_params.num_gpus_per_node = get_local_size()
+    cfg.dist_params.world_size = get_world_size()
+    cfg.dist_params.nnodes = (get_world_size()) // (get_local_size())
+    cfg.dist_params.node_rank = get_node_rank()
+    cfg.dist_params.global_rank = get_world_rank()
+    cfg.dist_params.local_rank = get_local_rank()
+    os.environ["WORLD_SIZE"] = str(get_world_size())
+
+
+def _init_dist_pytorch(cfg):
+    # load env. paras.
+    local_rank = int(os.environ['LOCAL_RANK'])
+    world_size = int(os.environ['WORLD_SIZE'])
+    global_rank = int(os.environ['RANK'])
+    num_gpus = torch.cuda.device_count()
+    
+    cfg.dist_params.num_gpus_per_node = num_gpus
+    cfg.dist_params.world_size = world_size
+    cfg.dist_params.nnodes = int(world_size // num_gpus)
+    cfg.dist_params.node_rank = int(global_rank % num_gpus)
+    cfg.dist_params.global_rank = global_rank
+
+    os.environ['NODE_RANK'] = str(cfg.dist_params.node_rank)
+    # set dist_url to 'env://' 
+    cfg.dist_params.dist_url =  'env://' #f"{master_addr}:{master_port}"
+
+
+def _init_dist_slurm(cfg):
+    if 'NNODES' not in os.environ:
+        os.environ['NNODES'] = str(cfg.dist_params.nnodes)
+    if 'NODE_RANK' not in os.environ:
+        os.environ['NODE_RANK'] = str(cfg.dist_params.node_rank)
+
+    #cfg.dist_params.
+    num_gpus = torch.cuda.device_count()
+    world_size = int(os.environ['NNODES']) * num_gpus
+    os.environ['WORLD_SIZE'] = str(world_size)
+
+    # config port
+    if 'MASTER_PORT' in os.environ:
+        master_port = str(os.environ['MASTER_PORT'])  # use MASTER_PORT in the environment variable
+    else:
+        # if torch.distributed default port(29500) is available
+        # then use it, else find a free port
+        if _is_free_port(16500):
+            master_port = '16500'
+        else:
+            master_port = str(_find_free_port())
+        os.environ['MASTER_PORT'] = master_port
+
+    # config addr
+    if 'MASTER_ADDR' in os.environ:
+        master_addr = str(os.environ['MASTER_PORT'])  # use MASTER_PORT in the environment variable
+    # elif cfg.dist_params.dist_url is not None:
+    #     master_addr = ':'.join(str(cfg.dist_params.dist_url).split(':')[:2])
+    else:
+        master_addr = '127.0.0.1' #'tcp://127.0.0.1'
+        os.environ['MASTER_ADDR'] = master_addr
+
+    # set dist_url to 'env://' 
+    cfg.dist_params.dist_url =  'env://' #f"{master_addr}:{master_port}"
+    
+    cfg.dist_params.num_gpus_per_node = num_gpus
+    cfg.dist_params.world_size = world_size
+    cfg.dist_params.nnodes = int(os.environ['NNODES'])
+    cfg.dist_params.node_rank = int(os.environ['NODE_RANK'])
+        
+    # if int(os.environ['NNODES']) > 1 and cfg.dist_params.dist_url.startswith("file://"):
+    #     raise Warning("file:// is not a reliable init_method in multi-machine jobs. Prefer tcp://")
+        
+
+def get_func(func_name):
+    """
+        Helper to return a function object by name. func_name must identify 
+        a function in this module or the path to a function relative to the base
+        module.
+        @ func_name: function name.
+    """
+    if func_name == '':
+        return None
+    try:
+        parts = func_name.split('.')
+        # Refers to a function in this module
+        if len(parts) == 1:
+            return globals()[parts[0]]
+        # Otherwise, assume we're referencing a module under modeling
+        module_name = '.'.join(parts[:-1])
+        module = importlib.import_module(module_name)
+        return getattr(module, parts[-1])
+    except:
+        raise RuntimeError(f'Failed to find function: {func_name}')
+
+class Timer(object):
+    """A simple timer."""
+
+    def __init__(self):
+        self.reset()
+
+    def tic(self):
+        # using time.time instead of time.clock because time time.clock
+        # does not normalize for multithreading
+        self.start_time = time.time()
+
+    def toc(self, average=True):
+        self.diff = time.time() - self.start_time
+        self.total_time += self.diff
+        self.calls += 1
+        self.average_time = self.total_time / self.calls
+        if average:
+            return self.average_time
+        else:
+            return self.diff
+
+    def reset(self):
+        self.total_time = 0.
+        self.calls = 0
+        self.start_time = 0.
+        self.diff = 0.
+        self.average_time = 0.
+
+class TrainingStats(object):
+    """Track vital training statistics."""
+    def __init__(self, log_period, tensorboard_logger=None):
+        self.log_period = log_period
+        self.tblogger = tensorboard_logger
+        self.tb_ignored_keys = ['iter', 'eta', 'epoch', 'time', 'val_err']
+        self.iter_timer = Timer()
+        # Window size for smoothing tracked values (with median filtering)
+        self.filter_size = log_period
+        def create_smoothed_value():
+            return AverageMeter()
+        self.smoothed_losses = defaultdict(create_smoothed_value)
+        #self.smoothed_metrics = defaultdict(create_smoothed_value)
+        #self.smoothed_total_loss = AverageMeter()
+
+
+    def IterTic(self):
+        self.iter_timer.tic()
+
+    def IterToc(self):
+        return self.iter_timer.toc(average=False)
+
+    def reset_iter_time(self):
+        self.iter_timer.reset()
+
+    def update_iter_stats(self, losses_dict):
+        """Update tracked iteration statistics."""
+        for k, v in losses_dict.items():
+            self.smoothed_losses[k].update(float(v), 1)
+
+    def log_iter_stats(self, cur_iter, optimizer, max_iters, val_err={}):
+        """Log the tracked statistics."""
+        if (cur_iter % self.log_period == 0):
+            stats = self.get_stats(cur_iter, optimizer, max_iters, val_err)
+            log_stats(stats)
+            if self.tblogger:
+                self.tb_log_stats(stats, cur_iter)
+            for k, v in self.smoothed_losses.items():
+                v.reset()
+            self.iter_timer.reset() # reset time counting every log period
+
+    def tb_log_stats(self, stats, cur_iter):
+        """Log the tracked statistics to tensorboard"""
+        for k in stats:
+            # ignore some logs
+            if k not in self.tb_ignored_keys:
+                v = stats[k]
+                if isinstance(v, dict):
+                    self.tb_log_stats(v, cur_iter)
+                else:
+                    self.tblogger.add_scalar(k, v, cur_iter)
+
+
+    def get_stats(self, cur_iter, optimizer, max_iters, val_err = {}):
+        eta_seconds = self.iter_timer.average_time * (max_iters - cur_iter)
+
+        eta = str(datetime.timedelta(seconds=int(eta_seconds)))
+        stats = OrderedDict(
+            iter=cur_iter,  # 1-indexed
+            time=self.iter_timer.average_time,
+            eta=eta,
+        )
+        optimizer_state_dict = optimizer.state_dict()
+        lr = {}
+        for i in range(len(optimizer_state_dict['param_groups'])):
+            lr_name = 'group%d_lr' % i
+            lr[lr_name] = optimizer_state_dict['param_groups'][i]['lr']
+
+        stats['lr'] = OrderedDict(lr)
+        for k, v in self.smoothed_losses.items():
+            stats[k] = v.avg
+
+        stats['val_err'] = OrderedDict(val_err)
+        stats['max_iters'] = max_iters
+        return stats
+
+
+def reduce_dict(input_dict, average=True):
+    """
+    Reduce the values in the dictionary from all processes so that process with rank
+    0 has the reduced results.
+    Args:
+        @input_dict (dict): inputs to be reduced. All the values must be scalar CUDA Tensor.
+        @average (bool): whether to do average or sum
+    Returns:
+        a dict with the same keys as input_dict, after reduction.
+    """
+    world_size = get_world_size()
+    if world_size < 2:
+        return input_dict
+    with torch.no_grad():
+        names = []
+        values = []
+        # sort the keys so that they are consistent across processes
+        for k in sorted(input_dict.keys()):
+            names.append(k)
+            values.append(input_dict[k])
+        values = torch.stack(values, dim=0)
+        dist.reduce(values, dst=0)
+        if dist.get_rank() == 0 and average:
+            # only main process gets accumulated, so only divide by
+            # world_size in this case
+            values /= world_size
+        reduced_dict = {k: v for k, v in zip(names, values)}
+    return reduced_dict
+
+
+def log_stats(stats):
+    logger = logging.getLogger()
+    """Log training statistics to terminal"""
+    lines = "[Step %d/%d]\n" % (
+            stats['iter'], stats['max_iters'])
+
+    lines += "\t\tloss: %.3f,    time: %.6f,    eta: %s\n" % (
+        stats['total_loss'], stats['time'], stats['eta'])
+
+    # log loss
+    lines += "\t\t" 
+    for k, v in stats.items():
+        if 'loss' in k.lower() and 'total_loss' not in k.lower():
+            lines += "%s: %.3f" % (k, v)  + ",  "
+    lines = lines[:-3]
+    lines += '\n'
+
+    # validate criteria
+    lines += "\t\tlast val err:" + ",  ".join("%s: %.6f" % (k, v) for k, v in stats['val_err'].items()) + ", "
+    lines += '\n'
+
+    # lr in different groups
+    lines += "\t\t" +  ",  ".join("%s: %.8f" % (k, v) for k, v in stats['lr'].items())
+    lines += '\n'
+    logger.info(lines[:-1])  # remove last new linen_pxl
+

external/Metric3D/training/mono/utils/db.py

@@ -0,0 +1,36 @@
+from types import ModuleType
+import data_server_info # data infomation on some server
+
+def load_data_info(module_name, data_info={}, db_type='db_info', module=None):
+    if module is None:
+        module = globals().get(module_name, None)
+    if module:
+        for key, value in module.__dict__.items():
+
+            if not (key.startswith('__')) and not (key.startswith('_')):
+                if key == 'db_info':
+                    data_info.update(value)
+                elif isinstance(value, ModuleType):
+                    load_data_info(module_name + '.' + key, data_info, module=value)
+    else:
+        raise RuntimeError(f'Try to access "db_info", but cannot find {module_name} module.')
+
+def reset_ckpt_path(cfg, data_info):
+    if isinstance(cfg, dict):
+        for key in cfg.keys():
+            if key == 'backbone':
+                new_ckpt_path = data_info['checkpoint']['db_root'] + '/' + data_info['checkpoint'][cfg.backbone.type]
+                cfg.backbone.update(checkpoint=new_ckpt_path)
+                continue
+            elif isinstance(cfg.get(key), dict):
+                reset_ckpt_path(cfg.get(key), data_info)
+            else:
+                continue
+    else:
+        return
+
+if __name__ == '__main__':
+    db_info_tmp = {}
+    load_data_info('db_data_info', db_info_tmp)
+    print('results', db_info_tmp.keys())
+

external/Metric3D/training/mono/utils/do_test.py

@@ -0,0 +1,245 @@
+import torch
+import logging
+import os
+from mono.utils.avg_meter import MetricAverageMeter
+from mono.utils.visualization import save_val_imgs, visual_train_data, create_html, save_raw_imgs, save_normal_val_imgs
+import cv2
+from tqdm import tqdm
+import numpy as np
+from mono.utils.logger import setup_logger
+from mono.utils.comm import main_process
+#from scipy.optimize import minimize
+#from torchmin import minimize
+import torch.optim as optim
+from torch.autograd import Variable
+
+
+def to_cuda(data: dict):
+    for k, v in data.items():
+        if isinstance(v, torch.Tensor):
+            data[k] = v.cuda(non_blocking=True)
+        if isinstance(v, list) and len(v)>=1 and isinstance(v[0], torch.Tensor):
+            for i, l_i in enumerate(v):
+                data[k][i] = l_i.cuda(non_blocking=True)
+    return data
+
+def align_scale(pred: torch.tensor, target: torch.tensor):
+    mask = target > 0
+    if torch.sum(mask) > 10:
+        scale = torch.median(target[mask]) / (torch.median(pred[mask]) + 1e-8)
+    else:
+        scale = 1
+    pred_scale = pred * scale
+    return pred_scale, scale
+
+def align_shift(pred: torch.tensor, target: torch.tensor):
+    mask = target > 0
+    if torch.sum(mask) > 10:
+        shift = torch.median(target[mask]) - (torch.median(pred[mask]) + 1e-8)
+    else:
+        shift = 0
+    pred_shift = pred + shift
+    return pred_shift, shift
+
+def align_scale_shift(pred: torch.tensor, target: torch.tensor):
+    mask = target > 0
+    target_mask = target[mask].cpu().numpy()
+    pred_mask = pred[mask].cpu().numpy()
+    if torch.sum(mask) > 10:
+        scale, shift = np.polyfit(pred_mask, target_mask, deg=1)
+        if scale < 0:
+            scale = torch.median(target[mask]) / (torch.median(pred[mask]) + 1e-8)
+            shift = 0
+    else:
+        scale = 1
+        shift = 0
+    pred = pred * scale + shift
+    return pred, scale
+
+def get_prediction(
+    model: torch.nn.Module,
+    input: torch.tensor, 
+    cam_model: torch.tensor,
+    pad_info: torch.tensor,
+    scale_info: torch.tensor,
+    gt_depth: torch.tensor,
+    normalize_scale: float,
+    intrinsic = None,
+    clip_range = None,
+    flip_aug = False):    
+    #clip_range = [0, 10],
+    #flip_aug = True):
+
+    data = dict(
+        input=input,
+        #ref_input=ref_input,
+        cam_model=cam_model
+    )
+    #output = model.module.inference(data)
+    output = model.module.inference(data)
+    pred_depth, confidence = output['prediction'], output['confidence']
+    pred_depth = torch.abs(pred_depth)
+    pred_depth = pred_depth.squeeze()
+
+    if flip_aug == True:
+        output_flip = model.module.inference(dict(
+        input=torch.flip(input, [3]),
+        #ref_input=ref_input,
+        cam_model=cam_model
+    ))
+
+        if clip_range != None:
+            output['prediction'] = torch.clamp(output['prediction'], clip_range[0], clip_range[1])
+            output_flip['prediction'] = torch.clamp(output_flip['prediction'], clip_range[0] / normalize_scale * scale_info , clip_range[1] / normalize_scale * scale_info)
+
+        output['prediction'] = 0.5 * (output['prediction'] + torch.flip(output_flip['prediction'], [3]))
+        output['confidence'] = 0.5 * (output['confidence'] + torch.flip(output_flip['confidence'], [3]))
+
+    output['pad'] = torch.Tensor(pad_info).cuda().unsqueeze(0).int()
+    output['mask'] = torch.ones_like(pred_depth).bool().unsqueeze(0).unsqueeze(1)
+    output['scale_info'] = scale_info 
+    if intrinsic is not None:
+        output['intrinsic'] = intrinsic
+
+    pred_depth = pred_depth[pad_info[0]: pred_depth.shape[0]-pad_info[1], pad_info[2]: pred_depth.shape[1]-pad_info[3]]
+    pred_depth = torch.nn.functional.interpolate(pred_depth[None, None, :, :], gt_depth.shape, mode='bilinear').squeeze() # to orginal size
+    pred_depth = pred_depth * normalize_scale / scale_info 
+
+    if clip_range != None:
+        pred_depth = torch.clamp(pred_depth, clip_range[0], clip_range[1])
+
+    pred_depth_scale, scale = align_scale(pred_depth, gt_depth) #align_scale_shift(pred_depth, gt_depth) 
+
+    if clip_range != None:
+        pred_depth_scale = torch.clamp(pred_depth_scale, clip_range[0], clip_range[1])
+
+    return pred_depth, pred_depth_scale, scale, output
+
+
+# def depth_normal_consistency_optimization(output_dict, consistency_fn): 
+#     s = torch.zeros_like(output_dict['scale_info'])
+#     def closure(x):
+#         output_dict['scale'] = torch.exp(x) * output_dict['scale_info']  
+#         error = consistency_fn(**output_dict)
+#         return error + x * x
+
+#     result = minimize(closure, s, method='newton-exact', disp=1, options={'max_iter':10, 'lr':0.1})
+#     return float(torch.exp(-result.x))
+
+
+def do_test_with_dataloader(
+    model: torch.nn.Module, 
+    cfg: dict, 
+    dataloader: torch.utils.data,
+    logger: logging.RootLogger,
+    is_distributed: bool = True,
+    local_rank: int = 0):
+    
+    show_dir = cfg.show_dir
+    save_interval = 100
+    save_html_path = show_dir + '/index.html'
+    save_imgs_dir = show_dir + '/vis'
+    os.makedirs(save_imgs_dir, exist_ok=True)
+    save_raw_dir = show_dir + '/raw'
+    os.makedirs(save_raw_dir, exist_ok=True)
+
+    normalize_scale = cfg.data_basic.depth_range[1]
+
+    dam = MetricAverageMeter(cfg.test_metrics)
+    dam_scale = MetricAverageMeter(cfg.test_metrics)
+
+    try:
+        depth_range = cfg.data_basic.clip_depth_range if cfg.clip_depth else None
+    except:
+        depth_range = None
+
+    for i, data in enumerate(tqdm(dataloader)):
+
+        # logger.info(f'{local_rank}: {i}/{len(dataloader)}')
+        data = to_cuda(data)
+        gt_depth = data['target'].squeeze()
+        mask = gt_depth > 1e-6
+        pad_info = data['pad']
+        pred_depth, pred_depth_scale, scale, output = get_prediction(
+            model,
+            data['input'],
+            data['cam_model'],
+            pad_info,
+            data['scale'],
+            gt_depth,
+            normalize_scale,
+            data['intrinsic'],
+        )
+        
+        logger.info(f'{data["filename"]}: {scale}')
+
+        # optimization
+        #if "normal_out_list" in output.keys():
+            #scale_opt = depth_normal_consistency_optimization(output, consistency_loss)
+            #print('scale', scale_opt, float(scale)) 
+        scale_opt = 1.0
+
+        # update depth metrics
+        dam_scale.update_metrics_gpu(pred_depth_scale, gt_depth, mask, is_distributed)
+        dam.update_metrics_gpu(pred_depth, gt_depth, mask, is_distributed)
+
+        # save evaluation results
+        if i % save_interval == 0:
+            # save 
+            rgb = data['input'][:, :, pad_info[0]: data['input'].shape[2]-pad_info[1], pad_info[2]: data['input'].shape[3]-pad_info[3]]
+            rgb = torch.nn.functional.interpolate(rgb, gt_depth.shape, mode='bilinear').squeeze()
+            max_scale = save_val_imgs(i,
+                          pred_depth, 
+                          gt_depth, 
+                          rgb, 
+                          data['filename'][0], 
+                          save_imgs_dir,
+                          )
+            logger.info(f'{data["filename"]}, {"max_scale"}: {max_scale}')
+
+            # # save original depth/rgb
+            # save_raw_imgs(
+            #     pred_depth.cpu().squeeze().numpy(),
+            #     data['raw_rgb'].cpu().squeeze().numpy(), 
+            #     data['filename'][0], 
+            #     save_raw_dir,
+            # )
+
+        
+        # surface normal metrics
+        if "normal_out_list" in output.keys():
+            normal_out_list = output['normal_out_list']
+            gt_normal = data['normal']
+
+            pred_normal = normal_out_list[-1][:, :3, :, :] # (B, 3, H, W)
+            H, W = pred_normal.shape[2:]
+            pred_normal = pred_normal[:, :, pad_info[0]:H-pad_info[1], pad_info[2]:W-pad_info[3]]
+            pred_normal = torch.nn.functional.interpolate(pred_normal, size=gt_normal.shape[2:], mode='bilinear', align_corners=True)
+
+            gt_normal_mask = ~torch.all(gt_normal == 0, dim=1, keepdim=True)
+            dam.update_normal_metrics_gpu(pred_normal, gt_normal, gt_normal_mask, cfg.distributed)# save valiad normal
+
+            if i % save_interval == 0:
+                save_normal_val_imgs(iter, 
+                                    pred_normal, 
+                                    gt_normal, 
+                                    rgb, # data['input'], 
+                                    'normal_' + data['filename'][0], 
+                                    save_imgs_dir,
+                                    )
+
+    # get validation error
+    if main_process():
+        eval_error = dam.get_metrics()
+        print('>>>>>W/o scale: ', eval_error)
+        eval_error_scale = dam_scale.get_metrics()
+        print('>>>>>W scale: ', eval_error_scale)
+        # disp_eval_error = dam_disp.get_metrics()
+        # print('>>>>>Disp to depth: ', disp_eval_error)
+        # for i, dam in enumerate(dams):
+        #     print(f'>>>>>W/o scale gru{i}: ', dam.get_metrics())
+
+        logger.info(eval_error)
+        logger.info(eval_error_scale)
+        # logger.info(disp_eval_error)
+        # [logger.info(dam.get_metrics()) for dam in dams]

external/Metric3D/training/mono/utils/do_train.py

@@ -0,0 +1,529 @@
+import os
+import torch
+import matplotlib.pyplot as plt
+from mono.model.monodepth_model import get_configured_monodepth_model
+from tensorboardX import SummaryWriter
+from mono.utils.comm import TrainingStats
+from mono.utils.avg_meter import MetricAverageMeter
+from mono.utils.running import build_lr_schedule_with_cfg, build_optimizer_with_cfg, load_ckpt, save_ckpt
+from mono.utils.comm import reduce_dict, main_process, get_rank
+from mono.utils.visualization import save_val_imgs, visual_train_data, create_html, save_normal_val_imgs
+import traceback
+from mono.utils.visualization import create_dir_for_validate_meta
+from mono.model.criterion import build_criterions
+from mono.datasets.distributed_sampler import build_dataset_n_sampler_with_cfg, build_data_array
+from mono.utils.logger import setup_logger
+import logging
+from .misc import NativeScalerWithGradNormCount, is_bf16_supported
+import math
+import sys
+import random
+import numpy as np
+import torch.distributed as dist
+import torch.nn.functional as F
+from contextlib import nullcontext
+
+def to_cuda(data):
+    for k, v in data.items():
+        if isinstance(v, torch.Tensor):
+            data[k] = v.cuda(non_blocking=True)
+        if isinstance(v, list) and len(v)>1 and isinstance(v[0], torch.Tensor):
+            for i, l_i in enumerate(v):
+                data[k][i] = l_i.cuda(non_blocking=True)
+    return data
+
+def do_train(local_rank: int, cfg: dict):
+
+    logger = setup_logger(cfg.log_file)
+
+    # build criterions
+    criterions = build_criterions(cfg)
+    
+    # build model
+    model = get_configured_monodepth_model(cfg,
+                                           criterions,
+                                           ) 
+    
+    # log model state_dict
+    if main_process():
+        logger.info(model.state_dict().keys())
+    
+    # build datasets
+    train_dataset, train_sampler = build_dataset_n_sampler_with_cfg(cfg, 'train')
+    if 'multi_dataset_eval' in cfg.evaluation and cfg.evaluation.multi_dataset_eval:
+        val_dataset = build_data_array(cfg, 'val')
+    else:
+        val_dataset, val_sampler = build_dataset_n_sampler_with_cfg(cfg, 'val')
+    # build data loaders
+    g = torch.Generator()
+    g.manual_seed(cfg.seed + cfg.dist_params.global_rank)
+    train_dataloader = torch.utils.data.DataLoader(dataset=train_dataset,
+                                                   batch_size=cfg.batchsize_per_gpu,
+                                                   num_workers=cfg.thread_per_gpu,
+                                                   sampler=train_sampler,
+                                                   drop_last=True, 
+                                                   pin_memory=True,
+                                                   generator=g,)
+                                                #    collate_fn=collate_fn)
+    if isinstance(val_dataset, list):
+        val_dataloader = [torch.utils.data.DataLoader(dataset=val_dataset,
+                                                      batch_size=1,
+                                                      num_workers=0,
+                                                      sampler=torch.utils.data.distributed.DistributedSampler(val_dataset, shuffle=False),
+                                                      drop_last=True,
+                                                      pin_memory=True,) for val_group in val_dataset for val_dataset in val_group]
+    else:
+        val_dataloader = torch.utils.data.DataLoader(dataset=val_dataset,
+                                                batch_size=1,
+                                                num_workers=0,
+                                                sampler=val_sampler,
+                                                drop_last=True,
+                                                pin_memory=True,)
+    
+    # build schedule
+    lr_scheduler = build_lr_schedule_with_cfg(cfg)
+    optimizer = build_optimizer_with_cfg(cfg, model)
+   
+    # config distributed training
+    if cfg.distributed:
+        model = torch.nn.SyncBatchNorm.convert_sync_batchnorm(model)
+        model = torch.nn.parallel.DistributedDataParallel(model.cuda(), 
+                                                          device_ids=[local_rank], 
+                                                          output_device=local_rank, 
+                                                          find_unused_parameters=False)
+    else:
+        model = torch.nn.DataParallel(model.cuda())
+    
+    # init automatic mix precision training
+    # if 'AMP' in cfg.runner.type:
+    #     loss_scaler = NativeScalerWithGradNormCount()
+    # else:
+    #     loss_scaler = None
+    loss_scaler = None
+    
+    # load ckpt
+    if cfg.load_from and cfg.resume_from is None:
+        model, _, _, loss_scaler = load_ckpt(cfg.load_from, model, optimizer=None, scheduler=None, strict_match=False, loss_scaler=loss_scaler)
+    elif cfg.resume_from:
+        model, optimizer, lr_scheduler, loss_scaler = load_ckpt(
+            cfg.resume_from, 
+            model, 
+            optimizer=optimizer, 
+            scheduler=lr_scheduler, 
+            strict_match=False, 
+            loss_scaler=loss_scaler)
+
+    if cfg.runner.type == 'IterBasedRunner':
+        train_by_iters(cfg,
+                    model, 
+                    optimizer, 
+                    lr_scheduler,
+                    train_dataloader,
+                    val_dataloader,
+                    )
+    elif cfg.runner.type == 'IterBasedRunner_MultiSize':
+        train_by_iters_multisize(cfg,
+                    model, 
+                    optimizer, 
+                    lr_scheduler,
+                    train_dataloader,
+                    val_dataloader,
+                    )
+    elif cfg.runner.type == 'IterBasedRunner_AMP':
+        train_by_iters_amp(
+            cfg = cfg,
+            model=model, 
+            optimizer=optimizer, 
+            lr_scheduler=lr_scheduler,
+            train_dataloader=train_dataloader,
+            val_dataloader=val_dataloader,
+            loss_scaler=loss_scaler
+        )
+    elif cfg.runner.type == 'IterBasedRunner_AMP_MultiSize':
+        train_by_iters_amp_multisize(
+            cfg = cfg,
+            model=model, 
+            optimizer=optimizer, 
+            lr_scheduler=lr_scheduler,
+            train_dataloader=train_dataloader,
+            val_dataloader=val_dataloader,
+            loss_scaler=loss_scaler
+        )
+    elif cfg.runner.type == 'EpochBasedRunner':
+        raise RuntimeError('It is not supported currently. :)')
+    else:
+        raise RuntimeError('It is not supported currently. :)')
+
+
+def train_by_iters(cfg, model, optimizer, lr_scheduler, train_dataloader, val_dataloader):
+    """
+    Do the training by iterations.
+    """
+    logger = logging.getLogger()
+    tb_logger = None
+    if cfg.use_tensorboard and main_process():
+        tb_logger = SummaryWriter(cfg.tensorboard_dir)
+    if main_process():
+        training_stats = TrainingStats(log_period=cfg.log_interval, tensorboard_logger=tb_logger)
+    
+    lr_scheduler.before_run(optimizer)
+    
+    # set training steps
+    max_iters = cfg.runner.max_iters
+    start_iter = lr_scheduler._step_count
+
+    save_interval = cfg.checkpoint_config.interval
+    eval_interval = cfg.evaluation.interval
+    epoch = 0
+    logger.info('Create iterator.')
+    dataloader_iterator = iter(train_dataloader)
+
+    val_err = {}
+    logger.info('Start training.')
+
+    try:
+        # for step in range(start_iter, max_iters):
+        # keep same step in all processes, avoid stuck during eval barrier
+        step = start_iter 
+        while step < max_iters:
+            if main_process():
+                training_stats.IterTic()
+            
+            # get the data batch
+            try:
+                data = next(dataloader_iterator)
+            except StopIteration:
+                dataloader_iterator = iter(train_dataloader)
+                data = next(dataloader_iterator)
+            except Exception as e:
+                logger.info('When load training data: ', e)
+                continue
+            except:
+                logger.info('Some training data errors exist in the current iter!')
+                continue
+            data = to_cuda(data)
+            # set random crop size
+            # if step % 10 == 0:
+            #     set_random_crop_size_for_iter(train_dataloader, step, size_sample_list[step])
+            
+            # check training data
+            #for i in range(data['target'].shape[0]):
+                # if 'DDAD' in data['dataset'][i] or \
+                #     'Lyft' in data['dataset'][i] or \
+                #     'DSEC' in data['dataset'][i] or \
+                #     'Argovers2' in data['dataset'][i]:
+                #     replace = True
+                # else:
+                #     replace = False
+                #visual_train_data(data['target'][i, ...], data['input'][i,...], data['filename'][i], cfg.work_dir, replace=replace)
+
+            # forward
+            pred_depth, losses_dict, conf = model(data)
+                
+            optimizer.zero_grad()
+            losses_dict['total_loss'].backward()
+            # if step > 100 and step % 10 == 0:
+            #     for param in model.parameters():
+            #         print(param.grad.max(), torch.norm(param.grad))
+            torch.nn.utils.clip_grad_norm_(model.parameters(), 10)
+            optimizer.step()
+
+            # reduce losses over all GPUs for logging purposes
+            loss_dict_reduced = reduce_dict(losses_dict)
+
+            lr_scheduler.after_train_iter(optimizer)
+            if main_process():
+                training_stats.update_iter_stats(loss_dict_reduced)
+                training_stats.IterToc()
+                training_stats.log_iter_stats(step, optimizer, max_iters, val_err)
+
+            # validate the model
+            if cfg.evaluation.online_eval and \
+                (step+1) % eval_interval == 0 and \
+                val_dataloader is not None:
+                if isinstance(val_dataloader, list):
+                    val_err = validate_multiple_dataset(cfg, step+1, model, val_dataloader, tb_logger)
+                else:
+                    val_err = validate(cfg, step+1, model, val_dataloader, tb_logger)
+                if main_process():
+                    training_stats.tb_log_stats(val_err, step)
+
+            # save checkpoint
+            if main_process():
+                if ((step+1) % save_interval == 0) or ((step+1)==max_iters):
+                    save_ckpt(cfg, model, optimizer, lr_scheduler, step+1, epoch)
+            
+            step += 1
+
+    except (RuntimeError, KeyboardInterrupt):
+        stack_trace = traceback.format_exc()
+        print(stack_trace)
+
+def train_by_iters_amp(cfg, model, optimizer, lr_scheduler, train_dataloader, val_dataloader, loss_scaler):
+    """
+    Do the training by iterations.
+    Mix precision is employed.
+    """
+    # set up logger
+    tb_logger = None
+    if cfg.use_tensorboard and main_process():
+        tb_logger = SummaryWriter(cfg.tensorboard_dir)
+    logger = logging.getLogger()
+    # training status
+    if main_process():
+        training_stats = TrainingStats(log_period=cfg.log_interval, tensorboard_logger=tb_logger)
+
+    # learning schedule
+    lr_scheduler.before_run(optimizer)
+    
+    # set training steps
+    max_iters = cfg.runner.max_iters
+    start_iter = lr_scheduler._step_count
+
+    save_interval = cfg.checkpoint_config.interval
+    eval_interval = cfg.evaluation.interval
+    epoch = 0
+
+    # If it's too slow try lowering num_worker
+    # see https://discuss.pytorch.org/t/define-iterator-on-dataloader-is-very-slow/52238
+    logger.info('Create iterator.')
+    dataloader_iterator = iter(train_dataloader)
+
+    val_err = {}
+    # torch.cuda.empty_cache()
+    logger.info('Start training.')
+
+    try:
+        acc_batch = cfg.acc_batch
+    except:
+        acc_batch = 1
+
+    try:
+        # for step in range(start_iter, max_iters):
+        # keep same step in all processes, avoid stuck during eval barrier
+        step = start_iter *  acc_batch
+        #while step < max_iters:
+        while True:
+            
+            if main_process():
+                training_stats.IterTic()
+
+            # get the data batch
+            try:
+                data = next(dataloader_iterator)
+            except StopIteration:
+                dataloader_iterator = iter(train_dataloader)
+                data = next(dataloader_iterator)
+            except Exception as e:
+                logger.info('When load training data: ', e)
+                continue
+            except:
+                logger.info('Some training data errors exist in the current iter!')
+                continue
+
+            data = to_cuda(data)
+
+            with torch.cuda.amp.autocast(dtype=torch.bfloat16):
+                pred_depth, losses_dict, conf = model(data)
+
+            total_loss = losses_dict['total_loss'] / acc_batch
+
+            if not math.isfinite(total_loss):
+                logger.info("Loss is {}, skiping this batch training".format(total_loss))
+                continue
+            
+            # optimize, backward
+            if (step+1-start_iter) % acc_batch == 0:
+                optimizer.zero_grad()
+            if loss_scaler == None:
+                total_loss.backward()
+                try:
+                    if (step+1-start_iter) % acc_batch == 0:
+                        torch.nn.utils.clip_grad_norm_(model.parameters(), 2.5, error_if_nonfinite=True)
+                        optimizer.step()
+                except:
+                    print('NAN gradient, skipping optimizer.step() for this round...')
+            else:
+                loss_scaler(total_loss, optimizer, clip_grad=5, parameters=model.parameters(), update_grad=True)
+
+            # reduce losses over all GPUs for logging purposes
+            if (step+1-start_iter) % acc_batch == 0:
+                loss_dict_reduced = reduce_dict(losses_dict)
+                lr_scheduler.after_train_iter(optimizer)
+
+                if main_process():
+                    training_stats.update_iter_stats(loss_dict_reduced)
+                    training_stats.IterToc()
+                    training_stats.log_iter_stats(step//acc_batch, optimizer, max_iters, val_err)
+
+            # validate the model
+                if cfg.evaluation.online_eval and \
+                    ((step+acc_batch)//acc_batch) % eval_interval == 0 and \
+                    val_dataloader is not None:
+                # if True:
+                    if isinstance(val_dataloader, list):
+                        val_err = validate_multiple_dataset(cfg, ((step+acc_batch)//acc_batch), model, val_dataloader, tb_logger)
+                    else:
+                        val_err = validate(cfg, ((step+acc_batch)//acc_batch), model, val_dataloader, tb_logger)
+                    if main_process():
+                        training_stats.tb_log_stats(val_err, step)
+
+                # save checkpoint
+                if main_process():
+                    if (((step+acc_batch)//acc_batch) % save_interval == 0) or (((step+acc_batch)//acc_batch)==max_iters):
+                        save_ckpt(cfg, model, optimizer, lr_scheduler, ((step+acc_batch)//acc_batch), epoch, loss_scaler=loss_scaler)
+
+            step += 1
+            
+
+    except (RuntimeError, KeyboardInterrupt):
+        stack_trace = traceback.format_exc()
+        print(stack_trace)
+
+def validate_multiple_dataset(cfg, iter, model, val_dataloaders, tb_logger):
+    val_errs = {}
+    for val_dataloader in val_dataloaders:
+        val_err = validate(cfg, iter, model, val_dataloader, tb_logger)
+        val_errs.update(val_err)
+    # mean of all dataset
+    mean_val_err = {}
+    for k, v in val_errs.items():
+        metric = 'AllData_eval/' + k.split('/')[-1]
+        if metric not in mean_val_err.keys():
+            mean_val_err[metric] = 0
+        mean_val_err[metric] += v / len(val_dataloaders)
+    val_errs.update(mean_val_err)
+    
+    return val_errs
+
+
+def validate(cfg, iter, model, val_dataloader, tb_logger):
+    """
+    Validate the model on single dataset
+    """
+    model.eval()
+    dist.barrier()
+    logger = logging.getLogger()
+    # prepare dir for visualization data
+    save_val_meta_data_dir = create_dir_for_validate_meta(cfg.work_dir, iter)
+    # save_html_path = save_val_meta_data_dir + '.html'
+    dataset_name = val_dataloader.dataset.data_name
+
+    save_point = max(int(len(val_dataloader) / 5), 1)
+    # save_point = 2
+    # depth metric meter
+    dam = MetricAverageMeter(cfg.evaluation.metrics)
+    # dam_disp = MetricAverageMeter([m for m in cfg.evaluation.metrics if m[:6]!='normal'])
+    for i, data in enumerate(val_dataloader):
+        if i % 10 == 0:
+            logger.info(f'Validation step on {dataset_name}: {i}')
+        data = to_cuda(data)
+        output = model.module.inference(data)
+        pred_depth = output['prediction']
+        pred_depth = pred_depth.squeeze()
+        gt_depth = data['target'].cuda(non_blocking=True).squeeze()
+        
+        pad = data['pad'].squeeze()
+        H, W = pred_depth.shape
+        pred_depth = pred_depth[pad[0]:H-pad[1], pad[2]:W-pad[3]]
+        gt_depth = gt_depth[pad[0]:H-pad[1], pad[2]:W-pad[3]]
+        rgb = data['input'][0, :, pad[0]:H-pad[1], pad[2]:W-pad[3]]
+        mask = gt_depth > 0
+        #pred_depth_resize = cv2.resize(pred_depth.cpu().numpy(), (torch.squeeze(data['B_raw']).shape[1], torch.squeeze(data['B_raw']).shape[0]))
+        dam.update_metrics_gpu(pred_depth, gt_depth, mask, cfg.distributed)
+
+        # save evaluation results
+        if i%save_point == 0 and main_process():
+            save_val_imgs(iter, 
+                          pred_depth, 
+                          gt_depth, 
+                          rgb, # data['input'], 
+                          dataset_name + '_' + data['filename'][0], 
+                          save_val_meta_data_dir,
+                          tb_logger=tb_logger)
+
+        ## surface normal
+        if "normal_out_list" in output.keys():
+            normal_out_list = output['normal_out_list']
+            pred_normal = normal_out_list[-1][:, :3, :, :] # (B, 3, H, W)
+            gt_normal = data['normal'].cuda(non_blocking=True)
+            # if pred_normal.shape != gt_normal.shape:
+            #     pred_normal = F.interpolate(pred_normal, size=[gt_normal.size(2), gt_normal.size(3)], mode='bilinear', align_corners=True)
+
+            H, W = pred_normal.shape[2:]
+            pred_normal = pred_normal[:, :, pad[0]:H-pad[1], pad[2]:W-pad[3]]
+            gt_normal = gt_normal[:, :, pad[0]:H-pad[1], pad[2]:W-pad[3]]
+            gt_normal_mask = ~torch.all(gt_normal == 0, dim=1, keepdim=True)
+            dam.update_normal_metrics_gpu(pred_normal, gt_normal, gt_normal_mask, cfg.distributed)
+
+            # save valiad normal
+            if i%save_point == 0 and main_process():
+                save_normal_val_imgs(iter, 
+                                    pred_normal, 
+                                    gt_normal, 
+                                    rgb, # data['input'], 
+                                    dataset_name + '_normal_' + data['filename'][0], 
+                                    save_val_meta_data_dir,
+                                    tb_logger=tb_logger)
+
+    # create html for visualization
+    merged_rgb_pred_gt = os.path.join(save_val_meta_data_dir, '*_merge.jpg')
+    name2path = dict(merg=merged_rgb_pred_gt) #dict(rgbs=rgbs, pred=pred, gt=gt)
+    # if main_process():
+    #    create_html(name2path, save_path=save_html_path, size=(256*3, 512))
+
+    # get validation error
+    eval_error = dam.get_metrics()
+    eval_error = {f'{dataset_name}_eval/{k}': v for k,v in eval_error.items()}
+    # eval_disp_error = {f'{dataset_name}_eval/disp_{k}': v for k,v in dam_disp.get_metrics().items()}
+    # eval_error.update(eval_disp_error)
+
+    model.train()
+    
+    if 'exclude' in cfg.evaluation and dataset_name in cfg.evaluation.exclude:
+        return {}
+    return eval_error
+
+def set_random_crop_size_for_iter(dataloader: torch.utils.data.dataloader.DataLoader, iter: int, size_pool=None):
+    if size_pool is None:
+        size_pool = [
+            # [504, 504], [560, 1008], [840, 1512], [1120, 2016],
+            [560, 1008], [840, 1512], [1120, 2016],
+            # [480, 768], [480, 960], 
+            # [480, 992], [480, 1024], 
+            # [480, 1120], 
+            # [480, 1280], 
+            # [480, 1312],
+            # [512, 512], [512, 640], 
+            # [512, 960], 
+            # [512, 992], 
+            # [512, 1024], [512, 1120], 
+            # [512, 1216], 
+            # [512, 1280],
+            # [576, 640], [576, 960], 
+            # [576, 992], 
+            # [576, 1024],
+            # [608, 608], [608, 640], 
+            # [608, 960], [608, 1024],
+        ]
+    random.seed(iter)
+    sample = random.choice(size_pool)
+    # idx = (iter // 10) % len(size_pool)
+    #sample = size_pool[size_idx]
+    
+    # random.seed(iter)
+    # flg = random.random() <= 1.0
+    # if flg:
+    crop_size = sample
+    # else:
+    #     crop_size = [sample[1], sample[0]]
+
+    # set crop size for each dataset
+    datasets_groups = len(dataloader.dataset.datasets)
+    for i in range(datasets_groups):
+        for j in range(len(dataloader.dataset.datasets[i].datasets)):
+            dataloader.dataset.datasets[i].datasets[j].set_random_crop_size(crop_size)
+    return crop_size
+
+    
+    

external/Metric3D/training/mono/utils/inverse_warp.py

@@ -0,0 +1,316 @@
+import torch
+import torch.nn.functional as F
+
+pixel_coords = None
+
+def set_id_grid(depth):
+    global pixel_coords
+    b, h, w = depth.size()
+    i_range = torch.arange(0, h).view(1, h, 1).expand(
+        1, h, w).type_as(depth)  # [1, H, W]
+    j_range = torch.arange(0, w).view(1, 1, w).expand(
+        1, h, w).type_as(depth)  # [1, H, W]
+    ones = torch.ones(1, h, w).type_as(depth)
+
+    pixel_coords = torch.stack((j_range, i_range, ones), dim=1)  # [1, 3, H, W]
+
+
+def check_sizes(input, input_name, expected):
+    condition = [input.ndimension() == len(expected)]
+    for i, size in enumerate(expected):
+        if size.isdigit():
+            condition.append(input.size(i) == int(size))
+    assert(all(condition)), "wrong size for {}, expected {}, got  {}".format(
+        input_name, 'x'.join(expected), list(input.size()))
+
+
+def pixel2cam(depth, intrinsics_inv):
+    global pixel_coords
+    """Transform coordinates in the pixel frame to the camera frame.
+    Args:
+        depth: depth maps -- [B, H, W]
+        intrinsics_inv: intrinsics_inv matrix for each element of batch -- [B, 3, 3]
+    Returns:
+        array of (u,v,1) cam coordinates -- [B, 3, H, W]
+    """
+    b, h, w = depth.size()
+    if (pixel_coords is None) or pixel_coords.size(2) < h:
+        set_id_grid(depth)
+    current_pixel_coords = pixel_coords[:, :, :h, :w].expand(
+        b, 3, h, w).reshape(b, 3, -1)  # [B, 3, H*W]
+    cam_coords = (intrinsics_inv @ current_pixel_coords).reshape(b, 3, h, w)
+    out = depth.unsqueeze(1) * cam_coords
+    return  out
+
+
+def cam2pixel(cam_coords, proj_c2p_rot, proj_c2p_tr, padding_mode):
+    """Transform coordinates in the camera frame to the pixel frame.
+    Args:
+        cam_coords: pixel coordinates defined in the first camera coordinates system -- [B, 4, H, W]
+        proj_c2p_rot: rotation matrix of cameras -- [B, 3, 4]
+        proj_c2p_tr: translation vectors of cameras -- [B, 3, 1]
+    Returns:
+        array of [-1,1] coordinates -- [B, 2, H, W]
+    """
+    b, _, h, w = cam_coords.size()
+    cam_coords_flat = cam_coords.reshape(b, 3, -1)  # [B, 3, H*W]
+    if proj_c2p_rot is not None:
+        pcoords = proj_c2p_rot @ cam_coords_flat
+    else:
+        pcoords = cam_coords_flat
+
+    if proj_c2p_tr is not None:
+        pcoords = pcoords + proj_c2p_tr  # [B, 3, H*W]
+    X = pcoords[:, 0]
+    Y = pcoords[:, 1]
+    Z = pcoords[:, 2].clamp(min=1e-3)
+
+    # Normalized, -1 if on extreme left, 1 if on extreme right (x = w-1) [B, H*W]
+    X_norm = 2*(X / Z)/(w-1) - 1
+    Y_norm = 2*(Y / Z)/(h-1) - 1  # Idem [B, H*W]
+
+    pixel_coords = torch.stack([X_norm, Y_norm], dim=2)  # [B, H*W, 2]
+    return pixel_coords.reshape(b, h, w, 2)
+
+
+def euler2mat(angle):
+    """Convert euler angles to rotation matrix.
+     Reference: https://github.com/pulkitag/pycaffe-utils/blob/master/rot_utils.py#L174
+    Args:
+        angle: rotation angle along 3 axis (in radians) -- size = [B, 3]
+    Returns:
+        Rotation matrix corresponding to the euler angles -- size = [B, 3, 3]
+    """
+    B = angle.size(0)
+    x, y, z = angle[:, 0], angle[:, 1], angle[:, 2]
+
+    cosz = torch.cos(z)
+    sinz = torch.sin(z)
+
+    zeros = z.detach()*0
+    ones = zeros.detach()+1
+    zmat = torch.stack([cosz, -sinz, zeros,
+                        sinz,  cosz, zeros,
+                        zeros, zeros,  ones], dim=1).reshape(B, 3, 3)
+
+    cosy = torch.cos(y)
+    siny = torch.sin(y)
+
+    ymat = torch.stack([cosy, zeros,  siny,
+                        zeros,  ones, zeros,
+                        -siny, zeros,  cosy], dim=1).reshape(B, 3, 3)
+
+    cosx = torch.cos(x)
+    sinx = torch.sin(x)
+
+    xmat = torch.stack([ones, zeros, zeros,
+                        zeros,  cosx, -sinx,
+                        zeros,  sinx,  cosx], dim=1).reshape(B, 3, 3)
+
+    rotMat = xmat @ ymat @ zmat
+    return rotMat
+
+
+def quat2mat(quat):
+    """Convert quaternion coefficients to rotation matrix.
+    Args:
+        quat: first three coeff of quaternion of rotation. fourht is then computed to have a norm of 1 -- size = [B, 3]
+    Returns:
+        Rotation matrix corresponding to the quaternion -- size = [B, 3, 3]
+    """
+    norm_quat = torch.cat([quat[:, :1].detach()*0 + 1, quat], dim=1)
+    norm_quat = norm_quat/norm_quat.norm(p=2, dim=1, keepdim=True)
+    w, x, y, z = norm_quat[:, 0], norm_quat[:,
+                                            1], norm_quat[:, 2], norm_quat[:, 3]
+
+    B = quat.size(0)
+
+    w2, x2, y2, z2 = w.pow(2), x.pow(2), y.pow(2), z.pow(2)
+    wx, wy, wz = w*x, w*y, w*z
+    xy, xz, yz = x*y, x*z, y*z
+
+    rotMat = torch.stack([w2 + x2 - y2 - z2, 2*xy - 2*wz, 2*wy + 2*xz,
+                          2*wz + 2*xy, w2 - x2 + y2 - z2, 2*yz - 2*wx,
+                          2*xz - 2*wy, 2*wx + 2*yz, w2 - x2 - y2 + z2], dim=1).reshape(B, 3, 3)
+    return rotMat
+
+
+def pose_vec2mat(vec, rotation_mode='euler'):
+    """
+    Convert 6DoF parameters to transformation matrix.
+    Args:s
+        vec: 6DoF parameters in the order of tx, ty, tz, rx, ry, rz -- [B, 6]
+    Returns:
+        A transformation matrix -- [B, 3, 4]
+    """
+    translation = vec[:, :3].unsqueeze(-1)  # [B, 3, 1]
+    rot = vec[:, 3:]
+    if rotation_mode == 'euler':
+        rot_mat = euler2mat(rot)  # [B, 3, 3]
+    elif rotation_mode == 'quat':
+        rot_mat = quat2mat(rot)  # [B, 3, 3]
+    transform_mat = torch.cat([rot_mat, translation], dim=2)  # [B, 3, 4]
+    return transform_mat
+
+
+def inverse_warp(img, depth, pose, intrinsics, rotation_mode='euler', padding_mode='zeros'):
+    """
+    Inverse warp a source image to the target image plane.
+    Args:
+        img: the source image (where to sample pixels) -- [B, 3, H, W]
+        depth: depth map of the target image -- [B, H, W]
+        pose: 6DoF pose parameters from target to source -- [B, 6]
+        intrinsics: camera intrinsic matrix -- [B, 3, 3]
+    Returns:
+        projected_img: Source image warped to the target image plane
+        valid_points: Boolean array indicating point validity
+    """
+    check_sizes(img, 'img', 'B3HW')
+    check_sizes(depth, 'depth', 'BHW')
+    check_sizes(pose, 'pose', 'B6')
+    check_sizes(intrinsics, 'intrinsics', 'B33')
+
+    batch_size, _, img_height, img_width = img.size()
+
+    cam_coords = pixel2cam(depth, intrinsics.inverse())  # [B,3,H,W]
+
+    pose_mat = pose_vec2mat(pose, rotation_mode)  # [B,3,4]
+
+    # Get projection matrix for tgt camera frame to source pixel frame
+    proj_cam_to_src_pixel = intrinsics @ pose_mat  # [B, 3, 4]
+
+    rot, tr = proj_cam_to_src_pixel[:, :, :3], proj_cam_to_src_pixel[:, :, -1:]
+    src_pixel_coords = cam2pixel(
+        cam_coords, rot, tr, padding_mode)  # [B,H,W,2]
+    projected_img = F.grid_sample(
+        img, src_pixel_coords, padding_mode=padding_mode)
+
+    valid_points = src_pixel_coords.abs().max(dim=-1)[0] <= 1
+
+    return projected_img, valid_points
+
+
+def cam2pixel2(cam_coords, proj_c2p_rot, proj_c2p_tr, padding_mode):
+    """Transform coordinates in the camera frame to the pixel frame.
+    Args:
+        cam_coords: pixel coordinates defined in the first camera coordinates system -- [B, 4, H, W]
+        proj_c2p_rot: rotation matrix of cameras -- [B, 3, 4]
+        proj_c2p_tr: translation vectors of cameras -- [B, 3, 1]
+    Returns:
+        array of [-1,1] coordinates -- [B, 2, H, W]
+    """
+    b, _, h, w = cam_coords.size()
+    cam_coords_flat = cam_coords.reshape(b, 3, -1)  # [B, 3, H*W]
+    if proj_c2p_rot is not None:
+        pcoords = proj_c2p_rot @ cam_coords_flat
+    else:
+        pcoords = cam_coords_flat
+
+    if proj_c2p_tr is not None:
+        pcoords = pcoords + proj_c2p_tr  # [B, 3, H*W]
+    X = pcoords[:, 0]
+    Y = pcoords[:, 1]
+    Z = pcoords[:, 2].clamp(min=1e-3)
+
+    # Normalized, -1 if on extreme left, 1 if on extreme right (x = w-1) [B, H*W]
+    X_norm = 2*(X / Z)/(w-1) - 1
+    Y_norm = 2*(Y / Z)/(h-1) - 1  # Idem [B, H*W]
+    if padding_mode == 'zeros':
+        X_mask = ((X_norm > 1)+(X_norm < -1)).detach()
+        # make sure that no point in warped image is a combinaison of im and gray
+        X_norm[X_mask] = 2
+        Y_mask = ((Y_norm > 1)+(Y_norm < -1)).detach()
+        Y_norm[Y_mask] = 2
+
+    pixel_coords = torch.stack([X_norm, Y_norm], dim=2)  # [B, H*W, 2]
+    return pixel_coords.reshape(b, h, w, 2), Z.reshape(b, 1, h, w)
+
+
+def inverse_warp2(img, depth, ref_depth, pose, intrinsics, padding_mode='zeros'):
+    """
+    Inverse warp a source image to the target image plane.
+    Args:
+        img: the source image (where to sample pixels) -- [B, 3, H, W]
+        depth: depth map of the target image -- [B, 1, H, W]
+        ref_depth: the source depth map (where to sample depth) -- [B, 1, H, W] 
+        pose: 6DoF pose parameters from target to source -- [B, 6]
+        intrinsics: camera intrinsic matrix -- [B, 3, 3]
+    Returns:
+        projected_img: Source image warped to the target image plane
+        valid_mask: Float array indicating point validity
+        projected_depth: sampled depth from source image  
+        computed_depth: computed depth of source image using the target depth
+    """
+    check_sizes(img, 'img', 'B3HW')
+    check_sizes(depth, 'depth', 'B1HW')
+    check_sizes(ref_depth, 'ref_depth', 'B1HW')
+    check_sizes(pose, 'pose', 'B6')
+    check_sizes(intrinsics, 'intrinsics', 'B33')
+
+    batch_size, _, img_height, img_width = img.size()
+
+    cam_coords = pixel2cam(depth.squeeze(1), intrinsics.inverse())  # [B,3,H,W]
+
+    pose_mat = pose_vec2mat(pose)  # [B,3,4]
+
+    # Get projection matrix for tgt camera frame to source pixel frame
+    proj_cam_to_src_pixel = intrinsics @ pose_mat  # [B, 3, 4]
+
+    rot, tr = proj_cam_to_src_pixel[:, :, :3], proj_cam_to_src_pixel[:, :, -1:]
+    src_pixel_coords, computed_depth = cam2pixel2(cam_coords, rot, tr, padding_mode)  # [B,H,W,2]
+    projected_img = F.grid_sample(img, src_pixel_coords, padding_mode=padding_mode, align_corners=False)
+
+    projected_depth = F.grid_sample(ref_depth, src_pixel_coords, padding_mode=padding_mode, align_corners=False)
+
+    return projected_img, projected_depth, computed_depth
+
+
+def inverse_rotation_warp(img, rot, intrinsics, padding_mode='zeros'):
+
+    b, _, h, w = img.size()
+    cam_coords = pixel2cam(torch.ones(b, h, w).type_as(img), intrinsics.inverse())  # [B,3,H,W]
+
+    rot_mat = euler2mat(rot)  # [B, 3, 3]
+
+    # Get projection matrix for tgt camera frame to source pixel frame
+    proj_cam_to_src_pixel = intrinsics @ rot_mat  # [B, 3, 3]
+
+    src_pixel_coords, computed_depth = cam2pixel2(cam_coords, proj_cam_to_src_pixel, None, padding_mode)  # [B,H,W,2]
+    projected_img = F.grid_sample(img, src_pixel_coords, padding_mode=padding_mode, align_corners=True)
+
+    return projected_img
+
+def grid_to_flow(grid):
+    b, h, w, _ = grid.size()
+    i_range = torch.arange(0, h).view(1, h, 1).expand(1, h, w).type_as(grid)  # [1, H, W]
+    j_range = torch.arange(0, w).view(1, 1, w).expand(1, h, w).type_as(grid)  # [1, H, W]
+    image_coords = torch.stack((j_range, i_range), dim=1)  # [1, 2, H, W]
+
+    flow = torch.zeros_like(grid).type_as(grid)
+    flow[:, :, :, 0] = (grid[:, :, :, 0]+1) / 2 * (w-1)
+    flow[:, :, :, 1] = (grid[:, :, :, 1]+1) / 2 * (h-1)
+    flow = flow.permute([0, 3, 1, 2])
+
+    flow -= image_coords
+
+    return flow
+
+def compute_translation_flow(depth, pose, intrinsics):
+    cam_coords = pixel2cam(depth.squeeze(1), intrinsics.inverse())  # [B,3,H,W]
+
+    pose_mat = pose_vec2mat(pose)  # [B,3,4]
+
+    # Get projection matrix for tgt camera frame to source pixel frame
+    proj_cam_to_src_pixel = intrinsics @ pose_mat  # [B, 3, 4]
+
+    rot, tr = proj_cam_to_src_pixel[:, :, :3], proj_cam_to_src_pixel[:, :, -1:]
+
+    grid_all, _ = cam2pixel2(cam_coords, rot, tr, padding_mode='zeros')  # [B,H,W,2]
+    grid_rot, _ = cam2pixel2(cam_coords, rot, None, padding_mode='zeros')  # [B,H,W,2]
+
+    flow_all = grid_to_flow(grid_all)
+    flow_rot = grid_to_flow(grid_rot)
+    flow_tr = (flow_all - flow_rot)
+
+    return flow_tr
+

external/Metric3D/training/mono/utils/logger.py

@@ -0,0 +1,105 @@
+import atexit
+import logging
+import os
+import sys
+import time
+import torch
+from termcolor import colored
+
+__all__ = ["setup_logger", ]
+
+class _ColorfulFormatter(logging.Formatter):
+    def __init__(self, *args, **kwargs):
+        self._root_name = kwargs.pop("root_name") + "."
+        self._abbrev_name = kwargs.pop("abbrev_name", "")
+        if len(self._abbrev_name):
+            self._abbrev_name = self._abbrev_name + "."
+        super(_ColorfulFormatter, self).__init__(*args, **kwargs)
+
+    def formatMessage(self, record):
+        record.name = record.name.replace(self._root_name, self._abbrev_name)
+        log = super(_ColorfulFormatter, self).formatMessage(record)
+        if record.levelno == logging.WARNING:
+            prefix = colored("WARNING", "red", attrs=["blink"])
+        elif record.levelno == logging.ERROR or record.levelno == logging.CRITICAL:
+            prefix = colored("ERROR", "red", attrs=["blink", "underline"])
+        else:
+            return log
+        return prefix + " " + log
+
+
+def setup_logger(
+    output=None, distributed_rank=0, *, name='mono@YvanYin', color=True, abbrev_name=None
+):
+    """
+    Initialize the detectron2 logger and set its verbosity level to "DEBUG".
+    Args:
+        output (str): a file name or a directory to save log. If None, will not save log file.
+            If ends with ".txt" or ".log", assumed to be a file name.
+            Otherwise, logs will be saved to `output/log.txt`.
+        abbrev_name (str): an abbreviation of the module, to avoid long names in logs.
+            Set to "" to not log the root module in logs.
+            By default, will abbreviate "detectron2" to "d2" and leave other
+            modules unchanged.
+    Returns:
+        logging.Logger: a logger
+    """
+    logger = logging.getLogger()
+    logger.setLevel(logging.DEBUG)
+    logger.propagate = False
+
+    if abbrev_name is None:
+        abbrev_name = "d2" 
+
+    plain_formatter = logging.Formatter(
+        "[%(asctime)s] %(name)s %(levelname)s: %(message)s", datefmt="%m/%d %H:%M:%S"
+    )
+    # stdout logging: master only
+    if distributed_rank == 0:
+        ch = logging.StreamHandler(stream=sys.stdout)
+        ch.setLevel(logging.DEBUG)
+        if color:
+            formatter = _ColorfulFormatter(
+                colored("[%(asctime)s %(name)s]: ", "green") + "%(message)s",
+                datefmt="%m/%d %H:%M:%S",
+                root_name=name,
+                abbrev_name=str(abbrev_name),
+            )
+        else:
+            formatter = plain_formatter
+        ch.setFormatter(formatter)
+        logger.addHandler(ch)
+
+    # file logging: all workers
+    if output is not None:
+        if output.endswith(".txt") or output.endswith(".log"):
+            filename = output
+        else:
+            filename = os.path.join(output, "log.txt")
+        if distributed_rank > 0:
+            filename = filename + ".rank{}".format(distributed_rank)
+        os.makedirs(os.path.dirname(filename), exist_ok=True)
+
+        # fh = logging.FileHandler(output, 'w')
+        fh = logging.StreamHandler(_cached_log_stream(filename))
+        fh.setLevel(logging.DEBUG)
+        fh.setFormatter(plain_formatter)
+        logger.addHandler(fh)
+
+
+    return logger
+
+
+from iopath.common.file_io import PathManager as PathManagerBase
+
+
+
+PathManager = PathManagerBase()
+
+# cache the opened file object, so that different calls to `setup_logger`
+# with the same file name can safely write to the same file.
+def _cached_log_stream(filename):
+    # use 1K buffer if writing to cloud storage
+    io = PathManager.open(filename, "a", buffering=1024 if "://" in filename else -1)
+    atexit.register(io.close)
+    return io

external/Metric3D/training/mono/utils/logit_to_depth.py

@@ -0,0 +1,58 @@
+import torch
+import torch.nn as nn
+
+class SoftWeight(nn.Module):
+    """
+    Transfer n-channel discrete depth bins to a depth map.
+    Args:
+        @depth_bin: n-channel output of the network, [b, c, h, w]
+    Return: 1-channel depth, [b, 1, h, w]
+    """
+    def __init__(self, depth_bins_border):
+        super(SoftWeight, self).__init__()
+        self.register_buffer("depth_bins_border", torch.tensor(depth_bins_border), persistent=False)
+
+    def forward(self, pred_logit):
+        if type(pred_logit).__module__ != torch.__name__:
+            pred_logit = torch.tensor(pred_logit, dtype=torch.float32, device="cuda")
+        pred_score = nn.functional.softmax(pred_logit, dim=1)
+        pred_score_ch = pred_score.permute(0, 2, 3, 1) #[b, h, w, c]
+        pred_score_weight = pred_score_ch * self.depth_bins_border
+        depth_log = torch.sum(pred_score_weight, dim=3, dtype=torch.float32, keepdim=True)
+        depth = 10 ** depth_log
+        depth = depth.permute(0, 3, 1, 2)  # [b, 1, h, w]
+        confidence, _ = torch.max(pred_logit, dim=1, keepdim=True)
+        return depth, confidence
+
+def soft_weight(pred_logit, depth_bins_border):
+    """
+    Transfer n-channel discrete depth bins to depth map.
+    Args:
+        @depth_bin: n-channel output of the network, [b, c, h, w]
+    Return: 1-channel depth, [b, 1, h, w]
+    """
+    if type(pred_logit).__module__ != torch.__name__:
+        pred_logit = torch.tensor(pred_logit, dtype=torch.float32, device="cuda")
+    if type(depth_bins_border).__module__ != torch.__name__:
+        depth_bins_border = torch.tensor(depth_bins_border, dtype=torch.float32, device="cuda")
+
+    pred_score = nn.functional.softmax(pred_logit, dim=1)
+    depth_bins_ch = pred_score.permute(0, 2, 3, 1) #[b, h, w, c]    depth = torch.sum(depth, dim=3, dtype=torch.float32, keepdim=True)
+    depth = 10 ** depth
+    depth = depth.permute(0, 3, 1, 2)  # [b, 1, h, w]
+
+    confidence, _ = torch.max(pred_logit, dim=1, keepdim=True)
+    return depth, confidence
+
+
+
+if __name__ == '__main__':
+    import numpy as np
+    depth_max = 100
+    depth_min = 0.5
+
+    depth_bin_interval = (np.log10(depth_max) - np.log10(depth_min)) / 200
+    depth_bins_border = [np.log10(depth_min) + depth_bin_interval * (i + 0.5)
+                     for i in range(200)]
+    
+    sw = SoftWeight(depth_bins_border)

external/Metric3D/training/mono/utils/misc.py

@@ -0,0 +1,67 @@
+
+
+
+import os
+import torch
+try:
+    from torch._six import inf
+except:
+    from torch import inf
+
+
+class NativeScalerWithGradNormCount:
+    state_dict_key = "amp_scaler"
+
+    def __init__(self):
+        #self._scaler = torch.cuda.amp.GradScaler(init_scale=16384) #init_scale=4096.0
+        self._scaler = torch.cuda.amp.GradScaler(init_scale=1)
+
+    def __call__(self, loss, optimizer, clip_grad=None, parameters=None, create_graph=False, update_grad=True):
+        self._scaler.scale(loss).backward(create_graph=create_graph)
+        if update_grad:
+            if clip_grad is not None:
+                assert parameters is not None
+                self._scaler.unscale_(optimizer)  # unscale the gradients of optimizer's assigned params in-place
+                try:
+                    norm = torch.nn.utils.clip_grad_norm_(parameters, clip_grad, error_if_nonfinite=True)
+                except:
+                    print('NAN gradient ....')
+            else:
+                raise NotImplementedError
+                self._scaler.unscale_(optimizer)
+                norm = get_grad_norm_(parameters)
+            self._scaler.step(optimizer)
+            self._scaler.update()
+        else:
+            norm = None
+        return True
+        #return norm
+
+    def state_dict(self):
+        return self._scaler.state_dict()
+
+    def load_state_dict(self, state_dict):
+        self._scaler.load_state_dict(state_dict)
+
+def get_grad_norm_(parameters, norm_type: float = 2.0) -> torch.Tensor:
+    if isinstance(parameters, torch.Tensor):
+        parameters = [parameters]
+    parameters = [p for p in parameters if p.grad is not None]
+    norm_type = float(norm_type)
+    if len(parameters) == 0:
+        return torch.tensor(0.)
+    device = parameters[0].grad.device
+    if norm_type == inf:
+        total_norm = max(p.grad.detach().abs().max().to(device) for p in parameters)
+    else:
+        total_norm = torch.norm(torch.stack([torch.norm(p.grad.detach(), norm_type).to(device) for p in parameters]), norm_type)
+    return total_norm
+
+def is_bf16_supported():
+    """Returns a bool indicating if the current CUDA device supports dtype bfloat16"""
+    cu_vers = torch.version.cuda
+    if cu_vers is not None:
+        cuda_maj_decide = int(cu_vers.split('.')[0]) >= 11
+    else:
+        cuda_maj_decide = False
+    return torch.cuda.get_device_properties(torch.cuda.current_device()).major >= 8 and cuda_maj_decide

external/Metric3D/training/mono/utils/pcd_utils.py

@@ -0,0 +1,52 @@
+import os
+import numpy as np
+from plyfile import PlyData, PlyElement
+
+
+def save_point_cloud(pcd, rgb, filename, binary=True):
+    """Save an RGB point cloud as a PLY file.
+    :paras
+      @pcd: Nx3 matrix, the XYZ coordinates
+      @rgb: NX3 matrix, the rgb colors for each 3D point
+    """
+    assert pcd.shape[0] == rgb.shape[0]
+
+    if rgb is None:
+        gray_concat = np.tile(np.array([128], dtype=np.uint8), (pcd.shape[0], 3))
+        points_3d = np.hstack((pcd, gray_concat))
+    else:
+        points_3d = np.hstack((pcd, rgb))
+    python_types = (float, float, float, int, int, int)
+    npy_types = [('x', 'f4'), ('y', 'f4'), ('z', 'f4'), ('red', 'u1'), ('green', 'u1'),
+                 ('blue', 'u1')]
+    if binary is True:
+        # Format into NumPy structured array
+        vertices = []
+        for row_idx in range(points_3d.shape[0]):
+            cur_point = points_3d[row_idx]
+            vertices.append(tuple(dtype(point) for dtype, point in zip(python_types, cur_point)))
+        vertices_array = np.array(vertices, dtype=npy_types)
+        el = PlyElement.describe(vertices_array, 'vertex')
+
+         # Write
+        PlyData([el]).write(filename)
+    else:
+        x = np.squeeze(points_3d[:, 0])
+        y = np.squeeze(points_3d[:, 1])
+        z = np.squeeze(points_3d[:, 2])
+        r = np.squeeze(points_3d[:, 3])
+        g = np.squeeze(points_3d[:, 4])
+        b = np.squeeze(points_3d[:, 5])
+
+        ply_head = 'ply\n' \
+                   'format ascii 1.0\n' \
+                   'element vertex %d\n' \
+                   'property float x\n' \
+                   'property float y\n' \
+                   'property float z\n' \
+                   'property uchar red\n' \
+                   'property uchar green\n' \
+                   'property uchar blue\n' \
+                   'end_header' % r.shape[0]
+        # ---- Save ply data to disk
+        np.savetxt(filename, np.column_stack((x, y, z, r, g, b)), fmt="%d %d %d %d %d %d", header=ply_head, comments='')

external/Metric3D/training/mono/utils/running.py

@@ -0,0 +1,374 @@
+import os
+import torch
+import torch.nn as nn
+from mono.utils.comm import main_process
+import copy
+import inspect
+import logging
+import glob
+
+class LrUpdater():
+    """Refer to LR Scheduler in MMCV.
+    Args:
+        @by_epoch (bool): LR changes epoch by epoch
+        @warmup (string): Type of warmup used. It can be None(use no warmup),
+            'constant', 'linear' or 'exp'
+        @warmup_iters (int): The number of iterations or epochs that warmup
+            lasts. Note when by_epoch == True, warmup_iters means the number 
+            of epochs that warmup lasts, otherwise means the number of 
+            iteration that warmup lasts
+        @warmup_ratio (float): LR used at the beginning of warmup equals to
+            warmup_ratio * initial_lr
+        @runner (dict): Configs for running. Run by epoches or iters.
+    """
+
+    def __init__(self,
+                 by_epoch: bool=True,
+                 warmup: str=None,
+                 warmup_iters: int=0,
+                 warmup_ratio: float=0.1,
+                 runner: dict={}):
+        # validate the "warmup" argument
+        if warmup is not None:
+            if warmup not in ['constant', 'linear', 'exp']:
+                raise ValueError(
+                    f'"{warmup}" is not a supported type for warming up, valid'
+                    ' types are "constant" and "linear"')
+        if warmup is not None:
+            assert warmup_iters > 0, \
+                '"warmup_iters" must be a positive integer'
+            assert 0 < warmup_ratio <= 1.0, \
+                '"warmup_ratio" must be in range (0,1]'
+        
+        if runner is None:
+            raise RuntimeError('runner should be set.')
+
+        self.by_epoch = by_epoch
+        self.warmup = warmup
+        self.warmup_iters = warmup_iters
+        self.warmup_ratio = warmup_ratio
+        self.runner = runner
+
+        self.max_iters = None
+        self.max_epoches = None
+        if 'IterBasedRunner' in self.runner.type:
+            self.max_iters = self.runner.max_iters
+            assert self.by_epoch==False
+            self.warmup_by_epoch = False
+        elif 'EpochBasedRunner' in self.runner.type:
+            self.max_epoches = self.runner.max_epoches
+            assert self.by_epoch==True
+            self.warmup_by_epoch = True
+        else:
+            raise ValueError(f'{self.runner.type} is not a supported type for running.')
+        
+        if self.warmup_by_epoch:
+            self.warmup_epochs = self.warmup_iters
+            self.warmup_iters = None
+        else:
+            self.warmup_epochs = None
+
+        self.base_lr = []  # initial lr for all param groups
+        self.regular_lr = []  # expected lr if no warming up is performed
+        self._step_count = 0
+
+    def _set_lr(self, optimizer, lr_groups):
+        if isinstance(optimizer, dict):
+            for k, optim in optimizer.items():
+                for param_group, lr in zip(optim.param_groups, lr_groups[k]):
+                    param_group['lr'] = lr
+        else:
+            for param_group, lr in zip(optimizer.param_groups,
+                                       lr_groups):
+                param_group['lr'] = lr
+
+    def get_lr(self, _iter, max_iter, base_lr):
+        raise NotImplementedError
+
+    def get_regular_lr(self, _iter, optimizer):
+        max_iters = self.max_iters if not self.by_epoch else self.max_epoches
+
+        if isinstance(optimizer, dict):
+            lr_groups = {}
+            for k in optimizer.keys():
+                _lr_group = [
+                    self.get_lr(_iter, max_iters,  _base_lr)
+                    for _base_lr in self.base_lr[k]
+                ]
+                lr_groups.update({k: _lr_group})
+
+            return lr_groups
+        else:
+            return [self.get_lr(_iter, max_iters, _base_lr) for _base_lr in self.base_lr]
+
+    def get_warmup_lr(self, cur_iters):
+
+        def _get_warmup_lr(cur_iters, regular_lr):
+            if self.warmup == 'constant':
+                warmup_lr = [_lr * self.warmup_ratio for _lr in regular_lr]
+            elif self.warmup == 'linear':
+                k = (1 - cur_iters / self.warmup_iters) * (1 -
+                                                           self.warmup_ratio)
+                warmup_lr = [_lr * (1 - k) for _lr in regular_lr]
+            elif self.warmup == 'exp':
+                k = self.warmup_ratio**(1 - cur_iters / self.warmup_iters)
+                warmup_lr = [_lr * k for _lr in regular_lr]
+            return warmup_lr
+
+        if isinstance(self.regular_lr, dict):
+            lr_groups = {}
+            for key, regular_lr in self.regular_lr.items():
+                lr_groups[key] = _get_warmup_lr(cur_iters, regular_lr)
+            return lr_groups
+        else:
+            return _get_warmup_lr(cur_iters, self.regular_lr)
+
+    def before_run(self, optimizer):
+        # NOTE: when resuming from a checkpoint, if 'initial_lr' is not saved,
+        # it will be set according to the optimizer params
+        if isinstance(optimizer, dict):
+            self.base_lr = {}
+            for k, optim in optimizer.items():
+                for group in optim.param_groups:
+                    group.setdefault('initial_lr', group['lr'])
+                _base_lr = [
+                    group['initial_lr'] for group in optim.param_groups
+                ]
+                self.base_lr.update({k: _base_lr})
+        else:
+            for group in optimizer.param_groups:
+                group.setdefault('initial_lr', group['lr'])
+            self.base_lr = [
+                group['initial_lr'] for group in optimizer.param_groups
+            ]
+
+    def after_train_epoch(self, optimizer):
+        self._step_count += 1
+        curr_epoch = self._step_count
+        self.regular_lr = self.get_regular_lr(curr_epoch, optimizer)
+        if self.warmup is None or curr_epoch > self.warmup_epoches:
+            self._set_lr(optimizer, self.regular_lr)
+        else:
+            #self.warmup_iters = int(self.warmup_epochs * epoch_len)
+            warmup_lr = self.get_warmup_lr(curr_epoch)
+            self._set_lr(optimizer, warmup_lr)
+
+    def after_train_iter(self, optimizer):
+        self._step_count += 1
+        cur_iter = self._step_count
+        self.regular_lr = self.get_regular_lr(cur_iter, optimizer)
+        if self.warmup is None or cur_iter >= self.warmup_iters:
+            self._set_lr(optimizer, self.regular_lr)
+        else:
+            warmup_lr = self.get_warmup_lr(cur_iter)
+            self._set_lr(optimizer, warmup_lr)
+
+    def get_curr_lr(self, cur_iter):
+        if self.warmup is None or cur_iter >= self.warmup_iters:
+            return self.regular_lr
+        else:
+            return self.get_warmup_lr(cur_iter)
+    
+    def state_dict(self):
+        """
+        Returns the state of the scheduler as a :class:`dict`.
+        It contains an entry for every variable in self.__dict__ which
+        is not the optimizer.
+        """
+        return {key: value for key, value in self.__dict__.items() if key != 'optimizer'}
+
+    def load_state_dict(self, state_dict):
+        """Loads the schedulers state.
+
+        Args:
+            @state_dict (dict): scheduler state. Should be an object returned
+                from a call to :meth:`state_dict`.
+        """
+        self.__dict__.update(state_dict)
+
+
+class PolyLrUpdater(LrUpdater):
+
+    def __init__(self, power=1., min_lr=0., **kwargs):
+        self.power = power
+        self.min_lr = min_lr
+        super(PolyLrUpdater, self).__init__(**kwargs)
+
+    def get_lr(self, _iter, max_iters, base_lr):
+        progress = _iter
+        max_progress = max_iters
+        coeff = (1 - progress / max_progress)**self.power
+        return (base_lr - self.min_lr) * coeff + self.min_lr
+
+
+def build_lr_schedule_with_cfg(cfg):
+    # build learning rate schedule with config.
+    lr_config = copy.deepcopy(cfg.lr_config)
+    policy = lr_config.pop('policy')
+    if cfg.lr_config.policy == 'poly':
+        schedule = PolyLrUpdater(runner=cfg.runner, **lr_config)
+    else:
+        raise RuntimeError(f'{cfg.lr_config.policy} \
+                            is not supported in this framework.')
+    return schedule
+  
+
+#def step_learning_rate(base_lr, epoch, step_epoch, multiplier=0.1):
+#    """Sets the learning rate to the base LR decayed by 10 every step epochs"""
+#    lr = base_lr * (multiplier ** (epoch // step_epoch))
+#    return lr
+
+def register_torch_optimizers():
+    torch_optimizers = {}
+    for module_name in dir(torch.optim):
+        if module_name.startswith('__'):
+            continue
+        _optim = getattr(torch.optim, module_name)
+        if inspect.isclass(_optim) and issubclass(_optim,
+                                                  torch.optim.Optimizer):
+            torch_optimizers[module_name] = _optim
+    return torch_optimizers
+
+
+TORCH_OPTIMIZER = register_torch_optimizers()
+
+def build_optimizer_with_cfg(cfg, model):
+    # encoder_parameters = []
+    # decoder_parameters = []
+    # nongrad_parameters = []
+    # for key, value in dict(model.named_parameters()).items():
+    #     if value.requires_grad:
+    #         if 'encoder' in key:
+    #             encoder_parameters.append(value)
+    #         else:
+    #             decoder_parameters.append(value)
+    #     else:
+    #         nongrad_parameters.append(value)
+
+    #params = [{"params": filter(lambda p: p.requires_grad, model.parameters())}]
+    optim_cfg = copy.deepcopy(cfg.optimizer)
+    optim_type = optim_cfg.pop('type', None)
+    
+    if optim_type is None:
+        raise RuntimeError(f'{optim_type} is not set')
+    if optim_type not in TORCH_OPTIMIZER:
+        raise RuntimeError(f'{optim_type} is not supported in torch {torch.__version__}')
+    if 'others' not in optim_cfg:
+        optim_cfg['others'] = optim_cfg['decoder']
+
+    def match(key1, key_list, strict_match=False):
+        if not strict_match:
+            for k in key_list:
+                if k in key1:
+                    return k
+        else:
+            for k in key_list:
+                if k == key1.split('.')[1]:
+                    return k        
+        return None
+    optim_obj = TORCH_OPTIMIZER[optim_type]
+    matching_type = optim_cfg.pop('strict_match', False)
+
+    module_names = optim_cfg.keys()
+    model_parameters = {i: [] for i in module_names}
+    model_parameters['others'] = []
+    nongrad_parameters = []
+    for key, value in dict(model.named_parameters()).items():
+        if value.requires_grad:
+            match_key =  match(key, module_names, matching_type)
+            # if optim_cfg[match_key]['lr'] == 0:
+            #     value.requires_grad=False
+            #     continue
+            if match_key is None:
+                model_parameters['others'].append(value)
+            else:
+                model_parameters[match_key].append(value)
+        else:
+            nongrad_parameters.append(value)
+
+    optims = [{'params':model_parameters[k], **optim_cfg[k]} for k in optim_cfg.keys()]
+    optimizer = optim_obj(optims)
+    # optim_args_encoder = optim_cfg.optimizer.encoder
+    # optim_args_decoder = optim_cfg.optimizer.decoder
+    # optimizer = optim_obj(
+    #     [{'params':encoder_parameters, **optim_args_encoder},
+    #     {'params':decoder_parameters, **optim_args_decoder},
+    # ])
+
+    return optimizer
+
+
+def load_ckpt(load_path, model, optimizer=None, scheduler=None, strict_match=True, loss_scaler=None): 
+    """
+        Load the check point for resuming training or finetuning.
+    """
+    logger = logging.getLogger()
+    if os.path.isfile(load_path):
+        if main_process():
+            logger.info(f"Loading weight '{load_path}'")
+        checkpoint = torch.load(load_path, map_location="cpu")
+        ckpt_state_dict = checkpoint['model_state_dict']
+        model.module.load_state_dict(ckpt_state_dict, strict=strict_match)
+
+        if optimizer is not None:
+            optimizer.load_state_dict(checkpoint['optimizer'])
+        if scheduler is not None:
+            scheduler.load_state_dict(checkpoint['scheduler'])
+        if loss_scaler is not None and 'scaler' in checkpoint:
+            loss_scaler.load_state_dict(checkpoint['scaler'])
+            print('Loss scaler loaded', loss_scaler)
+        del ckpt_state_dict
+        del checkpoint
+        if main_process():
+            logger.info(f"Successfully loaded weight: '{load_path}'")
+            if scheduler is not None and optimizer is not None:
+                logger.info(f"Resume training from: '{load_path}'")
+    else:
+        if main_process():
+            raise RuntimeError(f"No weight found at '{load_path}'")
+    return model, optimizer, scheduler, loss_scaler
+
+
+def save_ckpt(cfg, model, optimizer, scheduler, curr_iter=0, curr_epoch=None, loss_scaler=None):
+    """
+        Save the model, optimizer, lr scheduler.
+    """
+    logger = logging.getLogger()
+
+    if 'IterBasedRunner' in cfg.runner.type:
+        max_iters = cfg.runner.max_iters
+    elif 'EpochBasedRunner' in cfg.runner.type:
+        max_iters = cfg.runner.max_epoches    
+    else:
+        raise TypeError(f'{cfg.runner.type} is not supported')
+
+    ckpt = dict(model_state_dict=model.module.state_dict(),
+                optimizer=optimizer.state_dict(),
+                max_iter=cfg.runner.max_iters if 'max_iters' in cfg.runner \
+                         else cfg.runner.max_epoches,
+                scheduler=scheduler.state_dict(),
+                # current_iter=curr_iter,
+                # current_epoch=curr_epoch,
+                )
+    if loss_scaler is not None:
+        # amp state_dict
+        ckpt.update(dict(scaler=loss_scaler.state_dict()))
+
+    ckpt_dir = os.path.join(cfg.work_dir, 'ckpt')
+    os.makedirs(ckpt_dir, exist_ok=True)
+    
+    save_name = os.path.join(ckpt_dir, 'step%08d.pth' % curr_iter)
+    saved_ckpts = glob.glob(ckpt_dir + '/step*.pth')
+    torch.save(ckpt, save_name)
+
+    # keep the last 8 ckpts
+    if len(saved_ckpts) > 8:
+        saved_ckpts.sort()
+        os.remove(saved_ckpts.pop(0))
+
+    logger.info(f'Save model: {save_name}')
+
+
+
+if __name__ == '__main__':
+    print(TORCH_OPTIMIZER)

external/Metric3D/training/mono/utils/transform.py

@@ -0,0 +1,1491 @@
+#import collections
+import collections.abc as collections
+import cv2
+import math
+import numpy as np
+import numbers
+import random
+import torch
+from imgaug import augmenters as iaa
+import matplotlib
+import matplotlib.cm
+import mono.utils.weather_aug_utils as wa
+
+"""
+Provides a set of Pytorch transforms that use OpenCV instead of PIL (Pytorch default)
+for image manipulation.
+"""
+
+class Compose(object):
+    # Composes transforms: transforms.Compose([transforms.RandScale([0.5, 2.0]), transforms.ToTensor()])
+    def __init__(self, transforms):
+        self.transforms = transforms
+
+    def __call__(self, images, labels, intrinsics, cam_models=None, normals=None, other_labels=None, transform_paras=None):
+        for t in self.transforms:
+            images, labels, intrinsics, cam_models, normals, other_labels, transform_paras = t(images, labels, intrinsics, cam_models, normals, other_labels, transform_paras)
+        return images, labels, intrinsics, cam_models, normals, other_labels, transform_paras
+
+class ToTensor(object):
+    # Converts numpy.ndarray (H x W x C) to a torch.FloatTensor of shape (C x H x W).
+    def __init__(self,  **kwargs):
+        return
+    def __call__(self, images, labels, intrinsics, cam_models=None, normals=None, other_labels=None, transform_paras=None):
+        if not isinstance(images, list) or not isinstance(labels, list) or not isinstance(intrinsics, list):
+            raise (RuntimeError("transform.ToTensor() only handle inputs/labels/intrinsics lists."))
+        if len(images) != len(intrinsics):
+            raise (RuntimeError("Numbers of images and intrinsics are not matched."))
+        if not isinstance(images[0], np.ndarray) or not isinstance(labels[0], np.ndarray):
+            raise (RuntimeError("transform.ToTensor() only handle np.ndarray for the input and label."
+                                "[eg: data readed by cv2.imread()].\n"))
+        if  not isinstance(intrinsics[0], list):
+            raise (RuntimeError("transform.ToTensor() only handle list for the camera intrinsics"))
+
+        if len(images[0].shape) > 3 or len(images[0].shape) < 2:
+            raise (RuntimeError("transform.ToTensor() only handle image(np.ndarray) with 3 dims or 2 dims.\n"))
+        if len(labels[0].shape) > 3 or len(labels[0].shape) < 2:
+            raise (RuntimeError("transform.ToTensor() only handle label(np.ndarray) with 3 dims or 2 dims.\n"))
+
+        if len(intrinsics[0]) >4 or len(intrinsics[0]) < 3:
+            raise (RuntimeError("transform.ToTensor() only handle intrinsic(list) with 3 sizes or 4 sizes.\n"))
+        
+        for i, img in enumerate(images):
+            if len(img.shape) == 2:
+                img = np.expand_dims(img, axis=2)
+            images[i] = torch.from_numpy(img.transpose((2, 0, 1))).float()
+        for i, lab in enumerate(labels):
+            if len(lab.shape) == 2:
+                lab = np.expand_dims(lab, axis=0)
+            labels[i] = torch.from_numpy(lab).float()
+        for i, intrinsic in enumerate(intrinsics):
+            if len(intrinsic) == 3:
+                intrinsic = [intrinsic[0],] + intrinsic
+            intrinsics[i] = torch.tensor(intrinsic, dtype=torch.float)
+        if cam_models is not None:
+            for i, cam_model in enumerate(cam_models):
+                cam_models[i] = torch.from_numpy(cam_model.transpose((2, 0, 1))).float() if cam_model is not None else None
+        if normals is not None:
+            for i, normal in enumerate(normals):
+                normals[i] = torch.from_numpy(normal.transpose((2, 0, 1))).float()
+        if other_labels is not None:
+            for i, lab in enumerate(other_labels):
+                if len(lab.shape) == 2:
+                    lab = np.expand_dims(lab, axis=0)
+                other_labels[i] = torch.from_numpy(lab).float()
+        return images, labels, intrinsics, cam_models, normals, other_labels, transform_paras
+
+class Normalize(object):
+    # Normalize tensor with mean and standard deviation along channel: channel = (channel - mean) / std
+    def __init__(self, mean, std=None, **kwargs):
+        if std is None:
+            assert len(mean) > 0
+        else:
+            assert len(mean) == len(std)
+        self.mean = torch.tensor(mean).float()[:, None, None]
+        self.std = torch.tensor(std).float()[:, None, None] if std is not None \
+            else torch.tensor([1.0, 1.0, 1.0]).float()[:, None, None]
+
+    def __call__(self, images, labels, intrinsics, cam_models=None, normals=None, other_labels=None, transform_paras=None):
+        # if self.std is None:
+        #     # for t, m in zip(image, self.mean):
+        #     #     t.sub(m)
+        #     image = image - self.mean
+        #     if ref_images is not None:
+        #         for i, ref_i in enumerate(ref_images):
+        #             ref_images[i] =  ref_i - self.mean
+        # else:
+        #     # for t, m, s in zip(image, self.mean, self.std):
+        #     #     t.sub(m).div(s)
+        #     image = (image - self.mean) / self.std
+        #     if ref_images is not None:
+        #         for i, ref_i in enumerate(ref_images):
+        #             ref_images[i] =  (ref_i - self.mean) / self.std
+        for i, img in enumerate(images):
+            img = torch.div((img - self.mean), self.std)
+            images[i] = img
+        return images, labels, intrinsics, cam_models, normals, other_labels, transform_paras
+
+class ResizeCanonical(object):
+    """
+    Resize the input to the canonical space first, then resize the input with random sampled size.
+    In the first stage, we assume the distance holds while the camera model varies. 
+    In the second stage, we aim to simulate the observation in different distance. The camera will move along the optical axis.
+    Args:
+        images: list of RGB images.
+        labels: list of depth/disparity labels.
+        other labels: other labels, such as instance segmentations, semantic segmentations...
+    """
+    def __init__(self, **kwargs):
+        self.ratio_range = kwargs['ratio_range']
+        self.canonical_focal = kwargs['focal_length']
+        self.crop_size = kwargs['crop_size']
+    
+    def random_on_canonical_transform(self, image, label, intrinsic, cam_model, to_random_ratio):
+        ori_h, ori_w, _ = image.shape
+        ori_focal = (intrinsic[0] + intrinsic[1]) / 2.0
+
+        to_canonical_ratio = self.canonical_focal / ori_focal
+        to_scale_ratio = to_random_ratio
+        resize_ratio = to_canonical_ratio * to_random_ratio
+        reshape_h = int(ori_h * resize_ratio + 0.5)
+        reshape_w = int(ori_w * resize_ratio + 0.5)
+
+        image = cv2.resize(image, dsize=(reshape_w, reshape_h), interpolation=cv2.INTER_LINEAR)
+        if intrinsic is not None:
+            intrinsic = [self.canonical_focal, self.canonical_focal, intrinsic[2]*resize_ratio, intrinsic[3]*resize_ratio]
+        if label is not None:
+            # number of other labels may be less than that of image
+            label = cv2.resize(label, dsize=(reshape_w, reshape_h), interpolation=cv2.INTER_NEAREST)
+            # scale the label and camera intrinsics
+            label = label / to_scale_ratio
+        
+        if cam_model is not None:
+            # Should not directly resize the cam_model.
+            # Camera model should be resized in 'to canonical' stage, while it holds in 'random resizing' stage. 
+            # cam_model = cv2.resize(cam_model, dsize=(reshape_w, reshape_h), interpolation=cv2.INTER_LINEAR)
+            cam_model = build_camera_model(reshape_h, reshape_w, intrinsic)
+        
+        return image, label, intrinsic, cam_model, to_scale_ratio       
+    
+    def random_on_crop_transform(self, image, label, intrinsic, cam_model, to_random_ratio):
+        ori_h, ori_w, _ = image.shape
+        crop_h, crop_w = self.crop_size
+        ori_focal = (intrinsic[0] + intrinsic[1]) / 2.0
+
+        to_canonical_ratio = self.canonical_focal / ori_focal
+        
+        # random resize based on the last crop size
+        proposal_reshape_h = int(crop_h * to_random_ratio + 0.5) 
+        proposal_reshape_w = int(crop_w * to_random_ratio + 0.5)
+        resize_ratio_h = proposal_reshape_h / ori_h
+        resize_ratio_w = proposal_reshape_w / ori_w
+        resize_ratio = min(resize_ratio_h, resize_ratio_w) # resize based on the long edge
+        reshape_h = int(ori_h * resize_ratio + 0.5)
+        reshape_w = int(ori_w * resize_ratio + 0.5)
+        
+        to_scale_ratio = resize_ratio / to_canonical_ratio        
+
+        image = cv2.resize(image, dsize=(reshape_w, reshape_h), interpolation=cv2.INTER_LINEAR)
+        if intrinsic is not None:
+            intrinsic = [self.canonical_focal, self.canonical_focal, intrinsic[2]*resize_ratio, intrinsic[3]*resize_ratio]
+        if label is not None:
+            # number of other labels may be less than that of image
+            label = cv2.resize(label, dsize=(reshape_w, reshape_h), interpolation=cv2.INTER_NEAREST)
+            # scale the label and camera intrinsics
+            label = label / to_scale_ratio
+        
+        if cam_model is not None:
+            # Should not directly resize the cam_model.
+            # Camera model should be resized in 'to canonical' stage, while it holds in 'random resizing' stage. 
+            # cam_model = cv2.resize(cam_model, dsize=(reshape_w, reshape_h), interpolation=cv2.INTER_LINEAR)
+            cam_model = build_camera_model(reshape_h, reshape_w, intrinsic)
+        return image, label, intrinsic, cam_model, to_scale_ratio       
+
+    def __call__(self, images, labels, intrinsics, cam_models=None, normals=None, other_labels=None, transform_paras=None):
+        assert len(images[0].shape) == 3 and len(labels[0].shape) == 2
+        assert labels[0].dtype == np.float
+        target_focal = (intrinsics[0][0] + intrinsics[0][1]) / 2.0
+        target_to_canonical_ratio = self.canonical_focal / target_focal
+        target_img_shape = images[0].shape
+        to_random_ratio = random.uniform(self.ratio_range[0], self.ratio_range[1])
+        to_scale_ratio = 0.0
+        for i in range(len(images)):
+            img = images[i]
+            label = labels[i] if i < len(labels) else None
+            intrinsic = intrinsics[i] if i < len(intrinsics) else None
+            cam_model = cam_models[i] if cam_models is not None and i < len(cam_models) else None
+            img, label, intrinsic, cam_model, to_scale_ratio = self.random_on_canonical_transform(
+                img, label, intrinsic, cam_model, to_random_ratio)
+                
+            images[i] = img
+            if label is not None:
+                labels[i] = label
+            if intrinsic is not None:
+                intrinsics[i] = intrinsic
+            if cam_model is not None:
+                cam_models[i] = cam_model 
+
+        if normals != None:
+            reshape_h, reshape_w, _ = images[0].shape
+            for i, normal in enumerate(normals):
+                normals[i] = cv2.resize(normal, dsize=(reshape_w, reshape_h), interpolation=cv2.INTER_NEAREST)
+                
+        if other_labels != None: 
+            # other labels are like semantic segmentations, instance segmentations, instance planes segmentations...           
+            #resize_ratio = target_to_canonical_ratio * to_scale_ratio
+            #reshape_h = int(target_img_shape[0] * resize_ratio + 0.5)
+            #reshape_w = int(target_img_shape[1] * resize_ratio + 0.5)
+            reshape_h, reshape_w, _ = images[0].shape
+            for i, other_label_i in enumerate(other_labels):
+                other_labels[i] = cv2.resize(other_label_i, dsize=(reshape_w, reshape_h), interpolation=cv2.INTER_NEAREST)
+        
+        if transform_paras is not None:
+            transform_paras.update(label_scale_factor = 1.0/to_scale_ratio)
+
+        return images, labels, intrinsics, cam_models, normals, other_labels, transform_paras
+
+
+class LabelScaleCononical(object):
+    """
+    To solve the ambiguity observation for the mono branch, i.e. different focal length (object size) with the same depth, cameras are
+    mapped to a cononical space. To mimic this, we set the focal length to a canonical one and scale the depth value. NOTE: resize the image based on the ratio can also solve this ambiguity.
+    Args:
+        images: list of RGB images.
+        labels: list of depth/disparity labels.
+        other labels: other labels, such as instance segmentations, semantic segmentations...
+    """
+    def __init__(self, **kwargs):
+        self.canonical_focal = kwargs['focal_length']
+    
+    def _get_scale_ratio(self, intrinsic):
+        target_focal_x = intrinsic[0]
+        label_scale_ratio = self.canonical_focal / target_focal_x
+        pose_scale_ratio = 1.0
+        return label_scale_ratio, pose_scale_ratio
+        
+    def __call__(self, images, labels, intrinsics, cam_models=None, normals=None, other_labels=None, transform_paras=None):
+        assert len(images[0].shape) == 3 and len(labels[0].shape) == 2
+        #assert labels[0].dtype == np.float
+
+        label_scale_ratio = None
+        pose_scale_ratio = None
+        
+        for i in range(len(intrinsics)): 
+            img_i = images[i]
+            label_i = labels[i] if  i < len(labels) else None
+            intrinsic_i = intrinsics[i].copy()
+            cam_model_i = cam_models[i] if cam_models is not None and i < len(cam_models) else None
+            
+            label_scale_ratio, pose_scale_ratio = self._get_scale_ratio(intrinsic_i)
+            
+            # adjust the focal length, map the current camera to the canonical space
+            intrinsics[i] = [intrinsic_i[0]*label_scale_ratio, intrinsic_i[1]*label_scale_ratio, intrinsic_i[2], intrinsic_i[3]]
+            
+            # scale the label to the canonical space
+            if label_i is not None:
+                labels[i] = label_i * label_scale_ratio
+                        
+            if cam_model_i is not None:
+                # As the focal length is adjusted (canonical focal length), the camera model should be re-built.
+                ori_h, ori_w, _ = img_i.shape
+                cam_models[i] = build_camera_model(ori_h, ori_w, intrinsics[i])
+            
+        
+        if transform_paras is not None:
+            transform_paras.update(label_scale_factor = label_scale_ratio)
+
+        return images, labels, intrinsics, cam_models, normals, other_labels, transform_paras
+
+
+
+class ResizeKeepRatio(object):
+    """
+    Resize and pad to a given size. Hold the aspect ratio.
+    This resizing assumes that the camera model remains unchanged.
+    Args:
+        resize_size: predefined output size.
+    """
+    def __init__(self, resize_size, padding=None, ignore_label=-1, **kwargs):
+        if isinstance(resize_size, int):
+            self.resize_h = resize_size
+            self.resize_w = resize_size
+        elif isinstance(resize_size, collections.Iterable) and len(resize_size) == 2 \
+                and isinstance(resize_size[0], int) and isinstance(resize_size[1], int) \
+                and resize_size[0] > 0 and resize_size[1] > 0:
+            self.resize_h = resize_size[0]
+            self.resize_w = resize_size[1]
+        else:
+            raise (RuntimeError("crop size error.\n"))
+        if padding is None:
+            self.padding = padding
+        elif isinstance(padding, list):
+            if all(isinstance(i, numbers.Number) for i in padding):
+                self.padding = padding
+            else:
+                raise (RuntimeError("padding in Crop() should be a number list\n"))
+            if len(padding) != 3:
+                raise (RuntimeError("padding channel is not equal with 3\n"))
+        else:
+            raise (RuntimeError("padding in Crop() should be a number list\n"))
+        if isinstance(ignore_label, int):
+            self.ignore_label = ignore_label
+        else:
+            raise (RuntimeError("ignore_label should be an integer number\n"))
+        self.crop_size = kwargs['crop_size']
+        self.canonical_focal = kwargs['focal_length']
+
+    def main_data_transform(self, image, label, intrinsic, cam_model, resize_ratio, padding, to_scale_ratio):
+        """
+        Resize data first and then do the padding.
+        'label' will be scaled.
+        """
+        h, w, _ = image.shape
+        reshape_h = int(resize_ratio * h)
+        reshape_w = int(resize_ratio * w)
+
+        pad_h, pad_w, pad_h_half, pad_w_half = padding
+        
+        # resize
+        image = cv2.resize(image, dsize=(reshape_w, reshape_h), interpolation=cv2.INTER_LINEAR)
+        # padding
+        image = cv2.copyMakeBorder(
+            image, 
+            pad_h_half, 
+            pad_h - pad_h_half, 
+            pad_w_half, 
+            pad_w - pad_w_half, 
+            cv2.BORDER_CONSTANT, 
+            value=self.padding)
+
+        if label is not None:
+            # label = cv2.resize(label, dsize=(reshape_w, reshape_h), interpolation=cv2.INTER_NEAREST)
+            label = resize_depth_preserve(label, (reshape_h, reshape_w))
+            label = cv2.copyMakeBorder(
+                label, 
+                pad_h_half, 
+                pad_h - pad_h_half, 
+                pad_w_half, 
+                pad_w - pad_w_half, 
+                cv2.BORDER_CONSTANT, 
+                value=self.ignore_label)
+            # scale the label
+            label = label / to_scale_ratio
+        
+        # Resize, adjust principle point
+        if intrinsic is not None:
+            intrinsic[2] = intrinsic[2] * resize_ratio
+            intrinsic[3] = intrinsic[3] * resize_ratio
+
+        if cam_model is not None:
+            #cam_model = cv2.resize(cam_model, dsize=(reshape_w, reshape_h), interpolation=cv2.INTER_LINEAR)
+            cam_model = build_camera_model(reshape_h, reshape_w, intrinsic)
+            cam_model = cv2.copyMakeBorder(
+                cam_model, 
+                pad_h_half, 
+                pad_h - pad_h_half, 
+                pad_w_half, 
+                pad_w - pad_w_half, 
+                cv2.BORDER_CONSTANT, 
+                value=self.ignore_label)
+
+        # Pad, adjust the principle point
+        if intrinsic is not None:
+            intrinsic[2] = intrinsic[2] + pad_w_half
+            intrinsic[3] = intrinsic[3] + pad_h_half
+        return image, label, intrinsic, cam_model
+    
+    def get_label_scale_factor(self, image, intrinsic, resize_ratio):
+        ori_h, ori_w, _ = image.shape
+        crop_h, crop_w = self.crop_size
+        ori_focal = (intrinsic[0] + intrinsic[1]) / 2.0 #intrinsic[0] #
+
+        to_canonical_ratio = self.canonical_focal / ori_focal
+        to_scale_ratio = resize_ratio / to_canonical_ratio 
+        return to_scale_ratio
+        
+    def __call__(self, images, labels, intrinsics, cam_models=None, normals=None, other_labels=None, transform_paras=None):
+        target_h, target_w, _ = images[0].shape
+        resize_ratio_h = self.resize_h / target_h
+        resize_ratio_w = self.resize_w / target_w
+        resize_ratio = min(resize_ratio_h, resize_ratio_w)
+        reshape_h = int(resize_ratio * target_h)
+        reshape_w = int(resize_ratio * target_w)
+        pad_h = max(self.resize_h - reshape_h, 0)
+        pad_w = max(self.resize_w - reshape_w, 0)
+        pad_h_half = int(pad_h / 2)
+        pad_w_half = int(pad_w / 2)
+        
+        pad_info = [pad_h, pad_w, pad_h_half, pad_w_half]
+        to_scale_ratio = self.get_label_scale_factor(images[0], intrinsics[0], resize_ratio)
+
+        for i in range(len(images)):
+            img = images[i]
+            label = labels[i] if i < len(labels) else None
+            intrinsic = intrinsics[i] if i < len(intrinsics) else None
+            cam_model = cam_models[i] if cam_models is not None and i < len(cam_models) else None
+            img, label, intrinsic, cam_model = self.main_data_transform(
+                img, label, intrinsic, cam_model, resize_ratio, pad_info, to_scale_ratio)
+            images[i] = img
+            if label is not None:
+                labels[i] = label
+            if intrinsic is not None:
+                intrinsics[i] = intrinsic
+            if cam_model is not None:
+                cam_models[i] = cam_model 
+        
+        if normals is not None:
+            for i, normal in enumerate(normals):
+                normal =  cv2.resize(normal, dsize=(reshape_w, reshape_h), interpolation=cv2.INTER_NEAREST)
+                # pad
+                normals[i] =  cv2.copyMakeBorder(
+                    normal, 
+                    pad_h_half, 
+                    pad_h - pad_h_half, 
+                    pad_w_half, 
+                    pad_w - pad_w_half, 
+                    cv2.BORDER_CONSTANT, 
+                    value=0)
+
+        if other_labels is not None:
+            
+            for i, other_lab in enumerate(other_labels):
+                # resize
+                other_lab =  cv2.resize(other_lab, dsize=(reshape_w, reshape_h), interpolation=cv2.INTER_NEAREST)
+                # pad
+                other_labels[i] =  cv2.copyMakeBorder(
+                    other_lab, 
+                    pad_h_half, 
+                    pad_h - pad_h_half, 
+                    pad_w_half, 
+                    pad_w - pad_w_half, 
+                    cv2.BORDER_CONSTANT, 
+                    value=self.ignore_label)
+
+
+        if transform_paras is not None:
+            transform_paras.update(pad=[pad_h_half, pad_h - pad_h_half, pad_w_half, pad_w - pad_w_half])
+            if 'label_scale_factor' in transform_paras:
+                transform_paras['label_scale_factor'] = transform_paras['label_scale_factor'] * 1.0 / to_scale_ratio
+            else:
+                transform_paras.update(label_scale_factor=1.0/to_scale_ratio)
+        return images, labels, intrinsics, cam_models, normals, other_labels, transform_paras
+    
+class KeepResizeCanoSize(object):
+    """
+    Resize and pad to a given size. Hold the aspect ratio.
+    This resizing assumes that the camera model remains unchanged.
+    Args:
+        resize_size: predefined output size.
+    """
+    def __init__(self, resize_size, padding=None, ignore_label=-1, **kwargs):
+        if isinstance(resize_size, int):
+            self.resize_h = resize_size
+            self.resize_w = resize_size
+        elif isinstance(resize_size, collections.Iterable) and len(resize_size) == 2 \
+                and isinstance(resize_size[0], int) and isinstance(resize_size[1], int) \
+                and resize_size[0] > 0 and resize_size[1] > 0:
+            self.resize_h = resize_size[0]
+            self.resize_w = resize_size[1]
+        else:
+            raise (RuntimeError("crop size error.\n"))
+        if padding is None:
+            self.padding = padding
+        elif isinstance(padding, list):
+            if all(isinstance(i, numbers.Number) for i in padding):
+                self.padding = padding
+            else:
+                raise (RuntimeError("padding in Crop() should be a number list\n"))
+            if len(padding) != 3:
+                raise (RuntimeError("padding channel is not equal with 3\n"))
+        else:
+            raise (RuntimeError("padding in Crop() should be a number list\n"))
+        if isinstance(ignore_label, int):
+            self.ignore_label = ignore_label
+        else:
+            raise (RuntimeError("ignore_label should be an integer number\n"))
+        self.crop_size = kwargs['crop_size']
+        self.canonical_focal = kwargs['focal_length']
+
+    def main_data_transform(self, image, label, intrinsic, cam_model, resize_ratio, padding, to_scale_ratio):
+        """
+        Resize data first and then do the padding.
+        'label' will be scaled.
+        """
+        h, w, _ = image.shape
+        reshape_h = int(resize_ratio * h)
+        reshape_w = int(resize_ratio * w)
+
+        pad_h, pad_w, pad_h_half, pad_w_half = padding
+        
+        # resize
+        image = cv2.resize(image, dsize=(reshape_w, reshape_h), interpolation=cv2.INTER_LINEAR)
+        # padding
+        image = cv2.copyMakeBorder(
+            image, 
+            pad_h_half, 
+            pad_h - pad_h_half, 
+            pad_w_half, 
+            pad_w - pad_w_half, 
+            cv2.BORDER_CONSTANT, 
+            value=self.padding)
+
+        if label is not None:
+            # label = cv2.resize(label, dsize=(reshape_w, reshape_h), interpolation=cv2.INTER_NEAREST)
+            label = resize_depth_preserve(label, (reshape_h, reshape_w))
+            label = cv2.copyMakeBorder(
+                label, 
+                pad_h_half, 
+                pad_h - pad_h_half, 
+                pad_w_half, 
+                pad_w - pad_w_half, 
+                cv2.BORDER_CONSTANT, 
+                value=self.ignore_label)
+            # scale the label
+            label = label / to_scale_ratio
+        
+        # Resize, adjust principle point
+        if intrinsic is not None:
+            intrinsic[2] = intrinsic[2] * resize_ratio
+            intrinsic[3] = intrinsic[3] * resize_ratio
+
+        if cam_model is not None:
+            #cam_model = cv2.resize(cam_model, dsize=(reshape_w, reshape_h), interpolation=cv2.INTER_LINEAR)
+            cam_model = build_camera_model(reshape_h, reshape_w, intrinsic)
+            cam_model = cv2.copyMakeBorder(
+                cam_model, 
+                pad_h_half, 
+                pad_h - pad_h_half, 
+                pad_w_half, 
+                pad_w - pad_w_half, 
+                cv2.BORDER_CONSTANT, 
+                value=self.ignore_label)
+
+        # Pad, adjust the principle point
+        if intrinsic is not None:
+            intrinsic[2] = intrinsic[2] + pad_w_half
+            intrinsic[3] = intrinsic[3] + pad_h_half
+        return image, label, intrinsic, cam_model
+    
+    # def get_label_scale_factor(self, image, intrinsic, resize_ratio):
+    #     ori_h, ori_w, _ = image.shape
+    #     crop_h, crop_w = self.crop_size
+    #     ori_focal = intrinsic[0] #(intrinsic[0] + intrinsic[1]) / 2.0
+
+    #     to_canonical_ratio = self.canonical_focal / ori_focal
+    #     to_scale_ratio = resize_ratio / to_canonical_ratio 
+    #     return to_scale_ratio
+        
+    def __call__(self, images, labels, intrinsics, cam_models=None, normals=None, other_labels=None, transform_paras=None):
+        target_h, target_w, _ = images[0].shape
+        ori_focal = intrinsics[0][0]
+        to_canonical_ratio = self.canonical_focal / ori_focal 
+        
+        resize_ratio = to_canonical_ratio
+        reshape_h = int(resize_ratio * target_h)
+        reshape_w = int(resize_ratio * target_w)
+        
+        pad_h = 32 - reshape_h % 32
+        pad_w = 32 - reshape_w % 32
+        pad_h_half = int(pad_h / 2)
+        pad_w_half = int(pad_w / 2)
+        
+        pad_info = [pad_h, pad_w, pad_h_half, pad_w_half]
+        to_scale_ratio = 1.0
+
+        for i in range(len(images)):
+            img = images[i]
+            label = labels[i] if i < len(labels) else None
+            intrinsic = intrinsics[i] if i < len(intrinsics) else None
+            cam_model = cam_models[i] if cam_models is not None and i < len(cam_models) else None
+            img, label, intrinsic, cam_model = self.main_data_transform(
+                img, label, intrinsic, cam_model, resize_ratio, pad_info, to_scale_ratio)
+            images[i] = img
+            if label is not None:
+                labels[i] = label
+            if intrinsic is not None:
+                intrinsics[i] = intrinsic
+            if cam_model is not None:
+                cam_models[i] = cam_model 
+        
+        if normals is not None:
+            
+            for i, normal in enumerate(normals):
+                # resize
+                normal =  cv2.resize(normal, dsize=(reshape_w, reshape_h), interpolation=cv2.INTER_NEAREST)
+                # pad
+                normals[i] =  cv2.copyMakeBorder(
+                    normal, 
+                    pad_h_half, 
+                    pad_h - pad_h_half, 
+                    pad_w_half, 
+                    pad_w - pad_w_half, 
+                    cv2.BORDER_CONSTANT, 
+                    value=0)
+
+        if other_labels is not None:
+            
+            for i, other_lab in enumerate(other_labels):
+                # resize
+                other_lab =  cv2.resize(other_lab, dsize=(reshape_w, reshape_h), interpolation=cv2.INTER_NEAREST)
+                # pad
+                other_labels[i] =  cv2.copyMakeBorder(
+                    other_lab, 
+                    pad_h_half, 
+                    pad_h - pad_h_half, 
+                    pad_w_half, 
+                    pad_w - pad_w_half, 
+                    cv2.BORDER_CONSTANT, 
+                    value=self.ignore_label)
+
+
+        if transform_paras is not None:
+            transform_paras.update(pad=[pad_h_half, pad_h - pad_h_half, pad_w_half, pad_w - pad_w_half])
+            if 'label_scale_factor' in transform_paras:
+                transform_paras['label_scale_factor'] = transform_paras['label_scale_factor'] * 1.0 / to_scale_ratio
+            else:
+                transform_paras.update(label_scale_factor=1.0/to_scale_ratio)
+        return images, labels, intrinsics, cam_models, normals, other_labels, transform_paras
+
+
+class RandomCrop(object):
+    """Crops the given ndarray image (H*W*C or H*W).
+    Args:
+        size (sequence or int): Desired output size of the crop. If size is an
+        int instead of sequence like (h, w), a square crop (size, size) is made.
+    """
+    def __init__(self, crop_size, crop_type='center', padding=None, ignore_label=-1, **kwargs):
+        if isinstance(crop_size, int):
+            self.crop_h = crop_size
+            self.crop_w = crop_size
+        elif isinstance(crop_size, collections.Iterable) and len(crop_size) == 2 \
+                and isinstance(crop_size[0], int) and isinstance(crop_size[1], int) \
+                and crop_size[0] > 0 and crop_size[1] > 0:
+            self.crop_h = crop_size[0]
+            self.crop_w = crop_size[1]
+        else:
+            raise (RuntimeError("crop size error.\n"))
+        if crop_type == 'center' or crop_type == 'rand' or crop_type=='rand_in_field':
+            self.crop_type = crop_type
+        else:
+            raise (RuntimeError("crop type error: rand | center | rand_in_field \n"))
+        if padding is None:
+            self.padding = padding
+        elif isinstance(padding, list):
+            if all(isinstance(i, numbers.Number) for i in padding):
+                self.padding = padding
+            else:
+                raise (RuntimeError("padding in Crop() should be a number list\n"))
+            if len(padding) != 3:
+                raise (RuntimeError("padding channel is not equal with 3\n"))
+        else:
+            raise (RuntimeError("padding in Crop() should be a number list\n"))
+        if isinstance(ignore_label, int):
+            self.ignore_label = ignore_label
+        else:
+            raise (RuntimeError("ignore_label should be an integer number\n"))
+        
+
+    def cal_padding_paras(self, h, w):
+        # padding if current size is not satisfied
+        pad_h = max(self.crop_h - h, 0)
+        pad_w = max(self.crop_w - w, 0)
+        pad_h_half = int(pad_h / 2)
+        pad_w_half = int(pad_w / 2)
+        return pad_h, pad_w, pad_h_half, pad_w_half
+
+    def cal_cropping_paras(self, h, w, intrinsic):
+        u0 = intrinsic[2]
+        v0 = intrinsic[3]
+        if self.crop_type == 'rand':
+            h_min = 0
+            h_max = h - self.crop_h
+            w_min = 0
+            w_max = w - self.crop_w 
+        elif self.crop_type == 'center':
+            h_min = (h - self.crop_h) / 2
+            h_max = (h - self.crop_h) / 2
+            w_min = (w - self.crop_w) / 2
+            w_max = (w - self.crop_w) / 2
+        else: # rand in field
+            h_min = min(max(0, v0 - 0.75*self.crop_h), h-self.crop_h)
+            h_max = min(max(v0 - 0.25*self.crop_h, 0), h-self.crop_h)
+            w_min = min(max(0, u0 - 0.75*self.crop_w), w-self.crop_w)
+            w_max = min(max(u0 - 0.25*self.crop_w, 0), w-self.crop_w)
+        
+        h_off = random.randint(int(h_min), int(h_max))
+        w_off = random.randint(int(w_min), int(w_max))
+        return h_off, w_off
+    
+    def main_data_transform(self, image, label, intrinsic, cam_model,
+        pad_h, pad_w, pad_h_half, pad_w_half, h_off, w_off):
+
+        # padding if current size is not satisfied
+        if pad_h > 0 or pad_w > 0:
+            if self.padding is None:
+                raise (RuntimeError("depthtransform.Crop() need padding while padding argument is None\n"))
+            image = cv2.copyMakeBorder(image, pad_h_half, pad_h - pad_h_half, pad_w_half, pad_w - pad_w_half, cv2.BORDER_CONSTANT, value=self.padding)
+            if label is not None:
+                label = cv2.copyMakeBorder(label, pad_h_half, pad_h - pad_h_half, pad_w_half, pad_w - pad_w_half, cv2.BORDER_CONSTANT, value=self.ignore_label)
+            if cam_model is not None:
+                cam_model = cv2.copyMakeBorder(cam_model, pad_h_half, pad_h - pad_h_half, pad_w_half, pad_w - pad_w_half, cv2.BORDER_CONSTANT, value=self.ignore_label)
+        
+        # cropping
+        image = image[h_off:h_off+self.crop_h, w_off:w_off+self.crop_w]
+        if label is not None:
+            label = label[h_off:h_off+self.crop_h, w_off:w_off+self.crop_w]
+        if cam_model is not None:
+            cam_model = cam_model[h_off:h_off+self.crop_h, w_off:w_off+self.crop_w]
+
+        if intrinsic is not None:
+            intrinsic[2] = intrinsic[2] + pad_w_half - w_off
+            intrinsic[3] = intrinsic[3] + pad_h_half - h_off    
+        return image, label, intrinsic, cam_model
+
+    def __call__(self, images, labels, intrinsics, cam_models=None, normals=None, other_labels=None, transform_paras=None):
+        if 'random_crop_size' in transform_paras and transform_paras['random_crop_size'] is not None \
+            and (transform_paras['random_crop_size'][0] + transform_paras['random_crop_size'][1] > 500):
+            self.crop_h = int(transform_paras['random_crop_size'][0].item())
+            self.crop_w = int(transform_paras['random_crop_size'][1].item())
+        target_img = images[0]
+        target_h, target_w, _ = target_img.shape
+        target_intrinsic = intrinsics[0]
+        pad_h, pad_w, pad_h_half, pad_w_half = self.cal_padding_paras(target_h, target_w)
+        h_off, w_off = self.cal_cropping_paras(target_h+pad_h, target_w+pad_w, target_intrinsic)
+
+        for i in range(len(images)):
+            img = images[i]
+            label = labels[i] if i < len(labels) else None
+            intrinsic = intrinsics[i].copy() if i < len(intrinsics) else None
+            cam_model = cam_models[i] if cam_models is not None and i < len(cam_models) else None
+            img, label, intrinsic, cam_model = self.main_data_transform(
+                img, label, intrinsic, cam_model,
+                pad_h, pad_w, pad_h_half, pad_w_half, h_off, w_off)
+            images[i] = img
+            if label is not None:
+                labels[i] = label
+            if intrinsic is not None:
+                intrinsics[i] = intrinsic
+            if cam_model is not None:
+                cam_models[i] = cam_model 
+        pad=[pad_h_half, pad_h - pad_h_half, pad_w_half, pad_w - pad_w_half]
+        if normals is not None:           
+            for i, normal  in enumerate(normals):
+                # padding if current size is not satisfied
+                normal = cv2.copyMakeBorder(normal, pad_h_half, pad_h - pad_h_half, pad_w_half, pad_w - pad_w_half, cv2.BORDER_CONSTANT, value=0)
+                normals[i] = normal[h_off:h_off+self.crop_h, w_off:w_off+self.crop_w]
+        if other_labels is not None:           
+            for i, other_lab  in enumerate(other_labels):
+                # padding if current size is not satisfied
+                other_lab = cv2.copyMakeBorder(other_lab, pad_h_half, pad_h - pad_h_half, pad_w_half, pad_w - pad_w_half, cv2.BORDER_CONSTANT, value=self.ignore_label)
+                other_labels[i] = other_lab[h_off:h_off+self.crop_h, w_off:w_off+self.crop_w]
+        if transform_paras is not None:
+            transform_paras.update(dict(pad=pad))
+        return images, labels, intrinsics, cam_models, normals, other_labels, transform_paras
+    
+
+class RandomResize(object):
+    """
+    Random resize the image. During this process, the camera model is hold, and thus the depth label is scaled.
+    Args:
+        images: list of RGB images.
+        labels: list of depth/disparity labels.
+        other labels: other labels, such as instance segmentations, semantic segmentations...
+    """
+    def __init__(self, ratio_range=(0.85, 1.15), prob=0.5, is_lidar=True, **kwargs):
+        self.ratio_range = ratio_range
+        self.is_lidar = is_lidar
+        self.prob = prob
+    
+    def random_resize(self, image, label, intrinsic, cam_model, to_random_ratio):
+        ori_h, ori_w, _ = image.shape
+        
+        resize_ratio = to_random_ratio
+        label_scale_ratio = 1.0 / resize_ratio
+        reshape_h = int(ori_h * resize_ratio + 0.5)
+        reshape_w = int(ori_w * resize_ratio + 0.5)
+
+        image = cv2.resize(image, dsize=(reshape_w, reshape_h), interpolation=cv2.INTER_LINEAR)
+        if intrinsic is not None:
+            intrinsic = [intrinsic[0], intrinsic[1], intrinsic[2]*resize_ratio, intrinsic[3]*resize_ratio]
+        if label is not None:
+            if self.is_lidar:
+                label = resize_depth_preserve(label, (reshape_h, reshape_w))
+            else:
+                label = cv2.resize(label, dsize=(reshape_w, reshape_h), interpolation=cv2.INTER_NEAREST)
+            # scale the label
+            label = label * label_scale_ratio
+        
+        if cam_model is not None:
+            # Should not directly resize the cam_model.
+            # Camera model should be resized in 'to canonical' stage, while it holds in 'random resizing' stage. 
+            # cam_model = cv2.resize(cam_model, dsize=(reshape_w, reshape_h), interpolation=cv2.INTER_LINEAR)
+            cam_model = build_camera_model(reshape_h, reshape_w, intrinsic)
+        
+        return image, label, intrinsic, cam_model, label_scale_ratio       
+
+    def __call__(self, images, labels, intrinsics, cam_models=None, normals=None, other_labels=None, transform_paras=None):
+        assert len(images[0].shape) == 3 and len(labels[0].shape) == 2
+        assert labels[0].dtype == np.float
+        # target_focal = (intrinsics[0][0] + intrinsics[0][1]) / 2.0
+        # target_to_canonical_ratio = self.canonical_focal / target_focal
+        # target_img_shape = images[0].shape
+        prob = random.uniform(0, 1)
+        if prob < self.prob:
+            to_random_ratio = random.uniform(self.ratio_range[0], self.ratio_range[1])
+        else:
+            to_random_ratio = 1.0
+        label_scale_ratio = 0.0
+        for i in range(len(images)):
+            img = images[i]
+            label = labels[i] if i < len(labels) else None
+            intrinsic = intrinsics[i].copy() if i < len(intrinsics) else None
+            cam_model = cam_models[i] if cam_models is not None and i < len(cam_models) else None
+            img, label, intrinsic, cam_model, label_scale_ratio = self.random_resize(
+                img, label, intrinsic, cam_model, to_random_ratio)
+                
+            images[i] = img
+            if label is not None:
+                labels[i] = label
+            if intrinsic is not None:
+                intrinsics[i] = intrinsic.copy()
+            if cam_model is not None:
+                cam_models[i] = cam_model 
+
+        if normals != None: 
+            reshape_h, reshape_w, _ = images[0].shape
+            for i, norm in enumerate(normals):
+                normals[i] = cv2.resize(norm, dsize=(reshape_w, reshape_h), interpolation=cv2.INTER_NEAREST)
+
+
+        if other_labels != None: 
+            # other labels are like semantic segmentations, instance segmentations, instance planes segmentations...           
+            #resize_ratio = target_to_canonical_ratio * to_scale_ratio
+            #reshape_h = int(target_img_shape[0] * resize_ratio + 0.5)
+            #reshape_w = int(target_img_shape[1] * resize_ratio + 0.5)
+            reshape_h, reshape_w, _ = images[0].shape
+            for i, other_label_i in enumerate(other_labels):
+                other_labels[i] = cv2.resize(other_label_i, dsize=(reshape_w, reshape_h), interpolation=cv2.INTER_NEAREST)
+        
+        if transform_paras is not None:
+            if 'label_scale_factor' in transform_paras:
+                transform_paras['label_scale_factor'] = transform_paras['label_scale_factor'] * label_scale_ratio
+            else:
+                transform_paras.update(label_scale_factor = label_scale_ratio)
+        return images, labels, intrinsics, cam_models, normals, other_labels, transform_paras
+
+class RandomEdgeMask(object):
+    """
+    Random mask the input and labels.
+    Args:
+        images: list of RGB images.
+        labels: list of depth/disparity labels.
+        other labels: other labels, such as instance segmentations, semantic segmentations...
+    """
+    def __init__(self, mask_maxsize=32, prob=0.5, rgb_invalid=[0,0,0], label_invalid=-1,**kwargs):
+        self.mask_maxsize = mask_maxsize
+        self.prob = prob
+        self.rgb_invalid = rgb_invalid
+        self.label_invalid = label_invalid
+    
+    def mask_edge(self, image, mask_edgesize, mask_value):
+        H, W = image.shape[0], image.shape[1]
+        # up
+        image[0:mask_edgesize[0], :, ...] = mask_value 
+        # down
+        image[H-mask_edgesize[1]:H, :, ...] = mask_value
+        # left
+        image[:, 0:mask_edgesize[2], ...] = mask_value
+        # right
+        image[:, W-mask_edgesize[3]:W, ...] = mask_value
+        
+        return image
+
+    def __call__(self, images, labels, intrinsics, cam_models=None, normals=None, other_labels=None, transform_paras=None):
+        assert len(images[0].shape) == 3 and len(labels[0].shape) == 2
+        assert labels[0].dtype == np.float
+        
+        prob = random.uniform(0, 1)
+        if prob > self.prob:
+            return images, labels, intrinsics, cam_models, normals, other_labels, transform_paras
+        
+        mask_edgesize = random.sample(range(self.mask_maxsize), 4) #[up, down, left, right]
+        for i in range(len(images)):
+            img = images[i]
+            label = labels[i] if i < len(labels) else None
+            img = self.mask_edge(img, mask_edgesize, self.rgb_invalid)
+                
+            images[i] = img
+            if label is not None:
+                label = self.mask_edge(label, mask_edgesize, self.label_invalid)
+                labels[i] = label
+        
+        if normals != None:       
+            for i, normal in enumerate(normals):
+                normals[i] = self.mask_edge(normal, mask_edgesize, mask_value=0)
+
+        if other_labels != None: 
+            # other labels are like semantic segmentations, instance segmentations, instance planes segmentations...           
+            for i, other_label_i in enumerate(other_labels):
+                other_labels[i] = self.mask_edge(other_label_i, mask_edgesize, self.label_invalid)
+
+        if transform_paras is not None:
+            pad = transform_paras['pad'] if 'pad' in transform_paras else [0,0,0,0]
+            new_pad = [max(mask_edgesize[0], pad[0]), max(mask_edgesize[1], pad[1]), max(mask_edgesize[2], pad[2]), max(mask_edgesize[3], pad[3])]
+            transform_paras.update(dict(pad=new_pad)) 
+        return images, labels, intrinsics, cam_models, normals, other_labels, transform_paras
+
+
+class AdjustSize(object):
+    """Crops the given ndarray image (H*W*C or H*W).
+    Args:
+        size (sequence or int): Desired output size of the crop. If size is an
+        int instead of sequence like (h, w), a square crop (size, size) is made.
+    """
+    def __init__(self, padding=None, ignore_label=-1, **kwargs):
+        
+        if padding is None:
+            self.padding = padding
+        elif isinstance(padding, list):
+            if all(isinstance(i, numbers.Number) for i in padding):
+                self.padding = padding
+            else:
+                raise (RuntimeError("padding in Crop() should be a number list\n"))
+            if len(padding) != 3:
+                raise (RuntimeError("padding channel is not equal with 3\n"))
+        else:
+            raise (RuntimeError("padding in Crop() should be a number list\n"))
+        if isinstance(ignore_label, int):
+            self.ignore_label = ignore_label
+        else:
+            raise (RuntimeError("ignore_label should be an integer number\n"))
+        
+    def get_pad_paras(self, h, w):
+        pad_h = 32 - h % 32 if h %32 != 0 else 0
+        pad_w = 32 - w % 32 if w %32 != 0 else 0
+        pad_h_half = int(pad_h // 2)
+        pad_w_half = int(pad_w // 2)
+        return pad_h, pad_w, pad_h_half, pad_w_half
+
+    def main_data_transform(self, image, label, intrinsic, cam_model):
+        h, w, _ = image.shape
+        pad_h, pad_w, pad_h_half, pad_w_half = self.get_pad_paras(h=h, w=w)
+        if pad_h > 0 or pad_w > 0:
+            if self.padding is None:
+                raise (RuntimeError("depthtransform.Crop() need padding while padding argument is None\n"))
+            image = cv2.copyMakeBorder(image, pad_h_half, pad_h - pad_h_half, pad_w_half, pad_w - pad_w_half, cv2.BORDER_CONSTANT, value=self.padding)
+            if label is not None:
+                label = cv2.copyMakeBorder(label, pad_h_half, pad_h - pad_h_half, pad_w_half, pad_w - pad_w_half, cv2.BORDER_CONSTANT, value=self.ignore_label)
+            if cam_model is not None:
+                cam_model = cv2.copyMakeBorder(cam_model, pad_h_half, pad_h - pad_h_half, pad_w_half, pad_w - pad_w_half, cv2.BORDER_CONSTANT, value=self.ignore_label)
+
+        if intrinsic is not None:
+            intrinsic[2] = intrinsic[2] + pad_w_half
+            intrinsic[3] = intrinsic[3] + pad_h_half
+        pad=[pad_h_half, pad_h - pad_h_half, pad_w_half, pad_w - pad_w_half]
+        return image, label, intrinsic, cam_model, pad
+    
+    def __call__(self, images, labels, intrinsics, cam_models=None, normals=None, other_labels=None, transform_paras=None):
+        target_img = images[0]
+        target_h, target_w, _ = target_img.shape
+        for i in range(len(images)):
+            img = images[i]
+            label = labels[i] if i < len(labels) else None
+            intrinsic = intrinsics[i] if i < len(intrinsics) else None
+            cam_model = cam_models[i] if cam_models is not None and i < len(cam_models) else None
+            img, label, intrinsic, cam_model, pad = self.main_data_transform(
+                img, label, intrinsic, cam_model)
+            images[i] = img
+            if label is not None:
+                labels[i] = label
+            if intrinsic is not None:
+                intrinsics[i] = intrinsic
+            if cam_model is not None:
+                cam_models[i] = cam_model 
+
+            if transform_paras is not None:
+                transform_paras.update(dict(pad=pad))
+        if normals is not None:
+            pad_h, pad_w, pad_h_half, pad_w_half = self.get_pad_paras(h=target_h, w=target_w)
+            for i, normal  in enumerate(normals):
+                normals[i] = cv2.copyMakeBorder(normal, pad_h_half, pad_h - pad_h_half, pad_w_half, pad_w - pad_w_half, cv2.BORDER_CONSTANT, value=0)
+
+        if other_labels is not None:
+            pad_h, pad_w, pad_h_half, pad_w_half = self.get_pad_paras(h=target_h, w=target_w)
+            for i, other_lab  in enumerate(other_labels):
+                other_labels[i] = cv2.copyMakeBorder(other_lab, pad_h_half, pad_h - pad_h_half, pad_w_half, pad_w - pad_w_half, cv2.BORDER_CONSTANT, value=self.ignore_label)
+        return images, labels, intrinsics, cam_models, normals, other_labels, transform_paras
+
+
+class RandomHorizontalFlip(object):
+    def __init__(self, prob=0.5, **kwargs):
+        self.p = prob
+
+    def main_data_transform(self, image, label, intrinsic, cam_model, rotate):
+        if rotate:
+            image = cv2.flip(image, 1)
+            if label is not None:
+                label = cv2.flip(label, 1)
+            if intrinsic is not None:
+                h, w, _ = image.shape
+                intrinsic[2] = w - intrinsic[2]
+                intrinsic[3] = h - intrinsic[3]
+            if cam_model is not None:
+                cam_model = cv2.flip(cam_model, 1)
+                cam_model[:, :, 0] = cam_model[:, :, 0] * -1
+                cam_model[:, :, 2] = cam_model[:, :, 2] * -1
+        return image, label, intrinsic, cam_model
+    
+    def __call__(self, images, labels, intrinsics, cam_models=None, normals=None, other_labels=None, transform_paras=None):
+        rotate = random.random() > self.p 
+
+        for i in range(len(images)):
+            img = images[i]
+            label = labels[i] if i < len(labels) else None
+            intrinsic = intrinsics[i] if i < len(intrinsics) else None
+            cam_model = cam_models[i] if cam_models is not None and i < len(cam_models) else None
+            img, label, intrinsic, cam_model = self.main_data_transform(
+                img, label, intrinsic, cam_model, rotate)
+            images[i] = img
+            if label is not None:
+                labels[i] = label
+            if intrinsic is not None:
+                intrinsics[i] = intrinsic
+            if cam_model is not None:
+                cam_models[i] = cam_model 
+        if normals is not None:
+            for i, normal in enumerate(normals):
+                if rotate:
+                    normal = cv2.flip(normal, 1)
+                    normal[:, :, 0] = -normal[:, :, 0] # NOTE: check the direction of normal coordinates axis, this is used in https://github.com/baegwangbin/surface_normal_uncertainty
+                normals[i] = normal
+
+        if other_labels is not None:
+            for i, other_lab in enumerate(other_labels):
+                if rotate:
+                    other_lab = cv2.flip(other_lab, 1)
+                other_labels[i] = other_lab
+        return images, labels, intrinsics, cam_models, normals, other_labels, transform_paras
+
+class RandomBlur(object):
+    def __init__(self, 
+                 aver_kernal=(2, 10), 
+                 motion_kernal=(5, 15), 
+                 angle=[-80, 80], 
+                 prob=0.3,
+                 **kwargs):
+
+        gaussian_blur = iaa.AverageBlur(k=aver_kernal)
+        motion_blur = iaa.MotionBlur(k=motion_kernal, angle=angle)
+        zoom_blur = iaa.imgcorruptlike.ZoomBlur(severity=1)
+        self.prob = prob
+        self.blurs = [gaussian_blur, motion_blur, zoom_blur]
+
+    def blur(self, imgs, id):
+        blur_mtd = self.blurs[id]
+        return blur_mtd(images=imgs)
+
+    def __call__(self, images, labels, intrinsics, cam_models=None, normals=None, other_labels=None, transform_paras=None):
+        prob = random.random()
+        if prob < self.prob:
+            id = random.randint(0, len(self.blurs)-1)
+            images = self.blur(images, id)
+        return images, labels, intrinsics, cam_models, normals, other_labels, transform_paras
+
+class RGBCompresion(object):
+    def __init__(self, prob=0.1, compression=(0, 50), **kwargs):
+        self.rgb_compress = iaa.Sequential(
+            [
+                iaa.JpegCompression(compression=compression),
+            ],
+            random_order=True,
+        )
+        self.prob = prob
+
+    def __call__(self, images, labels, intrinsics, cam_models=None, normals=None, other_labels=None, transform_paras=None):
+        if random.random() < self.prob:
+            images = self.rgb_compress(images=images)
+        return images, labels, intrinsics, cam_models, normals, other_labels, transform_paras
+
+
+class RGB2BGR(object):
+    # Converts image from RGB order to BGR order, for model initialized from Caffe
+    def __init__(self,  **kwargs):
+        return
+    def __call__(self, images, labels, intrinsics, cam_models=None, normals=None, other_labels=None, transform_paras=None):
+        for i, img in enumerate(images):
+            images[i] = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
+        return images, labels, intrinsics, cam_models, normals, other_labels, transform_paras
+
+
+class BGR2RGB(object):
+    # Converts image from BGR order to RGB order, for model initialized from Pytorch
+    def __init__(self,  **kwargs):
+        return
+    def __call__(self, images, labels, intrinsics, cam_models=None, normals=None, other_labels=None, transform_paras=None):
+        for i, img in enumerate(images):
+            images[i] = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+        return images, labels, intrinsics, cam_models, normals, other_labels, transform_paras
+
+
+class PhotoMetricDistortion(object):
+    """Apply photometric distortion to image sequentially, every transformation
+    is applied with a probability of 0.5. The position of random contrast is in
+    second or second to last.
+    1. random brightness
+    2. random contrast (mode 0)
+    3. convert color from BGR to HSV
+    4. random saturation
+    5. random hue
+    6. convert color from HSV to BGR
+    7. random contrast (mode 1)
+    Args:
+        brightness_delta (int): delta of brightness.
+        contrast_range (tuple): range of contrast.
+        saturation_range (tuple): range of saturation.
+        hue_delta (int): delta of hue.
+    """
+
+    def __init__(self,
+                 brightness_delta=32,
+                 contrast_range=(0.5, 1.5),
+                 saturation_range=(0.5, 1.5),
+                 hue_delta=18,
+                 to_gray_prob=0.3,
+                 distortion_prob=0.3,
+                 **kwargs):
+        self.brightness_delta = brightness_delta
+        self.contrast_lower, self.contrast_upper = contrast_range
+        self.saturation_lower, self.saturation_upper = saturation_range
+        self.hue_delta = hue_delta
+        self.gray_aug = iaa.Grayscale(alpha=(0.8, 1.0))
+        self.to_gray_prob = to_gray_prob
+        self.distortion_prob = distortion_prob
+
+    def convert(self, img, alpha=1.0, beta=0.0):
+        """Multiple with alpha and add beat with clip."""
+        img = img.astype(np.float32) * alpha + beta
+        img = np.clip(img, 0, 255)
+        return img.astype(np.uint8)
+
+    def brightness(self, img, beta, do):
+        """Brightness distortion."""
+        if do:
+            # beta = random.uniform(-self.brightness_delta,
+            #                         self.brightness_delta)
+            img = self.convert(
+                img,
+                beta=beta)
+        return img
+
+    def contrast(self, img, alpha, do):
+        """Contrast distortion."""
+        if do:
+            #alpha = random.uniform(self.contrast_lower, self.contrast_upper)
+            img = self.convert(
+                img,
+                alpha=alpha)
+        return img
+
+    def saturation(self, img, alpha, do):
+        """Saturation distortion."""
+        if do:
+            # alpha = random.uniform(self.saturation_lower,
+            #                         self.saturation_upper)
+            img = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
+            img[:, :, 1] = self.convert(
+                img[:, :, 1],
+                alpha=alpha)
+            img = cv2.cvtColor(img, cv2.COLOR_HSV2BGR)        
+        return img
+
+    def hue(self, img, rand_hue, do):
+        """Hue distortion."""
+        if do:
+            # rand_hue = random.randint(-self.hue_delta, self.hue_delta)
+            img = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
+            img[:, :, 0] = (img[:, :, 0].astype(int) + rand_hue) % 180
+            img = cv2.cvtColor(img, cv2.COLOR_HSV2BGR)
+        return img
+    
+    def rgb2gray(self, img):
+        img = self.gray_aug(image=img)
+        return img
+
+    def __call__(self, images, labels, intrinsics, cam_models=None, normals=None, other_labels=None, transform_paras=None):
+        """Call function to perform photometric distortion on images.
+        Args:
+            results (dict): Result dict from loading pipeline.
+        Returns:
+            dict: Result dict with images distorted.
+        """
+        brightness_beta = random.uniform(-self.brightness_delta, self.brightness_delta)
+        brightness_do = random.random() < self.distortion_prob
+
+        contrast_alpha = random.uniform(self.contrast_lower, self.contrast_upper)
+        contrast_do = random.random() < self.distortion_prob
+
+        saturate_alpha = random.uniform(self.saturation_lower, self.saturation_upper)
+        saturate_do = random.random() < self.distortion_prob
+
+        rand_hue = random.randint(-self.hue_delta, self.hue_delta)
+        rand_hue_do = random.random() < self.distortion_prob
+
+        # mode == 0 --> do random contrast first
+        # mode == 1 --> do random contrast last
+        mode = 1 if random.random() > 0.5 else 2
+        for i, img in enumerate(images):
+            if random.random() < self.to_gray_prob:
+                img = self.rgb2gray(img)
+            else:
+                # random brightness
+                img = self.brightness(img, brightness_beta, brightness_do)
+
+                if mode == 1:
+                    img = self.contrast(img, contrast_alpha, contrast_do)
+
+                # random saturation
+                img = self.saturation(img, saturate_alpha, saturate_do)
+
+                # random hue
+                img = self.hue(img, rand_hue, rand_hue_do)
+
+                # random contrast
+                if mode == 0:
+                    img = self.contrast(img, contrast_alpha, contrast_do)
+            images[i] = img
+        return images, labels, intrinsics, cam_models, normals, other_labels, transform_paras
+
+class Weather(object):
+    """Apply the following weather augmentations to data.
+    Args:
+        prob (float): probability to enforce the weather augmentation.
+    """
+
+    def __init__(self,
+                 prob=0.3,
+                 **kwargs):
+        snow = iaa.FastSnowyLandscape(
+            lightness_threshold=[50, 100],
+            lightness_multiplier=(1.2, 2)
+            )
+        cloud = iaa.Clouds()
+        fog = iaa.Fog()
+        snow_flakes = iaa.Snowflakes(flake_size=(0.2, 0.4), speed=(0.001, 0.03)) #iaa.imgcorruptlike.Snow(severity=2)# 
+        rain = iaa.Rain(speed=(0.1, 0.3), drop_size=(0.1, 0.3))
+        # rain_drops = RainDrop_Augmentor()
+        self.aug_list = [
+            snow, cloud, fog, snow_flakes, rain, 
+            #wa.add_sun_flare, wa.darken, wa.random_brightness,
+        ]
+        self.prob = prob
+    
+    def aug_with_weather(self, imgs, id):
+        weather = self.aug_list[id]
+        if id <5:
+            return weather(images=imgs)
+        else:
+            return weather(imgs)
+
+    def __call__(self, images, labels, intrinsics, cam_models=None, normals=None, other_labels=None, transform_paras=None):
+        """Call function to perform photometric distortion on images.
+        Args:
+            results (dict): Result dict from loading pipeline.
+        Returns:
+            dict: Result dict with images distorted.
+        """
+        if random.random() < self.prob:
+            select_id = np.random.randint(0, high=len(self.aug_list))  
+            images = self.aug_with_weather(images, select_id)        
+        return images, labels, intrinsics, cam_models, normals, other_labels, transform_paras
+        
+    
+def resize_depth_preserve(depth, shape):
+    """
+    Resizes depth map preserving all valid depth pixels
+    Multiple downsampled points can be assigned to the same pixel.
+
+    Parameters
+    ----------
+    depth : np.array [h,w]
+        Depth map
+    shape : tuple (H,W)
+        Output shape
+
+    Returns
+    -------
+    depth : np.array [H,W,1]
+        Resized depth map
+    """
+    # Store dimensions and reshapes to single column
+    depth = np.squeeze(depth)
+    h, w = depth.shape
+    x = depth.reshape(-1)
+    # Create coordinate grid
+    uv = np.mgrid[:h, :w].transpose(1, 2, 0).reshape(-1, 2)
+    # Filters valid points
+    idx = x > 0
+    crd, val = uv[idx], x[idx]
+    # Downsamples coordinates
+    crd[:, 0] = (crd[:, 0] * (shape[0] / h) + 0.5).astype(np.int32)
+    crd[:, 1] = (crd[:, 1] * (shape[1] / w) + 0.5).astype(np.int32)
+    # Filters points inside image
+    idx = (crd[:, 0] < shape[0]) & (crd[:, 1] < shape[1])
+    crd, val = crd[idx], val[idx]
+    # Creates downsampled depth image and assigns points
+    depth = np.zeros(shape)
+    depth[crd[:, 0], crd[:, 1]] = val
+    # Return resized depth map
+    return depth
+
+
+def gray_to_colormap(img, cmap='rainbow', max_value=None):
+    """
+    Transfer gray map to matplotlib colormap
+    """
+    assert img.ndim == 2
+
+    img[img<0] = 0
+    mask_invalid = img < 1e-10
+    if max_value == None:
+        img = img / (img.max() + 1e-8)
+    else:
+        img = img / (max_value + 1e-8)
+    norm = matplotlib.colors.Normalize(vmin=0, vmax=1.1)
+    cmap_m = matplotlib.cm.get_cmap(cmap)
+    map = matplotlib.cm.ScalarMappable(norm=norm, cmap=cmap_m)
+    colormap = (map.to_rgba(img)[:, :, :3] * 255).astype(np.uint8)
+    colormap[mask_invalid] = 0
+    return colormap
+
+
+class LiDarResizeCanonical(object):
+    """
+    Resize the input to the canonical space first, then resize the input with random sampled size.
+    In the first stage, we assume the distance holds while the camera model varies. 
+    In the second stage, we aim to simulate the observation in different distance. The camera will move along the optical axis.
+    """
+    def __init__(self, **kwargs):
+        self.ratio_range = kwargs['ratio_range']
+        self.canonical_focal = kwargs['focal_length']
+        self.crop_size = kwargs['crop_size']
+    
+    def random_on_canonical_transform(self, image, label, intrinsic, cam_model, to_random_ratio):
+        ori_h, ori_w, _ = image.shape
+        ori_focal = (intrinsic[0] + intrinsic[1]) / 2.0
+
+        to_canonical_ratio = self.canonical_focal / ori_focal
+        to_scale_ratio = to_random_ratio
+        resize_ratio = to_canonical_ratio * to_random_ratio
+        reshape_h = int(ori_h * resize_ratio + 0.5)
+        reshape_w = int(ori_w * resize_ratio + 0.5)
+
+        image = cv2.resize(image, dsize=(reshape_w, reshape_h), interpolation=cv2.INTER_LINEAR)
+        if intrinsic is not None:
+            intrinsic = [self.canonical_focal, self.canonical_focal, intrinsic[2]*resize_ratio, intrinsic[3]*resize_ratio]
+        if label is not None:
+            # number of other labels may be less than that of image
+            #label = cv2.resize(label, dsize=(reshape_w, reshape_h), interpolation=cv2.INTER_NEAREST)
+            label = resize_depth_preserve(label, (reshape_h, reshape_w))
+            # scale the label and camera intrinsics
+            label = label / to_scale_ratio
+        
+        if cam_model is not None:
+            # Should not directly resize the cam_model.
+            # Camera model should be resized in 'to canonical' stage, while it holds in 'random resizing' stage. 
+            # cam_model = cv2.resize(cam_model, dsize=(reshape_w, reshape_h), interpolation=cv2.INTER_LINEAR)
+            cam_model = build_camera_model(reshape_h, reshape_w, intrinsic)
+        return image, label, intrinsic, cam_model, to_scale_ratio    
+    
+    def random_on_crop_transform(self, image, label, intrinsic, cam_model, to_random_ratio):
+        ori_h, ori_w, _ = image.shape
+        crop_h, crop_w = self.crop_size
+        ori_focal = (intrinsic[0] + intrinsic[1]) / 2.0
+
+        to_canonical_ratio = self.canonical_focal / ori_focal
+        
+        # random resize based on the last crop size
+        proposal_reshape_h = int(crop_h * to_random_ratio + 0.5) 
+        proposal_reshape_w = int(crop_w * to_random_ratio + 0.5)
+        resize_ratio_h = proposal_reshape_h / ori_h
+        resize_ratio_w = proposal_reshape_w / ori_w
+        resize_ratio = min(resize_ratio_h, resize_ratio_w) # resize based on the long edge
+        reshape_h = int(ori_h * resize_ratio + 0.5)
+        reshape_w = int(ori_w * resize_ratio + 0.5)
+        
+        to_scale_ratio = resize_ratio / to_canonical_ratio        
+
+        image = cv2.resize(image, dsize=(reshape_w, reshape_h), interpolation=cv2.INTER_LINEAR)
+        if intrinsic is not None:
+            intrinsic = [self.canonical_focal, self.canonical_focal, intrinsic[2]*resize_ratio, intrinsic[3]*resize_ratio]
+        if label is not None:
+            # number of other labels may be less than that of image
+            # label = cv2.resize(label, dsize=(reshape_w, reshape_h), interpolation=cv2.INTER_NEAREST)
+            label = resize_depth_preserve(label, (reshape_h, reshape_w))
+            # scale the label and camera intrinsics
+            label = label / to_scale_ratio
+        
+        if cam_model is not None:
+            # Should not directly resize the cam_model.
+            # Camera model should be resized in 'to canonical' stage, while it holds in 'random resizing' stage. 
+            # cam_model = cv2.resize(cam_model, dsize=(reshape_w, reshape_h), interpolation=cv2.INTER_LINEAR)
+            cam_model = build_camera_model(reshape_h, reshape_w, intrinsic)
+        return image, label, intrinsic, cam_model, to_scale_ratio          
+
+    def __call__(self, images, labels, intrinsics, cam_models=None, normals=None, other_labels=None, transform_paras=None):
+        assert len(images[0].shape) == 3 and len(labels[0].shape) == 2
+        assert labels[0].dtype == np.float
+        target_focal = (intrinsics[0][0] + intrinsics[0][1]) / 2.0
+        target_to_canonical_ratio = self.canonical_focal / target_focal
+        target_img_shape = images[0].shape
+        to_random_ratio = random.uniform(self.ratio_range[0], self.ratio_range[1])
+        to_scale_ratio = 0
+        for i in range(len(images)):
+            img = images[i]
+            label = labels[i] if i < len(labels) else None
+            intrinsic = intrinsics[i] if i < len(intrinsics) else None
+            cam_model = cam_models[i] if cam_models is not None and i < len(cam_models) else None
+            img, label, intrinsic, cam_model, to_scale_ratio = self.random_on_canonical_transform(
+                img, label, intrinsic, cam_model, to_random_ratio)
+                
+            images[i] = img
+            if label is not None:
+                labels[i] = label
+            if intrinsic is not None:
+                intrinsics[i] = intrinsic
+            if cam_model is not None:
+                cam_models[i] = cam_model 
+        if normals != None: 
+            reshape_h, reshape_w, _ = images[0].shape
+            for i, normal in enumerate(normals):
+                normals[i] = cv2.resize(normal, dsize=(reshape_w, reshape_h), interpolation=cv2.INTER_NEAREST)
+                
+        if other_labels != None: 
+            # other labels are like semantic segmentations, instance segmentations, instance planes segmentations...           
+            # resize_ratio = target_to_canonical_ratio * to_random_ratio
+            # reshape_h = int(target_img_shape[0] * resize_ratio + 0.5)
+            # reshape_w = int(target_img_shape[1] * resize_ratio + 0.5)
+            reshape_h, reshape_w, _ = images[0].shape
+            for i, other_label_i in enumerate(other_labels):
+                other_labels[i] = cv2.resize(other_label_i, dsize=(reshape_w, reshape_h), interpolation=cv2.INTER_NEAREST)
+              
+        if transform_paras is not None:
+            transform_paras.update(label_scale_factor = 1.0/to_scale_ratio)
+
+        return images, labels, intrinsics, cam_models, normals, other_labels, transform_paras
+
+
+
+def build_camera_model(H : int, W : int, intrinsics : list) -> np.array:
+    """
+    Encode the camera intrinsic parameters (focal length and principle point) to a 4-channel map. 
+    """
+    fx, fy, u0, v0 = intrinsics
+    f = (fx + fy) / 2.0
+    # principle point location
+    x_row = np.arange(0, W).astype(np.float32)
+    x_row_center_norm = (x_row - u0) / W
+    x_center = np.tile(x_row_center_norm, (H, 1)) # [H, W]
+
+    y_col = np.arange(0, H).astype(np.float32) 
+    y_col_center_norm = (y_col - v0) / H
+    y_center = np.tile(y_col_center_norm, (W, 1)).T
+
+    # FoV
+    fov_x = np.arctan(x_center / (f / W))
+    fov_y =  np.arctan(y_center/ (f / H))
+
+    cam_model = np.stack([x_center, y_center, fov_x, fov_y], axis=2)
+    return cam_model
+
+
+if __name__ == '__main__':
+    img = cv2.imread('/mnt/mldb/raw/62b3ed3455e805efcb28c74b/NuScenes/data_test/samples/CAM_FRONT/n008-2018-08-01-15-34-25-0400__CAM_FRONT__1533152214512404.jpg', -1)
+    H, W, _ = img.shape
+    label = img[:, :, 0]
+    intrinsic = [1000, 1000, W//2, H//2]
+    for i in range(20):
+        weather_aug = Weather(prob=1.0)
+        img_aug,  label, intrinsic, cam_model, ref_images, transform_paras = weather_aug([img, ], [label,], [intrinsic,])
+        cv2.imwrite(f'test_aug_{i}.jpg', img_aug[0])
+    
+    print('Done')

external/Metric3D/training/mono/utils/unproj_pcd.py

@@ -0,0 +1,82 @@
+import numpy as np
+import torch
+from plyfile import PlyData, PlyElement
+import cv2
+
+def get_pcd_base(H, W, u0, v0, focal_length):
+    x_row = np.arange(0, W)
+    x = np.tile(x_row, (H, 1))
+    x = x.astype(np.float32)
+    u_m_u0 = x - u0
+
+    y_col = np.arange(0, H)  # y_col = np.arange(0, height)
+    y = np.tile(y_col, (W, 1)).T
+    y = y.astype(np.float32)
+    v_m_v0 = y - v0
+
+    x = u_m_u0  / focal_length
+    y = v_m_v0 / focal_length
+    z = np.ones_like(x)
+    pw = np.stack([x, y, z], 2) # [h, w, c]
+    return pw
+
+def reconstruct_pcd(depth, focal_length, u0, v0, pcd_base=None, mask=None):
+    if type(depth) == torch.__name__:
+        depth = depth.cpu().numpy().squeeze()
+    depth = cv2.medianBlur(depth, 5)
+    if pcd_base is None:
+        H, W = depth.shape
+        pcd_base = get_pcd_base(H, W, u0, v0, focal_length)
+    pcd = depth[:, :, None] * pcd_base
+    if mask:
+        pcd[mask] = 0
+    return pcd
+
+
+def save_point_cloud(pcd, rgb, filename, binary=True):
+    """Save an RGB point cloud as a PLY file.
+    :paras
+      @pcd: Nx3 matrix, the XYZ coordinates
+      @rgb: NX3 matrix, the rgb colors for each 3D point
+    """
+    assert pcd.shape[0] == rgb.shape[0]
+
+    if rgb is None:
+        gray_concat = np.tile(np.array([128], dtype=np.uint8), (pcd.shape[0], 3))
+        points_3d = np.hstack((pcd, gray_concat))
+    else:
+        points_3d = np.hstack((pcd, rgb))
+    python_types = (float, float, float, int, int, int)
+    npy_types = [('x', 'f4'), ('y', 'f4'), ('z', 'f4'), ('red', 'u1'), ('green', 'u1'),
+                 ('blue', 'u1')]
+    if binary is True:
+        # Format into NumPy structured array
+        vertices = []
+        for row_idx in range(points_3d.shape[0]):
+            cur_point = points_3d[row_idx]
+            vertices.append(tuple(dtype(point) for dtype, point in zip(python_types, cur_point)))
+        vertices_array = np.array(vertices, dtype=npy_types)
+        el = PlyElement.describe(vertices_array, 'vertex')
+
+         # Write
+        PlyData([el]).write(filename)
+    else:
+        x = np.squeeze(points_3d[:, 0])
+        y = np.squeeze(points_3d[:, 1])
+        z = np.squeeze(points_3d[:, 2])
+        r = np.squeeze(points_3d[:, 3])
+        g = np.squeeze(points_3d[:, 4])
+        b = np.squeeze(points_3d[:, 5])
+
+        ply_head = 'ply\n' \
+                   'format ascii 1.0\n' \
+                   'element vertex %d\n' \
+                   'property float x\n' \
+                   'property float y\n' \
+                   'property float z\n' \
+                   'property uchar red\n' \
+                   'property uchar green\n' \
+                   'property uchar blue\n' \
+                   'end_header' % r.shape[0]
+        # ---- Save ply data to disk
+        np.savetxt(filename, np.column_stack((x, y, z, r, g, b)), fmt="%d %d %d %d %d %d", header=ply_head, comments='')

external/Metric3D/training/mono/utils/visualization.py

@@ -0,0 +1,209 @@
+import matplotlib.pyplot as plt
+import os, cv2
+import numpy as np
+from mono.utils.transform import gray_to_colormap
+import shutil
+import glob
+from mono.utils.running import main_process
+import torch
+from html4vision import Col, imagetable
+
+def save_raw_imgs( 
+    pred: torch.tensor,  
+    rgb: torch.tensor, 
+    filename: str, 
+    save_dir: str,
+    scale: float=1000.0, 
+    target: torch.tensor=None,
+    ):
+    """
+    Save raw GT, predictions, RGB in the same file.
+    """
+    cv2.imwrite(os.path.join(save_dir, filename[:-4]+'_rgb.jpg'), rgb)
+    cv2.imwrite(os.path.join(save_dir, filename[:-4]+'_gt.png'), (pred*scale).astype(np.uint16))
+    if target is not None:
+        cv2.imwrite(os.path.join(save_dir, filename[:-4]+'_gt.png'), (target*scale).astype(np.uint16))
+    
+def save_normal_val_imgs(
+    iter: int, 
+    pred: torch.tensor, 
+    #targ: torch.tensor, 
+    #rgb: torch.tensor, 
+    filename: str, 
+    save_dir: str, 
+    tb_logger=None, 
+    mask=None,
+    ):
+    """
+    Save GT, predictions, RGB in the same file.
+    """
+    mean = np.array([123.675, 116.28, 103.53])[np.newaxis, np.newaxis, :]
+    std= np.array([58.395, 57.12, 57.375])[np.newaxis, np.newaxis, :]
+    pred = pred.squeeze()
+    
+    # if pred.size(0) == 3:
+    #     pred = pred.permute(1,2,0)
+    # pred_color = vis_surface_normal(pred, mask)
+
+    # #save one image only
+    # plt.imsave(os.path.join(save_dir, filename[:-4]+'.jpg'), pred_color)
+
+    targ = targ.squeeze()
+    rgb = rgb.squeeze()
+
+    if pred.size(0) == 3:
+        pred = pred.permute(1,2,0)
+    if targ.size(0) == 3:
+        targ = targ.permute(1,2,0)
+    if rgb.size(0) == 3:
+        rgb = rgb.permute(1,2,0)
+
+    pred_color = vis_surface_normal(pred, mask)
+    targ_color = vis_surface_normal(targ, mask)
+    rgb_color = ((rgb.cpu().numpy() * std) + mean).astype(np.uint8)
+
+    try:
+        cat_img = np.concatenate([rgb_color, pred_color, targ_color], axis=0)
+    except:
+        pred_color = cv2.resize(pred_color, (rgb.shape[1], rgb.shape[0]))
+        targ_color = cv2.resize(targ_color, (rgb.shape[1], rgb.shape[0]))
+        cat_img = np.concatenate([rgb_color, pred_color, targ_color], axis=0)
+
+    plt.imsave(os.path.join(save_dir, filename[:-4]+'_merge.jpg'), cat_img)
+    # cv2.imwrite(os.path.join(save_dir, filename[:-4]+'.jpg'), pred_color)
+    # save to tensorboard
+    if tb_logger is not None:
+        tb_logger.add_image(f'{filename[:-4]}_merge.jpg', cat_img.transpose((2, 0, 1)), iter)
+
+    
+
+
+def save_val_imgs(
+    iter: int, 
+    pred: torch.tensor, 
+    target: torch.tensor, 
+    rgb: torch.tensor, 
+    filename: str, 
+    save_dir: str, 
+    tb_logger=None
+    ):
+    """
+    Save GT, predictions, RGB in the same file.
+    """
+    rgb, pred_scale, target_scale, pred_color, target_color, max_scale = get_data_for_log(pred, target, rgb)
+    rgb = rgb.transpose((1, 2, 0))
+    # plt.imsave(os.path.join(save_dir, filename[:-4]+'_rgb.jpg'), rgb)
+    # plt.imsave(os.path.join(save_dir, filename[:-4]+'_pred.png'), pred_scale, cmap='rainbow')
+    # plt.imsave(os.path.join(save_dir, filename[:-4]+'_gt.png'), target_scale, cmap='rainbow')
+    cat_img = np.concatenate([rgb, pred_color, target_color], axis=0)
+    plt.imsave(os.path.join(save_dir, filename[:-4]+'_merge.jpg'), cat_img)
+
+    # save to tensorboard
+    if tb_logger is not None:
+        # tb_logger.add_image(f'{filename[:-4]}_rgb.jpg', rgb, iter)
+        # tb_logger.add_image(f'{filename[:-4]}_pred.jpg', gray_to_colormap(pred_scale).transpose((2, 0, 1)), iter)
+        # tb_logger.add_image(f'{filename[:-4]}_gt.jpg', gray_to_colormap(target_scale).transpose((2, 0, 1)), iter)
+        tb_logger.add_image(f'{filename[:-4]}_merge.jpg', cat_img.transpose((2, 0, 1)), iter)
+    return max_scale
+
+def get_data_for_log(pred: torch.tensor, target: torch.tensor, rgb: torch.tensor):
+    mean = np.array([123.675, 116.28, 103.53])[:, np.newaxis, np.newaxis]
+    std= np.array([58.395, 57.12, 57.375])[:, np.newaxis, np.newaxis]
+
+    pred = pred.squeeze().cpu().numpy()
+    target = target.squeeze().cpu().numpy()
+    rgb = rgb.squeeze().cpu().numpy()
+
+    pred[pred<0] = 0
+    target[target<0] = 0
+    #max_scale = max(pred.max(), target.max())
+    max_scale = min(2.0 * target.max(), pred.max())
+    pred[pred > max_scale] = max_scale
+
+    pred_scale = (pred/max_scale * 10000).astype(np.uint16)
+    target_scale = (target/max_scale * 10000).astype(np.uint16)
+    pred_color = gray_to_colormap(pred, max_value=max_scale)
+    target_color = gray_to_colormap(target, max_value=max_scale)
+    
+    dilate = True
+    if dilate == True:
+        k=np.ones((3,3),np.uint8)
+        target_color=cv2.dilate(target_color,k,iterations=1)
+
+    pred_color = cv2.resize(pred_color, (rgb.shape[2], rgb.shape[1]))
+    target_color = cv2.resize(target_color, (rgb.shape[2], rgb.shape[1]))
+
+    rgb = ((rgb * std) + mean).astype(np.uint8)
+    return rgb, pred_scale, target_scale, pred_color, target_color, max_scale
+
+
+def create_html(name2path, save_path='index.html', size=(256, 384)):
+    # table description
+    cols = []
+    for k, v in name2path.items():
+        col_i =  Col('img', k, v) # specify image content for column
+        cols.append(col_i)
+    # html table generation
+    imagetable(cols, out_file=save_path, imsize=size)
+
+
+def visual_train_data(gt_depth, rgb, filename, wkdir, replace=False, pred=None):
+    gt_depth = gt_depth.cpu().squeeze().numpy()
+    rgb = rgb.cpu().squeeze().numpy()
+
+    mean = np.array([123.675, 116.28, 103.53])[:, np.newaxis, np.newaxis]
+    std= np.array([58.395, 57.12, 57.375])[:, np.newaxis, np.newaxis]
+    mask = gt_depth > 0
+    
+    rgb = ((rgb * std) + mean).astype(np.uint8).transpose((1, 2, 0))
+    gt_vis = gray_to_colormap(gt_depth)
+    if replace:
+        rgb[mask] = gt_vis[mask]
+
+    if pred is not None:
+        pred_depth = pred.detach().cpu().squeeze().numpy()
+        pred_vis = gray_to_colormap(pred_depth)
+
+    merge = np.concatenate([rgb, gt_vis, pred_vis], axis=0)
+    
+    save_path = os.path.join(wkdir, 'test_train', filename)
+    os.makedirs(os.path.dirname(save_path), exist_ok=True)
+    plt.imsave(save_path, merge)
+
+
+def create_dir_for_validate_meta(work_dir, iter_id):
+    curr_folders = glob.glob(work_dir + '/online_val/*0')
+    curr_folders = [i for i in curr_folders if os.path.isdir(i)]
+    if len(curr_folders) > 8:
+        curr_folders.sort()
+        del_foler = curr_folders.pop(0)
+        print(del_foler)
+        if main_process():
+            # only rank==0 do it
+            if os.path.exists(del_foler):   
+                shutil.rmtree(del_foler)
+            if os.path.exists(del_foler + '.html'):
+                os.remove(del_foler + '.html')
+        
+    save_val_meta_data_dir = os.path.join(work_dir, 'online_val', '%08d'%iter_id)
+    os.makedirs(save_val_meta_data_dir, exist_ok=True)
+    return save_val_meta_data_dir
+
+
+def vis_surface_normal(normal: torch.tensor, mask: torch.tensor=None) -> np.array:
+    """
+    Visualize surface normal. Transfer surface normal value from [-1, 1] to [0, 255]
+    Aargs:
+        normal (torch.tensor, [h, w, 3]): surface normal
+        mask (torch.tensor, [h, w]): valid masks
+    """
+    normal = normal.cpu().numpy().squeeze()
+    n_img_L2 = np.sqrt(np.sum(normal ** 2, axis=2, keepdims=True))
+    n_img_norm = normal / (n_img_L2 + 1e-8)
+    normal_vis = n_img_norm * 127
+    normal_vis += 128
+    normal_vis = normal_vis.astype(np.uint8)
+    if mask is not None:
+        mask = mask.cpu().numpy().squeeze()
+        normal_vis[~mask] = 0
+    return normal_vis

external/Metric3D/training/mono/utils/weather_aug_utils.py

@@ -0,0 +1,872 @@
+
+# import glob
+import cv2 as cv2
+import numpy as np
+# import matplotlib.pyplot as plt
+import random
+import math
+
+
+###################### HLS #############################
+
+def hls(image,src='RGB'):
+    verify_image(image)
+    if(is_list(image)):
+        image_HLS=[]
+        image_list=image
+        for img in image_list:
+            eval('image_HLS.append(cv2.cvtColor(img,cv2.COLOR_'+src.upper()+'2HLS))')
+    else:
+        image_HLS = eval('cv2.cvtColor(image,cv2.COLOR_'+src.upper()+'2HLS)')
+    return image_HLS
+
+def hue(image,src='RGB'):
+    verify_image(image)
+    if(is_list(image)):
+        image_Hue=[]
+        image_list=image
+        for img in image_list:
+            image_Hue.append(hls(img,src)[:,:,0])
+    else:
+        image_Hue= hls(image,src)[:,:,0]
+    return image_Hue
+
+def lightness(image,src='RGB'):
+    verify_image(image)
+    if(is_list(image)):
+        image_lightness=[]
+        image_list=image
+        for img in image_list:
+            image_lightness.append(hls(img,src)[:,:,1])
+    else:
+        image_lightness= hls(image,src)[:,:,1]
+    return image_lightness
+
+def saturation(image,src='RGB'):
+    verify_image(image)
+    if(is_list(image)):
+        image_saturation=[]
+        image_list=image
+        for img in image_list:
+            image_saturation.append(hls(img,src)[:,:,2])
+    else:
+        image_saturation= hls(image,src)[:,:,2]
+    return image_saturation
+
+###################### HSV #############################
+
+def hsv(image,src='RGB'):
+    verify_image(image)
+    if(is_list(image)):
+        image_HSV=[]
+        image_list=image
+        for img in image_list:
+            eval('image_HSV.append(cv2.cvtColor(img,cv2.COLOR_'+src.upper()+'2HSV))')
+    else:
+        image_HSV = eval('cv2.cvtColor(image,cv2.COLOR_'+src.upper()+'2HSV)')
+    return image_HSV
+
+def value(image,src='RGB'):
+    verify_image(image)
+    if(is_list(image)):
+        image_value=[]
+        image_list=image
+        for img in image_list:
+            image_value.append(hsv(img,src)[:,:,2])
+    else:
+        image_value= hsv(image,src)[:,:,2]
+    return image_value
+
+###################### BGR #############################
+
+def bgr(image, src='RGB'):
+    verify_image(image)
+    if(is_list(image)):
+        image_BGR=[]
+        image_list=image
+        for img in image_list:
+            eval('image_BGR.append(cv2.cvtColor(img,cv2.COLOR_'+src.upper()+'2BGR))')
+    else:
+        image_BGR= eval('cv2.cvtColor(image,cv2.COLOR_'+src.upper()+'2BGR)')
+    return image_BGR
+
+###################### RGB #############################
+def rgb(image, src='BGR'):
+    verify_image(image)
+    if(is_list(image)):
+        image_RGB=[]
+        image_list=image
+        for img in image_list:
+            eval('image_RGB.append(cv2.cvtColor(img,cv2.COLOR_'+src.upper()+'2RGB))')
+    else:
+        image_RGB= eval('cv2.cvtColor(image,cv2.COLOR_'+src.upper()+'2RGB)')
+    return image_RGB
+
+def red(image,src='BGR'):
+    verify_image(image)
+    if(is_list(image)):
+        image_red=[]
+        image_list=image
+        for img in image_list:
+            i= eval('cv2.cvtColor(img,cv2.COLOR_'+src.upper()+'2RGB)')
+            image_red.append(i[:,:,0])
+    else:
+        image_red= eval('cv2.cvtColor(image,cv2.COLOR_'+src.upper()+'2RGB)[:,:,0]')
+    return image_red
+
+def green(image,src='BGR'):
+    verify_image(image)
+    if(is_list(image)):
+        image_green=[]
+        image_list=image
+        for img in image_list:
+            i= eval('cv2.cvtColor(img,cv2.COLOR_'+src.upper()+'2RGB)')
+            image_green.append(i[:,:,1])
+    else:
+        image_green= eval('cv2.cvtColor(image,cv2.COLOR_'+src.upper()+'2RGB)[:,:,1]')
+    return image_green
+
+def blue(image,src='BGR'):
+    verify_image(image)
+    if(is_list(image)):
+        image_blue=[]
+        image_list=image
+        for img in image_list:
+            i=eval('cv2.cvtColor(img,cv2.COLOR_'+src.upper()+'2RGB)')
+            image_blue.append(i[:,:,2])
+    else:
+        image_blue= eval('cv2.cvtColor(image,cv2.COLOR_'+src.upper()+'2RGB)[:,:,2]')
+    return image_blue
+
+err_not_np_img= "not a numpy array or list of numpy array" 
+err_img_arr_empty="Image array is empty"
+err_row_zero="No. of rows can't be <=0"
+err_column_zero="No. of columns can't be <=0"
+err_invalid_size="Not a valid size tuple (x,y)"
+err_caption_array_count="Caption array length doesn't matches the image array length"
+
+def is_numpy_array(x):
+
+    return isinstance(x, np.ndarray)
+def is_tuple(x):
+    return type(x) is tuple
+def is_list(x):
+    return type(x) is list
+def is_numeric(x):
+    return type(x) is int
+def is_numeric_list_or_tuple(x):
+    for i in x:
+        if not is_numeric(i):
+            return False
+    return True
+
+err_brightness_coeff="brightness coeff can only be between 0.0 to 1.0" 
+err_darkness_coeff="darkness coeff can only be between 0.0 to 1.0" 
+
+def change_light(image, coeff):
+    image_HLS = cv2.cvtColor(image,cv2.COLOR_RGB2HLS) ## Conversion to HLS
+    image_HLS = np.array(image_HLS, dtype = np.float64) 
+    image_HLS[:,:,1] = image_HLS[:,:,1]*coeff ## scale pixel values up or down for channel 1(Lightness)
+    if(coeff>1):
+        image_HLS[:,:,1][image_HLS[:,:,1]>255]  = 255 ##Sets all values above 255 to 255
+    else:
+        image_HLS[:,:,1][image_HLS[:,:,1]<0]=0
+    image_HLS = np.array(image_HLS, dtype = np.uint8)
+    image_RGB = cv2.cvtColor(image_HLS,cv2.COLOR_HLS2RGB) ## Conversion to RGB
+    return image_RGB 
+
+def verify_image(image):
+    if is_numpy_array(image):
+        pass
+    elif(is_list(image)):
+        image_list=image
+        for img in image_list:
+            if not is_numpy_array(img):
+                raise Exception(err_not_np_img)
+    else:
+        raise Exception(err_not_np_img)
+
+def brighten(image, brightness_coeff=-1): ##function to brighten the image
+    verify_image(image)
+    if(brightness_coeff!=-1):
+        if(brightness_coeff<0.0 or brightness_coeff>1.0):
+            raise Exception(err_brightness_coeff)
+    if(is_list(image)):
+        image_RGB=[]
+        image_list=image
+        for img in image_list:
+            if(brightness_coeff==-1):
+                brightness_coeff_t=1+ random.uniform(0,1) ## coeff between 1.0 and 1.5
+            else:
+                brightness_coeff_t=1+ brightness_coeff ## coeff between 1.0 and 2.0
+            image_RGB.append(change_light(img,brightness_coeff_t))
+    else:
+        if(brightness_coeff==-1):
+            brightness_coeff_t=1+ random.uniform(0,1) ## coeff between 1.0 and 1.5
+        else:
+            brightness_coeff_t=1+ brightness_coeff ## coeff between 1.0 and 2.0
+        image_RGB= change_light(image,brightness_coeff_t)
+    return image_RGB
+
+def darken(image, darkness_coeff=-1): ##function to darken the image
+    verify_image(image)
+    if(darkness_coeff!=-1):
+        if(darkness_coeff<0.0 or darkness_coeff>1.0):
+            raise Exception(err_darkness_coeff) 
+
+    if(is_list(image)):
+        image_RGB=[]
+        image_list=image
+        for img in image_list:
+            if(darkness_coeff==-1):
+                darkness_coeff_t=1- random.uniform(0,1)
+            else:
+                darkness_coeff_t=1- darkness_coeff            
+            image_RGB.append(change_light(img,darkness_coeff_t))
+    else:
+        if(darkness_coeff==-1):
+             darkness_coeff_t=1- random.uniform(0,1)
+        else:
+            darkness_coeff_t=1- darkness_coeff  
+        image_RGB= change_light(image,darkness_coeff_t)
+    return image_RGB
+
+
+def random_brightness(image):
+    verify_image(image)
+
+    if(is_list(image)):
+        image_RGB=[]
+        image_list=image
+        for img in image_list:
+            random_brightness_coefficient = 2* np.random.uniform(0,1) ## generates value between 0.0 and 2.0
+            image_RGB.append(change_light(img,random_brightness_coefficient))
+    else:
+        random_brightness_coefficient = 2* np.random.uniform(0,1) ## generates value between 0.0 and 2.0
+        image_RGB= change_light(image,random_brightness_coefficient)
+    return image_RGB
+
+err_shadow_count="only 1-10 shadows can be introduced in an image"
+err_invalid_rectangular_roi="Rectangular ROI dimensions are not valid"
+err_shadow_dimension="polygons with dim<3 dont exist and >10 take time to plot"
+
+def generate_shadow_coordinates(imshape, no_of_shadows, rectangular_roi, shadow_dimension):
+    vertices_list=[]
+    x1=rectangular_roi[0]
+    y1=rectangular_roi[1]
+    x2=rectangular_roi[2]
+    y2=rectangular_roi[3]
+    for index in range(no_of_shadows):
+        vertex=[]
+        for dimensions in range(shadow_dimension): ## Dimensionality of the shadow polygon
+            vertex.append((random.randint(x1, x2),random.randint(y1, y2)))
+        vertices = np.array([vertex], dtype=np.int32) ## single shadow vertices 
+        vertices_list.append(vertices)
+    return vertices_list ## List of shadow vertices
+
+def shadow_process(image,no_of_shadows,x1,y1,x2,y2, shadow_dimension):
+    image_HLS = cv2.cvtColor(image,cv2.COLOR_RGB2HLS) ## Conversion to HLS
+    mask = np.zeros_like(image) 
+    imshape = image.shape
+    vertices_list= generate_shadow_coordinates(imshape, no_of_shadows,(x1,y1,x2,y2), shadow_dimension) #3 getting list of shadow vertices
+    for vertices in vertices_list: 
+        cv2.fillPoly(mask, vertices, 255) ## adding all shadow polygons on empty mask, single 255 denotes only red channel
+    image_HLS[:,:,1][mask[:,:,0]==255] = image_HLS[:,:,1][mask[:,:,0]==255]*0.5   ## if red channel is hot, image's "Lightness" channel's brightness is lowered 
+    image_RGB = cv2.cvtColor(image_HLS,cv2.COLOR_HLS2RGB) ## Conversion to RGB
+    return image_RGB
+
+def add_shadow(image,no_of_shadows=1,rectangular_roi=(-1,-1,-1,-1), shadow_dimension=5):## ROI:(top-left x1,y1, bottom-right x2,y2), shadow_dimension=no. of sides of polygon generated
+    verify_image(image)
+    if not(is_numeric(no_of_shadows) and no_of_shadows>=1 and no_of_shadows<=10):
+        raise Exception(err_shadow_count)
+    if not(is_numeric(shadow_dimension) and shadow_dimension>=3 and shadow_dimension<=10):
+        raise Exception(err_shadow_dimension)
+    if is_tuple(rectangular_roi) and is_numeric_list_or_tuple(rectangular_roi) and len(rectangular_roi)==4:
+        x1=rectangular_roi[0]
+        y1=rectangular_roi[1]
+        x2=rectangular_roi[2]
+        y2=rectangular_roi[3]
+    else:
+        raise Exception(err_invalid_rectangular_roi)
+    if rectangular_roi==(-1,-1,-1,-1):
+        x1=0
+        
+        if(is_numpy_array(image)):
+            y1=image.shape[0]//2
+            x2=image.shape[1]
+            y2=image.shape[0]
+        else:
+            y1=image[0].shape[0]//2
+            x2=image[0].shape[1]
+            y2=image[0].shape[0]
+
+    elif x1==-1 or y1==-1 or x2==-1 or y2==-1 or x2<=x1 or y2<=y1:
+        raise Exception(err_invalid_rectangular_roi)
+    if(is_list(image)):
+        image_RGB=[]
+        image_list=image
+        for img in image_list:
+            output=shadow_process(img,no_of_shadows,x1,y1,x2,y2, shadow_dimension)
+            image_RGB.append(output)
+    else:
+        output=shadow_process(image,no_of_shadows,x1,y1,x2,y2, shadow_dimension)
+        image_RGB = output
+
+    return image_RGB
+
+err_snow_coeff="Snow coeff can only be between 0 and 1"
+def snow_process(image,snow_coeff):
+    image_HLS = cv2.cvtColor(image,cv2.COLOR_RGB2HLS) ## Conversion to HLS
+    image_HLS = np.array(image_HLS, dtype = np.float64) 
+    brightness_coefficient = 2.5 
+    imshape = image.shape
+    snow_point=snow_coeff ## increase this for more snow
+    image_HLS[:,:,1][image_HLS[:,:,1]<snow_point] = image_HLS[:,:,1][image_HLS[:,:,1]<snow_point]*brightness_coefficient ## scale pixel values up for channel 1(Lightness)
+    image_HLS[:,:,1][image_HLS[:,:,1]>255]  = 255 ##Sets all values above 255 to 255
+    image_HLS = np.array(image_HLS, dtype = np.uint8)
+    image_RGB = cv2.cvtColor(image_HLS,cv2.COLOR_HLS2RGB) ## Conversion to RGB
+    return image_RGB
+
+def add_snow(image, snow_coeff=-1):
+    verify_image(image)
+    if(snow_coeff!=-1):
+        if(snow_coeff<0.0 or snow_coeff>1.0):
+            raise Exception(err_snow_coeff)
+    else:
+        snow_coeff=random.uniform(0,1)
+    snow_coeff*=255/2
+    snow_coeff+=255/3
+    if(is_list(image)):
+        image_RGB=[]
+        image_list=image
+        for img in image_list:
+            output= snow_process(img,snow_coeff)
+            image_RGB.append(output) 
+    else:
+        output= snow_process(image,snow_coeff)
+        image_RGB=output
+
+    return image_RGB
+
+err_rain_slant="Numeric value between -20 and 20 is allowed"
+err_rain_width="Width value between 1 and 5 is allowed"
+err_rain_length="Length value between 0 and 100 is allowed"
+def generate_random_lines(imshape,slant,drop_length,rain_type):
+    drops=[]
+    area=imshape[0]*imshape[1]
+    no_of_drops=area//600
+
+    if rain_type.lower()=='drizzle':
+        no_of_drops=area//770
+        drop_length=10
+    elif rain_type.lower()=='heavy':
+        drop_length=30
+    elif rain_type.lower()=='torrential':
+        no_of_drops=area//500
+        drop_length=60
+
+    for i in range(no_of_drops): ## If You want heavy rain, try increasing this
+        if slant<0:
+            x= np.random.randint(slant,imshape[1])
+        else:
+            x= np.random.randint(0,imshape[1]-slant)
+        y= np.random.randint(0,imshape[0]-drop_length)
+        drops.append((x,y))
+    return drops,drop_length
+
+def rain_process(image,slant,drop_length,drop_color,drop_width,rain_drops):
+    imshape = image.shape  
+    image_t= image.copy()
+    for rain_drop in rain_drops:
+        cv2.line(image_t,(rain_drop[0],rain_drop[1]),(rain_drop[0]+slant,rain_drop[1]+drop_length),drop_color,drop_width)
+    image= cv2.blur(image_t,(7,7)) ## rainy view are blurry
+    brightness_coefficient = 0.7 ## rainy days are usually shady 
+    image_HLS = hls(image) ## Conversion to HLS
+    image_HLS[:,:,1] = image_HLS[:,:,1]*brightness_coefficient ## scale pixel values down for channel 1(Lightness)
+    image_RGB= rgb(image_HLS,'hls') ## Conversion to RGB
+    return image_RGB
+
+##rain_type='drizzle','heavy','torrential'
+def add_rain(image,slant=-1,drop_length=20,drop_width=1,drop_color=(200,200,200),rain_type='None'): ## (200,200,200) a shade of gray
+    verify_image(image)
+    slant_extreme=slant
+    if not(is_numeric(slant_extreme) and (slant_extreme>=-20 and slant_extreme<=20)or slant_extreme==-1):
+        raise Exception(err_rain_slant)
+    if not(is_numeric(drop_width) and drop_width>=1 and drop_width<=5):
+        raise Exception(err_rain_width)
+    if not(is_numeric(drop_length) and drop_length>=0 and drop_length<=100):
+        raise Exception(err_rain_length)
+
+    if(is_list(image)):
+        image_RGB=[]
+        image_list=image
+        imshape = image[0].shape
+        if slant_extreme==-1:
+            slant= np.random.randint(-10,10) ##generate random slant if no slant value is given
+        rain_drops,drop_length= generate_random_lines(imshape,slant,drop_length,rain_type)
+        for img in image_list:
+            output= rain_process(img,slant_extreme,drop_length,drop_color,drop_width,rain_drops)
+            image_RGB.append(output)
+    else:
+        imshape = image.shape
+        if slant_extreme==-1:
+            slant= np.random.randint(-10,10) ##generate random slant if no slant value is given
+        rain_drops,drop_length= generate_random_lines(imshape,slant,drop_length,rain_type)
+        output= rain_process(image,slant_extreme,drop_length,drop_color,drop_width,rain_drops)
+        image_RGB=output
+
+    return image_RGB
+
+err_fog_coeff="Fog coeff can only be between 0 and 1"
+def add_blur(image, x,y,hw,fog_coeff):
+    overlay= image.copy()
+    output= image.copy()
+    alpha= 0.08*fog_coeff
+    rad= hw//2
+    point=(x+hw//2, y+hw//2)
+    cv2.circle(overlay,point, int(rad), (255,255,255), -1)
+    cv2.addWeighted(overlay, alpha, output, 1 -alpha ,0, output)
+    return output
+
+def generate_random_blur_coordinates(imshape,hw):
+    blur_points=[]
+    midx= imshape[1]//2-2*hw
+    midy= imshape[0]//2-hw
+    index=1
+    while(midx>-hw or midy>-hw):
+        for i in range(hw//10*index):
+            x= np.random.randint(midx,imshape[1]-midx-hw)
+            y= np.random.randint(midy,imshape[0]-midy-hw)
+            blur_points.append((x,y))
+        midx-=3*hw*imshape[1]//sum(imshape)
+        midy-=3*hw*imshape[0]//sum(imshape)
+        index+=1
+    return blur_points
+
+def add_fog(image, fog_coeff=-1):
+    verify_image(image)
+
+    if(fog_coeff!=-1):
+        if(fog_coeff<0.0 or fog_coeff>1.0):
+            raise Exception(err_fog_coeff)
+    if(is_list(image)):
+        image_RGB=[]
+        image_list=image
+        imshape = image[0].shape
+
+        for img in image_list:
+            if fog_coeff==-1:
+                fog_coeff_t=random.uniform(0.3,1)
+            else:
+                fog_coeff_t=fog_coeff
+            hw=int(imshape[1]//3*fog_coeff_t)
+            haze_list= generate_random_blur_coordinates(imshape,hw)
+            for haze_points in haze_list: 
+                img= add_blur(img, haze_points[0],haze_points[1], hw,fog_coeff_t) ## adding all shadow polygons on empty mask, single 255 denotes only red channel
+            img = cv2.blur(img ,(hw//10,hw//10))
+            image_RGB.append(img) 
+    else:
+        imshape = image.shape
+        if fog_coeff==-1:
+            fog_coeff_t=random.uniform(0.3,1)
+        else:
+            fog_coeff_t=fog_coeff
+        hw=int(imshape[1]//3*fog_coeff_t)
+        haze_list= generate_random_blur_coordinates(imshape,hw)
+        for haze_points in haze_list: 
+            image= add_blur(image, haze_points[0],haze_points[1], hw,fog_coeff_t) 
+        image = cv2.blur(image ,(hw//10,hw//10))
+        image_RGB = image
+
+    return image_RGB
+
+def generate_gravel_patch(rectangular_roi):
+    x1=rectangular_roi[0]
+    y1=rectangular_roi[1]
+    x2=rectangular_roi[2]
+    y2=rectangular_roi[3] 
+    gravels=[]
+    area= abs((x2-x1)*(y2-y1))
+    for i in range((int)(area//10)):
+        x= np.random.randint(x1,x2)
+        y= np.random.randint(y1,y2)
+        gravels.append((x,y))
+    return gravels
+
+def gravel_process(image,x1,x2,y1,y2,no_of_patches):
+    x=image.shape[1]
+    y=image.shape[0]
+    rectangular_roi_default=[]
+    for i in range(no_of_patches):
+        xx1=random.randint(x1, x2)
+        xx2=random.randint(x1, xx1)
+        yy1=random.randint(y1, y2)
+        yy2=random.randint(y1, yy1)
+        rectangular_roi_default.append((xx2,yy2,min(xx1,xx2+200),min(yy1,yy2+30)))
+    img_hls=hls(image)
+    for roi in rectangular_roi_default:
+        gravels= generate_gravel_patch(roi)
+        for gravel in gravels:
+            x=gravel[0]
+            y=gravel[1]
+            r=random.randint(1, 4)
+            r1=random.randint(0, 255)
+            img_hls[max(y-r,0):min(y+r,y),max(x-r,0):min(x+r,x),1]=r1
+    image_RGB= rgb(img_hls,'hls') 
+    return image_RGB
+
+def add_gravel(image,rectangular_roi=(-1,-1,-1,-1), no_of_patches=8):
+    verify_image(image)
+    if is_tuple(rectangular_roi) and is_numeric_list_or_tuple(rectangular_roi) and len(rectangular_roi)==4:
+        x1=rectangular_roi[0]
+        y1=rectangular_roi[1]
+        x2=rectangular_roi[2]
+        y2=rectangular_roi[3]
+    else:
+        raise Exception(err_invalid_rectangular_roi)
+    if rectangular_roi==(-1,-1,-1,-1):
+        if(is_numpy_array(image)):
+            x1=0
+            y1=int(image.shape[0]*3/4)
+            x2=image.shape[1]
+            y2=image.shape[0]
+        else:
+            x1=0
+            y1=int(image[0].shape[0]*3/4)
+            x2=image[0].shape[1]
+            y2=image[0].shape[0]
+    elif x1==-1 or y1==-1 or x2==-1 or y2==-1 or x2<=x1 or y2<=y1:
+        raise Exception(err_invalid_rectangular_roi)
+    color=[0,255]  
+    if(is_list(image)):
+        image_RGB=[]
+        image_list=image
+        for img in image_list:
+            output= gravel_process(img,x1,x2,y1,y2,no_of_patches)
+            image_RGB.append(output)
+    else:
+        output= gravel_process(image,x1,x2,y1,y2,no_of_patches)
+        image_RGB= output    
+    return image_RGB
+
+err_flare_circle_count="Numeric value between 0 and 20 is allowed"
+def flare_source(image, point,radius,src_color):
+    overlay= image.copy()
+    output= image.copy()
+    num_times=radius//10
+    alpha= np.linspace(0.0,1,num= num_times)
+    rad= np.linspace(1,radius, num=num_times)
+    for i in range(num_times):
+        cv2.circle(overlay,point, int(rad[i]), src_color, -1)
+        alp=alpha[num_times-i-1]*alpha[num_times-i-1]*alpha[num_times-i-1]
+        cv2.addWeighted(overlay, alp, output, 1 -alp ,0, output)
+    return output
+
+def add_sun_flare_line(flare_center,angle,imshape):
+    x=[]
+    y=[]
+    i=0
+    for rand_x in range(0,imshape[1],10):
+        rand_y= math.tan(angle)*(rand_x-flare_center[0])+flare_center[1]
+        x.append(rand_x)
+        y.append(2*flare_center[1]-rand_y)
+    return x,y
+
+def add_sun_process(image, no_of_flare_circles,flare_center,src_radius,x,y,src_color):
+    overlay= image.copy()
+    output= image.copy()
+    imshape=image.shape
+    for i in range(no_of_flare_circles):
+        alpha=random.uniform(0.05,0.2)
+        r=random.randint(0, len(x)-1)
+        rad=random.randint(1, imshape[0]//100-2)
+        cv2.circle(overlay,(int(x[r]),int(y[r])), rad*rad*rad, (random.randint(max(src_color[0]-50,0), src_color[0]),random.randint(max(src_color[1]-50,0), src_color[1]),random.randint(max(src_color[2]-50,0), src_color[2])), -1)
+        cv2.addWeighted(overlay, alpha, output, 1 - alpha,0, output)                      
+    output= flare_source(output,(int(flare_center[0]),int(flare_center[1])),src_radius,src_color)
+    return output
+
+def add_sun_flare(image,flare_center=-1, angle=-1, no_of_flare_circles=8,src_radius=400, src_color=(255,255,255)):
+    verify_image(image)
+    if(angle!=-1):
+        angle=angle%(2*math.pi)
+    if not(no_of_flare_circles>=0 and no_of_flare_circles<=20):
+        raise Exception(err_flare_circle_count)
+    if(is_list(image)):
+        image_RGB=[]
+        image_list=image
+        imshape=image_list[0].shape
+        for img in image_list: 
+            if(angle==-1):
+                angle_t=random.uniform(0,2*math.pi)
+                if angle_t==math.pi/2:
+                    angle_t=0
+            else:
+                angle_t=angle
+            if flare_center==-1:   
+                flare_center_t=(random.randint(0,imshape[1]),random.randint(0,imshape[0]//2))
+            else:
+                flare_center_t=flare_center
+            x,y= add_sun_flare_line(flare_center_t,angle_t,imshape)
+            output= add_sun_process(img, no_of_flare_circles,flare_center_t,src_radius,x,y,src_color)
+            image_RGB.append(output)
+    else:
+        imshape=image.shape
+        if(angle==-1):
+            angle_t=random.uniform(0,2*math.pi)
+            if angle_t==math.pi/2:
+                angle_t=0
+        else:
+            angle_t=angle
+        if flare_center==-1:
+            flare_center_t=(random.randint(0,imshape[1]),random.randint(0,imshape[0]//2))
+        else:
+            flare_center_t=flare_center
+        x,y= add_sun_flare_line(flare_center_t,angle_t,imshape)
+        output= add_sun_process(image, no_of_flare_circles,flare_center_t,src_radius,x,y,src_color)
+        image_RGB = output
+    return image_RGB
+
+err_speed_coeff="Speed coeff can only be between 0 and 1"
+def apply_motion_blur(image,count):
+    image_t=image.copy()
+    imshape=image_t.shape
+    size=15
+    kernel_motion_blur = np.zeros((size, size))
+    kernel_motion_blur[int((size-1)/2), :] = np.ones(size)
+    kernel_motion_blur = kernel_motion_blur / size
+    i= imshape[1]*3//4 - 10*count
+    while(i<=imshape[1]):
+        image_t[:,i:,:] = cv2.filter2D(image_t[:,i:,:], -1, kernel_motion_blur)
+        image_t[:,:imshape[1]-i,:] = cv2.filter2D(image_t[:,:imshape[1]-i,:], -1, kernel_motion_blur)
+        i+=imshape[1]//25-count
+        count+=1
+    image_RGB=image_t
+    return image_RGB
+
+def add_speed(image, speed_coeff=-1):
+    verify_image(image)
+    if(speed_coeff !=-1):
+        if(speed_coeff<0.0 or speed_coeff>1.0):
+            raise Exception(err_speed_coeff)
+    if(is_list(image)):
+        image_RGB=[]
+        image_list=image
+        for img in image_list:
+            if(speed_coeff==-1):
+                count_t=int(15*random.uniform(0,1))
+            else:
+                count_t=int(15*speed_coeff)
+            img=apply_motion_blur(img,count_t)
+            image_RGB.append(img)
+    else:
+        if(speed_coeff==-1):
+            count_t=int(15*random.uniform(0,1))
+        else:
+            count_t=int(15*speed_coeff)
+        image_RGB= apply_motion_blur(image,count_t)
+
+
+    return image_RGB
+
+
+
+def autumn_process(image):
+    image_t=image.copy()
+    imshape=image_t.shape
+    image_hls= hls(image_t)
+    step=8
+    aut_colors=[1,5,9,11]
+    col= aut_colors[random.randint(0,3)]
+    for i in range(0,imshape[1],step):
+        for j in range(0,imshape[0],step):
+            avg=np.average(image_hls[j:j+step,i:i+step,0])
+#             print(avg)
+            if(avg >20 and avg< 100 and np.average(image[j:j+step,i:i+step,1])<100):
+                image_hls[j:j+step,i:i+step,0]= col
+                image_hls[j:j+step,i:i+step,2]=255
+    return rgb(image_hls,'hls')
+
+
+def add_autumn(image):
+    verify_image(image)
+
+    if(is_list(image)):
+        image_RGB=[]
+        image_list=image
+        for img in image_list:
+
+            img=autumn_process(img)
+            image_RGB.append(img)
+    else:
+        image=autumn_process(image)
+        image_RGB= image
+
+    return image_RGB
+
+def fliph(image): ##function to flip the image on horizontal axis
+    verify_image(image)
+    
+    if(is_list(image)):
+        image_RGB=[]
+        image_list=image
+        for img in image_list:
+            image_RGB.append(cv2.flip(img,0))
+    else:
+        image_RGB= cv2.flip(image,0)
+    return image_RGB
+
+def flipv(image): ##function to flip the image on vertical axis
+    verify_image(image)
+    
+    if(is_list(image)):
+        image_RGB=[]
+        image_list=image
+        for img in image_list:
+            image_RGB.append(cv2.flip(img,1))
+    else:
+        image_RGB= cv2.flip(image,1)
+    return image_RGB
+
+def random_flip(image): ##function to flip the image on horizontal axis
+    verify_image(image)
+    
+    if(is_list(image)):
+        image_RGB=[]
+        image_list=image
+        for img in image_list:
+            p= random.uniform(0,1)
+            if(p>0.5):
+                image_RGB.append(cv2.flip(img,0))
+            else:
+                image_RGB.append(cv2.flip(img,1))
+    else:
+        p= random.uniform(0,1)
+        if(p>0.5):
+            image_RGB=cv2.flip(image,0)
+        else:
+            image_RGB=cv2.flip(image,1)
+    return image_RGB
+
+def manhole_process(image,center,height,width,src_color=(0,0,0)):
+    overlay= image.copy()
+    output= image.copy()
+#     cv2.ellipse(overlay, center =center,box=None,color =src_color)
+    cv2.ellipse(overlay, center, (width,height), 0, 0, 360, src_color, -1)
+#     cv2.circle(overlay, center, radius, src_color, -1)
+    alp=1
+    cv2.addWeighted(overlay, alp, output, 1 -alp ,0, output)
+    return output
+
+err_invalid_center_manhole="center should be in the format (x,y)"
+err_invalid_height_width_manhole="height and width should be positive integers."
+def add_manhole(image,center=-1,color=(120,120,120),height=1,width=1, type='closed'): ##function to flip the image on horizontal axis
+    verify_image(image)
+
+    if(center!=-1):
+        if not(is_tuple(center) and is_numeric_list_or_tuple(center) and len(center)==2):
+            raise Exception(err_invalid_center_manhole)
+    if not (is_numeric(height) and is_numeric(width) and height>0 and width>0):
+        raise Exception(err_invalid_height_width_manhole)
+    if color==(120,120,120):
+        if type=='closed':
+            color=(67,70,75)
+        elif type=='open':
+            color=(0,0,0)
+        
+    if(is_list(image)):
+        image_RGB=[]
+        image_list=image
+        for img in image_list:
+            height_t=height
+            width_t=width
+            center_t=center
+            if height==1:
+                height_t=img.shape[0]//25
+            if width==1:
+                width_t=int(img.shape[0]*3//25)
+            if center==-1:
+                center_t= (img.shape[0]-100, img.shape[1]//2)
+            image_RGB.append(manhole_process(img,center_t,height_t,width_t,color))
+    else:
+        height_t=height
+        width_t=width
+        center_t=center
+        if height==1:
+            height_t=image.shape[0]//25
+        if width==1:
+            width_t=int(image.shape[0]*3//25) 
+        if center==-1:
+            center= (image.shape[0]-100, image.shape[1]//2)
+        image_RGB= manhole_process(image,center_t,height_t,width_t,color)
+    return image_RGB
+
+def exposure_process(image):
+    image= np.copy(image)
+    img_yuv = cv2.cvtColor(image, cv2.COLOR_BGR2YUV)
+    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(4,4))
+    ones= np.ones(img_yuv[:,:,0].shape)
+    ones[img_yuv[:,:,0]>150]= 0.85
+    img_yuv[:,:,0]= img_yuv[:,:,0]*ones
+
+    img_yuv[:,:,0] = clahe.apply(img_yuv[:,:,0])
+    img_yuv[:,:,0] = cv2.equalizeHist(img_yuv[:,:,0])
+    img_yuv[:,:,0] = clahe.apply(img_yuv[:,:,0])
+
+    image_res = cv2.cvtColor(img_yuv, cv2.COLOR_YUV2BGR)
+    image_res= cv2.fastNlMeansDenoisingColored(image_res,None,3,3,7,21)
+    return image_res
+
+def correct_exposure(image):
+    verify_image(image)
+    if(is_list(image)):
+        image_RGB=[]
+        image_list=image
+        for img in image_list:
+            image_RGB.append(exposure_process(img))
+    else:
+        image_RGB= exposure_process(image)
+    return image_RGB
+            
+err_aug_type='wrong augmentation function is defined'
+err_aug_list_type='aug_types should be a list of string function names'
+err_aug_volume='volume type can only be "same" or "expand"'
+def augment_random(image, aug_types="", volume='expand' ):
+    
+    aug_types_all=["random_brightness","add_shadow","add_snow","add_rain","add_fog","add_gravel","add_sun_flare","add_speed","add_autumn","random_flip","add_manhole"]
+    if aug_types=="":
+        aug_types=aug_types_all
+    output=[]
+    if not(is_list(aug_types)):
+        raise Exception(err_aug_list_type)
+    
+    if volume=='expand':
+        for aug_type in aug_types:
+
+            if not(aug_type in aug_types_all):
+                raise Exception(err_aug_type)
+            command=aug_type+'(image)'
+            result=eval(command)
+            if(is_list(result)):
+                output+=result
+            else:
+                output.append(result)
+    elif volume=='same':
+        verify_image(image)
+        for aug_type in aug_types:
+            if not(aug_type in aug_types_all):
+                raise Exception(err_aug_type)
+        if(is_list(image)):
+            image_list=image
+            for img in image_list:
+                selected_aug=aug_types[random.randint(0,len(aug_types)-1)]
+                command=selected_aug+'(img)'
+                output.append(eval(command))
+        else:
+            selected_aug=aug_types[random.randint(0,len(aug_types)-1)]
+            command=selected_aug+'(image)'
+            output=eval(command)
+
+    else: 
+        raise Exception(err_aug_volume)
+
+    return output