augmentation

Module diagram

classDiagram
  class augmentation {
  }
  class api {
  }
  class augment_function {
  }
  class augment_transform {
  }
  class base_transform {
  }
  class builder {
  }
  class compose {
  }
  class base_compose {
  }
  class builder {
  }
  class compose {
  }
  augmentation --> builder
  api --> augment_function
  augment_transform --> augment_function
  augment_transform --> base_transform
  builder --> augment_transform
  builder --> builder
  builder --> compose
  compose --> base_compose

data.transform.augmentation

Data augmentation을 위한 기본 BaseTransform 클래스 및 Transform 구현, 그리고 여러 Data Transform들을 하나로 묶어서 관리해주는 기본 BaseCompose 클래스 및 Compose 구현을 제공합니다.

build_augmentation

build_augmentation(config: Dict) -> Augmentation

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

def build_augmentation(config: Dict) -> Augmentation:
    logger.info(f"[AUGMENTATION]\n{pprint.pformat(config, sort_dicts=False)}")

    config = dict(config.items())
    _target_ = config.pop("_target_")
    target_class = _types[_target_]

    # Build transform
    if issubclass(target_class, ImageTransform):
        transform = target_class(**config)

    # Build compose
    elif issubclass(target_class, BaseCompose):
        transform_configs = config.pop("transforms", [])

        _transforms = []
        for transform_config in transform_configs:
            _transform = build_transform(**transform_config)
            _transforms.append(_transform)
        config["transforms"] = _transforms

        transform = build_compose(_target_, **config)

    else:
        raise NotImplementedError(f"Unsupported augmentation type: {_target_}")

    return Augmentation(transform)

api

Image Augmentation Preview를 위한 API를 제공합니다.

ImageProcessor 클래스를 통해 각 augmentation들이 특정 파라미터 값에 대해 이미지를 어떻게 변형 시키는지 확인할 수 있습니다.

error_handler module-attribute

error_handler = get_error_handler(SaigeSegmentationError)

_APIDecorator

ImageProcessor에서 정의된 함수들을 decorate 해주는 헬퍼입니다.

staticmethod 와 decorator를 함께 사용할 경우 Cythonize시 제대로 동작하지 않는 이슈를 해결하기 위한 패치입니다. 참고: https://github.com/cython/cython/issues/1434

ImageProcessor의 각 함수에 다음과 같은 decorator를 씌우는 것과 동일한 역할을 합니다.

@staticmethod
@error_handler
@support_multi_image
@support_3dim_gray_image
def image_processor_function(image: np.ndarray, ...):
    ...

__init_subclass__

__init_subclass__(**kwargs)

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

def __init_subclass__(cls, **kwargs):
    for name in dir(cls):
        if name in dir(_APIDecorator):
            continue
        func = getattr(cls, name)
        func = cls.support_3dim_gray_image(func)
        func = cls.support_multi_image(func)
        func = error_handler(func)
        func = staticmethod(func)
        setattr(cls, name, func)

support_3dim_gray_image staticmethod

support_3dim_gray_image(function)

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

@staticmethod
def support_3dim_gray_image(function):
    @wraps(function)
    def decorator(image: ImageType, *args, **kwargs) -> Any:
        is_3dim_gray = image.ndim == 3 and image.shape[2] == 1
        if is_3dim_gray:
            image = image[:, :, 0]

        image, aug_params = function(image=image, *args, **kwargs)

        if is_3dim_gray:
            image = image[:, :, np.newaxis]

        return image, aug_params

    return decorator

support_multi_image staticmethod

support_multi_image(function)

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

@staticmethod
def support_multi_image(function):
    @wraps(function)
    def decorator(image: Union[List[ImageType], ImageType], *args, **kwargs) -> Any:
        multipage = isinstance(image, List)
        if not multipage:
            image = [image]

        image_0, aug_params = function(image=image[0], *args, **kwargs)
        results = [image_0]
        for image_i in image[1:]:
            if aug_params is not None:
                results.append(function(image=image_i, fixed_aug_params=aug_params)[0])
            else:
                results.append(function(image=image_i, *args, **kwargs)[0])

        if not multipage:
            results = results[0]
        return results, aug_params

    return decorator

ImageProcessor

Bases: _APIDecorator

Image Augmentation Preview를 위한 API 입니다. 각 augmentation들이 특정 파라미터 값에 대해 이미지를 어떻게 변형 시키는지 확인할 수 있습니다.

Note1

일반적으로 학습 시에는 파라미터를 특정 값이 아닌 범위로 설정하여 해당 범위에서 매번 랜덤한 값을 선택해 이미지에 적용합니다. 따라서 preview API의 입력 파라미터와 학습 시 넘겨주는 파라미터는 대부분 값 vs 범위의 차이를 가지게 됩니다. 예를 들어 preview API에서 rotate의 경우 angle (float) 값을 받지만, 학습 config에서는 angle_limit (List[float]) 범위를 받게됩니다. 각 augmentation을 학습에 사용시 필요한 config는 각 함수 설명의 Trainer Config 섹션을 참고하세요.

Note2

API 기획상, augmentation의 실제 자유도보다, 유저가 설정할 수 있는 파라미터가 적은 경우가 있습니다. (각 변 혹은 꼭짓점 마다 독립적으로 적용되는 ratio_jitter나 perspective_transform의 경우) 이러한 augmentation들은 api 호출 시, '값'을 입력 받아서, 이 '값'으로 부터 정의된 '범위'에서 필요한 값들을 랜덤하게 샘플링하게 됩니다. 이러한 augmentation들의 preview 함수를 정의할 때는, 인풋에 fixed_aug_params를 받을 수 있도록 해주어야합니다. (ImageProcessor.ratio_jitter 참고)

Usage

rotate augmentation preview 예제입니다. 상세 설명은 각 함수 설명 참고.

image = np.zeros((100, 100, 3), dtype=np.unit8)
error, augmented_result = ImageProcessor.rotate(image=image, angle=15)
augmented_image, augmentation_parameters = augmented_result

# In the case of 'rotate' augmentation, `augmentation_parameters` is None

vertical_flip

vertical_flip(image: ndarray) -> Tuple[ndarray, None]

image를 상하로 뒤집습니다.

Parameters:

• image (ndarray) –

  augmentation을 적용할 image 입니다.

  data type: uint8
  channel: H x W / H x W x 1  - Gray
           H x W x 3 - RGB
           H x W x 4 - RGBA
  

Returns:

• ndarray –

  np.ndarray: augmentation이 적용된 image 입니다.

• NoneType ( None ) –

  None

Example

error, augmented_image = ImageProcessor.vertical_flip(image=image)

Trainer Config

{
    "_target_": "vertical_flip",
}

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

def vertical_flip(image: np.ndarray) -> Tuple[np.ndarray, None]:
    """image를 상하로 뒤집습니다.

    Args:
        image (np.ndarray): augmentation을 적용할 image 입니다.
            ```
            data type: uint8
            channel: H x W / H x W x 1  - Gray
                     H x W x 3 - RGB
                     H x W x 4 - RGBA
            ```

    Returns:
        np.ndarray: augmentation이 적용된 image 입니다.
        NoneType: None

    Example:
        ```python
        error, augmented_image = ImageProcessor.vertical_flip(image=image)
        ```

    Trainer Config:
        ```python
        {
            "_target_": "vertical_flip",
        }
        ```
    """
    return vertical_flip(image=image), None

horizontal_flip

horizontal_flip(image: ndarray) -> Tuple[ndarray, None]

image를 좌우로 뒤집습니다.

Parameters:

• image (ndarray) –

  augmentation을 적용할 image 입니다.

  data type: uint8
  channel: H x W / H x W x 1  - Gray
           H x W x 3 - RGB
           H x W x 4 - RGBA
  

Returns:

• ndarray –

  np.ndarray: augmentation이 적용된 image 입니다.

• NoneType ( None ) –

  None

Example

error, augmented_image = ImageProcessor.horizontal_flip(image=image)

Trainer Config

{
    "_target_": "horizontal_flip",
}

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

def horizontal_flip(image: np.ndarray) -> Tuple[np.ndarray, None]:
    """image를 좌우로 뒤집습니다.

    Args:
        image (np.ndarray): augmentation을 적용할 image 입니다.
            ```
            data type: uint8
            channel: H x W / H x W x 1  - Gray
                     H x W x 3 - RGB
                     H x W x 4 - RGBA
            ```

    Returns:
        np.ndarray: augmentation이 적용된 image 입니다.
        NoneType: None

    Example:
        ```python
        error, augmented_image = ImageProcessor.horizontal_flip(image=image)
        ```

    Trainer Config:
        ```python
        {
            "_target_": "horizontal_flip",
        }
        ```
    """
    return horizontal_flip(image=image), None

rotate

rotate(image: ndarray, angle: float = 0.0) -> Tuple[ndarray, None]

image를 angle만큼 회전시킵니다.

Parameters:

• image (ndarray) –

  augmentation을 적용할 image 입니다.

  data type: uint8
  channel: H x W / H x W x 1  - Gray
           H x W x 3 - RGB
           H x W x 4 - RGBA
  

• angle (float, default: 0.0 ) –

  회전하는 각도 입니다. 유효 범위는 다음과 같습니다. [-360.0, 360.0]. Defaults to 0.0.

Returns:

• ndarray –

  np.ndarray: augmentation이 적용된 image 입니다.

• NoneType ( None ) –

  None

Example

error, augmented_image = ImageProcessor.rotate(image=image, angle=60.0)

Trainer Config

{
    "_target_": "rotate",
    "angle_limit": List[float],  # angle 최소 최대 범위
}

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

def rotate(image: np.ndarray, angle: float = 0.0) -> Tuple[np.ndarray, None]:
    """image를 angle만큼 회전시킵니다.

    Args:
        image (np.ndarray): augmentation을 적용할 image 입니다.
            ```
            data type: uint8
            channel: H x W / H x W x 1  - Gray
                     H x W x 3 - RGB
                     H x W x 4 - RGBA
            ```
        angle (float, optional): 회전하는 각도 입니다. 유효 범위는 다음과 같습니다. [-360.0, 360.0]. Defaults to 0.0.

    Returns:
        np.ndarray: augmentation이 적용된 image 입니다.
        NoneType: None

    Example:
        ```python
        error, augmented_image = ImageProcessor.rotate(image=image, angle=60.0)
        ```

    Trainer Config:
        ```python
        {
            "_target_": "rotate",
            "angle_limit": List[float],  # angle 최소 최대 범위
        }
        ```
    """
    return (
        rotate(
            image=image,
            angle=angle,
            interpolation=cv2.INTER_LINEAR,
            border_mode=cv2.BORDER_REFLECT_101,
            value=0,
            crop_border=False,
        ),
        None,
    )

random_rotate90

random_rotate90(image: ndarray, factor: int = 0) -> Tuple[ndarray, None]

image를 [0, 90, 180, 270] 중 랜덤한 각도만큼 회전시킵니다.

NOTE

• 모든 이미지 픽셀은 유지되며, 회전 후 이미지 크기가 변경될 수 있습니다.
• 예시: factor가 1일 경우 90도 회전하며, 이미지 사이즈는 (W, H) -> (H, W)로 변경됩니다.

Parameters:

• image (ndarray) –

  augmentation을 적용할 image 입니다.

  data type: uint8
  channel: H x W / H x W x 1  - Gray
           H x W x 3 - RGB
           H x W x 4 - RGBA
  

• factor (int, default: 0 ) –

  회전하는 각도 입니다. factor에 90을 곱한 값만큼 회전합니다. (ex. factor가 1일 경우 90도) 유효범위는 다음과 같습니다 [0, 3]. Defaults to 0.

Returns:

• ndarray –

  np.ndarray: augmentation이 적용된 image 입니다.

• NoneType ( None ) –

  None

Example

error, augmented_image = ImageProcessor.random_rotate90(image=image, factor=1)

Trainer Config

{
    "_target_": "random_rotate90",
}

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

def random_rotate90(image: np.ndarray, factor: int = 0) -> Tuple[np.ndarray, None]:
    """image를 [0, 90, 180, 270] 중 랜덤한 각도만큼 회전시킵니다.

    NOTE:
        - 모든 이미지 픽셀은 유지되며, 회전 후 이미지 크기가 변경될 수 있습니다.
        - 예시: factor가 1일 경우 90도 회전하며, 이미지 사이즈는 (W, H) -> (H, W)로 변경됩니다.

    Args:
        image (np.ndarray): augmentation을 적용할 image 입니다.
            ```
            data type: uint8
            channel: H x W / H x W x 1  - Gray
                     H x W x 3 - RGB
                     H x W x 4 - RGBA
            ```
        factor (int, optional): 회전하는 각도 입니다. factor에 90을 곱한 값만큼 회전합니다. (ex. factor가 1일 경우 90도)
                                유효범위는 다음과 같습니다 [0, 3]. Defaults to 0.

    Returns:
        np.ndarray: augmentation이 적용된 image 입니다.
        NoneType: None

    Example:
        ```python
        error, augmented_image = ImageProcessor.random_rotate90(image=image, factor=1)
        ```

    Trainer Config:
        ```python
        {
            "_target_": "random_rotate90",
        }
        ```
    """
    return random_rotate90(image=image, factor=factor), None

color_jitter

color_jitter(image: ndarray, brightness: float = 1.0, contrast: float = 1.0, saturation: float = 1.0, hue: float = 0.0) -> Tuple[ndarray, None]

image의 밝기 (brightness), 대비 (contrast), 채도 (saturation), 색상 (hue)을 변경합니다.

Parameters:

• image (ndarray) –

  augmentation을 적용할 image 입니다.

  data type: uint8
  channel: H x W / H x W x 1  - Gray
           H x W x 3 - RGB
           H x W x 4 - RGBA
  

• brightness (float, default: 1.0 ) –

  밝기를 담당하는 요소입니다. 유효 범위는 다음과 같습니다. [0.01, 10.00]. Defaults to 1.0.

• contrast (float, default: 1.0 ) –

  대비를 담당하는 요소입니다. 유효 범위는 다음과 같습니다. [0.01, 10.00]. Defaults to 1.0.

• saturation (float, default: 1.0 ) –

  채도를 담당하는 요소입니다. 유효 범위는 다음과 같습니다. [0.01, 10.00]. Defaults to 1.0.

• hue (float, default: 0.0 ) –

  색상을 담당하는 요소입니다. 유효 범위는 다음과 같습니다. [-0.50, 0.50]. Defaults to 0.0.

Returns:

• ndarray –

  np.ndarray: augmentation이 적용된 image 입니다.

• NoneType ( None ) –

  None

Example

error, augmented_image = ImageProcessor.color_jitter(image=image,
                                                     brightness=0.5,
                                                     contrast=0.5,
                                                     saturation=0.5,
                                                     hue=0.1)  #  augmentation 적용

Trainer Config

{
    "_target_": "color_jitter",
    "brightness_limit": List[float],  # brightness 최소 최대 범위
    "contrast_limit": List[float],  # contrast 최소 최대 범위
    "saturation_limit": List[float],  # saturation 최소 최대 범위
    "hue_limit": List[float],  # hue 최소 최대 범위
}

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

def color_jitter(
    image: np.ndarray,
    brightness: float = 1.0,
    contrast: float = 1.0,
    saturation: float = 1.0,
    hue: float = 0.0,
) -> Tuple[np.ndarray, None]:
    """image의 밝기 (brightness), 대비 (contrast), 채도 (saturation), 색상 (hue)을 변경합니다.

    Args:
        image (np.ndarray): augmentation을 적용할 image 입니다.
            ```
            data type: uint8
            channel: H x W / H x W x 1  - Gray
                     H x W x 3 - RGB
                     H x W x 4 - RGBA
            ```
        brightness (float, optional): 밝기를 담당하는 요소입니다. 유효 범위는 다음과 같습니다. [0.01, 10.00]. Defaults to 1.0.
        contrast (float, optional): 대비를 담당하는 요소입니다. 유효 범위는 다음과 같습니다. [0.01, 10.00]. Defaults to 1.0.
        saturation (float, optional): 채도를 담당하는 요소입니다. 유효 범위는 다음과 같습니다. [0.01, 10.00]. Defaults to 1.0.
        hue (float, optional): 색상을 담당하는 요소입니다. 유효 범위는 다음과 같습니다. [-0.50, 0.50]. Defaults to 0.0.

    Returns:
        np.ndarray: augmentation이 적용된 image 입니다.
        NoneType: None

    Example:
        ```python
        error, augmented_image = ImageProcessor.color_jitter(image=image,
                                                             brightness=0.5,
                                                             contrast=0.5,
                                                             saturation=0.5,
                                                             hue=0.1)  #  augmentation 적용
        ```

    Trainer Config:
        ```python
        {
            "_target_": "color_jitter",
            "brightness_limit": List[float],  # brightness 최소 최대 범위
            "contrast_limit": List[float],  # contrast 최소 최대 범위
            "saturation_limit": List[float],  # saturation 최소 최대 범위
            "hue_limit": List[float],  # hue 최소 최대 범위
        }
        ```
    """
    return (
        color_jitter(
            image=image,
            brightness=brightness,
            contrast=contrast,
            saturation=saturation,
            hue=hue,
            order=[0, 1, 2, 3],
        ),
        None,
    )

blur

blur(image: ndarray, ksize: int = 1) -> Tuple[ndarray, None]

image에 averaging blur를 적용합니다.

Parameters:

• image (ndarray) –

  augmentation을 적용할 image 입니다.

  data type: uint8
  channel: H x W / H x W x 1  - Gray
           H x W x 3 - RGB
           H x W x 4 - RGBA
  

• ksize (int, default: 1 ) –

  blur kernel의 크기 입니다. 유효 범위는 다음과 같습니다. [1, 100]. Defaults to 1.

Returns:

• ndarray –

  np.ndarray: augmentation이 적용된 image 입니다.

• NoneType ( None ) –

  None

Example

error, augmented_image = ImageProcessor.blur(image=image, ksize=3)

Trainer Config

{
    "_target_": "blur",
    "ksize_limit": List[int],  # ksize 최소 최대 범위
}

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

def blur(image: np.ndarray, ksize: int = 1) -> Tuple[np.ndarray, None]:
    """image에 averaging blur를 적용합니다.

    Args:
        image (np.ndarray): augmentation을 적용할 image 입니다.
            ```
            data type: uint8
            channel: H x W / H x W x 1  - Gray
                     H x W x 3 - RGB
                     H x W x 4 - RGBA
            ```
        ksize (int, optional): blur kernel의 크기 입니다. 유효 범위는 다음과 같습니다. [1, 100]. Defaults to 1.

    Returns:
        np.ndarray: augmentation이 적용된 image 입니다.
        NoneType: None

    Example:
        ```python
        error, augmented_image = ImageProcessor.blur(image=image, ksize=3)
        ```

    Trainer Config:
        ```python
        {
            "_target_": "blur",
            "ksize_limit": List[int],  # ksize 최소 최대 범위
        }
        ```
    """
    return blur(image=image, ksize=ksize), None

gaussian_blur

gaussian_blur(image: ndarray, ksize: int = 1) -> Tuple[ndarray, None]

image에 gaussian blur를 적용합니다.

Parameters:

• image (ndarray) –

  augmentation을 적용할 image 입니다.

  data type: uint8
  channel: H x W / H x W x 1  - Gray
           H x W x 3 - RGB
           H x W x 4 - RGBA
  

• ksize (int, default: 1 ) –

  blur kernel의 크기 입니다. 유효 범위는 다음과 같습니다. [1, 100]. Defaults to 1.

Returns:

• ndarray –

  np.ndarray: augmentation이 적용된 image 입니다.

• NoneType ( None ) –

  None

Example

error, augmented_image = ImageProcessor.gaussian_blur(image=image, ksize=3)

Trainer Config

{
    "_target_": "gaussian_blur",
    "ksize_limit": List[int],  # ksize 최소 최대 범위
}

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

def gaussian_blur(image: np.ndarray, ksize: int = 1) -> Tuple[np.ndarray, None]:
    """image에 gaussian blur를 적용합니다.

    Args:
        image (np.ndarray): augmentation을 적용할 image 입니다.
            ```
            data type: uint8
            channel: H x W / H x W x 1  - Gray
                     H x W x 3 - RGB
                     H x W x 4 - RGBA
            ```
        ksize (int, optional): blur kernel의 크기 입니다. 유효 범위는 다음과 같습니다. [1, 100]. Defaults to 1.

    Returns:
        np.ndarray: augmentation이 적용된 image 입니다.
        NoneType: None

    Example:
        ```python
        error, augmented_image = ImageProcessor.gaussian_blur(image=image, ksize=3)
        ```

    Trainer Config:
        ```python
        {
            "_target_": "gaussian_blur",
            "ksize_limit": List[int],  # ksize 최소 최대 범위
        }
        ```
    """
    return gaussian_blur(image=image, ksize=ksize, sigma=0.0), None

adjust_brightness

adjust_brightness(image: ndarray, brightness: float = 0.0) -> Tuple[ndarray, None]

image의 밝기 (brightness)를 변경합니다.

Parameters:

• image (ndarray) –

  augmentation을 적용할 image 입니다.

  data type: uint8
  channel: H x W / H x W x 1  - Gray
           H x W x 3 - RGB
           H x W x 4 - RGBA
  

• brightness (float, default: 0.0 ) –

  밝기를 변화 강도입니다. 유효 범위는 다음과 같습니다. [-1.00, 1.00]. Defaults to 0.0.

Returns:

• ndarray –

  np.ndarray: augmentation이 적용된 image 입니다.

• NoneType ( None ) –

  None

Example

error, augmented_image = ImageProcessor.adjust_brightness(image=image, brightness=0.3)

Trainer Config

{
    "_target_": "adjust_brightness",
    "brightness_limit": List[float],  # brightness 최소 최대 범위
}

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

def adjust_brightness(image: np.ndarray, brightness: float = 0.0) -> Tuple[np.ndarray, None]:
    """image의 밝기 (brightness)를 변경합니다.

    Args:
        image (np.ndarray): augmentation을 적용할 image 입니다.
            ```
            data type: uint8
            channel: H x W / H x W x 1  - Gray
                     H x W x 3 - RGB
                     H x W x 4 - RGBA
            ```
        brightness (float, optional): 밝기를 변화 강도입니다. 유효 범위는 다음과 같습니다. [-1.00, 1.00]. Defaults to 0.0.

    Returns:
        np.ndarray: augmentation이 적용된 image 입니다.
        NoneType: None

    Example:
        ```python
        error, augmented_image = ImageProcessor.adjust_brightness(image=image, brightness=0.3)
        ```

    Trainer Config:
        ```python
        {
            "_target_": "adjust_brightness",
            "brightness_limit": List[float],  # brightness 최소 최대 범위
        }
        ```
    """
    return (
        adjust_brightness(image=image, brightness=brightness, brightness_by_max=True),
        None,
    )

adjust_contrast

adjust_contrast(image: ndarray, contrast: float = 0.0) -> Tuple[ndarray, None]

image의 대비 (contrast)를 변경합니다.

Parameters:

• image (ndarray) –

  augmentation을 적용할 image 입니다.

  data type: uint8
  channel: H x W / H x W x 1  - Gray
           H x W x 3 - RGB
           H x W x 4 - RGBA
  

• contrast (float, default: 0.0 ) –

  대비 변화 강도입니다. 유효 범위는 다음과 같습니다. [-1.00, 1.00]. Defaults to 0.0.

Returns:

• ndarray –

  np.ndarray: augmentation이 적용된 image 입니다.

• NoneType ( None ) –

  None

Example

error, augmented_image = ImageProcessor.adjust_contrast(image=image, contrast=0.7)

Trainer Config

{
    "_target_": "adjust_contrast",
    "contrast_limit": List[float],  # contrast 최소 최대 범위
}

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

def adjust_contrast(image: np.ndarray, contrast: float = 0.0) -> Tuple[np.ndarray, None]:
    """image의 대비 (contrast)를 변경합니다.

    Args:
        image (np.ndarray): augmentation을 적용할 image 입니다.
            ```
            data type: uint8
            channel: H x W / H x W x 1  - Gray
                     H x W x 3 - RGB
                     H x W x 4 - RGBA
            ```
        contrast (float, optional): 대비 변화 강도입니다. 유효 범위는 다음과 같습니다. [-1.00, 1.00]. Defaults to 0.0.

    Returns:
        np.ndarray: augmentation이 적용된 image 입니다.
        NoneType: None

    Example:
        ```python
        error, augmented_image = ImageProcessor.adjust_contrast(image=image, contrast=0.7)
        ```

    Trainer Config:
        ```python
        {
            "_target_": "adjust_contrast",
            "contrast_limit": List[float],  # contrast 최소 최대 범위
        }
        ```
    """
    return adjust_contrast(image=image, contrast=contrast), None

adjust_hue

adjust_hue(image: ndarray, hue: float = 0.0) -> Tuple[ndarray, None]

image의 색조 (hue)를 변경합니다.

Parameters:

• image (ndarray) –

  augmentation을 적용할 image 입니다.

  data type: uint8
  channel: H x W / H x W x 1  - Gray
           H x W x 3 - RGB
           H x W x 4 - RGBA
  

• hue (float, default: 0.0 ) –

  색조 변화 강도입니다. 유효 범위는 다음과 같습니다. [-1.00, 1.00]. Defaults to 0.0.

Returns:

• ndarray –

  np.ndarray: augmentation이 적용된 image 입니다.

• NoneType ( None ) –

  None

Example

error, augmented_image = ImageProcessor.adjust_hue(image=image, hue=0.7)

Trainer Config

{
    "_target_": "adjust_hue",
    "hue_limit": List[float],  # hue 최소 최대 범위
}

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

def adjust_hue(image: np.ndarray, hue: float = 0.0) -> Tuple[np.ndarray, None]:
    """image의 색조 (hue)를 변경합니다.

    Args:
        image (np.ndarray): augmentation을 적용할 image 입니다.
            ```
            data type: uint8
            channel: H x W / H x W x 1  - Gray
                     H x W x 3 - RGB
                     H x W x 4 - RGBA
            ```
        hue (float, optional): 색조 변화 강도입니다. 유효 범위는 다음과 같습니다. [-1.00, 1.00]. Defaults to 0.0.

    Returns:
        np.ndarray: augmentation이 적용된 image 입니다.
        NoneType: None

    Example:
        ```python
        error, augmented_image = ImageProcessor.adjust_hue(image=image, hue=0.7)
        ```

    Trainer Config:
        ```python
        {
            "_target_": "adjust_hue",
            "hue_limit": List[float],  # hue 최소 최대 범위
        }
        ```
    """
    return adjust_hue(image=image, hue=hue), None

adjust_saturation

adjust_saturation(image: ndarray, saturation: float = 0.0) -> Tuple[ndarray, None]

image의 채도 (saturation)를 변경합니다.

Parameters:

• image (ndarray) –

  augmentation을 적용할 image 입니다.

  data type: uint8
  channel: H x W / H x W x 1  - Gray
           H x W x 3 - RGB
           H x W x 4 - RGBA
  

• saturation (float, default: 0.0 ) –

  채도 변화 강도입니다. 유효 범위는 다음과 같습니다. [-1.00, 1.00]. Defaults to 0.0.

Returns:

• ndarray –

  np.ndarray: augmentation이 적용된 image 입니다.

• NoneType ( None ) –

  None

Example

error, augmented_image = ImageProcessor.adjust_saturation(image=image, saturation=0.7)

Trainer Config

{
    "_target_": "adjust_saturation",
    "saturation_limit": List[float],  # saturation 최소 최대 범위
}

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

def adjust_saturation(image: np.ndarray, saturation: float = 0.0) -> Tuple[np.ndarray, None]:
    """image의 채도 (saturation)를 변경합니다.

    Args:
        image (np.ndarray): augmentation을 적용할 image 입니다.
            ```
            data type: uint8
            channel: H x W / H x W x 1  - Gray
                     H x W x 3 - RGB
                     H x W x 4 - RGBA
            ```
        saturation (float, optional): 채도 변화 강도입니다. 유효 범위는 다음과 같습니다. [-1.00, 1.00]. Defaults to 0.0.

    Returns:
        np.ndarray: augmentation이 적용된 image 입니다.
        NoneType: None

    Example:
        ```python
        error, augmented_image = ImageProcessor.adjust_saturation(image=image, saturation=0.7)
        ```

    Trainer Config:
        ```python
        {
            "_target_": "adjust_saturation",
            "saturation_limit": List[float],  # saturation 최소 최대 범위
        }
        ```
    """
    return adjust_saturation(image=image, saturation=saturation), None

adjust_gamma

adjust_gamma(image: ndarray, gamma: float = 0.0) -> Tuple[ndarray, None]

image의 gamma를 조절하여 밝기를 변화시킵니다.

Parameters:

• image (ndarray) –

  augmentation을 적용할 image 입니다.

  data type: uint8
  channel: H x W / H x W x 1  - Gray
           H x W x 3 - RGB
           H x W x 4 - RGBA
  

• gamma (float, default: 0.0 ) –

  조절할 gamma value 입니다. 유효 범위는 다음과 같습니다. [-1.0, 1.0]. Defaults to 0.0.

Returns:

• ndarray –

  np.ndarray: augmentation이 적용된 image 입니다.

• NoneType ( None ) –

  None

Example

error, augmented_image = ImageProcessor.adjust_gamma(image=image, gamma=0.5)

Trainer Config

{
    "_target_": "adjust_gamma",
    "gamma_limit": List[float],  # gamma 최소 최대 범위
}

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

def adjust_gamma(image: np.ndarray, gamma: float = 0.0) -> Tuple[np.ndarray, None]:
    """image의 gamma를 조절하여 밝기를 변화시킵니다.

    Args:
        image (np.ndarray): augmentation을 적용할 image 입니다.
            ```
            data type: uint8
            channel: H x W / H x W x 1  - Gray
                     H x W x 3 - RGB
                     H x W x 4 - RGBA
            ```
        gamma (float, optional): 조절할 gamma value 입니다. 유효 범위는 다음과 같습니다. [-1.0, 1.0]. Defaults to 0.0.

    Returns:
        np.ndarray: augmentation이 적용된 image 입니다.
        NoneType: None

    Example:
        ```python
        error, augmented_image = ImageProcessor.adjust_gamma(image=image, gamma=0.5)
        ```

    Trainer Config:
        ```python
        {
            "_target_": "adjust_gamma",
            "gamma_limit": List[float],  # gamma 최소 최대 범위
        }
        ```
    """
    return adjust_gamma(image=image, gamma=gamma), None

adjust_brightness_contrast

adjust_brightness_contrast(image: ndarray, brightness: float = 0.0, contrast: float = 0.0) -> Tuple[ndarray, None]

image의 밝기 (brightness), 대비 (contrast)를 변경합니다.

Parameters:

• image (ndarray) –

  augmentation을 적용할 image 입니다.

  data type: uint8
  channel: H x W / H x W x 1  - Gray
           H x W x 3 - RGB
           H x W x 4 - RGBA
  

• brightness (float, default: 0.0 ) –

  밝기를 담당하는 요소입니다. 유효 범위는 다음과 같습니다. [-1.00, 1.00]. Defaults to 0.0.

• contrast (float, default: 0.0 ) –

  대비를 담당하는 요소입니다. 유효 범위는 다음과 같습니다. [-1.00, 1.00]. Defaults to 0.0.

Returns:

• ndarray –

  np.ndarray: augmentation이 적용된 image 입니다.

• NoneType ( None ) –

  None

Example

error, augmented_image = ImageProcessor.adjust_brightness_contrast(image=image, brightness=0.3, contrast=0.7)

Trainer Config

{
    "_target_": "adjust_brightness_contrast",
    "brightness_limit": List[float],  # brightness 최소 최대 범위
    "contrast_limit": List[float],  # contrast 최소 최대 범위
}

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

def adjust_brightness_contrast(
    image: np.ndarray, brightness: float = 0.0, contrast: float = 0.0
) -> Tuple[np.ndarray, None]:
    """image의 밝기 (brightness), 대비 (contrast)를 변경합니다.

    Args:
        image (np.ndarray): augmentation을 적용할 image 입니다.
            ```
            data type: uint8
            channel: H x W / H x W x 1  - Gray
                     H x W x 3 - RGB
                     H x W x 4 - RGBA
            ```
        brightness (float, optional): 밝기를 담당하는 요소입니다. 유효 범위는 다음과 같습니다. [-1.00, 1.00]. Defaults to 0.0.
        contrast (float, optional): 대비를 담당하는 요소입니다. 유효 범위는 다음과 같습니다. [-1.00, 1.00]. Defaults to 0.0.

    Returns:
        np.ndarray: augmentation이 적용된 image 입니다.
        NoneType: None

    Example:
        ```python
        error, augmented_image = ImageProcessor.adjust_brightness_contrast(image=image, brightness=0.3, contrast=0.7)
        ```

    Trainer Config:
        ```python
        {
            "_target_": "adjust_brightness_contrast",
            "brightness_limit": List[float],  # brightness 최소 최대 범위
            "contrast_limit": List[float],  # contrast 최소 최대 범위
        }
        ```
    """
    return (
        adjust_brightness_contrast(
            image=image, brightness=brightness, contrast=contrast, brightness_by_max=True
        ),
        None,
    )

iso_noise

iso_noise(image: ndarray, color_shift: float = 0.0, intensity: float = 0.0) -> Tuple[ndarray, None]

Apply camera sensor noise.

Parameters:

• image (ndarray) –

  augmentation을 적용할 image 입니다.

  data type: uint8
  channel: H x W / H x W x 1  - Gray
           H x W x 3 - RGB
           H x W x 4 - RGBA
  

• color_shift (float, default: 0.0 ) –

  variance range for color hue change. Measured as a fraction of 360 degree Hue angle in HLS colorspace. 유효 범위는 다음과 같습니다. [0.00, 1.00]. Defaults to 0.0.

• intensity (float, default: 0.0 ) –

  Multiplicative factor that control strength of color and luminace noise. 유효 범위는 다음과 같습니다. [0.00, 2.00]. Defaults to 0.0.

Returns:

• ndarray –

  np.ndarray: augmentation이 적용된 image 입니다.

• NoneType ( None ) –

  None

Example

error, augmented_image = ImageProcessor.iso_noise(image=image, color_shift=0.2, intensity=0.2)

Trainer Config

{
    "_target_": "iso_noise",
    "color_shift_limit": List[float],  # color_shift 최소 최대 범위
    "intensity_limit": List[float],  # intensity 최소 최대 범위
}

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

def iso_noise(
    image: np.ndarray, color_shift: float = 0.0, intensity: float = 0.0
) -> Tuple[np.ndarray, None]:
    """Apply camera sensor noise.

    Args:
        image (np.ndarray): augmentation을 적용할 image 입니다.
            ```
            data type: uint8
            channel: H x W / H x W x 1  - Gray
                     H x W x 3 - RGB
                     H x W x 4 - RGBA
            ```
        color_shift (float, optional): variance range for color hue change. Measured as a fraction of 360 degree Hue angle in HLS colorspace.
                                       유효 범위는 다음과 같습니다. [0.00, 1.00]. Defaults to 0.0.
        intensity (float, optional): Multiplicative factor that control strength of color and luminace noise.
                                     유효 범위는 다음과 같습니다. [0.00, 2.00]. Defaults to 0.0.

    Returns:
        np.ndarray: augmentation이 적용된 image 입니다.
        NoneType: None

    Example:
        ```python
        error, augmented_image = ImageProcessor.iso_noise(image=image, color_shift=0.2, intensity=0.2)
        ```

    Trainer Config:
        ```python
        {
            "_target_": "iso_noise",
            "color_shift_limit": List[float],  # color_shift 최소 최대 범위
            "intensity_limit": List[float],  # intensity 최소 최대 범위
        }
        ```
    """
    return (
        iso_noise(image=image, color_shift=color_shift, intensity=intensity, random_state=0),
        None,
    )

ratio_jitter

ratio_jitter(image: ndarray, proportion: Optional[int] = 0, fixed_aug_params: Optional[Dict] = None) -> Tuple[ndarray, Dict]

image에 random하게 padding과 crop을 한 뒤, 원래 size로 resize 하는 과정을 통해 image의 가로 세로 비율을 변경합니다. NOTE: 프리뷰에서는 네변에 각각 [0, proportion] 범위에서 crop 혹은 padding한 예시를 보여줍니다.

Parameters:

• image (ndarray) –

  augmentation을 적용할 image 입니다.

  data type: uint8
  channel: H x W / H x W x 1  - Gray
           H x W x 3 - RGB
           H x W x 4 - RGBA
  

• proportion (int, default: 0 ) –

  padding 혹은 crop을 할 비율(단위: 백분율)입니다. 유효 범위는 다음과 같습니다. [0, 50]. Defaults to 0. (fixed_aug_params=None일 때만 작동합니다.)

• fixed_aug_params (Dict, default: None ) –

  각 변에 대해서 고정된 crop 혹은 padding을 직접 정해주고자 할 때 사용합니다.

Returns:

• ndarray –

  np.ndarray: augmentation이 적용된 image 입니다.

• Dict ( Dict ) –

  각 변에 적용된 proportioin 비율(-50 ~ 50 사이의 실수, 양수이면 crop, 음수이면 pad)들입니다.

  {
      "proportion_left": float,
      "proportion_right": float,
      "proportion_top": float,
      "proportion_bottom": float,
  }
  

각 변에 대해 crop 혹은 padding할 비율을 직접 설정

error, augmented_image = ImageProcessor.ratio_jitter(
    image=image,
    proportion=None,
    fixed_aug_params={
        "proportion_left": 2.0,
        "proportion_right": 2.0,
        "proportion_top": 2.0,
        "proportion_bottom": 2.0,
    }
)

각 변에 [-proportion, proportion] 범위에서 랜덤하게 crop 혹은 padding 적용

error, augmented_image = ImageProcessor.ratio_jitter(image=image, proportion=2)

Trainer Config

{
    "_target_": "ratio_jitter",
    "proportion_limit": int,  # proportion 최대 범위
}

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

def ratio_jitter(
    image: np.ndarray,
    proportion: Optional[int] = 0,
    fixed_aug_params: Optional[Dict] = None,
) -> Tuple[np.ndarray, Dict]:
    """image에 random하게 padding과 crop을 한 뒤, 원래 size로 resize 하는 과정을 통해 image의 가로 세로 비율을 변경합니다.
    NOTE: 프리뷰에서는 네변에 각각 [0, proportion] 범위에서 crop 혹은 padding한 예시를 보여줍니다.

    Args:
        image (np.ndarray): augmentation을 적용할 image 입니다.
            ```
            data type: uint8
            channel: H x W / H x W x 1  - Gray
                     H x W x 3 - RGB
                     H x W x 4 - RGBA
            ```
        proportion (int, optional): padding 혹은 crop을 할 비율(단위: 백분율)입니다. 유효 범위는 다음과 같습니다. [0, 50]. Defaults to 0. (`fixed_aug_params=None`일 때만 작동합니다.)
        fixed_aug_params (Dict, optional): 각 변에 대해서 고정된 crop 혹은 padding을 직접 정해주고자 할 때 사용합니다.

    Returns:
        np.ndarray: augmentation이 적용된 image 입니다.
        Dict: 각 변에 적용된 proportioin 비율(-50 ~ 50 사이의 실수, 양수이면 crop, 음수이면 pad)들입니다.
            ```python
            {
                "proportion_left": float,
                "proportion_right": float,
                "proportion_top": float,
                "proportion_bottom": float,
            }
            ```

    Example1: 각 변에 대해 crop 혹은 padding할 비율을 직접 설정
        ```python
        error, augmented_image = ImageProcessor.ratio_jitter(
            image=image,
            proportion=None,
            fixed_aug_params={
                "proportion_left": 2.0,
                "proportion_right": 2.0,
                "proportion_top": 2.0,
                "proportion_bottom": 2.0,
            }
        )
        ```

    Example2: 각 변에 [-proportion, proportion] 범위에서 랜덤하게 crop 혹은 padding 적용
        ```python
        error, augmented_image = ImageProcessor.ratio_jitter(image=image, proportion=2)
        ```

    Trainer Config:
        ```python
        {
            "_target_": "ratio_jitter",
            "proportion_limit": int,  # proportion 최대 범위
        }
        ```
    """
    aug_param_keys = ["proportion_left", "proportion_right", "proportion_top", "proportion_bottom"]
    if fixed_aug_params is None:
        check_value(proportion, 0, 50)
        proportion_limit = [-proportion, proportion]
        fixed_aug_params = {k: random.uniform(*proportion_limit) for k in aug_param_keys}
    else:
        for k in aug_param_keys:
            check_value(fixed_aug_params[k], -50, 50)

    return (
        ratio_jitter(
            image=image,
            proportion_left=fixed_aug_params["proportion_left"] / 100,
            proportion_right=fixed_aug_params["proportion_right"] / 100,
            proportion_top=fixed_aug_params["proportion_top"] / 100,
            proportion_bottom=fixed_aug_params["proportion_bottom"] / 100,
            resampling="bilinear",
            border_mode=cv2.BORDER_CONSTANT,
            value=0,
        ),
        fixed_aug_params,
    )

zoom

zoom(image: ndarray, ratio: float = 1.0) -> Tuple[ndarray, None]

image에 zoom in/out 효과를 줍니다.

Parameters:

• image (ndarray) –

  augmentation을 적용할 image 입니다.

  data type: uint8
  channel: H x W / H x W x 1  - Gray
           H x W x 3 - RGB
           H x W x 4 - RGBA
  

• ratio (float, default: 1.0 ) –

  zoom in/out 할 비율입니다. 1보다 크면 zoom in을 1보다 작으면 zoom out을 합니다. 유효 범위는 다음과 같습니다. [0.01, 100.00]. Defaults to 1.0.

Returns:

• ndarray –

  np.ndarray: augmentation이 적용된 image 입니다.

• NoneType ( None ) –

  None

Example

error, augmented_image = ImageProcessor.zoom(image=image, ratio=2.0)

Trainer Config

{
    "_target_": "zoom",
    "ratio_limit": List[float],  # ratio 최소 최대 범위
}

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

def zoom(image: np.ndarray, ratio: float = 1.0) -> Tuple[np.ndarray, None]:
    """image에 zoom in/out 효과를 줍니다.

    Args:
        image (np.ndarray): augmentation을 적용할 image 입니다.
            ```
            data type: uint8
            channel: H x W / H x W x 1  - Gray
                     H x W x 3 - RGB
                     H x W x 4 - RGBA
            ```
        ratio (float, optional): zoom in/out 할 비율입니다. 1보다 크면 zoom in을 1보다 작으면 zoom out을 합니다.
                                 유효 범위는 다음과 같습니다. [0.01, 100.00]. Defaults to 1.0.

    Returns:
        np.ndarray: augmentation이 적용된 image 입니다.
        NoneType: None

    Example:
        ```python
        error, augmented_image = ImageProcessor.zoom(image=image, ratio=2.0)
        ```

    Trainer Config:
        ```python
        {
            "_target_": "zoom",
            "ratio_limit": List[float],  # ratio 최소 최대 범위
        }
        ```
    """
    return (
        zoom(
            image=image,
            ratio=ratio,
            h_start=0,
            w_start=0,
            resampling="bilinear",
            border_mode=cv2.BORDER_CONSTANT,
            value=0,
        ),
        None,
    )

random_resized_crop_and_pad

random_resized_crop_and_pad(image: ndarray, scale: float = 1.0, aspect_ratio: float = 1.0, height: Optional[int] = None, width: Optional[int] = None) -> Tuple[ndarray, None]

원본 image의 scale 비율의 면적을 가지면서 가로 세로 비가 aspect_ratio인 image를 random하게 crop 한 뒤, (crop image가 원본 image 보다 커지는 경우 padding을 통해 해결합니다.) 크기가 (height, width)가 되도록 resize를 합니다.

Parameters:

• image (ndarray) –

  augmentation을 적용할 image 입니다.

  data type: uint8
  channel: H x W / H x W x 1  - Gray
           H x W x 3 - RGB
           H x W x 4 - RGBA
  

• scale (float, default: 1.0 ) –

  crop할 image의 면적을 나타내는 값입니다. 실제 면적은 [원본 이미지의 면적 * scale] 입니다. 유효 범위는 다음과 같습니다. [0.01, 1.00]. Defaults to 1.0.

• aspect_ratio (float, default: 1.0 ) –

  crop할 image의 가로 세로 비를 나타내는 값입니다. 유효 범위는 다음과 같습니다. [0.10, 10.00]. Defaults to 1.0.

• height (int, default: None ) –

  crop image를 resize할 height 입니다. None인 경우 입력 이미지의 원본 height를 사용합니다.

• width (int, default: None ) –

  crop image를 resize할 width 입니다. None인 경우 입력 이미지의 원본 width를 사용합니다.

Returns:

• ndarray –

  np.ndarray: augmentation이 적용된 image 입니다.

• NoneType ( None ) –

  None

Example

error, augmented_image = ImageProcessor.random_resized_crop_and_pad(image=image,
                                                                    scale=0.5,
                                                                    aspect_ratio=2,
                                                                    height=256,
                                                                    width=256)

Trainer Config

{
    "_target_": "random_resized_crop_and_pad",
    "scale_limit": List[float],  # scale 최소 최대 범위
    "aspect_ratio_limit": List[float],  # aspect_ratio 최소 최대 범위
    "height": Optional[int],  # crop 후 resize할 이미지 height (None인 경우 원본 height 사용)
    "width": Optional[int],  # crop 후 resize할 이미지 width (None인 경우 원본 width 사용)
}

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

def random_resized_crop_and_pad(
    image: np.ndarray,
    scale: float = 1.0,
    aspect_ratio: float = 1.0,
    height: Optional[int] = None,
    width: Optional[int] = None,
) -> Tuple[np.ndarray, None]:
    """원본 image의 scale 비율의 면적을 가지면서 가로 세로 비가 aspect_ratio인 image를 random하게 crop 한 뒤,
       (crop image가 원본 image 보다 커지는 경우 padding을 통해 해결합니다.)
       크기가 (height, width)가 되도록 resize를 합니다.

    Args:
        image (np.ndarray): augmentation을 적용할 image 입니다.
            ```
            data type: uint8
            channel: H x W / H x W x 1  - Gray
                     H x W x 3 - RGB
                     H x W x 4 - RGBA
            ```
        scale (float, optional): crop할 image의 면적을 나타내는 값입니다. 실제 면적은 [원본 이미지의 면적 * scale] 입니다.
                                 유효 범위는 다음과 같습니다. [0.01, 1.00]. Defaults to 1.0.
        aspect_ratio (float, optional): crop할 image의 가로 세로 비를 나타내는 값입니다.
                                        유효 범위는 다음과 같습니다. [0.10, 10.00]. Defaults to 1.0.
        height (int): crop image를 resize할 height 입니다. None인 경우 입력 이미지의 원본 height를 사용합니다.
        width (int): crop image를 resize할 width 입니다. None인 경우 입력 이미지의 원본 width를 사용합니다.

    Returns:
        np.ndarray: augmentation이 적용된 image 입니다.
        NoneType: None

    Example:
        ```python
        error, augmented_image = ImageProcessor.random_resized_crop_and_pad(image=image,
                                                                            scale=0.5,
                                                                            aspect_ratio=2,
                                                                            height=256,
                                                                            width=256)
        ```

    Trainer Config:
        ```python
        {
            "_target_": "random_resized_crop_and_pad",
            "scale_limit": List[float],  # scale 최소 최대 범위
            "aspect_ratio_limit": List[float],  # aspect_ratio 최소 최대 범위
            "height": Optional[int],  # crop 후 resize할 이미지 height (None인 경우 원본 height 사용)
            "width": Optional[int],  # crop 후 resize할 이미지 width (None인 경우 원본 width 사용)
        }
        ```
    """
    return (
        random_resized_crop_and_pad(
            image=image,
            scale=scale,
            aspect_ratio=aspect_ratio,
            h_start=0,
            w_start=0,
            height=height,
            width=width,
            resampling="bilinear",
            border_mode=cv2.BORDER_CONSTANT,
            value=0,
        ),
        None,
    )

light_reflect

light_reflect(image: ndarray, radius: float = 0.0) -> Tuple[ndarray, None]

image에 원형 빛을 비춘 것 같은 효과를 줍니다.

Parameters:

• image (ndarray) –

  augmentation을 적용할 image 입니다.

  data type: uint8
  channel: H x W / H x W x 1  - Gray
           H x W x 3 - RGB
           H x W x 4 - RGBA
  

• radius (float, default: 0.0 ) –

  원형 빛의 반지름 크기 입니다. 유효 범위는 다음과 같습니다. [0.00, 1.00]. Defaults to 0.0.

Returns:

• ndarray –

  np.ndarray: augmentation이 적용된 image 입니다.

• NoneType ( None ) –

  None

Example

error, augmented_image = ImageProcessor.light_reflect(image=image, radius=0.30)

Trainer Config

{
    "_target_": "light_reflect",
    "radius_limit": List[float],  # radius 최소 최대 범위
}

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

def light_reflect(image: np.ndarray, radius: float = 0.0) -> Tuple[np.ndarray, None]:
    """image에 원형 빛을 비춘 것 같은 효과를 줍니다.

    Args:
        image (np.ndarray): augmentation을 적용할 image 입니다.
            ```
            data type: uint8
            channel: H x W / H x W x 1  - Gray
                     H x W x 3 - RGB
                     H x W x 4 - RGBA
            ```
        radius (float, optional): 원형 빛의 반지름 크기 입니다. 유효 범위는 다음과 같습니다. [0.00, 1.00]. Defaults to 0.0.

    Returns:
        np.ndarray: augmentation이 적용된 image 입니다.
        NoneType: None

    Example:
        ```python
        error, augmented_image = ImageProcessor.light_reflect(image=image, radius=0.30)
        ```

    Trainer Config:
        ```python
        {
            "_target_": "light_reflect",
            "radius_limit": List[float],  # radius 최소 최대 범위
        }
        ```
    """
    return (
        light_reflect(image=image, xc=0.5, yc=0.5, x_radius=radius, y_radius=radius, angle=0),
        None,
    )

perspective_transform

perspective_transform(image: ndarray, intensity: Optional[int] = 0, fixed_aug_params: Optional[Dict] = None) -> Tuple[ndarray, Dict]

이미지를 투영 변환(Perspective Transform)합니다. image를 다른 각도(시점)에서 바라본 형태로 변환합니다. Perspective Transform 을 위한 네개의 도착점의 좌표 (offset)은 다음과 같이 샘플링됩니다. offset_top_left: 원본 이미지의 좌측 상단 모서리를 얼마만큼 중심부로 이동시킬 지에 대한 실수 값이 들어있습니다. 즉, Perspective Transform 의 좌측 상단점의 도착점은 아래와 같이 계산할 수 있습니다.

```
x` = 0 + width * offset_top_left[0]
y` = 0 + height * offset_top_left[1]
point_dst = (x`, y`)
```

offset_bottom_right

offset_top_left 와 동일하되 우측 하단 점을 나타냅니다. Perspective Transform 의 우측 하단점의 도착점은 아래와 같이 계산할 수 있습니다.

x` = width - width * offset_bottom_right[0]
y` = height - height * offset_bottom_right[1]
point_dst = (x`, y`)

offset_top_right: offset_top_left 와 동일하되 우측 상단 점을 나타냅니다. offset_bottom_left: offset_top_left 와 동일하되 좌측 하단 점을 나타냅니다.

Parameters:

• image (ndarray) –

  augmentation을 적용할 image 입니다.

  data type: uint8
  channel: H x W / H x W x 1  - Gray
           H x W x 3 - RGB
           H x W x 4 - RGBA
  

• intensity (int, default: 0 ) –

  perspective transform 을 적용 강도(단위: 백분율)입니다. intensity 범위 내에서 랜덤한 값으로 샘플된 네개의 offset 을 이용해 perspective transform 을 수행합니다. 유효 범위는 [0, 49] 로, 각 도착지 점들은 이미지의 중간 선을 지나칠 수 없습니다. 이를 통해 이미지가 반전되는 정도의 왜곡을 방지합니다. Defaults to 0. (fixed_aug_params=None일 때만 작동합니다.)

• fixed_aug_params (Dict, default: None ) –

  각 꼭짓점에 대해서 offset 비율을 직접 정해주고자 할 때 사용합니다.

Returns:

• ndarray –

  np.ndarray: augmentation이 적용된 image 입니다.

• Dict ( Dict ) –

  각 꼭짓점에 적용된 offset들입니다.

  {
      "offset_top_left": Tuple[float, float],
      "offset_top_right": Tuple[float, float],
      "offset_bottom_right": Tuple[float, float],
      "offset_bottom_left": Tuple[float, float],
  }
  

각 꼭짓점의 offset 비율을 직접 설정

error, augmented_image = ImageProcessor.perspective_transform(
    image=image,
    fixed_aug_params={
        "offset_top_left": (25.0, 30.0),
        "offset_top_right": (10.0, 40.0),
        "offset_bottom_right": (0.0, 20.0),
        "offset_bottom_left": (20.0, 35.0),
    }
)

각 꼭짓점에 [0, intensity] 범위에서 랜덤하게 offset 비율을 적용

error, augmented_image = ImageProcessor.perspective_transform(
    image=image,
    intensity=10,
)

Trainer Config

{
    "_target_": "perspective_transform",
    "intensity_limit": List[float],  # intensity 최소 최대 범위
}

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

def perspective_transform(
    image: np.ndarray,
    intensity: Optional[int] = 0,
    fixed_aug_params: Optional[Dict] = None,
) -> Tuple[np.ndarray, Dict]:
    """이미지를 투영 변환(Perspective Transform)합니다. image를 다른 각도(시점)에서 바라본 형태로 변환합니다.
    Perspective Transform 을 위한 네개의 도착점의 좌표 (offset)은 다음과 같이 샘플링됩니다.
    offset_top_left:
        원본 이미지의 좌측 상단 모서리를 얼마만큼 중심부로 이동시킬 지에 대한 실수 값이 들어있습니다.
        즉, Perspective Transform 의 좌측 상단점의 도착점은 아래와 같이 계산할 수 있습니다.

        ```
        x` = 0 + width * offset_top_left[0]
        y` = 0 + height * offset_top_left[1]
        point_dst = (x`, y`)
        ```

    offset_bottom_right:
        `offset_top_left` 와 동일하되 우측 하단 점을 나타냅니다.
        Perspective Transform 의 우측 하단점의 도착점은 아래와 같이 계산할 수 있습니다.

        ```
        x` = width - width * offset_bottom_right[0]
        y` = height - height * offset_bottom_right[1]
        point_dst = (x`, y`)
        ```

    offset_top_right: `offset_top_left` 와 동일하되 우측 상단 점을 나타냅니다.
    offset_bottom_left: `offset_top_left` 와 동일하되 좌측 하단 점을 나타냅니다.


    Args:
        image (np.ndarray): augmentation을 적용할 image 입니다.
            ```
            data type: uint8
            channel: H x W / H x W x 1  - Gray
                     H x W x 3 - RGB
                     H x W x 4 - RGBA
            ```
        intensity (int, optional): perspective transform 을 적용 강도(단위: 백분율)입니다.
            intensity 범위 내에서 랜덤한 값으로 샘플된 네개의 offset 을 이용해 perspective transform 을 수행합니다.
            유효 범위는 [0, 49] 로, 각 도착지 점들은 이미지의 중간 선을 지나칠 수 없습니다.
            이를 통해 이미지가 반전되는 정도의 왜곡을 방지합니다. Defaults to 0. (`fixed_aug_params=None`일 때만 작동합니다.)
        fixed_aug_params (Dict, optional): 각 꼭짓점에 대해서 offset 비율을 직접 정해주고자 할 때 사용합니다.

    Returns:
        np.ndarray: augmentation이 적용된 image 입니다.
        Dict: 각 꼭짓점에 적용된 offset들입니다.
            ```python
            {
                "offset_top_left": Tuple[float, float],
                "offset_top_right": Tuple[float, float],
                "offset_bottom_right": Tuple[float, float],
                "offset_bottom_left": Tuple[float, float],
            }
            ```

    Example1:  각 꼭짓점의 offset 비율을 직접 설정
        ```python
        error, augmented_image = ImageProcessor.perspective_transform(
            image=image,
            fixed_aug_params={
                "offset_top_left": (25.0, 30.0),
                "offset_top_right": (10.0, 40.0),
                "offset_bottom_right": (0.0, 20.0),
                "offset_bottom_left": (20.0, 35.0),
            }
        )
        ```

    Example2:  각 꼭짓점에 [0, intensity] 범위에서 랜덤하게 offset 비율을 적용
        ```python
        error, augmented_image = ImageProcessor.perspective_transform(
            image=image,
            intensity=10,
        )
        ```

    Trainer Config:
        ```python
        {
            "_target_": "perspective_transform",
            "intensity_limit": List[float],  # intensity 최소 최대 범위
        }
        ```
    """
    aug_param_keys = [
        "offset_top_left",
        "offset_top_right",
        "offset_bottom_right",
        "offset_bottom_left",
    ]
    if fixed_aug_params is None:
        check_value(intensity, 0, 49)
        fixed_aug_params = {
            k: tuple((random.uniform(0, intensity), random.uniform(0, intensity)))
            for k in aug_param_keys
        }
    else:
        for k in aug_param_keys:
            offset_x, offset_y = fixed_aug_params[k]
            check_value(offset_x, 0, 49)
            check_value(offset_y, 0, 49)

    return (
        perspective_transform(
            image=image,
            **fixed_aug_params,
        ),
        fixed_aug_params,
    )

augment_function

INTERPOLATE_METHOD_CV2 module-attribute

INTERPOLATE_METHOD_CV2 = {'nearest': INTER_NEAREST, 'linear': INTER_LINEAR, 'cubic': INTER_CUBIC}

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_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)

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

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_in

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

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

def _zoom_in(
    image: ImageType,
    ratio: float = 1.0,
    h_start: float = 0.0,
    w_start: float = 0.0,
    resampling: str = "bilinear",
) -> Union[ImageType, MaskType]:
    check_value(ratio, 1.00, 100.00)
    check_value(w_start, 0.00, 1.00)
    check_value(h_start, 0.00, 1.00)

    # zoom in/out
    h_original, w_original = image.shape[:2]
    target_size = (int(w_original * ratio), int(h_original * ratio))
    image = resize_image(image, target_size, resampling)

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

    return image

_zoom_out

_zoom_out(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_out(
    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, 1.00)

    # zoom in/out
    h_original, w_original = image.shape[:2]
    target_size = (max(int(w_original * ratio), 1), max(int(h_original * ratio), 1))
    image = resize_image(image, target_size, resampling)

    # pad
    h_current, w_current = image.shape[:2]
    x1, y1, x2, y2 = AFCrops.get_random_crop_coords(
        h_original, w_original, h_current, w_current, h_start, w_start
    )
    pad_top = y1
    pad_bottom = h_original - y2
    pad_left = x1
    pad_right = w_original - x2

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

    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

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

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")

augment_transform

Implement ImageTransform classes for image augmentation.

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 = {}

targets property

targets: Dict[str, Callable]

apply_to_image

apply_to_image(image: ImageType, **params) -> ImageType

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

def apply_to_image(self, image: ImageType, **params) -> ImageType:
    return image

apply_to_mask

apply_to_mask(mask: MaskType, **params) -> MaskType

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

def apply_to_mask(self, mask: MaskType, **params) -> MaskType:
    return mask

apply_to_bboxes

apply_to_bboxes(bboxes: BBoxesType, **params) -> BBoxesType

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

def apply_to_bboxes(self, bboxes: BBoxesType, **params) -> BBoxesType:
    return bboxes

apply_to_polygons

apply_to_polygons(polygons: PolygonType, **params) -> PolygonType

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

def apply_to_polygons(self, polygons: PolygonType, **params) -> PolygonType:
    return polygons

ImageSizeParams

data_for_params property

data_for_params: List[str]

get_params_from_data

get_params_from_data(data_for_params: ParamsType) -> ParamsType

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

def get_params_from_data(self, data_for_params: ParamsType) -> ParamsType:
    img = data_for_params["image"]
    if not isinstance(img, list):
        return {"image_size": read_image_size(img)}
    else:
        return {"image_size": read_image_size(img[0])}

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 = {}

apply_to_image

apply_to_image(image: ImageType, **params) -> ImageType

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

def apply_to_image(self, image: ImageType, **params) -> ImageType:
    return to_numpy(image=image)

apply_to_mask

apply_to_mask(mask: MaskType, **params) -> MaskType

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

def apply_to_mask(self, mask: MaskType, **params) -> MaskType:
    return to_numpy(image=mask)

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 = {}

apply_to_image

apply_to_image(image: ImageType, **params) -> ImageType

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

def apply_to_image(self, image: ImageType, **params) -> ImageType:
    return to_pil(image=image)

apply_to_mask

apply_to_mask(mask: MaskType, **params) -> MaskType

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

def apply_to_mask(self, mask: MaskType, **params) -> MaskType:
    return to_pil(image=mask)

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 = {}

apply_to_image

apply_to_image(image: ImageType, **params) -> ImageType

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

def apply_to_image(self, image: ImageType, **params) -> ImageType:
    return vertical_flip(image=image)

apply_to_mask

apply_to_mask(mask: MaskType, **params) -> MaskType

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

def apply_to_mask(self, mask: MaskType, **params) -> MaskType:
    return vertical_flip(image=mask)

apply_to_bboxes

apply_to_bboxes(bboxes: BBoxesType, image_size: Tuple[int], **params) -> BBoxesType

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

def apply_to_bboxes(self, bboxes: BBoxesType, image_size: Tuple[int], **params) -> BBoxesType:
    return box_function.vflip_box(bboxes=bboxes, image_size=image_size)

apply_to_polygons

apply_to_polygons(polygons: PolygonType, image_size: Tuple[int], **params) -> PolygonType

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

def apply_to_polygons(self, polygons: PolygonType, image_size: Tuple[int], **params) -> PolygonType:
    return polygon_function.vertical_flip(polygons=polygons, image_size=image_size)

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 = {}

apply_to_image

apply_to_image(image: ImageType, **params) -> ImageType

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

def apply_to_image(self, image: ImageType, **params) -> ImageType:
    return horizontal_flip(image=image)

apply_to_mask

apply_to_mask(mask: MaskType, **params) -> MaskType

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

def apply_to_mask(self, mask: MaskType, **params) -> MaskType:
    return horizontal_flip(image=mask)

apply_to_bboxes

apply_to_bboxes(bboxes: BBoxesType, image_size: Tuple[int], **params) -> BBoxesType

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

def apply_to_bboxes(self, bboxes: BBoxesType, image_size: Tuple[int], **params) -> BBoxesType:
    return box_function.hflip_box(bboxes=bboxes, image_size=image_size)

apply_to_polygons

apply_to_polygons(polygons: PolygonType, image_size: Tuple[int], **params) -> PolygonType

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

def apply_to_polygons(self, polygons: PolygonType, image_size: Tuple[int], **params) -> PolygonType:
    return polygon_function.horizontal_flip(polygons=polygons, image_size=image_size)

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

angle_limit instance-attribute

angle_limit = angle_limit

interpolation instance-attribute

interpolation = interpolation

border_mode instance-attribute

border_mode = border_mode

value instance-attribute

value = value

mask_value instance-attribute

mask_value = mask_value

crop_border instance-attribute

crop_border = crop_border

get_apply_params

get_apply_params() -> ParamsType

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

def get_apply_params(self) -> ParamsType:
    return {"angle": random.uniform(*self.angle_limit)}

apply_to_image

apply_to_image(image: ImageType, angle: float = 0, **params) -> ImageType

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

def apply_to_image(self, image: ImageType, angle: float = 0, **params) -> ImageType:
    return rotate(
        image=image,
        angle=angle,
        interpolation=self.interpolation,
        border_mode=self.border_mode,
        value=self.value,
        crop_border=self.crop_border,
    )

apply_to_mask

apply_to_mask(mask: MaskType, angle: float = 0, **params) -> MaskType

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

def apply_to_mask(self, mask: MaskType, angle: float = 0, **params) -> MaskType:
    return rotate(
        image=mask,
        angle=angle,
        interpolation=cv2.INTER_NEAREST,
        border_mode=self.border_mode,
        value=self.mask_value,
        crop_border=self.crop_border,
    )

apply_to_bboxes

apply_to_bboxes(bboxes: BBoxesType, image_size: Tuple[int], angle: float = 0, **params) -> BBoxesType

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

def apply_to_bboxes(
    self,
    bboxes: BBoxesType,
    image_size: Tuple[int],
    angle: float = 0,
    **params,
) -> BBoxesType:
    return box_function.rotate(bboxes=bboxes, angle=angle, image_size=image_size)

apply_to_polygons

apply_to_polygons(polygons: PolygonType, angle: float, image_size: Tuple[int], **params) -> PolygonType

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

def apply_to_polygons(
    self,
    polygons: PolygonType,
    angle: float,
    image_size: Tuple[int],
    **params,
) -> PolygonType:
    return polygon_function.rotate(polygons=polygons, angle=angle, image_size=image_size)

RandomRotate90

RandomRotate90(**kwargs)

Bases: ImageSizeParams, ImageTransform

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

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

get_apply_params

get_apply_params() -> ParamsType

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

def get_apply_params(self) -> ParamsType:
    return {"factor": random.randint(0, 3)}

apply_to_image

apply_to_image(image: ImageType, factor: int = 0, **params) -> ImageType

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

def apply_to_image(self, image: ImageType, factor: int = 0, **params) -> ImageType:
    return random_rotate90(
        image=image,
        factor=factor,
    )

apply_to_mask

apply_to_mask(mask: MaskType, factor: int = 0, **params) -> MaskType

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

def apply_to_mask(self, mask: MaskType, factor: int = 0, **params) -> MaskType:
    return random_rotate90(
        image=mask,
        factor=factor,
    )

apply_to_bboxes

apply_to_bboxes(bboxes: BBoxesType, image_size: Tuple[int], factor: int = 0, **params) -> BBoxesType

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

def apply_to_bboxes(
    self,
    bboxes: BBoxesType,
    image_size: Tuple[int],
    factor: int = 0,
    **params,
) -> BBoxesType:
    return box_function.rotate90(bboxes=bboxes, factor=factor, image_size=image_size)

apply_to_polygons

apply_to_polygons(polygons: PolygonType, image_size: Tuple[int], factor: int = 0, **params) -> PolygonType

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

def apply_to_polygons(
    self,
    polygons: PolygonType,
    image_size: Tuple[int],
    factor: int = 0,
    **params,
) -> PolygonType:
    return polygon_function.rotate90(polygons=polygons, factor=factor, image_size=image_size)

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

brightness_limit instance-attribute

brightness_limit = brightness_limit

contrast_limit instance-attribute

contrast_limit = contrast_limit

saturation_limit instance-attribute

saturation_limit = saturation_limit

hue_limit instance-attribute

hue_limit = hue_limit

get_apply_params

get_apply_params() -> ParamsType

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

def get_apply_params(self) -> ParamsType:
    order = [0, 1, 2, 3]
    random.shuffle(order)

    return {
        "brightness": random.uniform(*self.brightness_limit),
        "contrast": random.uniform(*self.contrast_limit),
        "saturation": random.uniform(*self.saturation_limit),
        "hue": random.uniform(*self.hue_limit),
        "order": order,
    }

apply_to_image

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

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

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

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

ksize_limit instance-attribute

ksize_limit = ksize_limit

get_apply_params

get_apply_params() -> ParamsType

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

def get_apply_params(self) -> ParamsType:
    return {"ksize": random.randint(*self.ksize_limit)}

apply_to_image

apply_to_image(image: ImageType, ksize: int = 3, **params) -> ImageType

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

def apply_to_image(self, image: ImageType, ksize: int = 3, **params) -> ImageType:
    return blur(image=image, ksize=ksize)

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

ksize_limit instance-attribute

ksize_limit = ksize_limit

sigma_limit instance-attribute

sigma_limit = sigma_limit

get_apply_params

get_apply_params() -> ParamsType

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

def get_apply_params(self) -> ParamsType:
    return {
        "ksize": random.randint(*self.ksize_limit),
        "sigma": random.uniform(*self.sigma_limit),
    }

apply_to_image

apply_to_image(image: ImageType, ksize: int = 3, sigma: float = 0.0, **params) -> ImageType

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

def apply_to_image(
    self, image: ImageType, ksize: int = 3, sigma: float = 0.0, **params
) -> ImageType:
    return gaussian_blur(image=image, ksize=ksize, sigma=sigma)

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

brightness_limit instance-attribute

brightness_limit = brightness_limit

get_apply_params

get_apply_params() -> ParamsType

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

def get_apply_params(self) -> ParamsType:
    return {"brightness": random.uniform(*self.brightness_limit)}

apply_to_image

apply_to_image(image: ImageType, brightness: float = 0.0, **params) -> ImageType

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

def apply_to_image(self, image: ImageType, brightness: float = 0.0, **params) -> ImageType:
    return adjust_brightness(image=image, brightness=brightness)

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

contrast_limit instance-attribute

contrast_limit = contrast_limit

get_apply_params

get_apply_params() -> ParamsType

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

def get_apply_params(self) -> ParamsType:
    return {"contrast": random.uniform(*self.contrast_limit)}

apply_to_image

apply_to_image(image: ImageType, contrast: float = 0.0, **params) -> ImageType

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

def apply_to_image(self, image: ImageType, contrast: float = 0.0, **params) -> ImageType:
    return adjust_contrast(image=image, contrast=contrast)

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

hue_limit instance-attribute

hue_limit = hue_limit

get_apply_params

get_apply_params() -> ParamsType

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

def get_apply_params(self) -> ParamsType:
    return {"hue": random.uniform(*self.hue_limit)}

apply_to_image

apply_to_image(image: ImageType, hue: float = 0.0, **params) -> ImageType

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

def apply_to_image(self, image: ImageType, hue: float = 0.0, **params) -> ImageType:
    return adjust_hue(image=image, hue=hue)

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

saturation_limit instance-attribute

saturation_limit = saturation_limit

get_apply_params

get_apply_params() -> ParamsType

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

def get_apply_params(self) -> ParamsType:
    return {"saturation": random.uniform(*self.saturation_limit)}

apply_to_image

apply_to_image(image: ImageType, saturation: float = 0.0, **params) -> ImageType

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

def apply_to_image(self, image: ImageType, saturation: float = 0.0, **params) -> ImageType:
    return adjust_saturation(image=image, saturation=saturation)

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

gamma_limit instance-attribute

gamma_limit = gamma_limit

get_apply_params

get_apply_params() -> ParamsType

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

def get_apply_params(self) -> ParamsType:
    return {"gamma": random.uniform(*self.gamma_limit)}

apply_to_image

apply_to_image(image: ImageType, gamma: float = 0.0, **params) -> ImageType

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

def apply_to_image(self, image: ImageType, gamma: float = 0.0, **params) -> ImageType:
    return adjust_gamma(image=image, gamma=gamma)

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

brightness_limit instance-attribute

brightness_limit = brightness_limit

contrast_limit instance-attribute

contrast_limit = contrast_limit

brightness_by_max instance-attribute

brightness_by_max = brightness_by_max

get_apply_params

get_apply_params() -> ParamsType

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

def get_apply_params(self) -> ParamsType:
    return {
        "brightness": random.uniform(*self.brightness_limit),
        "contrast": random.uniform(*self.contrast_limit),
    }

apply_to_image

apply_to_image(image: ImageType, brightness: float = 0.0, contrast: float = 0.0, **params) -> ImageType

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

def apply_to_image(
    self, image: ImageType, brightness: float = 0.0, contrast: float = 0.0, **params
) -> ImageType:
    return adjust_brightness_contrast(
        image=image,
        brightness=brightness,
        contrast=contrast,
        brightness_by_max=self.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

color_shift_limit instance-attribute

color_shift_limit = color_shift_limit

intensity_limit instance-attribute

intensity_limit = intensity_limit

get_apply_params

get_apply_params() -> ParamsType

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

def get_apply_params(self) -> ParamsType:
    return {
        "color_shift": random.uniform(*self.color_shift_limit),
        "intensity": random.uniform(*self.intensity_limit),
        "random_state": random.randint(0, 65536),
    }

apply_to_image

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

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

def apply_to_image(
    self,
    image: ImageType,
    color_shift: float = 0.05,
    intensity: float = 0.50,
    random_state: Optional[int] = None,
    **params,
) -> ImageType:
    return iso_noise(
        image=image, color_shift=color_shift, intensity=intensity, random_state=random_state
    )

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

quality_limit instance-attribute

quality_limit = quality_limit

get_apply_params

get_apply_params() -> ParamsType

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

def get_apply_params(self) -> ParamsType:
    return {"quality": random.randint(*self.quality_limit)}

apply_to_image

apply_to_image(image: ImageType, quality: int = 100) -> ImageType

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

def apply_to_image(
    self,
    image: ImageType,
    quality: int = 100,
) -> ImageType:
    return image_compression(image=image, quality=quality, image_type=".jpeg")

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

alpha_limit instance-attribute

alpha_limit = alpha_limit

lightness_limit instance-attribute

lightness_limit = lightness_limit

_generate_sharpening_matrix

_generate_sharpening_matrix(alpha: float, lightness: float) -> ndarray

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

def _generate_sharpening_matrix(self, alpha: float, lightness: float) -> np.ndarray:
    matrix_nochange = np.array([[0, 0, 0], [0, 1, 0], [0, 0, 0]], dtype=np.float32)
    matrix_effect = np.array(
        [[-1, -1, -1], [-1, 8 + lightness, -1], [-1, -1, -1]],
        dtype=np.float32,
    )
    matrix = (1 - alpha) * matrix_nochange + alpha * matrix_effect
    return matrix

get_apply_params

get_apply_params() -> ParamsType

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

def get_apply_params(self) -> ParamsType:
    sharpening_matrix = self._generate_sharpening_matrix(
        random.uniform(*self.alpha_limit), random.uniform(*self.lightness_limit)
    )
    return {"sharpening_matrix": sharpening_matrix}

apply_to_image

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

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

def apply_to_image(
    self,
    image: ImageType,
    sharpening_matrix: np.ndarray,
) -> ImageType:
    return sharpen(image=image, sharpening_matrix=sharpening_matrix)

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

multiplier instance-attribute

multiplier = multiplier

per_channel instance-attribute

per_channel = per_channel

_generate_multiplier

_generate_multiplier(image: ImageType, multiplier: ndarray, random_seed: int) -> ndarray

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

def _generate_multiplier(
    self, image: ImageType, multiplier: np.ndarray, random_seed: int
) -> np.ndarray:
    if multiplier[0] == multiplier[1]:
        return np.array([multiplier[0]])

    height, width = image.shape[:2]
    num_channels = 3

    result_multiplier = np.random.RandomState(seed=random_seed).uniform(
        multiplier[0], multiplier[1], [height, width, num_channels]
    )
    return result_multiplier

get_apply_params

get_apply_params() -> ParamsType

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

def get_apply_params(self) -> ParamsType:
    def _shrink_range(low: int, high: int) -> List[int]:
        lower_bound = random.uniform(low, high)
        upper_bound = random.uniform(lower_bound, high)
        return [lower_bound, upper_bound]

    return {
        "multiplier": np.array(_shrink_range(*self.multiplier)),
        "random_seed": random.randint(0, 65536),
    }

apply_to_image

apply_to_image(image: ImageType, multiplier: ndarray, random_seed: int) -> ImageType

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

def apply_to_image(self, image: ImageType, multiplier: np.ndarray, random_seed: int) -> ImageType:
    _multiplier = self._generate_multiplier(image, multiplier, random_seed)
    return multiplicative_noise(image=image, multiplier=_multiplier)

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

proportion_limit instance-attribute

proportion_limit = proportion_limit

resampling instance-attribute

resampling = resampling

border_mode instance-attribute

border_mode = border_mode

value instance-attribute

value = value

mask_value instance-attribute

mask_value = mask_value

get_apply_params

get_apply_params() -> ParamsType

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

def get_apply_params(self) -> ParamsType:
    return {
        "proportion_left": random.uniform(*self.proportion_limit),
        "proportion_right": random.uniform(*self.proportion_limit),
        "proportion_top": random.uniform(*self.proportion_limit),
        "proportion_bottom": random.uniform(*self.proportion_limit),
    }

apply_to_image

apply_to_image(image: ImageType, proportion_left: float, proportion_right: float, proportion_top: float, proportion_bottom: float, **params) -> ImageType

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

def apply_to_image(
    self,
    image: ImageType,
    proportion_left: float,
    proportion_right: float,
    proportion_top: float,
    proportion_bottom: float,
    **params,
) -> ImageType:
    return ratio_jitter(
        image=image,
        proportion_left=proportion_left,
        proportion_right=proportion_right,
        proportion_top=proportion_top,
        proportion_bottom=proportion_bottom,
        resampling=self.resampling,
        border_mode=self.border_mode,
        value=self.value,
    )

apply_to_mask

apply_to_mask(mask: MaskType, proportion_left: float, proportion_right: float, proportion_top: float, proportion_bottom: float, **params) -> MaskType

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

def apply_to_mask(
    self,
    mask: MaskType,
    proportion_left: float,
    proportion_right: float,
    proportion_top: float,
    proportion_bottom: float,
    **params,
) -> MaskType:
    return ratio_jitter(
        image=mask,
        proportion_left=proportion_left,
        proportion_right=proportion_right,
        proportion_top=proportion_top,
        proportion_bottom=proportion_bottom,
        resampling="nearest",
        border_mode=self.border_mode,
        value=self.mask_value,
    )

apply_to_bboxes

apply_to_bboxes(bboxes: BBoxesType, image_size: Tuple[int], proportion_left: float, proportion_right: float, proportion_top: float, proportion_bottom: float, **params) -> BBoxesType

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

def apply_to_bboxes(
    self,
    bboxes: BBoxesType,
    image_size: Tuple[int],
    proportion_left: float,
    proportion_right: float,
    proportion_top: float,
    proportion_bottom: float,
    **params,
) -> BBoxesType:
    return box_function.ratio_jitter(
        bboxes=bboxes,
        image_size=image_size,
        proportion_left=proportion_left,
        proportion_right=proportion_right,
        proportion_top=proportion_top,
        proportion_bottom=proportion_bottom,
    )

apply_to_polygons

apply_to_polygons(polygons: PolygonType, image_size: Tuple[int], proportion_left: float, proportion_right: float, proportion_top: float, proportion_bottom: float, **params) -> PolygonType

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

def apply_to_polygons(
    self,
    polygons: PolygonType,
    image_size: Tuple[int],
    proportion_left: float,
    proportion_right: float,
    proportion_top: float,
    proportion_bottom: float,
    **params,
) -> PolygonType:
    return polygon_function.ratio_jitter(
        polygons=polygons,
        image_size=image_size,
        proportion_left=proportion_left,
        proportion_right=proportion_right,
        proportion_top=proportion_top,
        proportion_bottom=proportion_bottom,
    )

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

ratio_limit instance-attribute

ratio_limit = ratio_limit

resampling instance-attribute

resampling = resampling

border_mode instance-attribute

border_mode = border_mode

value instance-attribute

value = value

mask_value instance-attribute

mask_value = mask_value

get_apply_params

get_apply_params() -> ParamsType

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

def get_apply_params(self) -> ParamsType:
    log_ratio = (math.log(self.ratio_limit[0]), math.log(self.ratio_limit[1]))
    return {
        "ratio": math.exp(random.uniform(*log_ratio)),
        "h_start": random.random(),
        "w_start": random.random(),
    }

apply_to_image

apply_to_image(image: ImageType, ratio: float, h_start: float, w_start: float, **params) -> ImageType

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

def apply_to_image(
    self,
    image: ImageType,
    ratio: float,
    h_start: float,
    w_start: float,
    **params,
) -> ImageType:
    return zoom(
        image=image,
        ratio=ratio,
        h_start=h_start,
        w_start=w_start,
        resampling=self.resampling,
        border_mode=self.border_mode,
        value=self.value,
    )

apply_to_mask

apply_to_mask(mask: MaskType, ratio: float, h_start: float, w_start: float, **params) -> MaskType

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

def apply_to_mask(
    self,
    mask: MaskType,
    ratio: float,
    h_start: float,
    w_start: float,
    **params,
) -> MaskType:
    return zoom(
        image=mask,
        ratio=ratio,
        h_start=h_start,
        w_start=w_start,
        resampling="nearest",
        border_mode=self.border_mode,
        value=self.mask_value,
    )

apply_to_bboxes

apply_to_bboxes(bboxes: BBoxesType, image_size: Tuple[int], ratio: float, h_start: float, w_start: float, **params) -> BBoxesType

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

def apply_to_bboxes(
    self,
    bboxes: BBoxesType,
    image_size: Tuple[int],
    ratio: float,
    h_start: float,
    w_start: float,
    **params,
) -> BBoxesType:
    return box_function.zoom(
        bboxes=bboxes,
        image_size=image_size,
        ratio=ratio,
        h_start=h_start,
        w_start=w_start,
    )

apply_to_polygons

apply_to_polygons(polygons: PolygonType, image_size: Tuple[int], ratio: float, h_start: float, w_start: float, **params) -> PolygonType

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

def apply_to_polygons(
    self,
    polygons: PolygonType,
    image_size: Tuple[int],
    ratio: float,
    h_start: float,
    w_start: float,
    **params,
) -> PolygonType:
    return polygon_function.zoom(
        polygons=polygons,
        image_size=image_size,
        ratio=ratio,
        h_start=h_start,
        w_start=w_start,
    )

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

scale_limit instance-attribute

scale_limit = scale_limit

aspect_ratio_limit instance-attribute

aspect_ratio_limit = aspect_ratio_limit

resampling instance-attribute

resampling = resampling

targets property

targets: Dict[str, Callable]

get_apply_params

get_apply_params() -> ParamsType

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

def get_apply_params(self) -> ParamsType:
    log_aspect_ratio = (math.log(self.aspect_ratio_limit[0]), math.log(self.aspect_ratio_limit[1]))
    w_scale, h_scale = 1.0, 1.0
    num_attempts = 10
    for _ in range(num_attempts):
        scale = random.uniform(*self.scale_limit)
        aspect_ratio = math.exp(random.uniform(*log_aspect_ratio))
        _w_scale = scale * math.sqrt(aspect_ratio)
        _h_scale = scale / math.sqrt(aspect_ratio)
        if _w_scale <= 1.0 and _h_scale <= 1.0:
            w_scale, h_scale = _w_scale, _h_scale
            break

    return {
        "w_scale": w_scale,
        "h_scale": h_scale,
        "h_start": random.random(),
        "w_start": random.random(),
    }

apply_to_image

apply_to_image(image: ImageType, h_scale: float, w_scale: float, h_start: float, w_start: float, **params) -> ImageType

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

def apply_to_image(
    self,
    image: ImageType,
    h_scale: float,
    w_scale: float,
    h_start: float,
    w_start: float,
    **params,
) -> ImageType:
    return random_resized_crop(
        image=image,
        h_scale=h_scale,
        w_scale=w_scale,
        h_start=h_start,
        w_start=w_start,
        resampling=self.resampling,
    )

apply_to_mask

apply_to_mask(mask: MaskType, h_scale: float, w_scale: float, h_start: float, w_start: float, **params) -> MaskType

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

def apply_to_mask(
    self,
    mask: MaskType,
    h_scale: float,
    w_scale: float,
    h_start: float,
    w_start: float,
    **params,
) -> MaskType:
    return random_resized_crop(
        image=mask,
        h_scale=h_scale,
        w_scale=w_scale,
        h_start=h_start,
        w_start=w_start,
        resampling="nearest",
    )

apply_to_bboxes

apply_to_bboxes(bboxes: BBoxesType, **params) -> BBoxesType

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

def apply_to_bboxes(self, bboxes: BBoxesType, **params) -> BBoxesType:
    raise NotImplementedError

apply_to_polygons

apply_to_polygons(polygons: PolygonType, **params) -> PolygonType

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

def apply_to_polygons(self, polygons: PolygonType, **params) -> PolygonType:
    raise NotImplementedError

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

height instance-attribute

height = height

width instance-attribute

width = width

scale_limit instance-attribute

scale_limit = scale_limit

aspect_ratio_limit instance-attribute

aspect_ratio_limit = aspect_ratio_limit

resampling instance-attribute

resampling = resampling

border_mode instance-attribute

border_mode = border_mode

value instance-attribute

value = value

mask_value instance-attribute

mask_value = mask_value

get_apply_params

get_apply_params() -> ParamsType

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

def get_apply_params(self) -> ParamsType:
    log_aspect_ratio = (math.log(self.aspect_ratio_limit[0]), math.log(self.aspect_ratio_limit[1]))
    return {
        "scale": random.uniform(*self.scale_limit),
        "aspect_ratio": math.exp(random.uniform(*log_aspect_ratio)),
        "h_start": random.random(),
        "w_start": random.random(),
    }

apply_to_image

apply_to_image(image: ImageType, scale: float, aspect_ratio: float, h_start: float, w_start: float, **params) -> ImageType

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

def apply_to_image(
    self,
    image: ImageType,
    scale: float,
    aspect_ratio: float,
    h_start: float,
    w_start: float,
    **params,
) -> ImageType:
    return random_resized_crop_and_pad(
        image=image,
        scale=scale,
        aspect_ratio=aspect_ratio,
        h_start=h_start,
        w_start=w_start,
        height=self.height,
        width=self.width,
        resampling=self.resampling,
        border_mode=self.border_mode,
        value=self.value,
    )

apply_to_mask

apply_to_mask(mask: MaskType, scale: float, aspect_ratio: float, h_start: float, w_start: float, **params) -> MaskType

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

def apply_to_mask(
    self,
    mask: MaskType,
    scale: float,
    aspect_ratio: float,
    h_start: float,
    w_start: float,
    **params,
) -> MaskType:
    return random_resized_crop_and_pad(
        image=mask,
        scale=scale,
        aspect_ratio=aspect_ratio,
        h_start=h_start,
        w_start=w_start,
        height=self.height,
        width=self.width,
        resampling="nearest",
        border_mode=self.border_mode,
        value=self.mask_value,
    )

apply_to_bboxes

apply_to_bboxes(bboxes: BBoxesType, image_size: Tuple[int], scale: float, aspect_ratio: float, h_start: float, w_start: float, **params) -> BBoxesType

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

def apply_to_bboxes(
    self,
    bboxes: BBoxesType,
    image_size: Tuple[int],
    scale: float,
    aspect_ratio: float,
    h_start: float,
    w_start: float,
    **params,
) -> BBoxesType:
    return box_function.random_resized_crop_and_pad(
        bboxes=bboxes,
        image_size=image_size,
        scale=scale,
        aspect_ratio=aspect_ratio,
        h_start=h_start,
        w_start=w_start,
        height=self.height,
        width=self.width,
    )

apply_to_polygons

apply_to_polygons(polygons: PolygonType, image_size: Tuple[int], scale: float, aspect_ratio: float, h_start: float, w_start: float, **params) -> PolygonType

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

def apply_to_polygons(
    self,
    polygons: PolygonType,
    image_size: Tuple[int],
    scale: float,
    aspect_ratio: float,
    h_start: float,
    w_start: float,
    **params,
) -> PolygonType:
    return polygon_function.random_resized_crop_and_pad(
        polygons=polygons,
        image_size=image_size,
        scale=scale,
        aspect_ratio=aspect_ratio,
        h_start=h_start,
        w_start=w_start,
    )

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

radius_limit instance-attribute

radius_limit = radius_limit

get_apply_params

get_apply_params() -> ParamsType

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

def get_apply_params(self) -> ParamsType:
    return {
        "xc": random.random(),
        "yc": random.random(),
        "x_radius": random.uniform(*self.radius_limit),
        "y_radius": random.uniform(*self.radius_limit),
        "angle": random.uniform(0.00, 360.00),
    }

apply_to_image

apply_to_image(image: ImageType, xc: float, yc: float, x_radius: float, y_radius: float, angle: float, **params) -> ImageType

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

def apply_to_image(
    self,
    image: ImageType,
    xc: float,
    yc: float,
    x_radius: float,
    y_radius: float,
    angle: float,
    **params,
) -> ImageType:
    return light_reflect(
        image=image, xc=xc, yc=yc, x_radius=x_radius, y_radius=y_radius, angle=angle
    )

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

intensity_limit instance-attribute

intensity_limit = intensity_limit

get_apply_params

get_apply_params() -> ParamsType

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

def get_apply_params(self) -> ParamsType:
    intensity = random.uniform(*self.intensity_limit)
    return {
        "offset_top_left": tuple((random.uniform(0, intensity), random.uniform(0, intensity))),
        "offset_top_right": tuple((random.uniform(0, intensity), random.uniform(0, intensity))),
        "offset_bottom_right": tuple((random.uniform(0, intensity), random.uniform(0, intensity))),
        "offset_bottom_left": tuple((random.uniform(0, intensity), random.uniform(0, intensity))),
    }

apply_to_image

apply_to_image(image: ImageType, offset_top_left: OffsetType, offset_top_right: OffsetType, offset_bottom_right: OffsetType, offset_bottom_left: OffsetType, **params) -> ImageType

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

def apply_to_image(
    self,
    image: ImageType,
    offset_top_left: OffsetType,
    offset_top_right: OffsetType,
    offset_bottom_right: OffsetType,
    offset_bottom_left: OffsetType,
    **params,
) -> ImageType:
    return perspective_transform(
        image=image,
        offset_top_left=offset_top_left,
        offset_top_right=offset_top_right,
        offset_bottom_right=offset_bottom_right,
        offset_bottom_left=offset_bottom_left,
        interpolate_method="linear",
    )

apply_to_mask

apply_to_mask(mask: MaskType, offset_top_left: OffsetType, offset_top_right: OffsetType, offset_bottom_right: OffsetType, offset_bottom_left: OffsetType, **params) -> MaskType

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

def apply_to_mask(
    self,
    mask: MaskType,
    offset_top_left: OffsetType,
    offset_top_right: OffsetType,
    offset_bottom_right: OffsetType,
    offset_bottom_left: OffsetType,
    **params,
) -> MaskType:
    return perspective_transform(
        image=mask,
        offset_top_left=offset_top_left,
        offset_top_right=offset_top_right,
        offset_bottom_right=offset_bottom_right,
        offset_bottom_left=offset_bottom_left,
        interpolate_method="nearest",
    )

apply_to_bboxes

apply_to_bboxes(bboxes: BBoxesType, image_size: Tuple[int], offset_top_left: OffsetType, offset_top_right: OffsetType, offset_bottom_right: OffsetType, offset_bottom_left: OffsetType, **params) -> BBoxesType

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

def apply_to_bboxes(
    self,
    bboxes: BBoxesType,
    image_size: Tuple[int],
    offset_top_left: OffsetType,
    offset_top_right: OffsetType,
    offset_bottom_right: OffsetType,
    offset_bottom_left: OffsetType,
    **params,
) -> BBoxesType:
    return box_function.perspective_transform(
        bboxes=bboxes,
        image_size=image_size,
        offset_top_left=offset_top_left,
        offset_top_right=offset_top_right,
        offset_bottom_right=offset_bottom_right,
        offset_bottom_left=offset_bottom_left,
    )

apply_to_polygons

apply_to_polygons(polygons: PolygonType, image_size: Tuple[int], offset_top_left: OffsetType, offset_top_right: OffsetType, offset_bottom_right: OffsetType, offset_bottom_left: OffsetType, **params) -> PolygonType

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

def apply_to_polygons(
    self,
    polygons: PolygonType,
    image_size: Tuple[int],
    offset_top_left: OffsetType,
    offset_top_right: OffsetType,
    offset_bottom_right: OffsetType,
    offset_bottom_left: OffsetType,
    **params,
) -> PolygonType:
    return polygon_function.perspective_transform(
        polygons=polygons,
        image_size=image_size,
        offset_top_left=offset_top_left,
        offset_top_right=offset_top_right,
        offset_bottom_right=offset_bottom_right,
        offset_bottom_left=offset_bottom_left,
    )

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

scale instance-attribute

scale = scale

ratio instance-attribute

ratio = ratio

_value instance-attribute

_value = value

randomly_select_values instance-attribute

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

get_apply_params

get_apply_params() -> ParamsType

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

def get_apply_params(self) -> ParamsType:
    value = self._value
    if self.randomly_select_values:
        value_options = {
            "erase": 0,
            "rgb": (random.randint(0, 255), random.randint(0, 255), random.randint(0, 255)),
            "random": "random",
        }
        value = value_options[random.choice(list(value_options.keys()))]

    x_in_ratio, y_in_ratio, h_in_ratio, w_in_ratio = self._get_random_erase_params()

    return dict(
        x_in_ratio=x_in_ratio,
        y_in_ratio=y_in_ratio,
        h_in_ratio=h_in_ratio,
        w_in_ratio=w_in_ratio,
        value=value,
    )

apply_to_image

apply_to_image(image: ImageType, x_in_ratio: float, y_in_ratio: float, h_in_ratio: float, w_in_ratio: float, value: Union[int, Tuple[int, int, int], str], **params) -> ImageType

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

def apply_to_image(
    self,
    image: ImageType,
    x_in_ratio: float,
    y_in_ratio: float,
    h_in_ratio: float,
    w_in_ratio: float,
    value: Union[int, Tuple[int, int, int], str],
    **params,
) -> ImageType:
    is_gray = image.ndim == 2
    if is_gray:
        img_height, img_width = image.shape
    else:
        img_height, img_width, _ = image.shape

    x = int(min(x_in_ratio * img_width, img_width))
    y = int(min(y_in_ratio * img_height, img_height))
    h = int(min(h_in_ratio * img_height, img_height))
    w = int(min(w_in_ratio * img_width, img_width))

    # cast value to script acceptable type
    if isinstance(value, (int, float)):
        value = np.array([float(value)]).astype("uint8")[None, None, :]
    elif isinstance(value, str):
        value = (np.random.normal(size=(h, w, 3)) * 255).astype("uint8")
    elif isinstance(value, (list, tuple)):
        value = np.array([float(v) for v in value]).astype("uint8")[None, None, :]

    return erase(image=image, x=x, y=y, w=w, h=h, v=value)

Grayscale

Grayscale(**kwargs)

Bases: ImageTransform

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

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

apply_to_image

apply_to_image(image: ImageType, **params) -> ImageType

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

def apply_to_image(self, image: ImageType, **params) -> ImageType:
    return grayscale(image=image)

base_transform

Data augmentation을 위한 기본 Transform의 interface를 정의합니다.

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 = {}

prob instance-attribute

prob = prob

_additional_targets instance-attribute

_additional_targets = {}

data_for_params property

data_for_params: List[str]

targets property

targets: Dict[str, Callable]

__call__

__call__(*args, force_apply: bool = False, **data) -> Any

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

def __call__(self, *args, force_apply: bool = False, **data) -> Any:
    if args:
        raise KeyError("Data must be passed as named arguments, for example: aug(image=image)")

    if (random.random() < self.prob) or force_apply:
        params = {}
        if self.data_for_params:
            data_for_params = {k: data[k] for k in self.data_for_params}
            params_from_data = self.get_params_from_data(data_for_params)
            params.update(params_from_data)

        apply_param = self.get_apply_params()
        params.update(apply_param)
        data = self.apply_with_params(params, **data)

    return data

get_apply_params

get_apply_params() -> ParamsType

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

def get_apply_params(self) -> ParamsType:
    return {}

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 {}

apply_with_params

apply_with_params(params: ParamsType, **data) -> ParamsType

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

def apply_with_params(self, params: ParamsType, **data) -> ParamsType:
    def _apply_with_params(method: callable, target: str, data: Dict, params: ParamsType):
        output = []

        if isinstance(data, List) and target == "image":
            is_multipage = True
        else:
            is_multipage = False
            data = [data]

        for d in data:
            output.append(method(d, **params))

        if not is_multipage:
            output = output[0]

        return output

    for target, target_method in self.targets.items():
        if target in data:
            data[target] = _apply_with_params(target_method, target, data[target], params)
    for additional_target, target in self._additional_targets.items():
        if additional_target in data:
            target_method = self.targets[target]
            data[additional_target] = _apply_with_params(
                target_method, target, data[additional_target], params
            )
    return data

add_targets

add_targets(additional_targets: Dict[str, str]) -> None

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

def add_targets(self, additional_targets: Dict[str, str]) -> None:
    self._additional_targets = additional_targets

builder

_types module-attribute

_types = {None: {__name__: _u1ELfor _type in _types}, None: {pascal_to_snake(__name__): _LpWafor _type in _types}}

logger module-attribute

logger = getLogger('SaigeResearch')

Augmentation

Augmentation(transform)

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

def __init__(self, transform) -> None:
    self.to_numpy = ToNumpy()
    self.to_pil = ToPil()
    self.transform = transform

to_numpy instance-attribute

to_numpy = ToNumpy()

to_pil instance-attribute

to_pil = ToPil()

transform instance-attribute

transform = transform

__call__

__call__(**data) -> Dict

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

def __call__(self, **data) -> Dict:
    # XXX: image는 np.ndarray, mask는 PIL.Image.Image 인 경우 에러 발생할 수 있음
    # 현재는 해당 케이스로 사용하지 않기 때문에 해결하지 않음
    # 추후 해결 시 고려 사항: Transform의 add_targets 에서 image 혹은 mask 타입이 추가된 경우 모두 함께 처리되어야함
    pil = False
    if "image" in data:
        image = data["image"]
        if isinstance(image, List):
            image = image[0]
        pil = isinstance(image, Image.Image)

    if pil:
        data = self.to_numpy(**data, force_apply=True)

    data = self.transform(**data)

    if pil:
        data = self.to_pil(**data, force_apply=True)

    return data

build_augmentation

build_augmentation(config: Dict) -> Augmentation

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

def build_augmentation(config: Dict) -> Augmentation:
    logger.info(f"[AUGMENTATION]\n{pprint.pformat(config, sort_dicts=False)}")

    config = dict(config.items())
    _target_ = config.pop("_target_")
    target_class = _types[_target_]

    # Build transform
    if issubclass(target_class, ImageTransform):
        transform = target_class(**config)

    # Build compose
    elif issubclass(target_class, BaseCompose):
        transform_configs = config.pop("transforms", [])

        _transforms = []
        for transform_config in transform_configs:
            _transform = build_transform(**transform_config)
            _transforms.append(_transform)
        config["transforms"] = _transforms

        transform = build_compose(_target_, **config)

    else:
        raise NotImplementedError(f"Unsupported augmentation type: {_target_}")

    return Augmentation(transform)

build_transform

build_transform(_target_: str, **config)

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

def build_transform(_target_: str, **config):
    transform = _types[_target_]
    return transform(**config)

compose

여러 Data Transform들을 하나로 묶어서 관리해주는 기본 BaseCompose 클래스 및 Compose 구현을 제공합니다.

base_compose

Data augmentation을 위한 기본 Compose의 interface를 정의합니다.

BaseCompose

BaseCompose(transforms: Sequence[Union[BaseTransform, BaseCompose]], prob: float = 1.0)

여러 Data Transform들을 하나로 묶어서 관리해주는 Compose의 기본 interface를 정의합니다.

Source code in SaigeToolkit/data/transform/augmentation/compose/base_compose.py

def __init__(
    self, transforms: Sequence[Union[BaseTransform, BaseCompose]], prob: float = 1.0
) -> None:
    self.transforms = transforms
    self.prob = prob

transforms instance-attribute

transforms = transforms

prob instance-attribute

prob = prob

__call__

__call__(*args, force_apply: bool = False, **data) -> Dict

Source code in SaigeToolkit/data/transform/augmentation/compose/base_compose.py

def __call__(self, *args, force_apply: bool = False, **data) -> Dict:
    if args:
        raise KeyError("Data must be passed as named arguments, for example: aug(image=image)")

    if (random.random() < self.prob) or force_apply:
        data = self.apply(**data)

    return data

apply

apply(**data) -> Dict

Source code in SaigeToolkit/data/transform/augmentation/compose/base_compose.py

def apply(self, **data) -> Dict:
    raise NotImplementedError

__len__

__len__() -> int

Source code in SaigeToolkit/data/transform/augmentation/compose/base_compose.py

def __len__(self) -> int:
    return len(self.transforms)

__getitem__

__getitem__(index: int) -> Union[BaseTransform, BaseCompose]

Source code in SaigeToolkit/data/transform/augmentation/compose/base_compose.py

def __getitem__(self, index: int) -> Union[BaseTransform, BaseCompose]:
    return self.transforms[index]

add_targets

add_targets(additional_targets: Dict[str, str]) -> None

Source code in SaigeToolkit/data/transform/augmentation/compose/base_compose.py

def add_targets(self, additional_targets: Dict[str, str]) -> None:
    for t in self.transforms:
        t.add_targets(additional_targets)

builder

logger module-attribute

logger = getLogger('SaigeResearch')

_types module-attribute

_types = {None: {__name__: _v4sKfor _type in _types}, None: {pascal_to_snake(__name__): _s9B7for _type in _types}}

build_compose

build_compose(_target_: str, transforms: List[BaseTransform], **config) -> BaseCompose

Source code in SaigeToolkit/data/transform/augmentation/compose/builder.py

def build_compose(_target_: str, transforms: List[BaseTransform], **config) -> BaseCompose:
    return _types[_target_](transforms=transforms, **config)

compose

Compose

Compose(transforms: Sequence[Union[BaseTransform, BaseCompose]], prob: float = 1.0)

Bases: BaseCompose

Source code in SaigeToolkit/data/transform/augmentation/compose/base_compose.py

def __init__(
    self, transforms: Sequence[Union[BaseTransform, BaseCompose]], prob: float = 1.0
) -> None:
    self.transforms = transforms
    self.prob = prob

apply

apply(**data) -> Dict

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

def apply(self, **data) -> Dict:
    for t in self.transforms:
        data = t(**data)

    return data

SomeOf

SomeOf(k: int, replacement: bool = False, **kwargs)

Bases: BaseCompose

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

def __init__(self, k: int, replacement: bool = False, **kwargs) -> None:
    super().__init__(**kwargs)
    self.k = k
    self.replacement = replacement

k instance-attribute

k = k

replacement instance-attribute

replacement = replacement

apply

apply(**data) -> Dict

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

def apply(self, **data) -> Dict:
    if self.replacement:
        cur_transforms = random.choices(self.transforms, k=self.k)
    else:
        cur_transforms = random.sample(self.transforms, k=min(len(self.transforms), self.k))

    for t in cur_transforms:
        data = t(**data)

    return data