augment_transform

data.transform.augmentation.augment_transform

Implement ImageTransform classes for image augmentation.

ImageType `module-attribute`

ImageType = ndarray

ParamsType `module-attribute`

ParamsType = Dict[str, Any]

MaskType `module-attribute`

MaskType = ndarray

BBoxesType `module-attribute`

BBoxesType = Union[ndarray, NumpyBoxes]

PolygonType `module-attribute`

PolygonType = List[ndarray]

OffsetType `module-attribute`

OffsetType = Tuple[float, float]

BaseTransform

BaseTransform(prob: float = 0.5)

Transform의 기본 interface를 정의합니다.

Source code in SaigeToolkit/data/transform/augmentation/base_transform.py

def __init__(self, prob: float = 0.5) -> None:
    self.prob = prob
    self._additional_targets = {}

get_params_from_data

get_params_from_data(data_for_params: ParamsType) -> ParamsType

이 함수는 input으로부터 parameter들을 뽑을 때 사용됩니다.

Parameters:

data_for_params (ParamsType) –

params을 추출할 데이터를 입력으로 갖습니다.

Returns:

ParamsType ( ParamsType ) –

params로 쓰일 데이터를 반환합니다.

Source code in SaigeToolkit/data/transform/augmentation/base_transform.py

def get_params_from_data(self, data_for_params: ParamsType) -> ParamsType:
    """이 함수는 input으로부터 parameter들을 뽑을 때 사용됩니다.

    Args:
        data_for_params (ParamsType): params을 추출할 데이터를 입력으로 갖습니다.

    Returns:
        ParamsType: params로 쓰일 데이터를 반환합니다.
    """
    return {}

ImageTransform

ImageTransform(prob: float = 0.5)

Bases: BaseTransform

Image와 라벨에 적용되는 Transform 입니다.

Source code in SaigeToolkit/data/transform/augmentation/base_transform.py

def __init__(self, prob: float = 0.5) -> None:
    self.prob = prob
    self._additional_targets = {}

ImageSizeParams

ToNumpy

ToNumpy(prob: float = 0.5)

Bases: ImageTransform

Source code in SaigeToolkit/data/transform/augmentation/base_transform.py

def __init__(self, prob: float = 0.5) -> None:
    self.prob = prob
    self._additional_targets = {}

ToPil

ToPil(prob: float = 0.5)

Bases: ImageTransform

Source code in SaigeToolkit/data/transform/augmentation/base_transform.py

def __init__(self, prob: float = 0.5) -> None:
    self.prob = prob
    self._additional_targets = {}

VerticalFlip

VerticalFlip(prob: float = 0.5)

Bases: ImageSizeParams, ImageTransform

Source code in SaigeToolkit/data/transform/augmentation/base_transform.py

def __init__(self, prob: float = 0.5) -> None:
    self.prob = prob
    self._additional_targets = {}

HorizontalFlip

HorizontalFlip(prob: float = 0.5)

Bases: ImageSizeParams, ImageTransform

Source code in SaigeToolkit/data/transform/augmentation/base_transform.py

def __init__(self, prob: float = 0.5) -> None:
    self.prob = prob
    self._additional_targets = {}

Rotate

Rotate(angle_limit: Optional[List[float]] = None, interpolation: int = cv2.INTER_LINEAR, border_mode: int = cv2.BORDER_CONSTANT, value: Union[int, float, List[int], List[float]] = 0, mask_value: Union[int, float] = 0, crop_border: bool = False, **kwargs)

Bases: ImageSizeParams, ImageTransform

Source code in SaigeToolkit/data/transform/augmentation/augment_transform.py

def __init__(
    self,
    angle_limit: Optional[List[float]] = None,
    interpolation: int = cv2.INTER_LINEAR,
    border_mode: int = cv2.BORDER_CONSTANT,
    value: Union[int, float, List[int], List[float]] = 0,
    mask_value: Union[int, float] = 0,
    crop_border: bool = False,
    **kwargs,
) -> None:
    super().__init__(**kwargs)

    if angle_limit is None:
        angle_limit = [-30.0, 30.0]

    check_range(angle_limit, -360.0, 360.0)

    self.angle_limit = angle_limit
    self.interpolation = interpolation
    self.border_mode = border_mode
    self.value = value
    self.mask_value = mask_value
    self.crop_border = crop_border

RandomRotate90

RandomRotate90(**kwargs)

Bases: ImageSizeParams, ImageTransform

Source code in SaigeToolkit/data/transform/augmentation/augment_transform.py

def __init__(self, **kwargs) -> None:
    super().__init__(**kwargs)

ColorJitter

ColorJitter(brightness_limit: Optional[List[float]] = None, contrast_limit: Optional[List[float]] = None, saturation_limit: Optional[List[float]] = None, hue_limit: Optional[List[float]] = None, **kwargs)

Bases: ImageTransform

Source code in SaigeToolkit/data/transform/augmentation/augment_transform.py

def __init__(
    self,
    brightness_limit: Optional[List[float]] = None,
    contrast_limit: Optional[List[float]] = None,
    saturation_limit: Optional[List[float]] = None,
    hue_limit: Optional[List[float]] = None,
    **kwargs,
) -> None:
    super().__init__(**kwargs)

    if brightness_limit is None:
        brightness_limit = [0.8, 1.2]
    if contrast_limit is None:
        contrast_limit = [0.8, 1.2]
    if saturation_limit is None:
        saturation_limit = [0.8, 1.2]
    if hue_limit is None:
        hue_limit = [-0.2, 0.2]

    check_range(brightness_limit, 0.01, 10.00)
    check_range(contrast_limit, 0.01, 10.00)
    check_range(saturation_limit, 0.01, 10.00)
    check_range(hue_limit, -0.50, 0.50)

    self.brightness_limit = brightness_limit
    self.contrast_limit = contrast_limit
    self.saturation_limit = saturation_limit
    self.hue_limit = hue_limit

Blur

Blur(ksize_limit: Optional[List[int]] = None, **kwargs)

Bases: ImageTransform

Source code in SaigeToolkit/data/transform/augmentation/augment_transform.py

def __init__(self, ksize_limit: Optional[List[int]] = None, **kwargs) -> None:
    super().__init__(**kwargs)

    if ksize_limit is None:
        ksize_limit = [3, 7]

    check_range(ksize_limit, 1, 100)

    self.ksize_limit = ksize_limit

GaussianBlur

GaussianBlur(ksize_limit: Optional[List[int]] = None, sigma_limit: Optional[List[float]] = None, **kwargs)

Bases: ImageTransform

Source code in SaigeToolkit/data/transform/augmentation/augment_transform.py

def __init__(
    self,
    ksize_limit: Optional[List[int]] = None,
    sigma_limit: Optional[List[float]] = None,
    **kwargs,
) -> None:
    super().__init__(**kwargs)

    if ksize_limit is None:
        ksize_limit = [3, 7]
    if sigma_limit is None:
        sigma_limit = [0.0, 0.0]

    check_range(ksize_limit, 1, 100)
    check_range(sigma_limit, 0.00, 100.00)

    self.ksize_limit = ksize_limit
    self.sigma_limit = sigma_limit

AdjustBrightness

AdjustBrightness(brightness_limit: Optional[List[float]] = None, **kwargs)

Bases: ImageTransform

Source code in SaigeToolkit/data/transform/augmentation/augment_transform.py

def __init__(self, brightness_limit: Optional[List[float]] = None, **kwargs) -> None:
    super().__init__(**kwargs)

    if brightness_limit is None:
        brightness_limit = [-0.2, 0.2]

    check_range(brightness_limit, -1.0, 1.0)

    self.brightness_limit = brightness_limit

AdjustContrast

AdjustContrast(contrast_limit: Optional[List[float]] = None, **kwargs)

Bases: ImageTransform

Source code in SaigeToolkit/data/transform/augmentation/augment_transform.py

def __init__(self, contrast_limit: Optional[List[float]] = None, **kwargs) -> None:
    super().__init__(**kwargs)

    if contrast_limit is None:
        contrast_limit = [-0.2, 0.2]

    check_range(contrast_limit, -1.0, 1.0)

    self.contrast_limit = contrast_limit

AdjustHue

AdjustHue(hue_limit: Optional[List[float]] = None, **kwargs)

Bases: ImageTransform

Source code in SaigeToolkit/data/transform/augmentation/augment_transform.py

def __init__(self, hue_limit: Optional[List[float]] = None, **kwargs) -> None:
    super().__init__(**kwargs)

    if hue_limit is None:
        hue_limit = [-0.2, 0.2]

    check_range(hue_limit, -1.0, 1.0)

    self.hue_limit = hue_limit

AdjustSaturation

AdjustSaturation(saturation_limit: Optional[List[float]] = None, **kwargs)

Bases: ImageTransform

Source code in SaigeToolkit/data/transform/augmentation/augment_transform.py

def __init__(self, saturation_limit: Optional[List[float]] = None, **kwargs) -> None:
    super().__init__(**kwargs)

    if saturation_limit is None:
        saturation_limit = [-0.2, 0.2]

    check_range(saturation_limit, -1.0, 1.0)

    self.saturation_limit = saturation_limit

AdjustGamma

AdjustGamma(gamma_limit: Optional[List[float]] = None, **kwargs)

Bases: ImageTransform

Source code in SaigeToolkit/data/transform/augmentation/augment_transform.py

def __init__(self, gamma_limit: Optional[List[float]] = None, **kwargs) -> None:
    super().__init__(**kwargs)

    if gamma_limit is None:
        gamma_limit = [-0.2, 0.2]

    check_range(gamma_limit, -1.0, 1.0)

    self.gamma_limit = gamma_limit

AdjustBrightnessContrast

AdjustBrightnessContrast(brightness_limit: Optional[List[float]] = None, contrast_limit: Optional[List[float]] = None, brightness_by_max: bool = True, **kwargs)

Bases: ImageTransform

Source code in SaigeToolkit/data/transform/augmentation/augment_transform.py

def __init__(
    self,
    brightness_limit: Optional[List[float]] = None,
    contrast_limit: Optional[List[float]] = None,
    brightness_by_max: bool = True,
    **kwargs,
) -> None:
    super().__init__(**kwargs)

    if brightness_limit is None:
        brightness_limit = [-0.2, 0.2]
    if contrast_limit is None:
        contrast_limit = [-0.2, 0.2]

    check_range(brightness_limit, -1.00, 1.00)
    check_range(contrast_limit, -1.00, 1.00)

    self.brightness_limit = brightness_limit
    self.contrast_limit = contrast_limit
    self.brightness_by_max = brightness_by_max

IsoNoise

IsoNoise(color_shift_limit: Optional[List[float]] = None, intensity_limit: Optional[List[float]] = None, **kwargs)

Bases: ImageTransform

Source code in SaigeToolkit/data/transform/augmentation/augment_transform.py

def __init__(
    self,
    color_shift_limit: Optional[List[float]] = None,
    intensity_limit: Optional[List[float]] = None,
    **kwargs,
) -> None:
    super().__init__(**kwargs)

    if color_shift_limit is None:
        color_shift_limit = [0.01, 0.05]
    if intensity_limit is None:
        intensity_limit = [0.1, 0.5]

    check_range(color_shift_limit, 0.00, 1.00)
    check_range(intensity_limit, 0.00, 2.00)

    self.color_shift_limit = color_shift_limit
    self.intensity_limit = intensity_limit

JpegCompression

JpegCompression(quality_limit: Optional[List[int]] = None, **kwargs)

Bases: ImageTransform

Source code in SaigeToolkit/data/transform/augmentation/augment_transform.py

def __init__(
    self,
    quality_limit: Optional[List[int]] = None,
    **kwargs,
) -> None:
    super().__init__(**kwargs)

    if quality_limit is None:
        quality_limit = [5, 30]

    check_range(quality_limit, 0, 100)

    self.quality_limit = quality_limit

Sharpen

Sharpen(alpha_limit: Optional[List[int]] = None, lightness_limit: Optional[List[int]] = None, **kwargs)

Bases: ImageTransform

Source code in SaigeToolkit/data/transform/augmentation/augment_transform.py

def __init__(
    self,
    alpha_limit: Optional[List[int]] = None,
    lightness_limit: Optional[List[int]] = None,
    **kwargs,
) -> None:
    super().__init__(**kwargs)

    if alpha_limit is None:
        alpha_limit = [0.20, 0.50]

    if lightness_limit is None:
        lightness_limit = [0.80, 1.20]

    check_range(alpha_limit, 0.00, 1.00)
    check_range(lightness_limit, 0.00, 10.00)

    self.alpha_limit = alpha_limit
    self.lightness_limit = lightness_limit

MultiplicativeNoise

MultiplicativeNoise(multiplier: Optional[List[float]] = None, per_channel: bool = True, **kwargs)

Bases: ImageTransform

Source code in SaigeToolkit/data/transform/augmentation/augment_transform.py

def __init__(
    self,
    multiplier: Optional[List[float]] = None,
    per_channel: bool = True,
    **kwargs,
) -> None:
    super().__init__(**kwargs)

    if multiplier is None:
        multiplier = [0.80, 1.20]

    check_range(multiplier, 0.00, 5.00)

    self.multiplier = multiplier
    self.per_channel = per_channel

RatioJitter

RatioJitter(proportion_limit: Optional[Union[List[float], int, float]] = None, resampling: str = 'bilinear', border_mode: int = cv2.BORDER_CONSTANT, value: Union[int, float, List[int], List[float]] = 0, mask_value: Union[int, float] = 0, **kwargs)

Bases: ImageSizeParams, ImageTransform

crop, pad, and resize to original image size

Source code in SaigeToolkit/data/transform/augmentation/augment_transform.py

def __init__(
    self,
    proportion_limit: Optional[Union[List[float], int, float]] = None,
    resampling: str = "bilinear",
    border_mode: int = cv2.BORDER_CONSTANT,
    value: Union[int, float, List[int], List[float]] = 0,
    mask_value: Union[int, float] = 0,
    **kwargs,
) -> None:
    super().__init__(**kwargs)

    if proportion_limit is None:
        proportion_limit = [-0.10, 0.10]

    if isinstance(proportion_limit, int):
        # NOTE: int 입력은 백분율로 적용.
        proportion_limit = [-abs(proportion_limit) / 100, abs(proportion_limit) / 100]

    if isinstance(proportion_limit, float):
        # NOTE: float 입력은 0~1 스케일로 적용.
        proportion_limit = [-abs(proportion_limit), abs(proportion_limit)]

    check_range(proportion_limit, -0.50, 0.50)

    self.proportion_limit = proportion_limit
    self.resampling = resampling
    self.border_mode = border_mode
    self.value = value
    self.mask_value = mask_value

Zoom

Zoom(ratio_limit: Optional[List[float]] = None, resampling: str = 'bilinear', border_mode: int = cv2.BORDER_CONSTANT, value: Union[int, float, List[int], List[float]] = 0, mask_value: Union[int, float] = 0, **kwargs)

Bases: ImageSizeParams, ImageTransform

Source code in SaigeToolkit/data/transform/augmentation/augment_transform.py

def __init__(
    self,
    ratio_limit: Optional[List[float]] = None,
    resampling: str = "bilinear",
    border_mode: int = cv2.BORDER_CONSTANT,
    value: Union[int, float, List[int], List[float]] = 0,
    mask_value: Union[int, float] = 0,
    **kwargs,
) -> None:
    super().__init__(**kwargs)

    if ratio_limit is None:
        ratio_limit = [0.50, 2.00]

    check_range(ratio_limit, 0.01, 100.00)

    self.ratio_limit = ratio_limit
    self.resampling = resampling
    self.border_mode = border_mode
    self.value = value
    self.mask_value = mask_value

RandomResizedCrop

RandomResizedCrop(scale_limit: Optional[List[float]] = None, aspect_ratio_limit: Optional[List[float]] = None, resampling: str = 'bilinear', **kwargs)

Bases: ImageSizeParams, ImageTransform

Crop a random part of the input and rescale it to original size

Parameters:

scale_limit (Optional[List[float]], default: None ) –

range of size of the origin size cropped. Defaults to [0.45, 1.00].
aspect_ratio_limit (Optional[List[float]], default: None ) –

range of aspect ratio of the origin aspect ratio cropped. Defaults to [0.50, 2.00].
resampling (str, default: 'bilinear' ) –

interpolation method. Defaults to "bilinear".

Source code in SaigeToolkit/data/transform/augmentation/augment_transform.py

def __init__(
    self,
    scale_limit: Optional[List[float]] = None,
    aspect_ratio_limit: Optional[List[float]] = None,
    resampling: str = "bilinear",
    **kwargs,
) -> None:
    """
    Args:
        scale_limit (Optional[List[float]], optional): range of size of the origin size cropped. Defaults to [0.45, 1.00].
        aspect_ratio_limit (Optional[List[float]], optional): range of aspect ratio of the origin aspect ratio cropped. Defaults to [0.50, 2.00].
        resampling (str, optional): interpolation method. Defaults to "bilinear".
    """
    super().__init__(**kwargs)

    if scale_limit is None:
        scale_limit = [0.45, 1.00]
    if aspect_ratio_limit is None:
        aspect_ratio_limit = [0.50, 2.00]

    check_range(scale_limit, 0.01, 1.00)
    check_range(aspect_ratio_limit, 0.10, 10.00)

    self.scale_limit = scale_limit
    self.aspect_ratio_limit = aspect_ratio_limit
    self.resampling = resampling

RandomResizedCropAndPad

RandomResizedCropAndPad(scale_limit: Optional[List[float]] = None, aspect_ratio_limit: Optional[List[float]] = None, height: Optional[int] = None, width: Optional[int] = None, resampling: str = 'bilinear', border_mode: int = cv2.BORDER_CONSTANT, value: Union[int, float, List[int], List[float]] = 0, mask_value: Union[int, float] = 0, **kwargs)

Bases: ImageSizeParams, ImageTransform

pad, crop and resize to original image size

Source code in SaigeToolkit/data/transform/augmentation/augment_transform.py

def __init__(
    self,
    scale_limit: Optional[List[float]] = None,
    aspect_ratio_limit: Optional[List[float]] = None,
    height: Optional[int] = None,
    width: Optional[int] = None,
    resampling: str = "bilinear",
    border_mode: int = cv2.BORDER_CONSTANT,
    value: Union[int, float, List[int], List[float]] = 0,
    mask_value: Union[int, float] = 0,
    **kwargs,
) -> None:
    super().__init__(**kwargs)

    if scale_limit is None:
        scale_limit = [0.45, 1.00]
    if aspect_ratio_limit is None:
        aspect_ratio_limit = [0.50, 2.00]

    check_range(scale_limit, 0.01, 1.00)
    check_range(aspect_ratio_limit, 0.10, 10.00)

    self.height = height
    self.width = width
    self.scale_limit = scale_limit
    self.aspect_ratio_limit = aspect_ratio_limit
    self.resampling = resampling
    self.border_mode = border_mode
    self.value = value
    self.mask_value = mask_value

LightReflect

LightReflect(radius_limit: Optional[List[float]] = None, **kwargs)

Bases: ImageTransform

Source code in SaigeToolkit/data/transform/augmentation/augment_transform.py

def __init__(self, radius_limit: Optional[List[float]] = None, **kwargs) -> None:
    super().__init__(**kwargs)

    if radius_limit is None:
        radius_limit = [0.10, 0.50]

    check_range(radius_limit, 0.00, 1.00)

    self.radius_limit = radius_limit

PerspectiveTransform

PerspectiveTransform(intensity_limit: Optional[List[float]] = None, **kwargs)

Bases: ImageSizeParams, ImageTransform

Source code in SaigeToolkit/data/transform/augmentation/augment_transform.py

def __init__(
    self,
    intensity_limit: Optional[List[float]] = None,
    **kwargs,
) -> None:
    super().__init__(**kwargs)

    if intensity_limit is None:
        intensity_limit = [0, 30]

    check_range(intensity_limit, 0, 49)

    self.intensity_limit = intensity_limit

RandomErasing

RandomErasing(scale: Tuple[float, float] = (0.02, 0.33), ratio: Tuple[float, float] = (0.2, 3.3), value: Union[int, Tuple[int, int, int], str] = 0, randomly_select_values: bool = False, **kwargs)

Bases: ImageTransform

Source code in SaigeToolkit/data/transform/augmentation/augment_transform.py

def __init__(
    self,
    scale: Tuple[float, float] = (0.02, 0.33),
    ratio: Tuple[float, float] = (0.2, 3.3),
    value: Union[int, Tuple[int, int, int], str] = 0,
    randomly_select_values: bool = False,
    **kwargs,
) -> None:
    super().__init__(**kwargs)
    self.scale = scale
    self.ratio = ratio
    self._value = value
    self.randomly_select_values = randomly_select_values

_get_random_erase_params

_get_random_erase_params()

This is modified version of get_params of random erasing see: https://pytorch.org/vision/main/_modules/torchvision/transforms/transforms.html#RandomErasing.forward

Source code in SaigeToolkit/data/transform/augmentation/augment_transform.py

def _get_random_erase_params(self):
    """
    This is modified version of get_params of random erasing
    see: https://pytorch.org/vision/main/_modules/torchvision/transforms/transforms.html#RandomErasing.forward
    """
    area = 1

    log_ratio = torch.log(torch.tensor(self.ratio))
    for _ in range(10):
        erase_area = area * torch.empty(1).uniform_(self.scale[0], self.scale[1]).item()
        aspect_ratio = torch.exp(torch.empty(1).uniform_(log_ratio[0], log_ratio[1])).item()

        h_in_ratio = math.sqrt(erase_area * aspect_ratio)
        w_in_ratio = math.sqrt(erase_area / aspect_ratio)

        if not (h_in_ratio < 1 and w_in_ratio < 1):
            continue

        x_in_ratio = random.uniform(0, 1 - w_in_ratio)
        y_in_ratio = random.uniform(0, 1 - h_in_ratio)

        return x_in_ratio, y_in_ratio, h_in_ratio, w_in_ratio

    # Return Original Image
    return 0, 0, 1.0, 1.0

Grayscale

Grayscale(**kwargs)

Bases: ImageTransform

Source code in SaigeToolkit/data/transform/augmentation/augment_transform.py

def __init__(self, **kwargs) -> None:
    super().__init__(**kwargs)

to_numpy

to_numpy(image: Union[Image, Tensor, ndarray], copy: bool = False) -> ndarray

Source code in SaigeToolkit/data/transform/image_function.py

def to_numpy(image: Union[Image.Image, torch.Tensor, np.ndarray], copy: bool = False) -> np.ndarray:
    if isinstance(image, Image.Image):
        image = np.array(image)  # Image.Image -> np.ndarray
    elif isinstance(image, torch.Tensor):
        assert image.ndim in [3, 4]  # BCHW / CHW

        if image.ndim == 4:  # if BCHW
            assert image.shape[0] == 1  # Batch size must be 1
            image = image.squeeze(0)  # BCHW -> CHW

        image = image.permute(1, 2, 0)  # CHW -> HWC

        if image.shape[2] == 1:  # if gray image
            image = image.squeeze(2)  # HWC -> HW

        image = image.detach().cpu().numpy()  # torch.Tensor, HW(C) -> np.ndarray, HW(C)
    elif isinstance(image, np.ndarray):
        if copy:
            image = image.copy()
    else:
        raise NotImplementedError

    # gray: HW / rgb & rgba: HWC
    return image

to_pil

to_pil(image: Union[Image, Tensor, ndarray], copy: bool = False) -> Image

Source code in SaigeToolkit/data/transform/image_function.py

def to_pil(image: Union[Image.Image, torch.Tensor, np.ndarray], copy: bool = False) -> Image.Image:
    if isinstance(image, Image.Image):
        if copy:
            image = image.copy()
    elif isinstance(image, torch.Tensor):
        image = to_numpy(image)  # torch.Tensor -> np.ndarray
        image = Image.fromarray(image)  # np.ndarray -> Image.Image
    elif isinstance(image, np.ndarray):
        assert image.ndim in [2, 3]  # HW / HWC

        if image.ndim == 3 and image.shape[2] == 1:  # grayscale shape HW1
            image = np.squeeze(image, axis=2)  # HW1 -> HW

        image = Image.fromarray(image)  # np.ndarray -> Image.Image
    else:
        raise NotImplementedError

    return image

read_image_size

read_image_size(image: Union[Image, Tensor, ndarray]) -> ImageSizeType

image size: (W, H)

Source code in SaigeToolkit/data/transform/image_function.py

def read_image_size(image: Union[Image.Image, torch.Tensor, np.ndarray]) -> ImageSizeType:
    """image size: (W, H)"""
    if isinstance(image, Image.Image):
        return image.size
    elif isinstance(image, torch.Tensor) and image.ndim in (2, 3, 4):  # HW, CHW, BCHW
        return (image.shape[-1], image.shape[-2])
    elif isinstance(image, np.ndarray) and image.ndim in (2, 3):  # HW, HWC
        return (image.shape[1], image.shape[0])
    else:
        raise NotImplementedError

vertical_flip

vertical_flip(image: Union[ImageType, MaskType]) -> Union[ImageType, MaskType]

Source code in SaigeToolkit/data/transform/augmentation/augment_function.py

def vertical_flip(image: Union[ImageType, MaskType]) -> Union[ImageType, MaskType]:
    return AF.vflip(image)

horizontal_flip

horizontal_flip(image: Union[ImageType, MaskType]) -> Union[ImageType, MaskType]

Source code in SaigeToolkit/data/transform/augmentation/augment_function.py

def horizontal_flip(image: Union[ImageType, MaskType]) -> Union[ImageType, MaskType]:
    if image.ndim == 3 and image.shape[2] > 1 and image.dtype == np.uint8:
        # Opencv is faster than numpy only in case of
        # non-gray scale 8bits images
        return AF.hflip_cv2(image)

    return AF.hflip(image)

rotate

rotate(image: Union[ImageType, MaskType], angle: float = 0, interpolation: int = cv2.INTER_LINEAR, border_mode: int = cv2.BORDER_REFLECT_101, value: Union[int, float, List[int], List[float]] = 0, crop_border: bool = False) -> Union[ImageType, MaskType]

Source code in SaigeToolkit/data/transform/augmentation/augment_function.py

def rotate(
    image: Union[ImageType, MaskType],
    angle: float = 0,
    interpolation: int = cv2.INTER_LINEAR,
    border_mode: int = cv2.BORDER_REFLECT_101,
    value: Union[int, float, List[int], List[float]] = 0,
    crop_border: bool = False,
) -> Union[ImageType, MaskType]:
    def _rotated_rect_with_max_area(h, w, angle):
        """
        Given a rectangle of size wxh that has been rotated by 'angle' (in
        degrees), computes the width and height of the largest possible
        axis-aligned rectangle (maximal area) within the rotated rectangle.

        Code from: https://stackoverflow.com/questions/16702966/rotate-image-and-crop-out-black-borders
        """

        angle = math.radians(angle)
        width_is_longer = w >= h
        side_long, side_short = (w, h) if width_is_longer else (h, w)

        # since the solutions for angle, -angle and 180-angle are all the same,
        # it is sufficient to look at the first quadrant and the absolute values of sin,cos:
        sin_a, cos_a = abs(math.sin(angle)), abs(math.cos(angle))
        if side_short <= 2.0 * sin_a * cos_a * side_long or abs(sin_a - cos_a) < 1e-10:
            # half constrained case: two crop corners touch the longer side,
            # the other two corners are on the mid-line parallel to the longer line
            x = 0.5 * side_short
            wr, hr = (x / sin_a, x / cos_a) if width_is_longer else (x / cos_a, x / sin_a)
        else:
            # fully constrained case: crop touches all 4 sides
            cos_2a = cos_a * cos_a - sin_a * sin_a
            wr, hr = (w * cos_a - h * sin_a) / cos_2a, (h * cos_a - w * sin_a) / cos_2a

        return dict(
            x_min=max(0, int(w / 2 - wr / 2)),
            x_max=min(w, int(w / 2 + wr / 2)),
            y_min=max(0, int(h / 2 - hr / 2)),
            y_max=min(h, int(h / 2 + hr / 2)),
        )

    check_value(angle, -360.0, 360.0)

    img_out = AFGeometric.rotate(image, angle, interpolation, border_mode, value)
    if crop_border:
        h, w = image.shape[:2]
        crop_bbox_dict = _rotated_rect_with_max_area(h, w, angle)
        x_min = crop_bbox_dict["x_min"]
        y_min = crop_bbox_dict["y_min"]
        x_max = crop_bbox_dict["x_max"]
        y_max = crop_bbox_dict["y_max"]
        img_out = AFCrops.crop(img_out, x_min, y_min, x_max, y_max)
    return img_out

random_rotate90

random_rotate90(image: Union[ImageType, MaskType], factor: int = 0) -> Union[ImageType, MaskType]

Source code in SaigeToolkit/data/transform/augmentation/augment_function.py

def random_rotate90(
    image: Union[ImageType, MaskType],
    factor: int = 0,
) -> Union[ImageType, MaskType]:
    check_value(factor, 0, 3)
    return AF.rot90(img=image, factor=factor)

color_jitter

color_jitter(image: ImageType, brightness: float = 1.0, contrast: float = 1.0, saturation: float = 1.0, hue: float = 0, order: List[int] = [0, 1, 2, 3]) -> ImageType

Source code in SaigeToolkit/data/transform/augmentation/augment_function.py

@support_rgba
def color_jitter(
    image: ImageType,
    brightness: float = 1.0,
    contrast: float = 1.0,
    saturation: float = 1.0,
    hue: float = 0,
    order: List[int] = [0, 1, 2, 3],
) -> ImageType:
    if not AF.is_rgb_image(image) and not AF.is_grayscale_image(image):
        raise TypeError("ColorJitter transformation expects 1-channel or 3-channel images.")

    check_value(brightness, 0.01, 10.00)
    check_value(contrast, 0.01, 10.00)
    check_value(saturation, 0.01, 10.00)
    check_value(hue, -0.50, 0.50)

    transforms = [
        AF.adjust_brightness_torchvision,
        AF.adjust_contrast_torchvision,
        AF.adjust_saturation_torchvision,
        AF.adjust_hue_torchvision,
    ]
    params = [brightness, contrast, saturation, hue]

    for i in order:
        image = transforms[i](image, params[i])
    return image

blur

blur(image: ImageType, ksize: int = 3) -> ImageType

Source code in SaigeToolkit/data/transform/augmentation/augment_function.py

def blur(image: ImageType, ksize: int = 3) -> ImageType:
    check_value(ksize, 1, 100)

    return AF.blur(image, ksize)

gaussian_blur

gaussian_blur(image: ImageType, ksize: int = 3, sigma: float = 0.0) -> ImageType

Source code in SaigeToolkit/data/transform/augmentation/augment_function.py

def gaussian_blur(image: ImageType, ksize: int = 3, sigma: float = 0.0) -> ImageType:
    check_value(ksize, 1, 100)
    check_value(sigma, 0.00, 100.00)

    if ksize % 2 != 1:
        ksize = ksize + 1

    return AF.gaussian_blur(image, ksize, sigma)

adjust_brightness

adjust_brightness(image: ImageType, brightness: float = 0.0, brightness_by_max: bool = True) -> ImageType

Source code in SaigeToolkit/data/transform/augmentation/augment_function.py

def adjust_brightness(
    image: ImageType, brightness: float = 0.0, brightness_by_max: bool = True
) -> ImageType:
    check_value(brightness, -1.00, 1.00)

    alpha = 1.0
    beta = 0.0 + brightness

    return AF.brightness_contrast_adjust(image, alpha, beta, brightness_by_max)

adjust_contrast

adjust_contrast(image: ImageType, contrast: float = 0.0) -> ImageType

Source code in SaigeToolkit/data/transform/augmentation/augment_function.py

def adjust_contrast(image: ImageType, contrast: float = 0.0) -> ImageType:
    check_value(contrast, -1.00, 1.00)

    alpha = 1.0 + contrast
    beta = 0.0

    return AF.brightness_contrast_adjust(image, alpha, beta)

adjust_hue

adjust_hue(image: ImageType, hue: float = 0.0) -> ImageType

Source code in SaigeToolkit/data/transform/augmentation/augment_function.py

@support_gray
@support_rgba
def adjust_hue(image: ImageType, hue: float = 0.0) -> ImageType:
    check_value(hue, -1.00, 1.00)

    hue_shift = int(hue * 180)
    sat_shift = 0
    val_shift = 0

    return AF.shift_hsv(image, hue_shift, sat_shift, val_shift)

adjust_saturation

adjust_saturation(image: ImageType, saturation: float = 0.0) -> ImageType

adjust_saturation

Parameters:

image (ImageType) –

입력 이미지
saturation (float, default: 0.0 ) –

변형 강도, [-1.0, 1.0] 범위, Defaults to 0.0.

Returns:

ImageType ( ImageType ) –

결과 이미지

Note

Ablumentation의 AF.shift_hsv()와 다른 알고리즘을 사용합니다. AF.shift_hsv()의 경우 색이 없는 픽셀을 붉은 색으로 변형합니다. 이 함수의 경우 색이 없는 픽셀은 변형하지 않습니다.

Source code in SaigeToolkit/data/transform/augmentation/augment_function.py

@support_gray
@support_rgba
def adjust_saturation(image: ImageType, saturation: float = 0.0) -> ImageType:
    """adjust_saturation

    Args:
        image (ImageType): 입력 이미지
        saturation (float, optional): 변형 강도, [-1.0, 1.0] 범위, Defaults to 0.0.

    Returns:
        ImageType: 결과 이미지

    Note:
        Ablumentation의 AF.shift_hsv()와 다른 알고리즘을 사용합니다.
        AF.shift_hsv()의 경우 색이 없는 픽셀을 붉은 색으로 변형합니다.
        이 함수의 경우 색이 없는 픽셀은 변형하지 않습니다.

    """
    check_value(saturation, -1.00, 1.00)
    saturation = (saturation + 1) ** 2
    gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
    result = image * saturation + gray[..., None] * (1 - saturation)

    dtype = image.dtype
    if dtype == np.uint8:
        result = np.clip(result, 0, 255)
    elif dtype == np.uint16:
        result = np.clip(result, 0, 65535)
    result = result.astype(dtype)

    return result

adjust_gamma

adjust_gamma(image: ImageType, gamma: float = 0.0) -> ImageType

Source code in SaigeToolkit/data/transform/augmentation/augment_function.py

def adjust_gamma(image: ImageType, gamma: float = 0.0) -> ImageType:
    check_value(gamma, -1.0, 1.0)

    gamma = gamma + 1

    return AF.gamma_transform(image, gamma=gamma)

adjust_brightness_contrast

adjust_brightness_contrast(image: ImageType, brightness: float = 0.0, contrast: float = 0.0, brightness_by_max: bool = True) -> ImageType

Source code in SaigeToolkit/data/transform/augmentation/augment_function.py

def adjust_brightness_contrast(
    image: ImageType, brightness: float = 0.0, contrast: float = 0.0, brightness_by_max: bool = True
) -> ImageType:
    check_value(brightness, -1.00, 1.00)
    check_value(contrast, -1.00, 1.00)

    alpha = 1.0 + contrast
    beta = 0.0 + brightness

    return AF.brightness_contrast_adjust(image, alpha, beta, brightness_by_max)

iso_noise

iso_noise(image: ImageType, color_shift: float = 0.05, intensity: float = 0.5, random_state: Optional[int] = None) -> ImageType

Source code in SaigeToolkit/data/transform/augmentation/augment_function.py

@support_gray
@support_rgba
def iso_noise(
    image: ImageType,
    color_shift: float = 0.05,
    intensity: float = 0.50,
    random_state: Optional[int] = None,
) -> ImageType:
    check_value(color_shift, 0.00, 1.00)
    check_value(intensity, 0.00, 2.00)

    return AF.iso_noise(image, color_shift, intensity, np.random.RandomState(random_state))

image_compression

image_compression(image: ImageType, quality: int = 100, image_type: str = '.jpeg') -> ImageType

Source code in SaigeToolkit/data/transform/augmentation/augment_function.py

@support_gray
@support_rgba
def image_compression(
    image: ImageType,
    quality: int = 100,
    image_type: str = ".jpeg",
) -> ImageType:
    return AF.image_compression(image, quality, image_type)

sharpen

sharpen(image: ImageType, sharpening_matrix: ndarray) -> ImageType

Source code in SaigeToolkit/data/transform/augmentation/augment_function.py

@support_gray
@support_rgba
def sharpen(
    image: ImageType,
    sharpening_matrix: np.ndarray,
) -> ImageType:
    return AF.convolve(image, sharpening_matrix)

multiplicative_noise

multiplicative_noise(image: ImageType, multiplier: ndarray) -> ImageType

Source code in SaigeToolkit/data/transform/augmentation/augment_function.py

@support_gray
@support_rgba
def multiplicative_noise(
    image: ImageType,
    multiplier: np.ndarray,
) -> ImageType:
    return AF.multiply(image, multiplier)

ratio_jitter

ratio_jitter(image: ImageType, proportion_left: float = 0.0, proportion_right: float = 0.0, proportion_top: float = 0.0, proportion_bottom: float = 0.0, resampling: str = 'bilinear', border_mode: int = cv2.BORDER_CONSTANT, value: Union[int, float, List[int], List[float]] = 0) -> Union[ImageType, MaskType]

Source code in SaigeToolkit/data/transform/augmentation/augment_function.py

def ratio_jitter(
    image: ImageType,
    proportion_left: float = 0.0,
    proportion_right: float = 0.0,
    proportion_top: float = 0.0,
    proportion_bottom: float = 0.0,
    resampling: str = "bilinear",
    border_mode: int = cv2.BORDER_CONSTANT,
    value: Union[int, float, List[int], List[float]] = 0,
) -> Union[ImageType, MaskType]:
    check_value(proportion_left, -0.50, 0.50)
    check_value(proportion_right, -0.50, 0.50)
    check_value(proportion_top, -0.50, 0.50)
    check_value(proportion_bottom, -0.50, 0.50)

    h_original, w_original = image.shape[:2]

    left = int(w_original * proportion_left)
    right = int(w_original * proportion_right)
    top = int(h_original * proportion_top)
    bottom = int(h_original * proportion_bottom)

    # crop
    crop_left = left if left > 0 else 0
    crop_right = right if right > 0 else 0
    crop_top = top if top > 0 else 0
    crop_bottom = bottom if bottom > 0 else 0

    crop_w = max(w_original - crop_left - crop_right, 1)
    crop_h = max(h_original - crop_top - crop_bottom, 1)

    image = image[crop_top : crop_top + crop_h, crop_left : crop_left + crop_w]

    # padding
    pad_left = 0 if left > 0 else -left
    pad_right = 0 if right > 0 else -right
    pad_top = 0 if top > 0 else -top
    pad_bottom = 0 if bottom > 0 else -bottom

    image = cv2.copyMakeBorder(
        image,
        top=pad_top,
        bottom=pad_bottom,
        left=pad_left,
        right=pad_right,
        borderType=border_mode,
        value=value,
    )

    # resize
    target_size = (w_original, h_original)
    image = resize_image(image, target_size, resampling)

    return image

zoom

zoom(image: ImageType, ratio: float = 1.0, h_start: float = 0.0, w_start: float = 0.0, resampling: str = 'bilinear', border_mode: int = cv2.BORDER_CONSTANT, value: Union[int, float, List[int], List[float]] = 0) -> Union[ImageType, MaskType]

Source code in SaigeToolkit/data/transform/augmentation/augment_function.py

def zoom(
    image: ImageType,
    ratio: float = 1.0,
    h_start: float = 0.0,
    w_start: float = 0.0,
    resampling: str = "bilinear",
    border_mode: int = cv2.BORDER_CONSTANT,
    value: Union[int, float, List[int], List[float]] = 0,
) -> Union[ImageType, MaskType]:
    check_value(ratio, 0.01, 100.00)
    check_value(h_start, 0.00, 1.00)
    check_value(w_start, 0.00, 1.00)

    if ratio < 1.0:
        output_image = _zoom_out(
            image=image,
            ratio=ratio,
            h_start=h_start,
            w_start=w_start,
            resampling=resampling,
            border_mode=border_mode,
            value=value,
        )
    elif ratio == 1.0:
        output_image = image
    elif ratio > 1.0:
        output_image = _zoom_in(
            image=image,
            ratio=ratio,
            h_start=h_start,
            w_start=w_start,
            resampling=resampling,
        )
    else:
        raise NotImplementedError

    return output_image

random_resized_crop

random_resized_crop(image: ImageType, h_scale: float = 1.0, w_scale: float = 1.0, h_start: float = 0.0, w_start: float = 0.0, resampling: str = 'bilinear') -> Union[ImageType, MaskType]

Crop the given image to given scale and then resize it to original size.

Parameters:

image (ImageType) –

original image
h_scale (float, default: 1.0 ) –

crop height scale. Defaults to 1.0.
w_scale (float, default: 1.0 ) –

crop width scale. Defaults to 1.0.
h_start (float, default: 0.0 ) –

crop height start ratio. Defaults to 0.0.
w_start (float, default: 0.0 ) –

crop width start ratio. Defaults to 0.0.
resampling (str, default: 'bilinear' ) –

interpolation method. Defaults to "bilinear".

Returns:

Union[ImageType, MaskType] –

Union[ImageType, MaskType]: augmented data

Source code in SaigeToolkit/data/transform/augmentation/augment_function.py

def random_resized_crop(
    image: ImageType,
    h_scale: float = 1.0,
    w_scale: float = 1.0,
    h_start: float = 0.0,
    w_start: float = 0.0,
    resampling: str = "bilinear",
) -> Union[ImageType, MaskType]:
    """Crop the given image to given scale and then resize it to original size.

    Args:
        image (ImageType): original image
        h_scale (float, optional): crop height scale. Defaults to 1.0.
        w_scale (float, optional): crop width scale. Defaults to 1.0.
        h_start (float, optional): crop height start ratio. Defaults to 0.0.
        w_start (float, optional): crop width start ratio. Defaults to 0.0.
        resampling (str, optional): interpolation method. Defaults to "bilinear".

    Returns:
        Union[ImageType, MaskType]: augmented data
    """
    check_value(h_scale, 0.01, 1.00)
    check_value(w_scale, 0.01, 1.00)
    check_value(h_start, 0.00, 1.00)
    check_value(w_start, 0.00, 1.00)

    h_original, w_original = image.shape[:2]
    target_height = int(round(h_original * h_scale))
    target_width = int(round(w_original * w_scale))

    # crop
    image = AFCrops.random_crop(
        img=image,
        crop_height=target_height,
        crop_width=target_width,
        h_start=min(h_start, 1.0 - 1e-5),
        w_start=min(w_start, 1.0 - 1e-5),
    )

    # resize
    target_size = (w_original, h_original)
    image = resize_image(image, target_size, resampling)

    return image

random_resized_crop_and_pad

random_resized_crop_and_pad(image: ImageType, scale: float = 1.0, aspect_ratio: float = 1.0, h_start: float = 0.0, w_start: float = 0.0, height: Optional[int] = None, width: Optional[int] = None, resampling: str = 'bilinear', border_mode: int = cv2.BORDER_CONSTANT, value: Union[int, float, List[int], List[float]] = 0) -> Union[ImageType, MaskType]

Source code in SaigeToolkit/data/transform/augmentation/augment_function.py

def random_resized_crop_and_pad(
    image: ImageType,
    scale: float = 1.0,
    aspect_ratio: float = 1.0,
    h_start: float = 0.0,
    w_start: float = 0.0,
    height: Optional[int] = None,
    width: Optional[int] = None,
    resampling: str = "bilinear",
    border_mode: int = cv2.BORDER_CONSTANT,
    value: Union[int, float, List[int], List[float]] = 0,
) -> Union[ImageType, MaskType]:
    check_value(scale, 0.01, 1.00)
    check_value(aspect_ratio, 0.10, 10.00)
    check_value(h_start, 0.00, 1.00)
    check_value(w_start, 0.00, 1.00)

    h_original, w_original = image.shape[:2]
    area = h_original * w_original
    target_area = scale * area

    crop_height = int(round(math.sqrt(target_area / aspect_ratio)))
    crop_width = int(round(math.sqrt(target_area * aspect_ratio)))

    # pad
    pad_top = max(crop_height - h_original, 0)
    pad_bottom = max(crop_height - h_original, 0)
    pad_left = max(crop_width - w_original, 0)
    pad_right = max(crop_width - w_original, 0)

    image = cv2.copyMakeBorder(
        image,
        top=pad_top,
        bottom=pad_bottom,
        left=pad_left,
        right=pad_right,
        borderType=border_mode,
        value=value,
    )

    # crop
    image = AFCrops.random_crop(
        img=image,
        crop_height=crop_height,
        crop_width=crop_width,
        h_start=min(h_start, 1.0 - 1e-5),
        w_start=min(w_start, 1.0 - 1e-5),
    )

    # resize
    target_size = (width or w_original, height or h_original)
    image = resize_image(image, target_size, resampling)

    return image

light_reflect

light_reflect(image: ImageType, xc: float, yc: float, x_radius: float, y_radius: float, angle: float) -> ImageType

Source code in SaigeToolkit/data/transform/augmentation/augment_function.py

@support_gray
def light_reflect(
    image: ImageType, xc: float, yc: float, x_radius: float, y_radius: float, angle: float
) -> ImageType:
    check_value(xc, 0.00, 1.00)
    check_value(yc, 0.00, 1.00)
    check_value(x_radius, 0.00, 1.00)
    check_value(y_radius, 0.00, 1.00)
    check_value(angle, 0.00, 360.00)

    if x_radius == 0 or y_radius == 0:
        return image

    image = cv2.cvtColor(image, cv2.COLOR_RGB2HSV)

    h_original, w_original = image.shape[:2]

    xc = ratio_to_value(xc, 0, w_original)
    yc = ratio_to_value(yc, 0, h_original)
    x_radius = ratio_to_value(x_radius, 0, w_original)
    y_radius = ratio_to_value(y_radius, 0, h_original)
    angle = math.radians(angle)

    c, r = np.meshgrid(np.arange(w_original), np.arange(h_original))
    x_rot = (c - xc) * math.cos(angle) + (r - yc) * math.sin(angle)
    y_rot = -(c - xc) * math.sin(angle) + (r - yc) * math.cos(angle)
    d = x_rot * x_rot / x_radius / x_radius + y_rot * y_rot / y_radius / y_radius
    k = 2 - np.power(d, 0.5)
    k[d >= 1] = 1

    image[:, :, 2] = np.clip(image[:, :, 2] * k, 0, 255).astype(np.uint8)

    image = cv2.cvtColor(image, cv2.COLOR_HSV2RGB)

    return image

perspective_transform

perspective_transform(image: ImageType, offset_top_left: OffsetType, offset_top_right: OffsetType, offset_bottom_right: OffsetType, offset_bottom_left: OffsetType, interpolate_method: str = 'nearest')

Source code in SaigeToolkit/data/transform/augmentation/augment_function.py

def perspective_transform(
    image: ImageType,
    offset_top_left: OffsetType,
    offset_top_right: OffsetType,
    offset_bottom_right: OffsetType,
    offset_bottom_left: OffsetType,
    interpolate_method: str = "nearest",
):
    height, width = image.shape[:2]

    for point_offset in [
        offset_top_left,
        offset_top_right,
        offset_bottom_right,
        offset_bottom_left,
    ]:
        offset_x, offset_y = point_offset

        check_value(offset_x, 0, 49)
        check_value(offset_y, 0, 49)

    transform_matrix = calculate_transform_matrix(
        width=width,
        height=height,
        offset_top_left=offset_top_left,
        offset_top_right=offset_top_right,
        offset_bottom_right=offset_bottom_right,
        offset_bottom_left=offset_bottom_left,
    )
    image = cv2.warpPerspective(
        image, transform_matrix, (width, height), flags=INTERPOLATE_METHOD_CV2[interpolate_method]
    )

    return image

erase

erase(image: ImageType, x: int, y: int, w: int, h: int, v: ndarray)

Source code in SaigeToolkit/data/transform/augmentation/augment_function.py

@support_gray
@support_rgba
def erase(
    image: ImageType,
    x: int,
    y: int,
    w: int,
    h: int,
    v: np.ndarray,
):
    image[y : y + h, x : x + w, ...] = v
    return image.astype("uint8")

grayscale

grayscale(image: ImageType) -> ndarray

Source code in SaigeToolkit/data/transform/augmentation/augment_function.py

@support_gray
@support_rgba
def grayscale(
    image: ImageType,
) -> np.ndarray:
    image = AF.to_gray(image)
    return image.astype("uint8")

check_range

check_range(data: Union[Sequence[int], Sequence[float]], min_value: Union[int, float], max_value: Union[int, float])

Source code in SaigeToolkit/data/transform/function_util.py

def check_range(
    data: Union[Sequence[int], Sequence[float]],
    min_value: Union[int, float],
    max_value: Union[int, float],
):
    if not (isinstance(data, Sequence) and len(data) == 2):
        raise AugmentationParameterTypeError

    check_value(data[0], min_value, max_value)
    check_value(data[1], min_value, max_value)

    if not (min_value <= data[0] <= data[1] <= max_value):
        raise AugmentationParameterRangeError

box_function

calculate_transform_matrix

calculate_transform_matrix(width: int, height: int, offset_top_left: OffsetType, offset_top_right: OffsetType, offset_bottom_right: OffsetType, offset_bottom_left: OffsetType) -> ndarray

Calculates the perspective transformation matrix using the given width, height, and corner points of a rectangle.

Parameters:

width (int) –

Width of the original image.
height (int) –

Height of the original image.
offset_top_left (OffsetType) –
The offset ratio of the top-left corner point. Represented by the coordinates (x, y) and has a range of [0, 49]. Calculate xand y according to the procedure below.
```
x` = width * offset_top_left[0]
y` = height * offset_top_left[1]
```
offset_bottom_right (OffsetType) –
The offset ratio of the bottom-right corner point. Calculate xand y according to the procedure below.
```
x` = width - width * offset_bottom_right[0]
y` = hegiht - height * offset_bottom_right[1]
```
offset_top_right (OffsetType) –

The offset ratio of the top-left corner point.
offset_bottom_left (OffsetType) –

The offset ratio of the bottom-left corner point.

Returns:

ndarray –

np.ndarray: The 4x3 perspective transform matrix.

Source code in SaigeToolkit/data/transform/augmentation/augment_function.py

def calculate_transform_matrix(
    width: int,
    height: int,
    offset_top_left: OffsetType,
    offset_top_right: OffsetType,
    offset_bottom_right: OffsetType,
    offset_bottom_left: OffsetType,
) -> np.ndarray:
    """
    Calculates the perspective transformation matrix
    using the given width, height, and corner points of a rectangle.

    Parameters:
        width (int): Width of the original image.
        height (int): Height of the original image.
        offset_top_left (OffsetType):
            The offset ratio of the top-left corner point.
            Represented by the coordinates (x, y) and has a range of [0, 49].
            Calculate x` and y` according to the procedure below.

            ```
            x` = width * offset_top_left[0]
            y` = height * offset_top_left[1]
            ```

        offset_bottom_right (OffsetType):
            The offset ratio of the bottom-right corner point.
            Calculate x` and y` according to the procedure below.

            ```
            x` = width - width * offset_bottom_right[0]
            y` = hegiht - height * offset_bottom_right[1]
            ```

        offset_top_right (OffsetType): The offset ratio of the top-left corner point.
        offset_bottom_left (OffsetType): The offset ratio of the bottom-left corner point.

    Returns:
        np.ndarray: The 4x3 perspective transform matrix.

    """
    points_from = np.float32([[0, 0], [width, 0], [width, height], [0, height]])

    point_top_left: OffsetType = (
        (offset_top_left[0] / 100) * width,
        (offset_top_left[1] / 100) * height,
    )
    point_top_right: OffsetType = (
        width - (offset_top_right[0] / 100) * width,
        (offset_top_right[1] / 100) * height,
    )
    point_bottom_right: OffsetType = (
        width - (offset_bottom_right[0] / 100) * width,
        height - (offset_bottom_right[1] / 100) * height,
    )
    point_bottom_left: OffsetType = (
        (offset_bottom_left[0] / 100) * width,
        height - (offset_bottom_left[1] / 100) * height,
    )
    points_to = np.float32(
        [
            point_top_left,
            point_top_right,
            point_bottom_right,
            point_bottom_left,
        ]
    )
    transform_matrix = cv2.getPerspectiveTransform(points_from, points_to)

    return transform_matrix

preserve_coordinates

preserve_coordinates(func)

Box augmentation이 (left, top, right, bottom) coordinate system을 기반으로 구현 되어있기 때문에, input bboxes의 coordinate system을 확인하고 augmentation에 맞는 coordinate system으로 변환하고, augmentation이 끝나면 다시 기존 coordinate system으로 변경하여 출력합니다.

np.ndarray의 경우 coordinate system을 체크할 수 없기 때문에 (left, top, right, bottom) coordinate system이라고 가정합니다.
NumpyBBoxes의 경우 NumpyBBoxes 내부 변수 coordinate과 내부 함수 convert_coordinate를 활용하여 구현됩니다.

Source code in SaigeToolkit/data/transform/box_function.py

def preserve_coordinates(func):
    """
    Box augmentation이 (left, top, right, bottom) coordinate system을 기반으로 구현 되어있기 때문에,
    input bboxes의 coordinate system을 확인하고 augmentation에 맞는 coordinate system으로 변환하고,
    augmentation이 끝나면 다시 기존 coordinate system으로 변경하여 출력합니다.

    - np.ndarray의 경우
    coordinate system을 체크할 수 없기 때문에 (left, top, right, bottom) coordinate system이라고 가정합니다.

    - NumpyBBoxes의 경우
    NumpyBBoxes 내부 변수 coordinate과 내부 함수 convert_coordinate를 활용하여 구현됩니다.

    """
    _FUNCTIONAL_BBOX_COORDINATE = "xyxy"

    def wrapped_function_for_ndarray(bboxes: np.ndarray, *args, **kwargs) -> np.ndarray:
        new_bboxes = func(bboxes, *args, **kwargs)

        return new_bboxes

    def wrapped_function_for_numpyboxes(bboxes: NumpyBoxes, *args, **kwargs) -> NumpyBoxes:
        # original coordinate -> (left, top, right, bottom)
        original_coordinate = bboxes.coordinate  # record original coordinate
        bboxes = bboxes.convert_coordinate(_FUNCTIONAL_BBOX_COORDINATE)  # -> (left, top, right, bottom)

        # box augmentation
        new_bboxes = func(bboxes, *args, **kwargs)
        if not isinstance(new_bboxes, bboxes.__class__):
            new_bboxes = bboxes.__class__(new_bboxes, _FUNCTIONAL_BBOX_COORDINATE)

        # (left, top, right, bottom) -> original coordinate
        new_bboxes = new_bboxes.convert_coordinate(original_coordinate)

        return new_bboxes

    @wraps(func)
    def wrapped_function(bboxes: BBoxesType, *args, **kwargs) -> BBoxesType:
        # isinstance가 상속된 type도 true를 return 하기 때문에 여기서는 type(instance) == class로 체크
        if isinstance(bboxes, NumpyBoxes):
            new_bboxes = wrapped_function_for_numpyboxes(bboxes, *args, **kwargs)
        elif isinstance(bboxes, np.ndarray):
            new_bboxes = wrapped_function_for_ndarray(bboxes, *args, **kwargs)
        else:
            raise NotImplementedError

        return new_bboxes

    return wrapped_function

resize_box

resize_box(bboxes: BBoxesType, image_size: Tuple[int], tw: int, th: int) -> BBoxesType

bbox resize from (w, h) to (tw, th)

Source code in SaigeToolkit/data/transform/box_function.py

@preserve_coordinates
def resize_box(bboxes: BBoxesType, image_size: Tuple[int], tw: int, th: int) -> BBoxesType:
    """bbox resize from (w, h) to (tw, th)"""
    dtype = bboxes.dtype
    w, h = image_size
    if w == tw and h == th:
        return bboxes
    else:
        w_scale = tw / w
        h_scale = th / h
        return (bboxes * (w_scale, h_scale, w_scale, h_scale)).astype(dtype)

crop_box

crop_box(bboxes: BBoxesType, cropping_box: Union[ndarray, List[int]]) -> BBoxesType

bbox crop. An image is cropped at (new_left, new_top, new_right, new_bottom)

Source code in SaigeToolkit/data/transform/box_function.py

@preserve_coordinates
def crop_box(bboxes: BBoxesType, cropping_box: Union[np.ndarray, List[int]]) -> BBoxesType:
    """bbox crop. An image is cropped at (new_left, new_top, new_right, new_bottom)"""
    dtype = bboxes.dtype
    new_left, new_top, new_right, new_bottom = map(round, cropping_box)
    new_h = new_bottom - new_top
    new_bboxes = bboxes - (new_left, new_top, new_left, new_top)
    new_bboxes[:, [0, 1]] = np.maximum(new_bboxes[:, [0, 1]], 0)
    new_bboxes[:, [2, 3]] = np.minimum(new_bboxes[:, [2, 3]], (new_right - new_left, new_h))
    return new_bboxes.astype(dtype)

polygon_function

calculate_transform_matrix

calculate_transform_matrix(width: int, height: int, offset_top_left: OffsetType, offset_top_right: OffsetType, offset_bottom_right: OffsetType, offset_bottom_left: OffsetType) -> ndarray

Calculates the perspective transformation matrix using the given width, height, and corner points of a rectangle.

Parameters:

width (int) –

Width of the original image.
height (int) –

Height of the original image.
offset_top_left (OffsetType) –
The offset ratio of the top-left corner point. Represented by the coordinates (x, y) and has a range of [0, 49]. Calculate xand y according to the procedure below.
```
x` = width * offset_top_left[0]
y` = height * offset_top_left[1]
```
offset_bottom_right (OffsetType) –
The offset ratio of the bottom-right corner point. Calculate xand y according to the procedure below.
```
x` = width - width * offset_bottom_right[0]
y` = hegiht - height * offset_bottom_right[1]
```
offset_top_right (OffsetType) –

The offset ratio of the top-left corner point.
offset_bottom_left (OffsetType) –

The offset ratio of the bottom-left corner point.

Returns:

ndarray –

np.ndarray: The 4x3 perspective transform matrix.

Source code in SaigeToolkit/data/transform/augmentation/augment_function.py

def calculate_transform_matrix(
    width: int,
    height: int,
    offset_top_left: OffsetType,
    offset_top_right: OffsetType,
    offset_bottom_right: OffsetType,
    offset_bottom_left: OffsetType,
) -> np.ndarray:
    """
    Calculates the perspective transformation matrix
    using the given width, height, and corner points of a rectangle.

    Parameters:
        width (int): Width of the original image.
        height (int): Height of the original image.
        offset_top_left (OffsetType):
            The offset ratio of the top-left corner point.
            Represented by the coordinates (x, y) and has a range of [0, 49].
            Calculate x` and y` according to the procedure below.

            ```
            x` = width * offset_top_left[0]
            y` = height * offset_top_left[1]
            ```

        offset_bottom_right (OffsetType):
            The offset ratio of the bottom-right corner point.
            Calculate x` and y` according to the procedure below.

            ```
            x` = width - width * offset_bottom_right[0]
            y` = hegiht - height * offset_bottom_right[1]
            ```

        offset_top_right (OffsetType): The offset ratio of the top-left corner point.
        offset_bottom_left (OffsetType): The offset ratio of the bottom-left corner point.

    Returns:
        np.ndarray: The 4x3 perspective transform matrix.

    """
    points_from = np.float32([[0, 0], [width, 0], [width, height], [0, height]])

    point_top_left: OffsetType = (
        (offset_top_left[0] / 100) * width,
        (offset_top_left[1] / 100) * height,
    )
    point_top_right: OffsetType = (
        width - (offset_top_right[0] / 100) * width,
        (offset_top_right[1] / 100) * height,
    )
    point_bottom_right: OffsetType = (
        width - (offset_bottom_right[0] / 100) * width,
        height - (offset_bottom_right[1] / 100) * height,
    )
    point_bottom_left: OffsetType = (
        (offset_bottom_left[0] / 100) * width,
        height - (offset_bottom_left[1] / 100) * height,
    )
    points_to = np.float32(
        [
            point_top_left,
            point_top_right,
            point_bottom_right,
            point_bottom_left,
        ]
    )
    transform_matrix = cv2.getPerspectiveTransform(points_from, points_to)

    return transform_matrix

resize_polygon

resize_polygon(polygons: PolygonType, image_size: Tuple[int], tw: int, th: int) -> PolygonType

Resize polygon from (w, h) to (tw, th)

Source code in SaigeToolkit/data/transform/polygon_function.py

def resize_polygon(polygons: PolygonType, image_size: Tuple[int], tw: int, th: int) -> PolygonType:
    """Resize polygon from (w, h) to (tw, th)"""
    if len(polygons) == 0:
        return polygons

    w, h = image_size
    if w == tw and h == th:
        return polygons

    dtype = polygons[0].dtype

    w_scale = tw / w
    h_scale = th / h

    new_polygons = deepcopy(polygons)

    for polygon in new_polygons:
        polygon[:, 0] = polygon[:, 0] * w_scale
        polygon[:, 1] = polygon[:, 1] * h_scale
        polygon = polygon.astype(dtype)

    return new_polygons

translate_polygon

translate_polygon(polygons: PolygonType, offset: Tuple[int]) -> PolygonType

Translate polyfon from [(x1, y1), ... ] to [(x1 - x_offset), (y1 - y_offset), ...]

Source code in SaigeToolkit/data/transform/polygon_function.py

def translate_polygon(
    polygons: PolygonType,
    offset: Tuple[int],
) -> PolygonType:
    """Translate polyfon from [(x1, y1), ... ] to [(x1 - x_offset), (y1 - y_offset), ...]"""
    if len(polygons) == 0:
        return polygons

    if offset[0] == 0 and offset[1] == 0:
        return polygons

    dtype = polygons[0].dtype

    x_offset, y_offset = np.array(offset).astype(dtype)

    new_polygons = deepcopy(polygons)

    for polygon in new_polygons:
        polygon[:, 0] -= x_offset
        polygon[:, 1] -= y_offset

    return new_polygons

augment_transform

data.transform.augmentation.augment_transform

ImageType module-attribute

ParamsType module-attribute

MaskType module-attribute

BBoxesType module-attribute

PolygonType module-attribute

OffsetType module-attribute

BaseTransform

get_params_from_data

ImageTransform

ImageSizeParams

ToNumpy

ToPil

VerticalFlip

HorizontalFlip

Rotate

RandomRotate90

ColorJitter

Blur

GaussianBlur

AdjustBrightness

AdjustContrast

AdjustHue

AdjustSaturation

AdjustGamma

AdjustBrightnessContrast

IsoNoise

JpegCompression

Sharpen

MultiplicativeNoise

RatioJitter

Zoom

RandomResizedCrop

RandomResizedCropAndPad

LightReflect

PerspectiveTransform

RandomErasing

_get_random_erase_params

Grayscale

to_numpy

to_pil

read_image_size

vertical_flip

horizontal_flip

rotate

random_rotate90

color_jitter

blur

gaussian_blur

adjust_brightness

adjust_contrast

adjust_hue

adjust_saturation

adjust_gamma

adjust_brightness_contrast

iso_noise

image_compression

sharpen

multiplicative_noise

ratio_jitter

zoom

random_resized_crop

random_resized_crop_and_pad

light_reflect

perspective_transform

erase

grayscale

check_range

box_function

calculate_transform_matrix

preserve_coordinates

resize_box

crop_box

polygon_function

calculate_transform_matrix

resize_polygon

translate_polygon

ImageType `module-attribute`

ParamsType `module-attribute`

MaskType `module-attribute`

BBoxesType `module-attribute`

PolygonType `module-attribute`

OffsetType `module-attribute`