def __init__(self, crop_size, keys=['imgs'], cat_max_ratio=1.0): self.keys = keys if len(keys) < 1: raise ValueError(f'please assign keys that you want to apply to.') elif len(keys) == 1: if is_list_of(crop_size, int): self.crop_size = [crop_size] elif is_list_of(crop_size, list) and len(crop_size) == 1: self.crop_size = crop_size else: raise TypeError( f'parameter "crop_size" must be type of "list of int" or ' f'"list of one list" when there is only one key, please check it.' ) else: if is_list_of(crop_size, list) and len(crop_size) == len(keys): self.crop_size = crop_size elif is_list_of(crop_size, int) and len(crop_size) == 1: self.crop_size = [crop_size for _ in range(len(keys))] else: raise TypeError( f'parameter "crop_size" must be type of "list of list" and ' f'have the same length as "keys".') self.cat_max_ratio = cat_max_ratio
def __init__(self, keys, order): if not isinstance(keys, list): raise TypeError( f'parameter "keys" should be type of list, ' f'but got {type(keys)}.') else: self.keys = keys if is_list_of(order, list): self.order = order elif is_list_of(order, int): self.order = [order for _ in range(len(keys))] else: raise TypeError( f'parameter "order" should be type of list, ' f'but got {type(order)}.')
def __init__(self, keys=['imgs'], img_scale=[], border_color=[127.5, 127.5, 127.5], interpolation='area', with_box=False, box_key=None): self.keys = keys if len(keys) < 1: raise ValueError(f'please assign keys that you want to apply to.') elif len(keys) == 1: if is_list_of(img_scale, int): self.img_scale = [img_scale] elif is_list_of(img_scale, list) and len(img_scale) == 1: self.img_scale = img_scale else: raise TypeError( f'paramater "img_scale" must be type of "list of list" or ' f'"list of int" when there is only one key.') if isinstance(interpolation, str): self.interpolation = [interpolation] elif is_list_of(interpolation, str) and \ len(interpolation) == len(keys): self.interpolation = interpolation else: raise TypeError( f'parameter "interpolation" must be type of "list of str" ' f'or "str" when there is only one key.') else: if is_list_of(img_scale, list) and len(img_scale) == len(keys): self.img_scale = img_scale else: raise TypeError( f'parameter "img_scale" must be type of "list of list" ' f'with same length as "keys" when there are more ' f'than one keys.') if is_list_of(interpolation, str) and \ len(interpolation) == len(keys): self.interpolation = interpolation else: raise TypeError( f'parameter "interpolation" must be type of "list of str" ' f'with some length as "keys" when there are more ' f'than one keys.') self.border_color = border_color self.with_box = with_box self.box_key = box_key
def __call__(self, results): # assert results.get(self.out_keys) is None assert len(self.zip_keys) > 0 and is_list_of(self.zip_keys, str) data = {} for key in self.zip_keys: assert results.get(key) is not None data[key] = results[key] results[self.out_keys] = data return results
def random_sample(img_scales): assert is_list_of(img_scales, list) and len(img_scales) == 2 img_scale_long = [max(s) for s in img_scales] img_scale_short = [min(s) for s in img_scales] long_edge = np.random.randint(min(img_scale_long), max(img_scale_long) + 1) short_edge = np.random.randint(min(img_scale_short), max(img_scale_short) + 1) img_scale = (long_edge, short_edge) return img_scale, None
def __init__(self, keys=['imgs'], flip_ratio=0.5, direction='horizontal', with_box=False, box_key=None, restore_size=False, begin_idx=0): self.keys = keys if len(keys) < 1: raise ValueError(f'please assign keys that you want to apply to.') elif len(keys) == 1: if isinstance(direction, str): self.direction = [direction] elif is_list_of(direction, str) and len(direction) == 1: self.direction = direction else: raise TypeError( f'parameter "direction" must be type of "list of str" or ' f'"str" when there is only one key, please check for it.') else: if is_list_of(direction, str) and len(direction) == len(keys): self.direction = direction else: raise TypeError( f'parameter "direction" must be type of "list of str" and ' f'have the same length as "keys".') for item in self.direction: assert item in ['horizontal', 'vertical'] self.with_box = with_box self.box_key = box_key self.begin_idx = begin_idx self.restore_size = restore_size if np.random.rand() < flip_ratio: self.flip = True else: self.flip = False
def __init__(self, key='imgs', img_scale=None, multiscale_mode='range', ratio_range=None, interpolation='bilinear', keep_ratio=True, rescale_edge='max', with_box=False, output_stride=None, box_key='gt_bbox', begin_idx=0): if img_scale is None: self.img_scale = None else: if is_list_of(img_scale, list): self.img_scale = img_scale else: self.img_scale = [img_scale] assert is_list_of(self.img_scale, list) if ratio_range is not None: # mode 1: given a scale and a range of image ratio assert len(self.img_scale) == 1 else: # mode 2: given multiple scales or a range of scales assert multiscale_mode in ['value', 'range'] self.multiscale_mode = multiscale_mode self.ratio_range = ratio_range self.keep_ratio = keep_ratio self.rescale_edge = rescale_edge self.interpolation = interpolation self.key = key self.with_box = with_box self.output_stride = output_stride self.box_key = box_key self.begin_idx = begin_idx
def build_module_from_registers(cfg, module_name=None, sub_cfg=None): if cfg is None: return None if module_name is None: key = list(cfg.keys()) assert len(key) == 1 module_name = key[0] module_cfg = copy.deepcopy(cfg[module_name]) else: module_cfg = copy.deepcopy(cfg) if not hasattr(Registers, module_name): # TODO: the module_name must be inside the Registers!!! if module_name == 'train_cfg' or module_name == 'test_cfg': return module_cfg else: raise ValueError(f'No module {module_name} found in Registers.') if is_list_of(module_cfg, dict): module = nn.ModuleList() for item in module_cfg: register = getattr(Registers, module_name) if item.get('type') is not None: module_type = item.pop('type') else: raise ValueError(f'{item} should include key "type".') if sub_cfg is not None: item = merge_subcfg(item, sub_cfg) module.append(register[module_type](**item)) elif isinstance(module_cfg, dict): register = getattr(Registers, module_name) if module_cfg.get('type') is not None: module_type = module_cfg.pop('type') else: raise ValueError(f'{module_cfg} should include key "type".') if sub_cfg is not None: module_cfg = merge_subcfg(module_cfg, sub_cfg) module = register[module_type](**module_cfg) else: raise ValueError( f'"module_cfg" must be type of "list of dict" or "dict"') return module
def __init__(self, keys=['imgs'], size=None, pad_val=0): self.keys = keys if len(keys) < 1: raise ValueError(f'please assign keys that you want to apply to.') elif len(keys) == 1: if size is None or is_list_of(size, int): self.size = [size] elif is_list_of_list_or_nontype(size) and len(size) == 1: self.size = size else: raise TypeError( f'parameter "size" must be type of "list of one int", "None", ' f'"list of one list" or "list of None" when ' f'there is only one key, please check for it.') if isinstance(pad_val, int): self.pad_val = [pad_val] elif is_list_of(pad_val, int) and len(pad_val) != 1: self.pad_val = [pad_val] elif is_list_of(pad_val, list) and len(pad_val) == 1: self.pad_val = pad_val elif is_list_of(pad_val, int) and len(pad_val) == 1: self.pad_val = pad_val else: raise TypeError( f'parameter "pad_val" must be type of "list of one int", ' f'"list of list", "list of one list" or "int" when ' f'there is only one key, please check for it.') else: if is_list_of(size, list) and len(size) == len(keys): self.size = size else: raise TypeError( f'parameter "size" must be type of "list of list" and ' f'have the same length as "keys".') if is_list_of(pad_val, list) and len(pad_val) == len(keys): self.pad_val = [ item[0] if len(item) == 1 else item for item in pad_val ] else: raise TypeError( f'parameter "pad_val" must be type of "list of list" and ' f'have the same length as "keys".')
def __init__(self, mean, std, keys=['imgs'], to_rgb=True): self.keys = keys if len(keys) < 1: raise ValueError(f'please assign keys that you want to apply to.') elif len(keys) == 1: if isinstance(mean, (float, int)) or is_list_of(mean, (float, int)): self.mean = [mean] elif is_list_of(mean, list) and len(mean) == 1: self.mean = mean else: raise TypeError( f'parameter "mean" must be type of "list of int(float)", ' f'"float", "int" or "list of one list" when ' f'there is only one key, please check for it.') if isinstance(std, (float, int)) or is_list_of(std, (float, int)): self.std = [std] elif is_list_of(std, list) and len(std) == 1: self.std = std else: raise TypeError( f'parameter "std" must be type of "list of int(float)", ' f'"float", "int" or "list of one list" when ' f'there is only one key, please check for it.') else: if is_list_of(mean, list) and len(mean) == len(keys): self.mean = mean else: raise TypeError( f'parameter "mean" must be type of "list of list" and ' f'have the same length as "keys".') if is_list_of(std, list) and len(std) == len(keys): self.std = std else: raise TypeError( f'parameter "std" must be type of "list of list" and ' f'have the same length as "keys".') self.mean = np.array(self.mean, dtype=np.float32) self.std = np.array(self.std, dtype=np.float32) self.to_rgb = to_rgb
def __init__(self, keys=['imgs'], degrees=[-10, 10], translate=[0.1, 0.1], scale=[0.9, 1.1], shear=[-2, 2], border_value=[127.5, 127.5, 127.5], with_box=False, box_key=None, to_xywh=False): self.keys = keys if len(keys) < 1: raise TypeError(f'please assign keys that you want to apply to.') elif len(keys) == 1: if is_list_of(degrees, int) or is_list_of(degrees, float): self.degrees = [degrees] elif is_list_of(degrees, list) and len(degrees) == len(keys): self.degrees = degrees else: raise TypeError( f'parameter "degrees" must be type of "list of int(float)", ' f'"list of one list" when there is only one key, ' f'please check for it.') if is_list_of(translate, int) or is_list_of(translate, float): self.translate = [translate] elif is_list_of(translate, list) and len(translate) == len(keys): self.translate = translate else: raise TypeError( f'parameter "translate" must be type of "list of int(float)", ' f'"list of one list" when there is only one key, ' f'please check for it.') if is_list_of(scale, int) or is_list_of(scale, float): self.scale = [scale] elif is_list_of(scale, list) and len(scale) == len(keys): self.scale = scale else: raise TypeError( f'parameter "scale" must be type of "list of int(float)", ' f'"list of one list" when there is only one key, ' f'please check for it.') if is_list_of(shear, int) or is_list_of(shear, float): self.shear = [shear] elif is_list_of(shear, list) and len(shear) == len(keys): self.shear = shear else: raise TypeError( f'parameter "shear" must be type of "list of int(float)", ' f'"list of one list" when there is only one key, ' f'please check for it.') else: if is_list_of(degrees, list) and len(degrees) == len(keys): self.degress = degrees else: raise TypeError( f'parameter "degrees" must be type of "list of list" and ' f'have the same length as "keys".') if is_list_of(scale, list) and len(scale) == len(scale): self.scale = scale else: raise TypeError( f'parameter "scale" must be type of "list of list" and ' f'have the same length as "keys".') if is_list_of(translate, list) and len(translate) == len(keys): self.translate = translate else: raise TypeError( f'parameter "translate" must be type of "list of list" and ' f'have the same length as "keys".') if is_list_of(shear, list) and len(shear) == len(shear): self.shear = shear else: raise TypeError( f'parameter "shear must be type of "list of list" and ' f'have the same length as "keys".') self.border_value = border_value self.with_box = with_box self.box_key = box_key self.to_xywh = to_xywh
def random_select(img_scales): assert is_list_of(img_scales, list) scale_idx = np.random.randint(len(img_scales)) img_scale = img_scales[scale_idx] return img_scale, scale_idx