| |
| from typing import List, Tuple, Union |
|
|
| import mmcv |
| import numpy as np |
| from mmengine.utils import is_str |
|
|
|
|
| def palette_val(palette: List[tuple]) -> List[tuple]: |
| """Convert palette to matplotlib palette. |
| |
| Args: |
| palette (List[tuple]): A list of color tuples. |
| |
| Returns: |
| List[tuple[float]]: A list of RGB matplotlib color tuples. |
| """ |
| new_palette = [] |
| for color in palette: |
| color = [c / 255 for c in color] |
| new_palette.append(tuple(color)) |
| return new_palette |
|
|
|
|
| def get_palette(palette: Union[List[tuple], str, tuple], |
| num_classes: int) -> List[Tuple[int]]: |
| """Get palette from various inputs. |
| |
| Args: |
| palette (list[tuple] | str | tuple): palette inputs. |
| num_classes (int): the number of classes. |
| |
| Returns: |
| list[tuple[int]]: A list of color tuples. |
| """ |
| assert isinstance(num_classes, int) |
|
|
| if isinstance(palette, list): |
| dataset_palette = palette |
| elif isinstance(palette, tuple): |
| dataset_palette = [palette] * num_classes |
| elif palette == 'random' or palette is None: |
| state = np.random.get_state() |
| |
| np.random.seed(42) |
| palette = np.random.randint(0, 256, size=(num_classes, 3)) |
| np.random.set_state(state) |
| dataset_palette = [tuple(c) for c in palette] |
| elif palette == 'coco': |
| from mmdet.datasets import CocoDataset, CocoPanopticDataset |
| dataset_palette = CocoDataset.METAINFO['palette'] |
| if len(dataset_palette) < num_classes: |
| dataset_palette = CocoPanopticDataset.METAINFO['palette'] |
| elif palette == 'citys': |
| from mmdet.datasets import CityscapesDataset |
| dataset_palette = CityscapesDataset.METAINFO['palette'] |
| elif palette == 'voc': |
| from mmdet.datasets import VOCDataset |
| dataset_palette = VOCDataset.METAINFO['palette'] |
| elif is_str(palette): |
| dataset_palette = [mmcv.color_val(palette)[::-1]] * num_classes |
| else: |
| raise TypeError(f'Invalid type for palette: {type(palette)}') |
|
|
| assert len(dataset_palette) >= num_classes, \ |
| 'The length of palette should not be less than `num_classes`.' |
| return dataset_palette |
|
|
|
|
| def _get_adaptive_scales(areas: np.ndarray, |
| min_area: int = 800, |
| max_area: int = 30000) -> np.ndarray: |
| """Get adaptive scales according to areas. |
| |
| The scale range is [0.5, 1.0]. When the area is less than |
| ``min_area``, the scale is 0.5 while the area is larger than |
| ``max_area``, the scale is 1.0. |
| |
| Args: |
| areas (ndarray): The areas of bboxes or masks with the |
| shape of (n, ). |
| min_area (int): Lower bound areas for adaptive scales. |
| Defaults to 800. |
| max_area (int): Upper bound areas for adaptive scales. |
| Defaults to 30000. |
| |
| Returns: |
| ndarray: The adaotive scales with the shape of (n, ). |
| """ |
| scales = 0.5 + (areas - min_area) // (max_area - min_area) |
| scales = np.clip(scales, 0.5, 1.0) |
| return scales |
|
|
|
|
| def jitter_color(color: tuple) -> tuple: |
| """Randomly jitter the given color in order to better distinguish instances |
| with the same class. |
| |
| Args: |
| color (tuple): The RGB color tuple. Each value is between [0, 255]. |
| |
| Returns: |
| tuple: The jittered color tuple. |
| """ |
| jitter = np.random.rand(3) |
| jitter = (jitter / np.linalg.norm(jitter) - 0.5) * 0.5 * 255 |
| color = np.clip(jitter + color, 0, 255).astype(np.uint8) |
| return tuple(color) |
|
|
