| | |
| |
|
| | from typing import Optional, Union |
| |
|
| | import cv2 |
| | import mmcv |
| | import numpy as np |
| | from mmcv.transforms import BaseTransform |
| | from mmcv.transforms.utils import cache_randomness |
| |
|
| | from mmdet.registry import TRANSFORMS |
| | from mmdet.structures.bbox import autocast_box_type |
| | from .augment_wrappers import _MAX_LEVEL, level_to_mag |
| |
|
| |
|
| | @TRANSFORMS.register_module() |
| | class GeomTransform(BaseTransform): |
| | """Base class for geometric transformations. All geometric transformations |
| | need to inherit from this base class. ``GeomTransform`` unifies the class |
| | attributes and class functions of geometric transformations (ShearX, |
| | ShearY, Rotate, TranslateX, and TranslateY), and records the homography |
| | matrix. |
| | |
| | Required Keys: |
| | |
| | - img |
| | - gt_bboxes (BaseBoxes[torch.float32]) (optional) |
| | - gt_masks (BitmapMasks | PolygonMasks) (optional) |
| | - gt_seg_map (np.uint8) (optional) |
| | |
| | Modified Keys: |
| | |
| | - img |
| | - gt_bboxes |
| | - gt_masks |
| | - gt_seg_map |
| | |
| | Added Keys: |
| | |
| | - homography_matrix |
| | |
| | Args: |
| | prob (float): The probability for performing the geometric |
| | transformation and should be in range [0, 1]. Defaults to 1.0. |
| | level (int, optional): The level should be in range [0, _MAX_LEVEL]. |
| | If level is None, it will generate from [0, _MAX_LEVEL] randomly. |
| | Defaults to None. |
| | min_mag (float): The minimum magnitude for geometric transformation. |
| | Defaults to 0.0. |
| | max_mag (float): The maximum magnitude for geometric transformation. |
| | Defaults to 1.0. |
| | reversal_prob (float): The probability that reverses the geometric |
| | transformation magnitude. Should be in range [0,1]. |
| | Defaults to 0.5. |
| | img_border_value (int | float | tuple): The filled values for |
| | image border. If float, the same fill value will be used for |
| | all the three channels of image. If tuple, it should be 3 elements. |
| | Defaults to 128. |
| | mask_border_value (int): The fill value used for masks. Defaults to 0. |
| | seg_ignore_label (int): The fill value used for segmentation map. |
| | Note this value must equals ``ignore_label`` in ``semantic_head`` |
| | of the corresponding config. Defaults to 255. |
| | interpolation (str): Interpolation method, accepted values are |
| | "nearest", "bilinear", "bicubic", "area", "lanczos" for 'cv2' |
| | backend, "nearest", "bilinear" for 'pillow' backend. Defaults |
| | to 'bilinear'. |
| | """ |
| |
|
| | def __init__(self, |
| | prob: float = 1.0, |
| | level: Optional[int] = None, |
| | min_mag: float = 0.0, |
| | max_mag: float = 1.0, |
| | reversal_prob: float = 0.5, |
| | img_border_value: Union[int, float, tuple] = 128, |
| | mask_border_value: int = 0, |
| | seg_ignore_label: int = 255, |
| | interpolation: str = 'bilinear') -> None: |
| | assert 0 <= prob <= 1.0, f'The probability of the transformation ' \ |
| | f'should be in range [0,1], got {prob}.' |
| | assert level is None or isinstance(level, int), \ |
| | f'The level should be None or type int, got {type(level)}.' |
| | assert level is None or 0 <= level <= _MAX_LEVEL, \ |
| | f'The level should be in range [0,{_MAX_LEVEL}], got {level}.' |
| | assert isinstance(min_mag, float), \ |
| | f'min_mag should be type float, got {type(min_mag)}.' |
| | assert isinstance(max_mag, float), \ |
| | f'max_mag should be type float, got {type(max_mag)}.' |
| | assert min_mag <= max_mag, \ |
| | f'min_mag should smaller than max_mag, ' \ |
| | f'got min_mag={min_mag} and max_mag={max_mag}' |
| | assert isinstance(reversal_prob, float), \ |
| | f'reversal_prob should be type float, got {type(max_mag)}.' |
| | assert 0 <= reversal_prob <= 1.0, \ |
| | f'The reversal probability of the transformation magnitude ' \ |
| | f'should be type float, got {type(reversal_prob)}.' |
| | if isinstance(img_border_value, (float, int)): |
| | img_border_value = tuple([float(img_border_value)] * 3) |
| | elif isinstance(img_border_value, tuple): |
| | assert len(img_border_value) == 3, \ |
| | f'img_border_value as tuple must have 3 elements, ' \ |
| | f'got {len(img_border_value)}.' |
| | img_border_value = tuple([float(val) for val in img_border_value]) |
| | else: |
| | raise ValueError( |
| | 'img_border_value must be float or tuple with 3 elements.') |
| | assert np.all([0 <= val <= 255 for val in img_border_value]), 'all ' \ |
| | 'elements of img_border_value should between range [0,255].' \ |
| | f'got {img_border_value}.' |
| | self.prob = prob |
| | self.level = level |
| | self.min_mag = min_mag |
| | self.max_mag = max_mag |
| | self.reversal_prob = reversal_prob |
| | self.img_border_value = img_border_value |
| | self.mask_border_value = mask_border_value |
| | self.seg_ignore_label = seg_ignore_label |
| | self.interpolation = interpolation |
| |
|
| | def _transform_img(self, results: dict, mag: float) -> None: |
| | """Transform the image.""" |
| | pass |
| |
|
| | def _transform_masks(self, results: dict, mag: float) -> None: |
| | """Transform the masks.""" |
| | pass |
| |
|
| | def _transform_seg(self, results: dict, mag: float) -> None: |
| | """Transform the segmentation map.""" |
| | pass |
| |
|
| | def _get_homography_matrix(self, results: dict, mag: float) -> np.ndarray: |
| | """Get the homography matrix for the geometric transformation.""" |
| | return np.eye(3, dtype=np.float32) |
| |
|
| | def _transform_bboxes(self, results: dict, mag: float) -> None: |
| | """Transform the bboxes.""" |
| | results['gt_bboxes'].project_(self.homography_matrix) |
| | results['gt_bboxes'].clip_(results['img_shape']) |
| |
|
| | def _record_homography_matrix(self, results: dict) -> None: |
| | """Record the homography matrix for the geometric transformation.""" |
| | if results.get('homography_matrix', None) is None: |
| | results['homography_matrix'] = self.homography_matrix |
| | else: |
| | results['homography_matrix'] = self.homography_matrix @ results[ |
| | 'homography_matrix'] |
| |
|
| | @cache_randomness |
| | def _random_disable(self): |
| | """Randomly disable the transform.""" |
| | return np.random.rand() > self.prob |
| |
|
| | @cache_randomness |
| | def _get_mag(self): |
| | """Get the magnitude of the transform.""" |
| | mag = level_to_mag(self.level, self.min_mag, self.max_mag) |
| | return -mag if np.random.rand() > self.reversal_prob else mag |
| |
|
| | @autocast_box_type() |
| | def transform(self, results: dict) -> dict: |
| | """Transform function for images, bounding boxes, masks and semantic |
| | segmentation map. |
| | |
| | Args: |
| | results (dict): Result dict from loading pipeline. |
| | |
| | Returns: |
| | dict: Transformed results. |
| | """ |
| |
|
| | if self._random_disable(): |
| | return results |
| | mag = self._get_mag() |
| | self.homography_matrix = self._get_homography_matrix(results, mag) |
| | self._record_homography_matrix(results) |
| | self._transform_img(results, mag) |
| | if results.get('gt_bboxes', None) is not None: |
| | self._transform_bboxes(results, mag) |
| | if results.get('gt_masks', None) is not None: |
| | self._transform_masks(results, mag) |
| | if results.get('gt_seg_map', None) is not None: |
| | self._transform_seg(results, mag) |
| | return results |
| |
|
| | def __repr__(self) -> str: |
| | repr_str = self.__class__.__name__ |
| | repr_str += f'(prob={self.prob}, ' |
| | repr_str += f'level={self.level}, ' |
| | repr_str += f'min_mag={self.min_mag}, ' |
| | repr_str += f'max_mag={self.max_mag}, ' |
| | repr_str += f'reversal_prob={self.reversal_prob}, ' |
| | repr_str += f'img_border_value={self.img_border_value}, ' |
| | repr_str += f'mask_border_value={self.mask_border_value}, ' |
| | repr_str += f'seg_ignore_label={self.seg_ignore_label}, ' |
| | repr_str += f'interpolation={self.interpolation})' |
| | return repr_str |
| |
|
| |
|
| | @TRANSFORMS.register_module() |
| | class ShearX(GeomTransform): |
| | """Shear the images, bboxes, masks and segmentation map horizontally. |
| | |
| | Required Keys: |
| | |
| | - img |
| | - gt_bboxes (BaseBoxes[torch.float32]) (optional) |
| | - gt_masks (BitmapMasks | PolygonMasks) (optional) |
| | - gt_seg_map (np.uint8) (optional) |
| | |
| | Modified Keys: |
| | |
| | - img |
| | - gt_bboxes |
| | - gt_masks |
| | - gt_seg_map |
| | |
| | Added Keys: |
| | |
| | - homography_matrix |
| | |
| | Args: |
| | prob (float): The probability for performing Shear and should be in |
| | range [0, 1]. Defaults to 1.0. |
| | level (int, optional): The level should be in range [0, _MAX_LEVEL]. |
| | If level is None, it will generate from [0, _MAX_LEVEL] randomly. |
| | Defaults to None. |
| | min_mag (float): The minimum angle for the horizontal shear. |
| | Defaults to 0.0. |
| | max_mag (float): The maximum angle for the horizontal shear. |
| | Defaults to 30.0. |
| | reversal_prob (float): The probability that reverses the horizontal |
| | shear magnitude. Should be in range [0,1]. Defaults to 0.5. |
| | img_border_value (int | float | tuple): The filled values for |
| | image border. If float, the same fill value will be used for |
| | all the three channels of image. If tuple, it should be 3 elements. |
| | Defaults to 128. |
| | mask_border_value (int): The fill value used for masks. Defaults to 0. |
| | seg_ignore_label (int): The fill value used for segmentation map. |
| | Note this value must equals ``ignore_label`` in ``semantic_head`` |
| | of the corresponding config. Defaults to 255. |
| | interpolation (str): Interpolation method, accepted values are |
| | "nearest", "bilinear", "bicubic", "area", "lanczos" for 'cv2' |
| | backend, "nearest", "bilinear" for 'pillow' backend. Defaults |
| | to 'bilinear'. |
| | """ |
| |
|
| | def __init__(self, |
| | prob: float = 1.0, |
| | level: Optional[int] = None, |
| | min_mag: float = 0.0, |
| | max_mag: float = 30.0, |
| | reversal_prob: float = 0.5, |
| | img_border_value: Union[int, float, tuple] = 128, |
| | mask_border_value: int = 0, |
| | seg_ignore_label: int = 255, |
| | interpolation: str = 'bilinear') -> None: |
| | assert 0. <= min_mag <= 90., \ |
| | f'min_mag angle for ShearX should be ' \ |
| | f'in range [0, 90], got {min_mag}.' |
| | assert 0. <= max_mag <= 90., \ |
| | f'max_mag angle for ShearX should be ' \ |
| | f'in range [0, 90], got {max_mag}.' |
| | super().__init__( |
| | prob=prob, |
| | level=level, |
| | min_mag=min_mag, |
| | max_mag=max_mag, |
| | reversal_prob=reversal_prob, |
| | img_border_value=img_border_value, |
| | mask_border_value=mask_border_value, |
| | seg_ignore_label=seg_ignore_label, |
| | interpolation=interpolation) |
| |
|
| | @cache_randomness |
| | def _get_mag(self): |
| | """Get the magnitude of the transform.""" |
| | mag = level_to_mag(self.level, self.min_mag, self.max_mag) |
| | mag = np.tan(mag * np.pi / 180) |
| | return -mag if np.random.rand() > self.reversal_prob else mag |
| |
|
| | def _get_homography_matrix(self, results: dict, mag: float) -> np.ndarray: |
| | """Get the homography matrix for ShearX.""" |
| | return np.array([[1, mag, 0], [0, 1, 0], [0, 0, 1]], dtype=np.float32) |
| |
|
| | def _transform_img(self, results: dict, mag: float) -> None: |
| | """Shear the image horizontally.""" |
| | results['img'] = mmcv.imshear( |
| | results['img'], |
| | mag, |
| | direction='horizontal', |
| | border_value=self.img_border_value, |
| | interpolation=self.interpolation) |
| |
|
| | def _transform_masks(self, results: dict, mag: float) -> None: |
| | """Shear the masks horizontally.""" |
| | results['gt_masks'] = results['gt_masks'].shear( |
| | results['img_shape'], |
| | mag, |
| | direction='horizontal', |
| | border_value=self.mask_border_value, |
| | interpolation=self.interpolation) |
| |
|
| | def _transform_seg(self, results: dict, mag: float) -> None: |
| | """Shear the segmentation map horizontally.""" |
| | results['gt_seg_map'] = mmcv.imshear( |
| | results['gt_seg_map'], |
| | mag, |
| | direction='horizontal', |
| | border_value=self.seg_ignore_label, |
| | interpolation='nearest') |
| |
|
| |
|
| | @TRANSFORMS.register_module() |
| | class ShearY(GeomTransform): |
| | """Shear the images, bboxes, masks and segmentation map vertically. |
| | |
| | Required Keys: |
| | |
| | - img |
| | - gt_bboxes (BaseBoxes[torch.float32]) (optional) |
| | - gt_masks (BitmapMasks | PolygonMasks) (optional) |
| | - gt_seg_map (np.uint8) (optional) |
| | |
| | Modified Keys: |
| | |
| | - img |
| | - gt_bboxes |
| | - gt_masks |
| | - gt_seg_map |
| | |
| | Added Keys: |
| | |
| | - homography_matrix |
| | |
| | Args: |
| | prob (float): The probability for performing ShearY and should be in |
| | range [0, 1]. Defaults to 1.0. |
| | level (int, optional): The level should be in range [0,_MAX_LEVEL]. |
| | If level is None, it will generate from [0, _MAX_LEVEL] randomly. |
| | Defaults to None. |
| | min_mag (float): The minimum angle for the vertical shear. |
| | Defaults to 0.0. |
| | max_mag (float): The maximum angle for the vertical shear. |
| | Defaults to 30.0. |
| | reversal_prob (float): The probability that reverses the vertical |
| | shear magnitude. Should be in range [0,1]. Defaults to 0.5. |
| | img_border_value (int | float | tuple): The filled values for |
| | image border. If float, the same fill value will be used for |
| | all the three channels of image. If tuple, it should be 3 elements. |
| | Defaults to 128. |
| | mask_border_value (int): The fill value used for masks. Defaults to 0. |
| | seg_ignore_label (int): The fill value used for segmentation map. |
| | Note this value must equals ``ignore_label`` in ``semantic_head`` |
| | of the corresponding config. Defaults to 255. |
| | interpolation (str): Interpolation method, accepted values are |
| | "nearest", "bilinear", "bicubic", "area", "lanczos" for 'cv2' |
| | backend, "nearest", "bilinear" for 'pillow' backend. Defaults |
| | to 'bilinear'. |
| | """ |
| |
|
| | def __init__(self, |
| | prob: float = 1.0, |
| | level: Optional[int] = None, |
| | min_mag: float = 0.0, |
| | max_mag: float = 30., |
| | reversal_prob: float = 0.5, |
| | img_border_value: Union[int, float, tuple] = 128, |
| | mask_border_value: int = 0, |
| | seg_ignore_label: int = 255, |
| | interpolation: str = 'bilinear') -> None: |
| | assert 0. <= min_mag <= 90., \ |
| | f'min_mag angle for ShearY should be ' \ |
| | f'in range [0, 90], got {min_mag}.' |
| | assert 0. <= max_mag <= 90., \ |
| | f'max_mag angle for ShearY should be ' \ |
| | f'in range [0, 90], got {max_mag}.' |
| | super().__init__( |
| | prob=prob, |
| | level=level, |
| | min_mag=min_mag, |
| | max_mag=max_mag, |
| | reversal_prob=reversal_prob, |
| | img_border_value=img_border_value, |
| | mask_border_value=mask_border_value, |
| | seg_ignore_label=seg_ignore_label, |
| | interpolation=interpolation) |
| |
|
| | @cache_randomness |
| | def _get_mag(self): |
| | """Get the magnitude of the transform.""" |
| | mag = level_to_mag(self.level, self.min_mag, self.max_mag) |
| | mag = np.tan(mag * np.pi / 180) |
| | return -mag if np.random.rand() > self.reversal_prob else mag |
| |
|
| | def _get_homography_matrix(self, results: dict, mag: float) -> np.ndarray: |
| | """Get the homography matrix for ShearY.""" |
| | return np.array([[1, 0, 0], [mag, 1, 0], [0, 0, 1]], dtype=np.float32) |
| |
|
| | def _transform_img(self, results: dict, mag: float) -> None: |
| | """Shear the image vertically.""" |
| | results['img'] = mmcv.imshear( |
| | results['img'], |
| | mag, |
| | direction='vertical', |
| | border_value=self.img_border_value, |
| | interpolation=self.interpolation) |
| |
|
| | def _transform_masks(self, results: dict, mag: float) -> None: |
| | """Shear the masks vertically.""" |
| | results['gt_masks'] = results['gt_masks'].shear( |
| | results['img_shape'], |
| | mag, |
| | direction='vertical', |
| | border_value=self.mask_border_value, |
| | interpolation=self.interpolation) |
| |
|
| | def _transform_seg(self, results: dict, mag: float) -> None: |
| | """Shear the segmentation map vertically.""" |
| | results['gt_seg_map'] = mmcv.imshear( |
| | results['gt_seg_map'], |
| | mag, |
| | direction='vertical', |
| | border_value=self.seg_ignore_label, |
| | interpolation='nearest') |
| |
|
| |
|
| | @TRANSFORMS.register_module() |
| | class Rotate(GeomTransform): |
| | """Rotate the images, bboxes, masks and segmentation map. |
| | |
| | Required Keys: |
| | |
| | - img |
| | - gt_bboxes (BaseBoxes[torch.float32]) (optional) |
| | - gt_masks (BitmapMasks | PolygonMasks) (optional) |
| | - gt_seg_map (np.uint8) (optional) |
| | |
| | Modified Keys: |
| | |
| | - img |
| | - gt_bboxes |
| | - gt_masks |
| | - gt_seg_map |
| | |
| | Added Keys: |
| | |
| | - homography_matrix |
| | |
| | Args: |
| | prob (float): The probability for perform transformation and |
| | should be in range 0 to 1. Defaults to 1.0. |
| | level (int, optional): The level should be in range [0, _MAX_LEVEL]. |
| | If level is None, it will generate from [0, _MAX_LEVEL] randomly. |
| | Defaults to None. |
| | min_mag (float): The maximum angle for rotation. |
| | Defaults to 0.0. |
| | max_mag (float): The maximum angle for rotation. |
| | Defaults to 30.0. |
| | reversal_prob (float): The probability that reverses the rotation |
| | magnitude. Should be in range [0,1]. Defaults to 0.5. |
| | img_border_value (int | float | tuple): The filled values for |
| | image border. If float, the same fill value will be used for |
| | all the three channels of image. If tuple, it should be 3 elements. |
| | Defaults to 128. |
| | mask_border_value (int): The fill value used for masks. Defaults to 0. |
| | seg_ignore_label (int): The fill value used for segmentation map. |
| | Note this value must equals ``ignore_label`` in ``semantic_head`` |
| | of the corresponding config. Defaults to 255. |
| | interpolation (str): Interpolation method, accepted values are |
| | "nearest", "bilinear", "bicubic", "area", "lanczos" for 'cv2' |
| | backend, "nearest", "bilinear" for 'pillow' backend. Defaults |
| | to 'bilinear'. |
| | """ |
| |
|
| | def __init__(self, |
| | prob: float = 1.0, |
| | level: Optional[int] = None, |
| | min_mag: float = 0.0, |
| | max_mag: float = 30.0, |
| | reversal_prob: float = 0.5, |
| | img_border_value: Union[int, float, tuple] = 128, |
| | mask_border_value: int = 0, |
| | seg_ignore_label: int = 255, |
| | interpolation: str = 'bilinear') -> None: |
| | assert 0. <= min_mag <= 180., \ |
| | f'min_mag for Rotate should be in range [0,180], got {min_mag}.' |
| | assert 0. <= max_mag <= 180., \ |
| | f'max_mag for Rotate should be in range [0,180], got {max_mag}.' |
| | super().__init__( |
| | prob=prob, |
| | level=level, |
| | min_mag=min_mag, |
| | max_mag=max_mag, |
| | reversal_prob=reversal_prob, |
| | img_border_value=img_border_value, |
| | mask_border_value=mask_border_value, |
| | seg_ignore_label=seg_ignore_label, |
| | interpolation=interpolation) |
| |
|
| | def _get_homography_matrix(self, results: dict, mag: float) -> np.ndarray: |
| | """Get the homography matrix for Rotate.""" |
| | img_shape = results['img_shape'] |
| | center = ((img_shape[1] - 1) * 0.5, (img_shape[0] - 1) * 0.5) |
| | cv2_rotation_matrix = cv2.getRotationMatrix2D(center, -mag, 1.0) |
| | return np.concatenate( |
| | [cv2_rotation_matrix, |
| | np.array([0, 0, 1]).reshape((1, 3))]).astype(np.float32) |
| |
|
| | def _transform_img(self, results: dict, mag: float) -> None: |
| | """Rotate the image.""" |
| | results['img'] = mmcv.imrotate( |
| | results['img'], |
| | mag, |
| | border_value=self.img_border_value, |
| | interpolation=self.interpolation) |
| |
|
| | def _transform_masks(self, results: dict, mag: float) -> None: |
| | """Rotate the masks.""" |
| | results['gt_masks'] = results['gt_masks'].rotate( |
| | results['img_shape'], |
| | mag, |
| | border_value=self.mask_border_value, |
| | interpolation=self.interpolation) |
| |
|
| | def _transform_seg(self, results: dict, mag: float) -> None: |
| | """Rotate the segmentation map.""" |
| | results['gt_seg_map'] = mmcv.imrotate( |
| | results['gt_seg_map'], |
| | mag, |
| | border_value=self.seg_ignore_label, |
| | interpolation='nearest') |
| |
|
| |
|
| | @TRANSFORMS.register_module() |
| | class TranslateX(GeomTransform): |
| | """Translate the images, bboxes, masks and segmentation map horizontally. |
| | |
| | Required Keys: |
| | |
| | - img |
| | - gt_bboxes (BaseBoxes[torch.float32]) (optional) |
| | - gt_masks (BitmapMasks | PolygonMasks) (optional) |
| | - gt_seg_map (np.uint8) (optional) |
| | |
| | Modified Keys: |
| | |
| | - img |
| | - gt_bboxes |
| | - gt_masks |
| | - gt_seg_map |
| | |
| | Added Keys: |
| | |
| | - homography_matrix |
| | |
| | Args: |
| | prob (float): The probability for perform transformation and |
| | should be in range 0 to 1. Defaults to 1.0. |
| | level (int, optional): The level should be in range [0, _MAX_LEVEL]. |
| | If level is None, it will generate from [0, _MAX_LEVEL] randomly. |
| | Defaults to None. |
| | min_mag (float): The minimum pixel's offset ratio for horizontal |
| | translation. Defaults to 0.0. |
| | max_mag (float): The maximum pixel's offset ratio for horizontal |
| | translation. Defaults to 0.1. |
| | reversal_prob (float): The probability that reverses the horizontal |
| | translation magnitude. Should be in range [0,1]. Defaults to 0.5. |
| | img_border_value (int | float | tuple): The filled values for |
| | image border. If float, the same fill value will be used for |
| | all the three channels of image. If tuple, it should be 3 elements. |
| | Defaults to 128. |
| | mask_border_value (int): The fill value used for masks. Defaults to 0. |
| | seg_ignore_label (int): The fill value used for segmentation map. |
| | Note this value must equals ``ignore_label`` in ``semantic_head`` |
| | of the corresponding config. Defaults to 255. |
| | interpolation (str): Interpolation method, accepted values are |
| | "nearest", "bilinear", "bicubic", "area", "lanczos" for 'cv2' |
| | backend, "nearest", "bilinear" for 'pillow' backend. Defaults |
| | to 'bilinear'. |
| | """ |
| |
|
| | def __init__(self, |
| | prob: float = 1.0, |
| | level: Optional[int] = None, |
| | min_mag: float = 0.0, |
| | max_mag: float = 0.1, |
| | reversal_prob: float = 0.5, |
| | img_border_value: Union[int, float, tuple] = 128, |
| | mask_border_value: int = 0, |
| | seg_ignore_label: int = 255, |
| | interpolation: str = 'bilinear') -> None: |
| | assert 0. <= min_mag <= 1., \ |
| | f'min_mag ratio for TranslateX should be ' \ |
| | f'in range [0, 1], got {min_mag}.' |
| | assert 0. <= max_mag <= 1., \ |
| | f'max_mag ratio for TranslateX should be ' \ |
| | f'in range [0, 1], got {max_mag}.' |
| | super().__init__( |
| | prob=prob, |
| | level=level, |
| | min_mag=min_mag, |
| | max_mag=max_mag, |
| | reversal_prob=reversal_prob, |
| | img_border_value=img_border_value, |
| | mask_border_value=mask_border_value, |
| | seg_ignore_label=seg_ignore_label, |
| | interpolation=interpolation) |
| |
|
| | def _get_homography_matrix(self, results: dict, mag: float) -> np.ndarray: |
| | """Get the homography matrix for TranslateX.""" |
| | mag = int(results['img_shape'][1] * mag) |
| | return np.array([[1, 0, mag], [0, 1, 0], [0, 0, 1]], dtype=np.float32) |
| |
|
| | def _transform_img(self, results: dict, mag: float) -> None: |
| | """Translate the image horizontally.""" |
| | mag = int(results['img_shape'][1] * mag) |
| | results['img'] = mmcv.imtranslate( |
| | results['img'], |
| | mag, |
| | direction='horizontal', |
| | border_value=self.img_border_value, |
| | interpolation=self.interpolation) |
| |
|
| | def _transform_masks(self, results: dict, mag: float) -> None: |
| | """Translate the masks horizontally.""" |
| | mag = int(results['img_shape'][1] * mag) |
| | results['gt_masks'] = results['gt_masks'].translate( |
| | results['img_shape'], |
| | mag, |
| | direction='horizontal', |
| | border_value=self.mask_border_value, |
| | interpolation=self.interpolation) |
| |
|
| | def _transform_seg(self, results: dict, mag: float) -> None: |
| | """Translate the segmentation map horizontally.""" |
| | mag = int(results['img_shape'][1] * mag) |
| | results['gt_seg_map'] = mmcv.imtranslate( |
| | results['gt_seg_map'], |
| | mag, |
| | direction='horizontal', |
| | border_value=self.seg_ignore_label, |
| | interpolation='nearest') |
| |
|
| |
|
| | @TRANSFORMS.register_module() |
| | class TranslateY(GeomTransform): |
| | """Translate the images, bboxes, masks and segmentation map vertically. |
| | |
| | Required Keys: |
| | |
| | - img |
| | - gt_bboxes (BaseBoxes[torch.float32]) (optional) |
| | - gt_masks (BitmapMasks | PolygonMasks) (optional) |
| | - gt_seg_map (np.uint8) (optional) |
| | |
| | Modified Keys: |
| | |
| | - img |
| | - gt_bboxes |
| | - gt_masks |
| | - gt_seg_map |
| | |
| | Added Keys: |
| | |
| | - homography_matrix |
| | |
| | Args: |
| | prob (float): The probability for perform transformation and |
| | should be in range 0 to 1. Defaults to 1.0. |
| | level (int, optional): The level should be in range [0, _MAX_LEVEL]. |
| | If level is None, it will generate from [0, _MAX_LEVEL] randomly. |
| | Defaults to None. |
| | min_mag (float): The minimum pixel's offset ratio for vertical |
| | translation. Defaults to 0.0. |
| | max_mag (float): The maximum pixel's offset ratio for vertical |
| | translation. Defaults to 0.1. |
| | reversal_prob (float): The probability that reverses the vertical |
| | translation magnitude. Should be in range [0,1]. Defaults to 0.5. |
| | img_border_value (int | float | tuple): The filled values for |
| | image border. If float, the same fill value will be used for |
| | all the three channels of image. If tuple, it should be 3 elements. |
| | Defaults to 128. |
| | mask_border_value (int): The fill value used for masks. Defaults to 0. |
| | seg_ignore_label (int): The fill value used for segmentation map. |
| | Note this value must equals ``ignore_label`` in ``semantic_head`` |
| | of the corresponding config. Defaults to 255. |
| | interpolation (str): Interpolation method, accepted values are |
| | "nearest", "bilinear", "bicubic", "area", "lanczos" for 'cv2' |
| | backend, "nearest", "bilinear" for 'pillow' backend. Defaults |
| | to 'bilinear'. |
| | """ |
| |
|
| | def __init__(self, |
| | prob: float = 1.0, |
| | level: Optional[int] = None, |
| | min_mag: float = 0.0, |
| | max_mag: float = 0.1, |
| | reversal_prob: float = 0.5, |
| | img_border_value: Union[int, float, tuple] = 128, |
| | mask_border_value: int = 0, |
| | seg_ignore_label: int = 255, |
| | interpolation: str = 'bilinear') -> None: |
| | assert 0. <= min_mag <= 1., \ |
| | f'min_mag ratio for TranslateY should be ' \ |
| | f'in range [0,1], got {min_mag}.' |
| | assert 0. <= max_mag <= 1., \ |
| | f'max_mag ratio for TranslateY should be ' \ |
| | f'in range [0,1], got {max_mag}.' |
| | super().__init__( |
| | prob=prob, |
| | level=level, |
| | min_mag=min_mag, |
| | max_mag=max_mag, |
| | reversal_prob=reversal_prob, |
| | img_border_value=img_border_value, |
| | mask_border_value=mask_border_value, |
| | seg_ignore_label=seg_ignore_label, |
| | interpolation=interpolation) |
| |
|
| | def _get_homography_matrix(self, results: dict, mag: float) -> np.ndarray: |
| | """Get the homography matrix for TranslateY.""" |
| | mag = int(results['img_shape'][0] * mag) |
| | return np.array([[1, 0, 0], [0, 1, mag], [0, 0, 1]], dtype=np.float32) |
| |
|
| | def _transform_img(self, results: dict, mag: float) -> None: |
| | """Translate the image vertically.""" |
| | mag = int(results['img_shape'][0] * mag) |
| | results['img'] = mmcv.imtranslate( |
| | results['img'], |
| | mag, |
| | direction='vertical', |
| | border_value=self.img_border_value, |
| | interpolation=self.interpolation) |
| |
|
| | def _transform_masks(self, results: dict, mag: float) -> None: |
| | """Translate masks vertically.""" |
| | mag = int(results['img_shape'][0] * mag) |
| | results['gt_masks'] = results['gt_masks'].translate( |
| | results['img_shape'], |
| | mag, |
| | direction='vertical', |
| | border_value=self.mask_border_value, |
| | interpolation=self.interpolation) |
| |
|
| | def _transform_seg(self, results: dict, mag: float) -> None: |
| | """Translate segmentation map vertically.""" |
| | mag = int(results['img_shape'][0] * mag) |
| | results['gt_seg_map'] = mmcv.imtranslate( |
| | results['gt_seg_map'], |
| | mag, |
| | direction='vertical', |
| | border_value=self.seg_ignore_label, |
| | interpolation='nearest') |
| |
|
