data

Module diagram

classDiagram
  class data {
  }
  class batch_sampler {
  }
  class balanced_sampler {
  }
  class base_sampler {
  }
  class builder {
  }
  class class_sampler {
  }
  class collate {
  }
  class crop {
  }
  class base_cropper {
  }
  class builder {
  }
  class edge_cropper {
  }
  class ocr_cropper {
  }
  class polygon_cropper {
  }
  class dataclass {
  }
  class box {
  }
  class segment {
  }
  class dataset {
  }
  class base_dataset {
  }
  class builder {
  }
  class platform_reader {
  }
  class saige_vision_reader {
  }
  class srproj_dataset {
  }
  class srproj_reader {
  }
  class process_config {
  }
  class sampler {
  }
  class builder {
  }
  class infinite_random_sampler {
  }
  class transform {
  }
  class augmentation {
  }
  class api {
  }
  class augment_function {
  }
  class augment_transform {
  }
  class base_transform {
  }
  class builder {
  }
  class compose {
  }
  class base_compose {
  }
  class builder {
  }
  class compose {
  }
  class box_function {
  }
  class function_util {
  }
  class image_function {
  }
  class image_load {
  }
  class polygon_function {
  }
  class resize {
  }
  class roi {
  }
  class api {
  }
  class roi_calculator {
  }
  class roi_handler {
  }
  class transform {
  }
  class typevar {
  }
  batch_sampler --> builder
  balanced_sampler --> base_sampler
  builder --> balanced_sampler
  builder --> base_sampler
  builder --> class_sampler
  class_sampler --> base_sampler
  crop --> builder
  builder --> base_cropper
  builder --> edge_cropper
  builder --> ocr_cropper
  builder --> polygon_cropper
  edge_cropper --> base_cropper
  polygon_cropper --> base_cropper
  dataset --> builder
  builder --> base_dataset
  builder --> srproj_dataset
  srproj_dataset --> base_dataset
  srproj_dataset --> srproj_reader
  sampler --> builder
  builder --> infinite_random_sampler
  augmentation --> builder
  api --> augment_function
  augment_transform --> augment_function
  augment_transform --> base_transform
  builder --> augment_transform
  builder --> builder
  builder --> compose
  compose --> base_compose
  box_function --> polygon_function
  box_function --> typevar
  function_util --> typevar
  image_function --> typevar
  image_load --> image_function
  polygon_function --> augment_function
  polygon_function --> typevar
  resize --> box_function
  resize --> image_function
  resize --> polygon_function
  resize --> typevar
  roi --> api
  roi --> roi_handler
  api --> roi_handler
  roi_handler --> roi_calculator
  transform --> augmentation
  transform --> image_function
  transform --> image_load
  transform --> resize
  transform --> roi_handler

data

데이터 처리 및 변환, 샘플링 등 data 관련 기능을 제공합니다.

batch_samper: torch dataloader와 호환 가능한 커스텀 batch sampler를 관리하는 모듈입니다.
sampler: torch dataloader와 호환 가능한 커스텀 sampler를 관리하는 모듈입니다.
dataset: 커스텀 데이터셋을 정의하고 관리하는 모듈입니다.
transform: Data augmentation을 위한 Transform 클래스 및 여러 Data Transform들을 하나로 묶어서 관리해주는 Compose 클래스를 제공합니다.
crop: 데이터셋에 포함되어 이미지 crop을 수행하는 Cropper 클래스를 제공합니다.
dataclass: Box, Segment 등 각종 커스텀 데이터 클래스를 정의하고 관리하는 모듈입니다.

batch_sampler

torch dataloader와 호환 가능한 커스텀 batch sampler를 관리하는 모듈입니다.

BatchSampler 클래스를 상속받아 새로운 batch sampler를 정의할 수 있습니다.

balanced_sampler

BalancedSampler

BalancedSampler(dataset: Dataset, balance_keys: Optional[List[str]] = None, balance_ratios: Optional[List[float]] = None, calculate_patch_number: bool = False, shuffle: bool = True, **kwargs)

Bases: BatchSampler

Sampler implementation for weighted API dataset balancing.

Sampler class is used to specify the sequence of indices/keys used in data loading. This class represents iterable objects over the indices to datasets.

When __iter__ is called, Sampler creates self.buffer, a sequence of data indices which is balanced to has exact same number of data sample from each data subset.

If balance_ratio is given, sampler autmatically re-weights each subset. Otherwise, each subset will be balanced to be equal size.

Attributes:

dataset (Dataset) –

dataset instance to be sampled
calculate_patch_number (bool) –

whether update number of patches in dataset, after sampling
subset_data_indices (List[List[int]]) –

split data indices, based on subset descriminator
multipliers (ndarray) –

number of repeats for each data subset
remainers (ndarray) –

number of remainers for each data subset
shuffle (bool) –

whether shuffle output data indices after sampling
buffer (ndarray) –

data indices for one epoch (accept duplication)

Note

Given:

dataset: Dataset with number of sample 300. which can be splitted into two subsets using given key set [key_a, key_b].
- subset_a: Data subset with number of sample 100, corresponds to key_a.
- subset_b: Data subset with number of sample 200, corresponds to key_b.
The word corresponds means that each domain, source, and category value parsed from the key is same to that of metadata information of each data in subset.

Output:

iterator: An iterator with 200 indices from subset_a and 200 indices from subset_b. The max element of iterator will be 299, which is len(subset_a) + len(subset_b) - 1.

The iterator must be directly fed to torch.utils.data.DataLoader class initializer with name sample, along with torch.utils.data.ApiDataset object.

Examples:

loader = torch.utils.data.DataLoader(
   dataset=torch.utils.data.ApiDataset(...),
   shuffle=False,
   batch_sampler=BalancedDatasetSampler(
            dataset,
            balance_keys=["Document/AI_HUB", "Document/CJ"],
            balance_ratios=[0.6, 0.3],
        ),
)

Reference: https://pytorch.org/docs/stable/data.html#data-loading-order-and-sampler

initializing balance sampler

Parameters:

dataset (Dataset) –

dataset to be sampled. directly set to class attribute.
balance_keys (List[str], default: None ) –

domain-source-categoty keys as subset descriminator. Defaults to None.
balance_ratios (Optional[List[float]], default: None ) –

balance of subsets. if None, subsets are equally sampled. Defaults to None.
calculate_patch_number (bool, default: False ) –

boolean to calculate patch_number after sampling. directly set to class attribute. Defaults to False.
shuffle (bool, default: True ) –

boolean to shuffle data sample. Defaults to True.

Source code in SaigeToolkit/data/batch_sampler/balanced_sampler.py

def __init__(
    self,
    dataset: Dataset,
    balance_keys: Optional[List[str]] = None,
    balance_ratios: Optional[List[float]] = None,
    calculate_patch_number: bool = False,
    shuffle: bool = True,
    **kwargs,
) -> None:
    """initializing balance sampler

    Args:
        dataset (data.Dataset): dataset to be sampled. directly set to class attribute.
        balance_keys (List[str], optional):
            domain-source-categoty keys as subset descriminator. Defaults to None.
        balance_ratios (Optional[List[float]], optional): balance of subsets.
            if None, subsets are equally sampled. Defaults to None.
        calculate_patch_number (bool, optional): boolean to calculate patch_number after sampling.
            directly set to class attribute. Defaults to False.
        shuffle (bool, optional): boolean to shuffle data sample. Defaults to True.
    """

    assert hasattr(dataset, "files"), "Given dataset has no attribute 'files'!"
    assert isinstance(dataset.files, list)

    super().__init__(
        dataset,
        shuffle=shuffle,
        **kwargs,
    )
    self.calculate_patch_number = True if dataset.crop_fn is not None else calculate_patch_number
    if self.calculate_patch_number:
        assert hasattr(
            dataset, "calculate_patch_number"
        ), "function 'calculate_patch_number' should exist in dataset class"

    if balance_keys is None:
        print("No balance key provided. All domain-source-category pair will be grouped separately")
        balance_keys = self._build_default_balance_keys(dataset)
        if balance_ratios is not None:
            balance_ratios = balance_ratios if len(balance_keys) == len(balance_ratios) else None

    if balance_ratios is not None:
        assert len(balance_keys) == len(balance_ratios)
        balance_ratios = np.array(balance_ratios) / min(balance_ratios)
    else:
        balance_ratios = np.ones(len(balance_keys))

    self.balance_state = {k: {"ratio": v} for k, v in zip(balance_keys, balance_ratios)}

    self._split_dataset_indices_using_keys(balance_keys)
    self._calculate_subset_weights(balance_ratios)

calculate_patch_number `instance-attribute`

calculate_patch_number = True if crop_fn is not None else calculate_patch_number

balance_state `instance-attribute`

balance_state = {k: {'ratio': v}for (k, v) in zip(balance_keys, balance_ratios)}

_build_default_balance_keys

_build_default_balance_keys(dataset: Dataset) -> List[str]

Build default balance_keys which is grouping all domain-source-category separately

Parameters:

dataset (Dataset) –

dataset instance. should have files attribute (SaigeDataset). each file data should have domain, source, category information, which would be used as subset descriminator.

Returns:

List[str] –

List[str]: balance_key list example: ["Document/AI_HUB", "Document/CJ"]

Author

Sukho Yoon

Source code in SaigeToolkit/data/batch_sampler/balanced_sampler.py

def _build_default_balance_keys(self, dataset: Dataset) -> List[str]:
    """Build default balance_keys which is grouping all domain-source-category separately

    Args:
        dataset (data.Dataset): dataset instance. should have `files` attribute (SaigeDataset).
            each file data should have domain, source, category information,
            which would be used as subset descriminator.

    Returns:
        List[str]: balance_key list
            example: ["Document/AI_HUB", "Document/CJ"]

    Author:
        Sukho Yoon
    """
    balance_keys = []
    for file in dataset.files:
        identity = "/".join([file["domain"], file["source"], file["category"]])
        if identity not in balance_keys:
            balance_keys.append(identity)

    return balance_keys

_extract_domain_source_category_from_key

_extract_domain_source_category_from_key(key: str) -> List[List[str]]

A function that parses given key for balancing.

empty string between slash (/) or "None" string will be treated as None-key

This function assumes target key is in the form of ...

"{domain}" # or ...
"{domain}/{source}" # or ...
"{domain}/{source}/{category}"
"''/None/{category}"

(ex) "Document/AI_HUB/상.하수도관리"

Parameters:

key (str) –

Key string for separating datasets into subsets.

Returns:

List[List[str]] –

List[List[str]]: domain_source_category_list. Key string parsed into list.
List[List[str]] –

(ex)
List[List[str]] –

```
List[List[str]] –

["Document", None, None]
List[List[str]] –

["Document", "AI_HUB", None]
List[List[str]] –

["Document", "AI_HUB", "상.하수도관리"]
List[List[str]] –

[None, None, "상.하수도관리"]
List[List[str]] –

```

Author

Jonghyuk Baek

Source code in SaigeToolkit/data/batch_sampler/balanced_sampler.py

def _extract_domain_source_category_from_key(self, key: str) -> List[List[str]]:
    """
    A function that parses given key for balancing.

    empty string between slash (/) or "None" string will be treated as None-key

    This function assumes target key is in the form of ...
    ```
    "{domain}" # or ...
    "{domain}/{source}" # or ...
    "{domain}/{source}/{category}"
    "''/None/{category}"
    ```
    (ex) "Document/AI_HUB/상.하수도관리"

    Args:
        key (str): Key string for separating datasets into subsets.

        (ex)
        ```
        "Document"
        "Document/AI_HUB"
        "Document/AI_HUB/상.하수도관리"
        "/None/상.하수도관리"
        ```

    Returns:
        List[List[str]]: domain_source_category_list. Key string parsed into list.

        (ex)
        ```
        ["Document", None, None]
        ["Document", "AI_HUB", None]
        ["Document", "AI_HUB", "상.하수도관리"]
        [None, None, "상.하수도관리"]
        ```

    Author:
        Jonghyuk Baek
    """

    domain_source_category = key.split("/")
    assert (
        len(domain_source_category) <= 3
    ), f"Proper key format is {{domain}}/{{souce}}/{{category}}."
    domain_source_category += [None] * (3 - len(domain_source_category))

    return [None if key in {"", "None"} else key for key in domain_source_category]

_split_dataset_indices_using_keys

_split_dataset_indices_using_keys(target_keys: List[str]) -> List[List[int]]

A function that splits dataset using given keys.

Each key contains metadata info: domain, source, and category. This key information will be used to separate total dataset into specific subsets.

For each data in dataset, check whether data's domain, source, and category corresponds to the key information.

For example, if a key is given as below:

key = "sample_domain/sample_source/sample_category"

Then the subset will be generated containing only index of data with metadata of:

{
    domain: "sample_domain",
    source: "sample_source",
    category: "sample_category",
    ...
}

For another example, if a key is given as below:

key = "sample_domain"

Then the subset will be generated containing only index of data with metadata of:

{
    domain: "sample_domain",
    ...
}

This generation process will be repeated for each key in target_keys.

Parameters:

target_keys (List[str]) –

List key for subset balancing.

Returns:

List[List[int]] –

List[List[int]]: subset_data_indices. List of data index list. Each element represents a subset of dataset.

Author

Jonghyuk Baek

Source code in SaigeToolkit/data/batch_sampler/balanced_sampler.py

def _split_dataset_indices_using_keys(self, target_keys: List[str]) -> List[List[int]]:
    """
    A function that splits dataset using given keys.

    Each key contains metadata info: `domain`, `source`, and `category`.
    This key information will be used to separate total dataset into specific subsets.

    For each data in dataset, check whether data's domain, source, and category corresponds
    to the key information.

    For example, if a key is given as below:
    ``` python
    key = "sample_domain/sample_source/sample_category"
    ```

    Then the subset will be generated containing only `index` of data with metadata of:
    ``` python
    {
        domain: "sample_domain",
        source: "sample_source",
        category: "sample_category",
        ...
    }
    ```

    For another example, if a key is given as below:
    ``` python
    key = "sample_domain"
    ```

    Then the subset will be generated containing only `index` of data with metadata of:
    ``` python
    {
        domain: "sample_domain",
        ...
    }
    ```

    This generation process will be repeated for each key in `target_keys`.

    Args:
        target_keys (List[str]): List key for subset balancing.

    Returns:
        List[List[int]]: subset_data_indices. List of data index list.
            Each element represents a subset of dataset.

    Author:
        Jonghyuk Baek
    """

    # To filter out concateneted dataset into subsets.
    target_keys = self.balance_state.keys()

    target_domain_source_category_list = []

    for target_key in target_keys:
        domain_source_category = self._extract_domain_source_category_from_key(target_key)
        target_domain_source_category_list.append(domain_source_category)

    # Split dataset into subsets using balancing target keys.
    # self.dataset.files: List containing each data's metadata dictionary.
    subset_data_indices = [[] for _ in range(len(target_domain_source_category_list))]
    for idx_data, metadata_dict in enumerate(self.dataset.files):
        data_domain_source_category = [metadata_dict[k] for k in ["domain", "source", "category"]]

        # Fill out each subset with matching condition.
        for idx_subset, target_domain_source_category in enumerate(
            target_domain_source_category_list
        ):
            if self.match_identifier(data_domain_source_category, target_domain_source_category):
                subset_data_indices[idx_subset].append(idx_data)
                break

    for key, indices in zip(target_keys, subset_data_indices):
        assert (
            len(indices) != 0
        ), f"No matching data for key [{key}]. Please check balance target keys.\n"
        self.balance_state[key].update({"data_indices": indices})

match_identifier

match_identifier(id_data: List[Optional[str]], id_target: List[Optional[str]]) -> bool

Check data identifier matches non-None target identifier identifier: [domain, source, category]

Parameters:

id_data (Optional[str]) –

data item identifier
id_target (Optional[str]) –

balance target subset identifier

Returns:

bool ( bool ) –

whether id's are matched

Author

Sukho Yoon

Source code in SaigeToolkit/data/batch_sampler/balanced_sampler.py

def match_identifier(self, id_data: List[Optional[str]], id_target: List[Optional[str]]) -> bool:
    """Check data identifier matches non-None target identifier
    identifier: [domain, source, category]

    Args:
        id_data (Optional[str]): data item identifier
        id_target (Optional[str]): balance target subset identifier

    Returns:
        bool: whether id's are matched

    Author:
        Sukho Yoon
    """

    for id_d, id_t in zip(id_data, id_target):
        if id_t is None:
            continue

        if id_d != id_t:
            return False

    return True

_update_subset_sizes

_update_subset_sizes()

Source code in SaigeToolkit/data/batch_sampler/balanced_sampler.py

def _update_subset_sizes(self):
    for key, balance_state in self.balance_state.items():
        indices = balance_state["data_indices"]
        if self.calculate_patch_number:
            num_patch = self._update_dataset_num_patch(indices)
            self.balance_state[key].update(
                {"size": num_patch, "patch_per_image": num_patch / len(indices)}
            )
        else:
            self.balance_state[key].update({"size": len(indices)})

_calculate_subset_weights

_calculate_subset_weights(balance_ratios: ndarray) -> None

Calculate subset multiplier and remainer using following two variables: balance_ratios, subset_size_ratios

balance_ratios: resultant data exposure ratio by subsets subset_size_ratios: data sizes ratio between subsets

Parameters:

balance_ratios (ndarray) –

resultant data exposure ratio by subsets

Author

Sukho Yoon

Source code in SaigeToolkit/data/batch_sampler/balanced_sampler.py

def _calculate_subset_weights(self, balance_ratios: np.ndarray) -> None:
    """
    Calculate subset multiplier and remainer using following two variables: balance_ratios, subset_size_ratios

    balance_ratios: resultant data exposure ratio by subsets
    subset_size_ratios: data sizes ratio between subsets

    Args:
        balance_ratios (np.ndarray): resultant data exposure ratio by subsets

    Author:
        Sukho Yoon
    """
    self._update_subset_sizes()

    balance_ratios = np.array([v["ratio"] for v in self.balance_state.values()])
    subset_sizes = np.array([v["size"] for v in self.balance_state.values()])
    subset_repeatance = balance_ratios / subset_sizes
    subset_repeatance = subset_repeatance / min(subset_repeatance)

    target_sizes = np.round(subset_repeatance * subset_sizes).astype(int)
    multipliers = np.floor(subset_repeatance).astype(int)
    remainers = target_sizes - multipliers * subset_sizes

    for key, multiplier, remainer in zip(self.balance_state.keys(), multipliers, remainers):
        if self.calculate_patch_number:
            remainer = np.round(remainer / self.balance_state[key]["patch_per_image"]).astype(int)

        self.balance_state[key].update({"multiplier": multiplier, "remainer": remainer})

generate_buffer

generate_buffer() -> deque

Creates index list of data instances, which is already balanced.

Exact result can be always different even when shuffle=False when non-zero element in self.balance_state[key]["remainer"] exists.

Author

Jonghyuk Baek

Source code in SaigeToolkit/data/batch_sampler/balanced_sampler.py

def generate_buffer(self) -> deque:
    """
    Creates index list of data instances, which is already balanced.

    Exact result can be always different even when `shuffle=False` when non-zero element
    in `self.balance_state[key]["remainer"]` exists.

    Author:
        Jonghyuk Baek
    """

    buffer = []

    if self.calculate_patch_number:
        n_patch = 0

    sample_with_replacement = bool(self.calculate_patch_number)
    # Expand data index list from smaller dataset, to be same length as the biggest one.
    for balance_state in self.balance_state.values():
        indices = balance_state["data_indices"]
        multiplier = balance_state["multiplier"]
        remainer = balance_state["remainer"]

        # update multipliers
        buffer.append(np.repeat(indices, multiplier))
        if self.calculate_patch_number:
            n_patch += balance_state["size"] * multiplier

        # update remainers
        _buffer_remainers = np.random.choice(indices, remainer, replace=sample_with_replacement)
        buffer.append(_buffer_remainers)
        if self.calculate_patch_number:
            n_patch += self._update_dataset_num_patch(_buffer_remainers)

    if self.calculate_patch_number:
        self.dataset.n_patch = n_patch

    # Concatenate index list from every dataset and shuffle.
    # Shuffle parameter should not be fed when initializing `torch.utils.data.DataLoader`.
    buffer = np.concatenate(buffer, axis=None)
    buffer = deque(buffer)

    return buffer

_update_dataset_num_patch

_update_dataset_num_patch(indices: Union[deque, List[int]]) -> int

Updates n_patch attribute in dataset, when indices is updated. (due to changes in remainer items)

Parameters:

indices (Union[deque, List[int]]) –

file indices for calculating data patch number

Returns:

int ( int ) –

number of patches in files

Author

Sukho Yoon

Source code in SaigeToolkit/data/batch_sampler/balanced_sampler.py

def _update_dataset_num_patch(self, indices: Union[deque, List[int]]) -> int:
    """Updates n_patch attribute in dataset, when indices is updated.
    (due to changes in remainer items)

    Args:
        indices (Union[deque, List[int]]): file indices for calculating data patch number

    Returns:
        int: number of patches in files

    Author:
        Sukho Yoon
    """

    subset_files = [self.dataset.files[index] for index in indices]
    return self.dataset.calculate_patch_number(subset_files)

base_sampler

Batch sampler 클래스의 기본이 되는 추상 클래스를 정의한 모듈입니다.

BatchSampler 클래스를 상속받아 새로운 batch sampler를 정의할 수 있습니다. Naive sampler는 가장 기본적인 sampler 구현 예시로, 데이터셋의 인덱스를 순서대로 배치로 묶어 반환합니다.

logger `module-attribute`

logger = getLogger('SaigeResearch')

BatchSampler

BatchSampler(dataset: Dataset, batch_size: int = 1, repeat: bool = False, shuffle: bool = False, drop_last: bool = False)

Bases: Registerable, ABC

Baseclass for all batch_sampler classes.

Attributes:

dataset (Dataset) –

dataset to sample from.
batch_size (int) –

batch size.
repeat (bool) –

repeat data when data is not enough for batch size.
shuffle (bool) –

shuffle data.
drop_last (bool) –

drop last data when data is not enough for batch size.

Note

batch_size, shuffle, and drop_last should be popped from dataloader config, then passed to the batch sampler config.
repeat: for SaigeVision2 api, should be set as True.
- if number of data is enough for batch size, then repeat is neglected.
drop_last: for SaigeVision2 api, should be set as True.
- to prevent the last batch from being smaller than the specified batch size.
- if False, even when repeat is set as True, the last batch will be smaller than the specified batch size.
for Training, shuffle should be set as True.
- drop_last and repeat are optional.
for Validation, repeat, shuffle, and drop_last should be set as False.

Examples:

cfg_sampler.update(
    {
        "shuffle": cfg_dataloader.pop("shuffle", False),
        "drop_last": cfg_dataloader.pop("drop_last", False),
        "batch_size": cfg_dataloader.pop("batch_size", 1),
    }
)
batch_sampler = build_batch_sampler(dataset=dataset, **cfg_sampler)
dataloader = build_dataloader(
    dataset,
    collate_fn=collate_fn,
    batch_sampler=batch_sampler,
    **cfg_dataloader,
)

Source code in SaigeToolkit/data/batch_sampler/base_sampler.py

def __init__(
    self,
    dataset: data.Dataset,
    batch_size: int = 1,
    repeat: bool = False,
    shuffle: bool = False,
    drop_last: bool = False,
) -> None:
    self.dataset = dataset

    self.batch_size = batch_size
    self.repeat = repeat

    self.shuffle = shuffle
    self.drop_last = drop_last

    self._n_repeat = None
    self._buffer_length = None

registry `instance-attribute`

registry: Dict[str, BatchSampler]

dataset `instance-attribute`

dataset = dataset

batch_size `instance-attribute`

batch_size = batch_size

repeat `instance-attribute`

repeat = repeat

shuffle `instance-attribute`

shuffle = shuffle

drop_last `instance-attribute`

drop_last = drop_last

_n_repeat `instance-attribute`

_n_repeat = None

_buffer_length `instance-attribute`

_buffer_length = None

buffer_length `property`

buffer_length: int

n_repeat `property`

n_repeat: int

iter

__iter__() -> Iterator[List[int]]

Source code in SaigeToolkit/data/batch_sampler/base_sampler.py

def __iter__(self) -> Iterator[List[int]]:
    if self.batch_size > self.buffer_length:
        if self.repeat:
            logger.info("data repeat activated.")
        elif self.drop_last:
            self.drop_last = False
            logger.warning("data too short. drop_last deactivated.")

    while True:
        yield from self._get_processed_buffer()

_get_processed_buffer

_get_processed_buffer() -> deque

Source code in SaigeToolkit/data/batch_sampler/base_sampler.py

def _get_processed_buffer(self) -> deque:
    buffer = self._shuffle_and_repeat_buffer()
    buffer = self._batch_buffer(buffer)
    return buffer

_shuffle_and_repeat_buffer

_shuffle_and_repeat_buffer() -> deque

Source code in SaigeToolkit/data/batch_sampler/base_sampler.py

def _shuffle_and_repeat_buffer(self) -> deque:
    if self.repeat and self.batch_size > self.buffer_length:
        buffer = deque()
        for _ in range(self.n_repeat):
            _buffer = self.generate_buffer()
            if self.shuffle:
                np.random.shuffle(_buffer)
            buffer.extend(_buffer)

    else:
        buffer = self.generate_buffer()
        if self.shuffle:
            np.random.shuffle(buffer)

    return buffer

_batch_buffer

_batch_buffer(buffer: deque) -> deque

Source code in SaigeToolkit/data/batch_sampler/base_sampler.py

def _batch_buffer(self, buffer: deque) -> deque:
    data_length, remainders = divmod(len(buffer), self.batch_size)
    _buffer = deque([[buffer.popleft() for _ in range(self.batch_size)] for _ in range(data_length)])
    if not self.drop_last and remainders > 0:
        _buffer.append([buffer.popleft() for _ in range(remainders)])
    return _buffer

len

__len__() -> int

Source code in SaigeToolkit/data/batch_sampler/base_sampler.py

def __len__(self) -> int:
    if self.drop_last:
        length = self.buffer_length // self.batch_size
    else:
        length = ceil(self.buffer_length / self.batch_size)
    return max(1, length)

generate_buffer `abstractmethod`

generate_buffer() -> deque

Source code in SaigeToolkit/data/batch_sampler/base_sampler.py

@abc.abstractmethod
def generate_buffer(self) -> deque:
    return deque([])

NaiveSampler

NaiveSampler(dataset: Dataset, batch_size: int = 1, repeat: bool = False, shuffle: bool = False, drop_last: bool = False)

Bases: BatchSampler

Naive sampler implementation with buffer extension feature added.

Source code in SaigeToolkit/data/batch_sampler/base_sampler.py

def __init__(
    self,
    dataset: data.Dataset,
    batch_size: int = 1,
    repeat: bool = False,
    shuffle: bool = False,
    drop_last: bool = False,
) -> None:
    self.dataset = dataset

    self.batch_size = batch_size
    self.repeat = repeat

    self.shuffle = shuffle
    self.drop_last = drop_last

    self._n_repeat = None
    self._buffer_length = None

generate_buffer

generate_buffer() -> deque

Source code in SaigeToolkit/data/batch_sampler/base_sampler.py

def generate_buffer(self) -> deque:
    return deque(np.arange(len(self.dataset)))

builder

build_batch_sampler

build_batch_sampler(_target_: str, **config) -> BatchSampler

Source code in SaigeToolkit/data/batch_sampler/builder.py

def build_batch_sampler(_target_: str, **config) -> BatchSampler:
    return BatchSampler.registry[_target_](**config)

class_sampler

ClassBalancedSampler

ClassBalancedSampler(dataset: Dataset, shuffle: bool = True, **kwargs)

Bases: BatchSampler

Sampler implementation for simple class balancing.

Uses class_index value in dataset file dictionaries. When more than one classes exist in single image, the multiplier of the rarest class within image will be applied to the data.

Raises:

IndexError –

Will be raised when class index exceeds MAX_NUM_CLS.

Notes

TODO: Weighted balancing.
TODO: Cropper applicability.

Source code in SaigeToolkit/data/batch_sampler/class_sampler.py

def __init__(
    self,
    dataset: Dataset,
    shuffle: bool = True,
    **kwargs,
) -> None:
    super().__init__(dataset, shuffle=shuffle, **kwargs)
    self.label_list, self.class_multiplier = self._make_weights_for_balanced_classes()

MAX_NUM_CLS `class-attribute` `instance-attribute`

MAX_NUM_CLS = 128

_make_weights_for_balanced_classes

_make_weights_for_balanced_classes() -> Tuple[List[int], List[int]]

Source code in SaigeToolkit/data/batch_sampler/class_sampler.py

def _make_weights_for_balanced_classes(self) -> Tuple[List[int], List[int]]:
    label_count = [0] * self.MAX_NUM_CLS
    label_list = [[] for _ in range(len(self.dataset.files))]
    for idx, file in enumerate(self.dataset.files):
        try:
            for label in file["labels"]:
                class_idx = label["class_index"]
                label_count[class_idx] += 1
                label_list[idx].append(class_idx)
        except KeyError:
            # XXX: For srproj compatibility.
            for label in file["LabelGroup"]["Label"]:
                class_idx = label["ClassIndex"]
                label_count[class_idx] += 1
                label_list[idx].append(class_idx)

    max_label_count = max(label_count)
    label_count = [
        max_label_count if cnt == 0 else cnt for cnt in label_count
    ]  # Multiplier 1 for cls not seen.
    data_multiplier_per_class = [round(max_label_count / i) for i in label_count]

    return label_list, data_multiplier_per_class

generate_buffer

generate_buffer() -> deque

Source code in SaigeToolkit/data/batch_sampler/class_sampler.py

def generate_buffer(self) -> deque:
    buffer_balanced = []
    for i in range(len(self.dataset.files)):
        labels = self.label_list[i]
        multipliers = [self.class_multiplier[i] for i in labels]
        multiplier = max(multipliers, default=1)
        buffer_balanced.extend([i] * multiplier)

    return deque(buffer_balanced)

collate

default_device `module-attribute`

default_device = device('cpu')

images_to_4d_tensor

images_to_4d_tensor(images: List[Union[ndarray, Image, List]], device: device = default_device, apply_contiguous_div255: bool = True) -> Tensor

Converts a list of images to a 4D tensor.

Parameters:

images (List[Union[ndarray, Image, List]]) –

images to convert.
device (device, default: default_device ) –

device to move the tensor to. Defaults to cpu.
apply_contiguous_div255 (bool, default: True ) –

whether to apply contiguous_div255. Defaults to True.

Returns:

Tensor –

torch.Tensor: 4D tensor of images.

Source code in SaigeToolkit/data/collate.py

def images_to_4d_tensor(
    images: List[Union[np.ndarray, Image.Image, List]],
    device: torch.device = default_device,
    apply_contiguous_div255: bool = True,
) -> torch.Tensor:
    """Converts a list of images to a 4D tensor.

    Args:
        images (List[Union[np.ndarray, Image.Image, List]]): images to convert.
        device (torch.device, optional): device to move the tensor to. Defaults to cpu.
        apply_contiguous_div255 (bool, optional): whether to apply contiguous_div255. Defaults to True.

    Returns:
        torch.Tensor: 4D tensor of images.

    """

    # multipage인 경우 List[image] -> n channel image로 변환
    if isinstance(images[0], List):
        images = [_merge_multipage_to_n_channel_array(image) for image in images]

    # list -> np.ndarray (BHWC) -> BCHW
    if isinstance(images[0], np.ndarray) and len(images) == 1:
        data = images[0][np.newaxis]
    else:
        data = np.stack(images)

    if data.ndim == 3:  # gray images
        data = data[:, None]
    else:
        data = data.transpose(0, 3, 1, 2)

    # array -> tensor
    data = torch.from_numpy(data).to(device)

    if apply_contiguous_div255:
        data = _contiguous_div255(tensor=data)

    return data

_contiguous_div255

_contiguous_div255(tensor: Tensor)

Source code in SaigeToolkit/data/collate.py

def _contiguous_div255(tensor: torch.Tensor):
    # contiguous -> uint8 -> float -> [0, 1] normalize
    return tensor.contiguous().div(255)

_merge_multipage_to_n_channel_array

_merge_multipage_to_n_channel_array(image: List[Union[ndarray, Image]]) -> ndarray

Source code in SaigeToolkit/data/collate.py

def _merge_multipage_to_n_channel_array(image: List[Union[np.ndarray, Image.Image]]) -> np.ndarray:
    # k장의 이미지를 n채널 이미지(H x W x n array)로 concat합니다.
    merged = []
    for image_i in image:
        if isinstance(image_i, Image.Image):
            image_i = np.array(image_i)
        if image_i.ndim == 2:
            image_i = image_i[..., np.newaxis]
        merged.append(image_i)
    merged = np.concatenate(merged, axis=-1)
    return merged

crop

데이터 전처리를 위한 cropper 클래스를 제공합니다.

모든 cropper 클래스는 BaseCropper 클래스를 상속받아 구현되어 있으며, get_n_patch와 call 메소드를 구현해야 합니다.

get_n_patch 메소드는 이미지를 잘라낼 때 몇 개의 패치로 나눌지를 결정합니다.
call 메소드는 이미지를 입력받아 패치로 나누어 반환합니다.

사용 방식에 대해서는 dataset/base_dataset.py를 참고해주세요.

base_cropper

Cropper 클래스의 추상화를 위한 BaseCropper 클래스를 제공합니다.

모든 Cropper 클래스는 BaseCropper 클래스를 상속받아 구현되어야 하며, get_n_patch와 call 메소드를 구현해야 합니다.

BaseCropper

Bases: ABC

get_n_patch `abstractmethod`

get_n_patch(*_) -> int

Source code in SaigeToolkit/data/crop/base_cropper.py

@abstractmethod
def get_n_patch(self, *_) -> int:
    pass

call `abstractmethod`

__call__(*_) -> Any

Source code in SaigeToolkit/data/crop/base_cropper.py

@abstractmethod
def __call__(self, *_) -> Any:
    pass

builder

logger `module-attribute`

logger = getLogger('SaigeResearch')

CROPPER_IMPLEMENTATION `module-attribute`

CROPPER_IMPLEMENTATION = {'ocr': OcrCropper, 'polygon': PolygonCropper, 'edge': EdgeCropper}

get_crop_fn

get_crop_fn(_target_: Optional[str] = None, **cfg_crop: dict) -> Optional[BaseCropper]

getting crop function

Parameters:

cfg_crop (dict, default: {} ) –

config dict for building cropper

Returns:

Optional[BaseCropper] –

Optional[BaseCropper]: saige cropper object. if cfg_crop is None, return None

Source code in SaigeToolkit/data/crop/builder.py

def get_crop_fn(_target_: Optional[str] = None, **cfg_crop: dict) -> Optional[BaseCropper]:
    """getting crop function

    Args:
        cfg_crop (dict): config dict for building cropper

    Returns:
        Optional[BaseCropper]: saige cropper object.
            if cfg_crop is None, return None
    """
    if _target_ is None:
        return None
    cropper = get_crop_class(_target_)
    logger.info(f"[{'CROPPER'.center(9)}] {_target_} [params] {cfg_crop}")
    return cropper(**cfg_crop)

get_crop_class

get_crop_class(cfg_crop_name: str) -> Type[BaseCropper]

getting crop class from name

Parameters:

cfg_crop_name (str) –

cropper name

Returns:

Type[BaseCropper] –

Type[BaseCropper]: cropper class

Source code in SaigeToolkit/data/crop/builder.py

def get_crop_class(cfg_crop_name: str) -> Type[BaseCropper]:
    """getting crop class from name

    Args:
        cfg_crop_name (str): cropper name

    Returns:
        Type[BaseCropper]: cropper class
    """

    try:
        return CROPPER_IMPLEMENTATION[cfg_crop_name]
    except KeyError as e:
        raise RuntimeError(
            f"Cropper {cfg_crop_name} not implemented. Supported cropper list: {CROPPER_IMPLEMENTATION.keys()}"
        ) from e
    except Exception as e:
        logger.error(f"Error: {e}")
        raise e

edge_cropper

Crop image patches along the contour of mask (or polygon)

Imported from DefectGeneration repository. generation/data/crop/edge_cropper.py

logger `module-attribute`

logger = getLogger('SaigeResearch')

WindowState

Bases: Enum

relation state enum between center point and target point

IN `class-attribute` `instance-attribute`

IN = 0

WIDTH_POSITIVE_OUT `class-attribute` `instance-attribute`

WIDTH_POSITIVE_OUT = 1

WIDTH_NEGATIVE_OUT `class-attribute` `instance-attribute`

WIDTH_NEGATIVE_OUT = 2

HEIGHT_POSITIVE_OUT `class-attribute` `instance-attribute`

HEIGHT_POSITIVE_OUT = 3

HEIGHT_NEGATIVE_OUT `class-attribute` `instance-attribute`

HEIGHT_NEGATIVE_OUT = 4

WindowManager

WindowManager(width: int = 256, height: int = 256, strict_inner_patch: bool = True)

Manager for cropping window size, relation and window coordinates.

Attributes:

width (int) –

window width for image patch.
half_width (int) –

half of window width for image patch.
height (int) –

window height for image patch.
half_height (int) –

half of window height for image patch.
strict_inner_patch (bool) –

whether not allowing outer area of image.

Source code in SaigeToolkit/data/crop/edge_cropper.py

def __init__(
    self,
    width: int = 256,
    height: int = 256,
    strict_inner_patch: bool = True,
):
    self.width = width
    self.half_width = width // 2
    self.height = height
    self.half_height = height // 2
    self.strict_inner_patch = strict_inner_patch

width `instance-attribute`

width = width

half_width `instance-attribute`

half_width = width // 2

height `instance-attribute`

height = height

half_height `instance-attribute`

half_height = height // 2

strict_inner_patch `instance-attribute`

strict_inner_patch = strict_inner_patch

check_window

check_window(point: Iterable[int], center: Iterable[int]) -> WindowState

check whether target point is inside of window, returns WindowState

Parameters:

point (Iterable[int]) –

target point to be checked
center (Iterable[int]) –

reference center point

Returns:

WindowState ( WindowState ) –

relation state enum

Source code in SaigeToolkit/data/crop/edge_cropper.py

def check_window(
    self, point: Iterable[int], center: Iterable[int]
) -> WindowState:  # XXX: is this ok?
    """check whether target point is inside of window, returns WindowState

    Args:
        point (Iterable[int]): target point to be checked
        center (Iterable[int]): reference center point

    Returns:
        WindowState: relation state enum
    """
    width_distance = point[0] - center[0]
    abs_width_distance = abs(width_distance)
    height_distance = point[1] - center[1]
    abs_height_distance = abs(height_distance)

    if abs_width_distance <= self.half_width and abs_height_distance <= self.half_height:
        return WindowState.IN

    if abs_width_distance > abs_height_distance:
        if width_distance > 0:
            return WindowState.WIDTH_POSITIVE_OUT
        else:
            return WindowState.WIDTH_NEGATIVE_OUT
    else:
        if height_distance > 0:
            return WindowState.HEIGHT_POSITIVE_OUT
        else:
            return WindowState.HEIGHT_NEGATIVE_OUT

is_in_window

is_in_window(point: Iterable[int], center: Iterable[int]) -> bool

is target point inside of window

Parameters:

point (Iterable[int]) –

target point to be checked
center (Iterable[int]) –

reference center point

Returns:

bool ( bool ) –

boolean result

Source code in SaigeToolkit/data/crop/edge_cropper.py

def is_in_window(self, point: Iterable[int], center: Iterable[int]) -> bool:
    """is target point inside of window

    Args:
        point (Iterable[int]): target point to be checked
        center (Iterable[int]): reference center point

    Returns:
        bool: boolean result
    """
    window_state = self.check_window(point, center)
    return window_state == WindowState.IN

is_in_any_window

is_in_any_window(point: Iterable[int], centers: Iterable[Iterable[int]]) -> bool

is target point inside of any of windows

Parameters:

point (Iterable[int]) –

target point to be checked
center (Iterable[int]) –

list of reference center points

Returns:

bool ( bool ) –

boolean result

Source code in SaigeToolkit/data/crop/edge_cropper.py

def is_in_any_window(self, point: Iterable[int], centers: Iterable[Iterable[int]]) -> bool:
    """is target point inside of any of windows

    Args:
        point (Iterable[int]): target point to be checked
        center (Iterable[int]): list of reference center points

    Returns:
        bool: boolean result
    """
    return any(self.is_in_window(point, c) for c in centers)

get_coordinates_from_center

get_coordinates_from_center(h_center: int, w_center: int, h: int, w: int) -> Tuple[int, int, int, int]

get left/right top/bottom coordinates from picked center point.

Parameters:

h_center (int) –

picked center point h-coordinate
w_center (int) –

picked center point w-coordinate
h (int) –

image size height
w (int) –

image size width

Returns:

Tuple[int, int, int, int] –

Tuple[int, int, int, int]: (crop_left, crop_top, crop_right, crop_bottom)

Source code in SaigeToolkit/data/crop/edge_cropper.py

def get_coordinates_from_center(
    self, h_center: int, w_center: int, h: int, w: int
) -> Tuple[int, int, int, int]:
    """get left/right top/bottom coordinates from picked center point.

    Args:
        h_center (int): picked center point h-coordinate
        w_center (int): picked center point w-coordinate
        h (int): image size height
        w (int): image size width

    Returns:
        Tuple[int, int, int, int]: (crop_left, crop_top, crop_right, crop_bottom)
    """
    if self.strict_inner_patch:
        w_center = np.clip(w_center, self.half_width, w - self.width + self.half_width)
        h_center = np.clip(h_center, self.half_height, h - self.height + self.half_height)
    crop_left = w_center - self.half_width
    crop_right = crop_left + self.width
    crop_top = h_center - self.half_height
    crop_bottom = crop_top + self.height
    return (crop_left, crop_top, crop_right, crop_bottom)

CenterWithSatellite `dataclass`

CenterWithSatellite(point: Iterable[int], window_manager: WindowManager, satellite: Optional[Iterable[int]] = None)

Center point with 'satellites'. 'Satellites' is a point within center point's window, but not the center point. Also intra distance between 'satellites' should shorter than window size.

Attributes:

coordinate (Iterable[int]) –

center point coordinate
window_manager (WindowManager) –

WindowManager
max_width_distance (int) –

max width-wise positive distance of satellites
max_height_distance (int) –

max height-wise positive distance of satellites
min_width_distance (int) –

max width-wise negative distance of satellites
min_height_distance (int) –

max height-wise negative distance of satellites
satellite_points (List[Dict[str, any]]) –

satellite_points data

Source code in SaigeToolkit/data/crop/edge_cropper.py

def __init__(
    self,
    point: Iterable[int],
    window_manager: WindowManager,
    satellite: Optional[Iterable[int]] = None,
):
    self.coordinate = point
    self.window_manager = window_manager

    self.max_width_distance = 0
    self.max_height_distance = 0
    self.min_width_distance = 0
    self.min_height_distance = 0

    self.satellite_points = {}
    if satellite is not None:
        self.calculate_relation_as_satellite(satellite)

coordinate `instance-attribute`

coordinate = point

window_manager `instance-attribute`

window_manager = window_manager

max_width_distance `instance-attribute`

max_width_distance = 0

max_height_distance `instance-attribute`

max_height_distance = 0

min_width_distance `instance-attribute`

min_width_distance = 0

min_height_distance `instance-attribute`

min_height_distance = 0

satellite_points `instance-attribute`

satellite_points = {}

calculate_relation_as_satellite

calculate_relation_as_satellite(point: Iterable[int]) -> Union[Dict[str, Any], List[Dict[str, Any]]]

calculate relation between target point and center point. case 1: If target point is outside of center point's window, target point should be considered as next center point candidate.

case 2

Even when target point is in the window, check whether distance between satellites is larger than window size. If so, target point should be considered as next center point candidate.

Parameters:

point (Iterable[int]) –

target point to be checked

Returns:

Union[Dict[str, Any], List[Dict[str, Any]]] –

Union[Dict[str, Any], List[Dict[str, Any]]]: Dict[str, Any]: simple relation between center point and target point List[Dict[str, Any]]: reltations between satellite points and target point

Source code in SaigeToolkit/data/crop/edge_cropper.py

def calculate_relation_as_satellite(
    self, point: Iterable[int]
) -> Union[Dict[str, Any], List[Dict[str, Any]]]:
    """calculate relation between target point and center point.
    case 1:
        If target point is outside of center point's window,
        target point should be considered as next center point candidate.

    case 2:
        Even when target point is in the window,
        check whether distance between satellites is larger than window size.
        If so, target point should be considered as next center point candidate.

    Args:
        point (Iterable[int]): target point to be checked

    Returns:
        Union[Dict[str, Any], List[Dict[str, Any]]]:
            Dict[str, Any]: simple relation between center point and target point
            List[Dict[str, Any]]: reltations between satellite points and target point
    """
    width_distance = point[0] - self.coordinate[0]
    height_distance = point[1] - self.coordinate[1]
    relation = self.window_manager.check_window(point, self.coordinate)

    # target point is outside of center point's window.
    # Do not update satellite and return the relationship.
    if relation != WindowState.IN:
        return {"coordinate": self.coordinate, "relation": relation}

    satellites_intra_distance_errors = []
    if width_distance > self.max_width_distance:
        if abs(width_distance) + abs(self.min_width_distance) > self.window_manager.half_width:
            self._compare_point_and_calculate_error(
                "min_width", point, satellites_intra_distance_errors
            )
        else:
            # else, update as satellite point.
            self.max_width_distance = width_distance
            self.satellite_points.update({"max_width": {"coordinate": point, "relation": relation}})

    if height_distance > self.max_height_distance:
        if abs(height_distance) + abs(self.min_height_distance) > self.window_manager.half_height:
            self._compare_point_and_calculate_error(
                "min_height", point, satellites_intra_distance_errors
            )
        else:
            # else, update as satellite point.
            self.max_height_distance = height_distance
            self.satellite_points.update({"max_height": {"coordinate": point, "relation": relation}})

    if width_distance < self.min_width_distance:
        if abs(width_distance) + abs(self.max_width_distance) > self.window_manager.half_width:
            self._compare_point_and_calculate_error(
                "max_width", point, satellites_intra_distance_errors
            )
        else:
            # else, update as satellite point.
            self.min_width_distance = width_distance
            self.satellite_points.update({"min_width": {"coordinate": point, "relation": relation}})

    if height_distance < self.min_height_distance:
        if abs(height_distance) + abs(self.max_height_distance) > self.window_manager.half_height:
            self._compare_point_and_calculate_error(
                "max_height", point, satellites_intra_distance_errors
            )
        else:
            # else, update as satellite point.
            self.min_height_distance = height_distance
            self.satellite_points.update({"min_height": {"coordinate": point, "relation": relation}})

    if satellites_intra_distance_errors:
        # any distance between satellites larger than window
        return satellites_intra_distance_errors

    return {"coordinate": self.coordinate, "relation": relation}

_compare_point_and_calculate_error

_compare_point_and_calculate_error(key, point, satellites_intra_distance_errors)

Refactored from the original code from Defect Generation (Function extracted).

Source code in SaigeToolkit/data/crop/edge_cropper.py

def _compare_point_and_calculate_error(self, key, point, satellites_intra_distance_errors):
    """Refactored from the original code from Defect Generation (Function extracted)."""
    # distance between satellites is larger than window size.
    compare_point = (
        self.satellite_points[key]["coordinate"] if key in self.satellite_points else self.coordinate
    )
    _relation = self.window_manager.check_window(point, compare_point)
    satellites_intra_distance_errors.append({"coordinate": compare_point, "relation": _relation})

EdgeCropper

EdgeCropper(crop_w: int = 512, crop_h: int = 512, random_sample: bool = False, patch_per_polygon: int = 1, strict_inner_patch: bool = True, ok_patch_prob: float = 0.01)

Bases: BaseCropper

Crop image patches along the contour of mask (or polygon)

Attributes:

window_manager (WindowManager) –

WindowManager
random_sample (bool) –

whether randomly select the first point of each polygon
patch_per_polygon (bool) –

number of repeat for cropping patches around each polygon.

Source code in SaigeToolkit/data/crop/edge_cropper.py

def __init__(
    self,
    crop_w: int = 512,
    crop_h: int = 512,
    random_sample: bool = False,
    patch_per_polygon: int = 1,
    strict_inner_patch: bool = True,
    ok_patch_prob: float = 0.01,
) -> None:
    self.crop_w = crop_w
    self.crop_h = crop_h
    self.window_manager = WindowManager(crop_w, crop_h, strict_inner_patch)
    self.random_sample = random_sample
    self.patch_per_polygon = patch_per_polygon
    self.ok_patch_prob = ok_patch_prob
    self.n_defect_patch_made = 0

    self.init_centers()

crop_w `instance-attribute`

crop_w = crop_w

crop_h `instance-attribute`

crop_h = crop_h

window_manager `instance-attribute`

window_manager = WindowManager(crop_w, crop_h, strict_inner_patch)

random_sample `instance-attribute`

random_sample = random_sample

patch_per_polygon `instance-attribute`

patch_per_polygon = patch_per_polygon

ok_patch_prob `instance-attribute`

ok_patch_prob = ok_patch_prob

n_defect_patch_made `instance-attribute`

n_defect_patch_made = 0

init_centers

init_centers()

Source code in SaigeToolkit/data/crop/edge_cropper.py

def init_centers(self):
    self.centers = []

get_n_patch

get_n_patch(polygons: List[ndarray]) -> int

PolygonCropper crops all polygon areas {self.patch_per_polygon} times per polygons, and also crops random position of image {self.random_patch_per_img} times per images. Therefore, resultant number of patches is weighted-sum result as coded below.

Parameters:

polygons (List[ndarray]) –

polygons of single image in dataset.

Returns:

int ( int ) –

number of patches to be cropped in single image

Source code in SaigeToolkit/data/crop/edge_cropper.py

def get_n_patch(self, polygons: List[np.ndarray]) -> int:
    """PolygonCropper crops all polygon areas {self.patch_per_polygon} times per polygons,
    and also crops random position of image {self.random_patch_per_img} times per images.
    Therefore, resultant number of patches is weighted-sum result as coded below.

    Args:
        polygons (List[np.ndarray]): polygons of single image in dataset.

    Returns:
        int: number of patches to be cropped in single image
    """
    raise NotImplementedError

call

__call__(image: Union[Image, ndarray], mask: Union[Image, ndarray], polygons: Optional[List[ndarray]] = None, **kwargs) -> List[dict]

crop image into image patches.

Parameters:

image (Union[Image, ndarray]) –

original image
polygons (List[ndarray], default: None ) –

polygon data (# of polygons, (4, 2)) polygon should have 4 points
mask (Union[Image, ndarray]) –

segmentation mask image

Returns:

List[dict] –

List[dict]: list of cropped image data dict

Source code in SaigeToolkit/data/crop/edge_cropper.py

def __call__(
    self,
    image: Union[Image.Image, np.ndarray],
    mask: Union[Image.Image, np.ndarray],
    polygons: Optional[List[np.ndarray]] = None,
    **kwargs,
) -> List[dict]:
    """crop image into image patches.

    Args:
        image (Union[Image.Image, np.ndarray]): original image
        polygons (List[np.ndarray]): polygon data
            (# of polygons, (4, 2)) polygon should have 4 points
        mask (Union[Image.Image, np.ndarray]): segmentation mask image

    Returns:
        List[dict]: list of cropped image data dict
    """

    w, h = read_image_size(image)

    if polygons is None:
        polygons, _ = cv2.findContours(np.asarray(mask), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
        polygons = [polygon[:, 0] for polygon in polygons]  # TODO: check..

    l_data = []
    self.init_centers()

    # crop defect polygon
    _polygons = random.sample(polygons, len(polygons)) if self.random_sample else polygons
    for polygon in _polygons:
        polygon = subdivide_points_into_min_resolution(list(polygon), 32, 32)
        for _ in range(self.patch_per_polygon):
            max_iter_per_polygon = 3 if self.random_sample else 1  # TODO: as class variable?
            min_num_point_not_included = None
            for _ in range(max_iter_per_polygon):
                new_centers = self.pick_centers_from_polygon(polygon)

                num_point_not_included = sum(
                    not self.window_manager.is_in_any_window(p, [*self.centers, *new_centers])
                    for p in polygon
                )
                if num_point_not_included == 0:
                    self.centers.extend(new_centers)
                    break

                if min_num_point_not_included is None:
                    min_num_point_not_included = num_point_not_included
                    new_centers_candidate = new_centers

                if num_point_not_included < min_num_point_not_included:
                    min_num_point_not_included = num_point_not_included
                    new_centers_candidate = new_centers

            else:
                # If fail to get `num_point_not_included==0` sample,
                # use min `num_point_not_included` sample.
                new_centers = new_centers_candidate
                self.centers.extend(new_centers)

            for center in new_centers:
                single_defect_patch_data = self.get_data_dict_from_center_point(
                    image, mask, center, **kwargs
                )
                l_data.append(single_defect_patch_data)

    self.n_defect_patch_made += len(l_data)

    # crop ok region
    # XXX: OK patch portion can be larger w.r.t num of ok images.
    probability_multiplier = max(self.n_defect_patch_made, 1)
    if random.random() < self.ok_patch_prob * probability_multiplier:
        num_to_make_ok_patch = ceil(self.ok_patch_prob * probability_multiplier)
        max_iteration = 5
        for _ in range(num_to_make_ok_patch):
            for _ in range(max_iteration):
                if self.window_manager.strict_inner_patch:
                    window_half_w = self.window_manager.half_width
                    window_half_h = self.window_manager.half_height

                    # Cannot sample random window center.
                    if w - window_half_w < window_half_w or h - window_half_h < window_half_h:
                        logger.warning(f"Crop size is larger than image size: ({w}, {h}).")
                        continue

                    random_center = (
                        random.randint(window_half_w, w - window_half_w),
                        random.randint(window_half_h, h - window_half_h),
                    )
                else:
                    random_center = random.randint(0, w), random.randint(0, h)
                if not self.window_manager.is_in_any_window(random_center, self.centers):
                    self.centers.append(random_center)
                    self.n_defect_patch_made -= 1 / self.ok_patch_prob
                    break
            else:
                # Max trial ended with no ok patch.
                return l_data

            single_ok_patch_data = self.get_data_dict_from_center_point(
                image, mask, random_center, **kwargs
            )
            l_data.append(single_ok_patch_data)

    return l_data

get_data_dict_from_center_point

get_data_dict_from_center_point(image: Union[Image, ndarray], mask: Union[Image, ndarray], center, **kwargs)

Source code in SaigeToolkit/data/crop/edge_cropper.py

def get_data_dict_from_center_point(
    self,
    image: Union[Image.Image, np.ndarray],
    mask: Union[Image.Image, np.ndarray],
    center,
    **kwargs,
):
    w, h = read_image_size(image)
    w_center, h_center = center
    crop_coordinates = self.window_manager.get_coordinates_from_center(h_center, w_center, h, w)
    return {
        "image": crop(image, crop_coordinates),
        "mask": crop(mask, crop_coordinates),
        "crop_coordinates": crop_coordinates,
        **kwargs,
    }

pick_centers_from_polygon

pick_centers_from_polygon(polygon_points: List[Iterable[int]]) -> List[Iterable[int]]

Source code in SaigeToolkit/data/crop/edge_cropper.py

def pick_centers_from_polygon(self, polygon_points: List[Iterable[int]]) -> List[Iterable[int]]:
    if self.random_sample:
        max_iter_init = 10 if self.random_sample else 1  # TODO: as class variable?
        for _ in range(max_iter_init):
            idx_start = random.choice(range(len(polygon_points)))

            if not self.window_manager.is_in_any_window(polygon_points[idx_start], self.centers):
                break

            # if fail to get proper init index, restart random choice
        else:
            # if fail to get proper init index in given repeat num, return []
            return []
    else:
        idx_start = 0

    polygon_points = [*polygon_points[idx_start:], *polygon_points[:idx_start]]
    new_centers = [polygon_points[0]]

    (
        polygon_points,
        inner_point_positive,
        inner_point_negative,
    ) = self.remove_inner_points_and_get_outer_points(new_centers[-1], polygon_points)
    if inner_point_positive is None:
        return new_centers

    while polygon_points:
        previous_boundary = CenterWithSatellite(inner_point_positive, self.window_manager)
        idx_inside_checked = 0
        for idx, p in enumerate(polygon_points):
            if self.window_manager.is_in_any_window(p, [*self.centers, *new_centers]):
                continue

            state_as_satellite = previous_boundary.calculate_relation_as_satellite(p)

            # if current point and boundary point of previous center
            # (or current point and satellites of boundary point of previous center)
            # in the condition [cannot be contained in one window],
            # break from searching next center point candidate.
            if (
                isinstance(state_as_satellite, list)
                or state_as_satellite["relation"] != WindowState.IN
            ):
                break
            else:
                # if condition failed, current point is considered as `point inside window`.
                idx_inside_checked = idx

        else:
            polygon_points_for_mid_point = [
                _point
                for _point in polygon_points
                if not self.window_manager.is_in_any_window(_point, [*self.centers, *new_centers])
            ]
            if polygon_points_for_mid_point:
                new_centers.append(get_mid_point(polygon_points_for_mid_point))
            break

        # When finding next center, following points should be contained in the window:
        # boundary point of previous edge and its satelitte points.
        # TODO: 이거 Center 클래스에 넣자
        must_contain_coordinate = [
            previous_boundary.coordinate,
            *[sate["coordinate"] for sate in previous_boundary.satellite_points.values()],
        ]

        for idx_positive_direction in range(idx - 1, idx_inside_checked - 1, -1):
            # `polygon_points[idx_positive_direction]` should in window of previouss edge point,
            # so the next center can be placed right outside of previous window.
            relation_prev_point = self.window_manager.check_window(
                polygon_points[idx_positive_direction], previous_boundary.coordinate
            )
            if relation_prev_point != WindowState.IN:
                continue

            # if needed, state_as_satellite for outside point should be re-calculated.
            if idx_positive_direction != idx - 1:
                state_as_satellite = previous_boundary.calculate_relation_as_satellite(
                    polygon_points[idx_positive_direction + 1]
                )

            p_dst = self.get_proper_point(
                state_as_satellite,
                must_contain_coordinate,
                polygon_points[idx_positive_direction],
                polygon_points[idx_positive_direction + 1],
            )

            # success finding new center point, break
            if p_dst is not None:
                break

        # failed to find more center points, break.
        else:
            break

        new_centers.append(p_dst)
        polygon_points, inner_point_positive, _check = self.remove_inner_points_and_get_outer_points(
            new_centers[-1], polygon_points[idx_positive_direction:]
        )

    return new_centers

get_proper_point

get_proper_point(state_as_satellite: Union[Dict[str, Any], List[Dict[str, Any]]], must_contain_coordinate: List[Iterable[int]], point_in: Iterable[int], point_out: Iterable[int]) -> Optional[Iterable[int]]

get proper next center point that contains every must_contain_coordinate

Parameters:

state_as_satellite (Union[Dict[str, Any], List[Dict[str, Any]]]) –

relation between center point(s) and target point.
must_contain_coordinate (List[Iterable[int]]) –

points should be in next window
point_in (Iterable[int]) –

point inside window from previous boundary
point_out (Iterable[int]) –

point outside window from previous boundary

Returns:

Optional[Iterable[int]] –

Optional[Iterable[int]]: proper next center (or None)

Source code in SaigeToolkit/data/crop/edge_cropper.py

def get_proper_point(
    self,
    state_as_satellite: Union[Dict[str, Any], List[Dict[str, Any]]],
    must_contain_coordinate: List[Iterable[int]],
    point_in: Iterable[int],
    point_out: Iterable[int],
) -> Optional[Iterable[int]]:
    """get proper next center point that contains every `must_contain_coordinate`

    Args:
        state_as_satellite (Union[Dict[str, Any], List[Dict[str, Any]]]):
            relation between center point(s) and target point.
        must_contain_coordinate (List[Iterable[int]]): points should be in next window
        point_in (Iterable[int]): point inside window from previous boundary
        point_out (Iterable[int]): point outside window from previous boundary

    Returns:
        Optional[Iterable[int]]: proper next center (or None)
    """

    if isinstance(state_as_satellite, list):
        for u_r in state_as_satellite:
            p_dst = self.get_proper_point(u_r, must_contain_coordinate, point_in, point_out)
            if p_dst is not None:
                break

        else:
            return None

    else:
        relation, inner_point = state_as_satellite["relation"], state_as_satellite["coordinate"]
        p_dst = self.get_destination_point(relation, inner_point, point_in, point_out)

        if p_dst is None:
            return None

        for _p in must_contain_coordinate:
            if not self.window_manager.is_in_window(_p, p_dst):
                return None

    return p_dst

get_destination_point

get_destination_point(relation: WindowState, point_ref: Iterable[int], point_in: Iterable[int], point_out: Iterable[int]) -> ndarray

calculate point a-window-away from reference point

Parameters:

relation (WindowState) –

relation between reference point and next center
point_ref (Iterable[int]) –

reference point to calculate next center
point_in (Iterable[int]) –

point inside window from previous boundary
point_out (Iterable[int]) –

point outside window from previous boundary

Returns:

ndarray –

np.ndarray: result destination point

Source code in SaigeToolkit/data/crop/edge_cropper.py

def get_destination_point(
    self,
    relation: WindowState,
    point_ref: Iterable[int],
    point_in: Iterable[int],
    point_out: Iterable[int],
) -> np.ndarray:
    """calculate point a-window-away from reference point

    Args:
        relation (WindowState): relation between reference point and next center
        point_ref (Iterable[int]): reference point to calculate next center
        point_in (Iterable[int]): point inside window from previous boundary
        point_out (Iterable[int]): point outside window from previous boundary

    Returns:
        np.ndarray: result destination point
    """
    w_in, h_in = point_in
    w_out, h_out = point_out

    def _get_interior_point(a_dst, a_in, a_out, b_in, b_out):
        if (a_out != a_in) and (a_in <= a_dst <= a_out or a_out <= a_dst <= a_in):
            rate = (a_dst - a_in) / (a_out - a_in)
        else:
            # if a_dst is not interior between two points, update a_dst to the middle point.
            a_dst = int(round((a_out + a_in) / 2))
            rate = 0.5

        b_dst = b_in + int(round(rate * (b_out - b_in)))
        return a_dst, b_dst

    if relation == WindowState.WIDTH_POSITIVE_OUT:
        w_dst = point_ref[0] + self.window_manager.half_width
        w_dst, h_dst = _get_interior_point(w_dst, w_in, w_out, h_in, h_out)
    elif relation == WindowState.WIDTH_NEGATIVE_OUT:
        w_dst = point_ref[0] - self.window_manager.half_width
        w_dst, h_dst = _get_interior_point(w_dst, w_in, w_out, h_in, h_out)
    elif relation == WindowState.HEIGHT_POSITIVE_OUT:
        h_dst = point_ref[1] + self.window_manager.half_height
        h_dst, w_dst = _get_interior_point(h_dst, h_in, h_out, w_in, w_out)
    elif relation == WindowState.HEIGHT_NEGATIVE_OUT:
        h_dst = point_ref[1] - self.window_manager.half_height
        h_dst, w_dst = _get_interior_point(h_dst, h_in, h_out, w_in, w_out)

    else:
        # if relation is `WindowState.In`, find farthest point and set as target point.
        width_distance = w_out - point_ref[0]
        height_distance = h_out - point_ref[1]
        if abs(width_distance) > abs(height_distance):
            if width_distance > 0:
                relation = WindowState.WIDTH_POSITIVE_OUT
            else:
                relation = WindowState.WIDTH_NEGATIVE_OUT
        else:
            if height_distance > 0:
                relation = WindowState.HEIGHT_POSITIVE_OUT
            else:
                relation = WindowState.HEIGHT_NEGATIVE_OUT

        dst = self.get_destination_point(relation, point_ref, point_in, point_out)

        return dst

    return np.array([w_dst, h_dst])

remove_inner_points_and_get_outer_points

remove_inner_points_and_get_outer_points(center: Iterable[int], points: List[Iterable[int]]) -> Tuple[List[Iterable[int]], Iterable[int], Iterable[int]]

once center decided, check other points and remove insiders.

Parameters:

center (Iterable[int]) –

next center coordinate
points (List[Iterable[int]]) –

current points on polygon

Returns:

Tuple[List[Iterable[int]], Iterable[int], Iterable[int]] –

Tuple[List[Iterable[int]], Iterable[int], Iterable[int]]: - List[Iterable[int]]: clean-up'd polygon points - Iterable[int]: boundary point (positive direction) - Iterable[int]: boundary point (negative direction)

Source code in SaigeToolkit/data/crop/edge_cropper.py

def remove_inner_points_and_get_outer_points(
    self, center: Iterable[int], points: List[Iterable[int]]
) -> Tuple[List[Iterable[int]], Iterable[int], Iterable[int]]:
    """once center decided, check other points and remove insiders.

    Args:
        center (Iterable[int]): next center coordinate
        points (List[Iterable[int]]): current points on polygon

    Returns:
        Tuple[List[Iterable[int]], Iterable[int], Iterable[int]]:
            - List[Iterable[int]]: clean-up'd polygon points
            - Iterable[int]: boundary point (positive direction)
            - Iterable[int]: boundary point (negative direction)
    """
    idx_positive_direction, idx_negative_direction = 0, 0
    p_dst, n_dst = None, None

    for idx, p in enumerate(points):
        relation = self.window_manager.check_window(p, center)
        if relation == WindowState.IN:
            continue

        idx_positive_direction = idx - 1
        p_dst = self.get_destination_point(
            relation,
            center,
            points[idx_positive_direction],
            points[idx_positive_direction + 1],
        )
        break

    for idx, p in enumerate(points[::-1]):
        relation = self.window_manager.check_window(p, center)
        if relation == WindowState.IN:
            continue

        idx_negative_direction = -idx
        n_dst = self.get_destination_point(
            relation,
            center,
            points[idx_negative_direction],
            points[idx_negative_direction - 1],
        )
        break

    if p_dst is None:
        return [], p_dst, n_dst

    points = (
        points[idx_positive_direction + 1 : idx_negative_direction]
        if idx_negative_direction < 0
        else points[idx_positive_direction + 1 :]
    )

    return points, p_dst, n_dst

subdivide_points_into_min_resolution

subdivide_points_into_min_resolution(points: List[Iterable[int]], width_resolution: int = 32, height_resolution: int = 32) -> List[Iterable[int]]

refine cv2.findContours result. long straight edge in mask results in long distance between two points.

Parameters:

points (List[Iterable[int]]) –

cv2.findContours result
width_resolution (int, default: 32 ) –

maximum distance width-wise. Defaults to 32.
height_resolution (int, default: 32 ) –

maximum distance height-wise. Defaults to 32.

Returns:

List[Iterable[int]] –

List[Iterable[int]]: refined polygon points

Source code in SaigeToolkit/data/crop/edge_cropper.py

def subdivide_points_into_min_resolution(
    points: List[Iterable[int]], width_resolution: int = 32, height_resolution: int = 32
) -> List[Iterable[int]]:
    """refine cv2.findContours result.
    long straight edge in mask results in long distance between two points.

    Args:
        points (List[Iterable[int]]): cv2.findContours result
        width_resolution (int, optional): maximum distance width-wise. Defaults to 32.
        height_resolution (int, optional): maximum distance height-wise. Defaults to 32.

    Returns:
        List[Iterable[int]]: refined polygon points
    """

    idx_inspected = 0

    while idx_inspected < len(points):
        for idx in range(idx_inspected, len(points)):
            point_prev = points[idx]
            point_next = points[idx + 1] if idx + 1 < len(points) else points[0]

            w_length = abs(point_next[0] - point_prev[0])
            if w_length > width_resolution:
                num_insert = ceil(w_length / width_resolution) - 1
                break

            h_length = abs(point_next[1] - point_prev[1])
            if h_length > height_resolution:
                num_insert = ceil(h_length / height_resolution) - 1
                break
        else:
            break

        for n in range(num_insert - 1, -1, -1):
            rate = (n + 1) / (num_insert + 1)
            point_prev = points[idx]
            point_next = points[idx + 1] if idx + 1 < len(points) else points[0]
            points.insert(
                idx + 1, point_prev + np.round(rate * (point_next - point_prev)).astype(np.int32)
            )

        idx_inspected = idx + n

    return points

get_mid_point

get_mid_point(points: List[Iterable[int]]) -> Iterable[int]

In case failed to get next center point, get mid point from remaining polygon points.

Parameters:

points (List[Iterable[int]]) –

remaining polygon points

Returns:

Iterable[int] –

Iterable[int]: next center point (mid)

Source code in SaigeToolkit/data/crop/edge_cropper.py

def get_mid_point(points: List[Iterable[int]]) -> Iterable[int]:
    """In case failed to get next center point,
    get mid point from remaining polygon points.

    Args:
        points (List[Iterable[int]]): remaining polygon points

    Returns:
        Iterable[int]: next center point (mid)
    """
    if len(points) == 1:
        return points[0]

    np_points = np.array(points)
    length_between_points = np.linalg.norm(np_points[1:] - np_points[:-1], axis=1)
    length_half = np.sum(length_between_points) / 2
    for idx in range(len(length_between_points)):
        if np.sum(length_between_points[:idx]) >= length_half:
            break

    length_desired = length_half - np.sum(length_between_points[: idx - 1])
    length_entire = length_between_points[idx - 1]
    rate = length_desired / length_entire

    return points[idx] + np.round(rate * (points[idx + 1] - points[idx])).astype(np.int32)

ocr_cropper

logger `module-attribute`

logger = getLogger('SaigeResearch')

OcrCropper

OcrCropper(chr_height: int = 32, crop_jitter: Optional[float] = None, crop_jitter_rate: Optional[List[float]] = None, save_polygons: bool = False)

Cropper class for OCR task.

Attributes:

chr_height (int) –

cropped image patch is resized to be the same height as chr_height.
crop_jitter (Optional[float]) –

if not None, cropping box is jittered horizontally with ratio crop_jitter.
crop_jitter_rate (Optional[List[float]]) –

if not None, cropping box points are jittered to any direction with ratio crop_jitter_rate.
save_polygons (bool) –

whether polygon label is preserved after cropping.

initializing OcrCropper. all initializing input is set to class attribute.

Parameters:

chr_height (int, default: 32 ) –

Defaults to 32.
crop_jitter (Optional[float], default: None ) –

Defaults to None.
crop_jitter_rate (Optional[List[float]], default: None ) –

Defaults to None.
save_polygons (bool, default: False ) –

Defaults to False.

Source code in SaigeToolkit/data/crop/ocr_cropper.py

def __init__(
    self,
    chr_height: int = 32,
    crop_jitter: Optional[float] = None,
    crop_jitter_rate: Optional[List[float]] = None,
    save_polygons: bool = False,
) -> None:
    """initializing OcrCropper.
    all initializing input is set to class attribute.

    Args:
        chr_height (int): Defaults to 32.
        crop_jitter (Optional[float], optional): Defaults to None.
        crop_jitter_rate (Optional[List[float]], optional): Defaults to None.
        save_polygons (bool): Defaults to False.
    """
    self.chr_height = chr_height
    self.crop_jitter = crop_jitter
    self.crop_jitter_rate = crop_jitter_rate
    self.save_polygons = save_polygons

chr_height `instance-attribute`

chr_height = chr_height

crop_jitter `instance-attribute`

crop_jitter = crop_jitter

crop_jitter_rate `instance-attribute`

crop_jitter_rate = crop_jitter_rate

save_polygons `instance-attribute`

save_polygons = save_polygons

get_n_patch

get_n_patch(polygons: List[List[ndarray]]) -> int

OcrCropper only crops all polygon areas, unlike SegCropper. Therefore, resultant number of patches is simply equals to number of polygons.

Parameters:

polygons (List[List[ndarray]]) –

polygons of all images in dataset.

Returns:

int ( int ) –

total number of patches to be cropped

Source code in SaigeToolkit/data/crop/ocr_cropper.py

def get_n_patch(self, polygons: List[List[np.ndarray]]) -> int:
    """OcrCropper only crops all polygon areas, unlike SegCropper.
    Therefore, resultant number of patches is simply equals to number of polygons.

    Args:
        polygons (List[List[np.ndarray]]): polygons of all images in dataset.

    Returns:
        int: total number of patches to be cropped
    """
    return len(polygons)

call

__call__(image: Union[Image, ndarray], polygons: List[ndarray], strings: List[str], ignore: List[bool], is_vertical: Optional[List[bool]] = None, **kwargs) -> List[dict]

crop image into image patches. polygon, string, ignore data should be same length.

Parameters:

image (Union[Image, ndarray]) –

original image
polygons (List[ndarray]) –

polygon data (# of polygons, (4, 2)) polygon should have 4 points
strings (List[str]) –

string data
ignore (List[bool]) –

ignore notation data
is_vertical (List[bool], default: None ) –

is_vertical notation data

Returns:

List[dict] –

List[dict]: list of cropped image data dict

Source code in SaigeToolkit/data/crop/ocr_cropper.py

def __call__(
    self,
    image: Union[Image.Image, np.ndarray],
    polygons: List[np.ndarray],
    strings: List[str],
    ignore: List[bool],
    is_vertical: Optional[List[bool]] = None,
    **kwargs,
) -> List[dict]:
    """crop image into image patches.
    polygon, string, ignore data should be same length.

    Args:
        image (Union[Image.Image, np.ndarray]): original image
        polygons (List[np.ndarray]): polygon data
            (# of polygons, (4, 2)) polygon should have 4 points
        strings (List[str]): string data
        ignore (List[bool]): ignore notation data
        is_vertical (List[bool]): is_vertical notation data

    Returns:
        List[dict]: list of cropped image data dict
    """
    image = np.asarray(image)

    if is_vertical is None:
        is_vertical = [False] * len(polygons)

    l_data = []
    for pol, string, ign, is_vert in zip(polygons, strings, ignore, is_vertical):
        if ign:
            continue

        max_trial = 10
        trial = 0
        while trial < max_trial:
            trial += 1

            tops, bots = self.jitter_polygon(pol)
            widths, heights = self.calculate_width_height(tops, bots)

            if all(np.array(widths + heights) >= 1):
                break

            if trial == max_trial:
                logger.info("Max trial exeeded.. no jitter applied.")
                tops = pol[: len(pol) // 2]
                bots = pol[: len(pol) // 2 - 1 : -1]
                widths, heights = self.calculate_width_height(tops, bots)

        if any(np.array(widths + heights) < 1):
            logger.warning(f"Invalid patch shape (jittered) encounter.. string: {string}")
            continue

        text_patch_list = []
        for i, (w, h) in enumerate(zip(widths, heights)):
            width = int(np.round((w / h * self.chr_height)))
            if width == 0:
                continue

            startpoints = np.array([tops[i], tops[i + 1], bots[i + 1], bots[i]], np.float32)
            endpoints = np.array(
                [
                    [0, 0],
                    [width - 1, 0],
                    [width - 1, self.chr_height - 1],
                    [0, self.chr_height - 1],
                ],
                np.float32,
            )

            affine_matrix = cv2.getPerspectiveTransform(startpoints, endpoints)
            text_patch = cv2.warpPerspective(
                image, affine_matrix, (width, self.chr_height), borderValue=0
            )
            if i != 0:
                # remove duplicated leftmost column
                # border area is duplicated in adjacent patches.
                text_patch = text_patch[:, 1:, :]
            text_patch_list.append(text_patch)

        text_patch = np.concatenate(text_patch_list, axis=1)

        if int(text_patch.shape[1] / (self.chr_height / 8)) + 1 >= len(string):
            patch_data = {
                "image": Image.fromarray(text_patch),
                "strings": string,
                "is_vertical": is_vert,
            }

            if self.save_polygons:
                patch_data.update(polygons=pol)

            l_data.append(patch_data)
        else:
            logger.warning(
                f"Invalid patch length! string: {string} patch width: {text_patch.shape[1]}"
            )

    return l_data

calculate_width_height

calculate_width_height(tops: ndarray, bots: ndarray) -> Tuple[List[ndarray], List[ndarray]]

calculate width and heights for every four polygon points (2 tops and 2 bots). Assuming that polygon is composed of top-points and bot-points, and every top and bot points are paired.

Parameters:

tops (ndarray) –

top points of polygon
bots (ndarray) –

bot points of polygon

Returns:

Tuple[List[ndarray], List[ndarray]] –

Tuple[List[np.ndarray]]: width and height list for every four points.

Source code in SaigeToolkit/data/crop/ocr_cropper.py

def calculate_width_height(
    self, tops: np.ndarray, bots: np.ndarray
) -> Tuple[List[np.ndarray], List[np.ndarray]]:
    """calculate width and heights for every four polygon points (2 tops and 2 bots).
    Assuming that polygon is composed of top-points and bot-points,
    and every top and bot points are paired.

    Args:
        tops (np.ndarray): top points of polygon
        bots (np.ndarray): bot points of polygon

    Returns:
        Tuple[List[np.ndarray]]: width and height list for every four points.
    """

    widths = []
    for i in range(len(tops) - 1):
        widths.append(
            np.mean(
                (
                    np.linalg.norm(tops[i + 1] - tops[i]),
                    np.linalg.norm(bots[i + 1] - bots[i]),
                )
            )
        )

    heights = []
    for t, b in zip(tops, bots):
        heights.append(np.linalg.norm(b - t))
    heights = [np.mean([heights[i + 1], heights[i]]) for i in range(len(heights) - 1)]

    return widths, heights

jitter_polygon

jitter_polygon(polygon: ndarray) -> Tuple[ndarray, ndarray]

jittering polygon points and split into tops and bots points

Parameters:

polygon (ndarray) –

original polygon data

Returns:

Tuple[ndarray, ndarray] –

Tuple[np.ndarray, np.ndarray]: jittered tops, bots points

Source code in SaigeToolkit/data/crop/ocr_cropper.py

def jitter_polygon(self, polygon: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
    """jittering polygon points and split into tops and bots points

    Args:
        polygon (np.ndarray): original polygon data

    Returns:
        Tuple[np.ndarray, np.ndarray]: jittered tops, bots points
    """
    tops = deepcopy(polygon[: len(polygon) // 2])
    bots = deepcopy(polygon[: len(polygon) // 2 - 1 : -1])

    if self.crop_jitter is not None:

        heights = []
        for i, (t, b) in enumerate(zip(tops, bots)):
            heights.append(np.linalg.norm(b - t))

            crop_jitter = self.crop_jitter * heights[-1]

            x_jitter = random.uniform(-crop_jitter, crop_jitter)
            tops[i, 0] += x_jitter
            bots[i, 0] += x_jitter

        height = np.mean(heights)
        y_jitter = self.crop_jitter * height

        tops[:, 1] += random.uniform(-y_jitter, y_jitter)
        bots[:, 1] += random.uniform(-y_jitter, y_jitter)

    elif self.crop_jitter_rate is not None:

        for i, (t, b) in enumerate(zip(tops, bots)):
            height = np.linalg.norm(b - t)

            crop_jitter_short = self.crop_jitter_rate[0] * height
            crop_jitter_long = self.crop_jitter_rate[1] * height

            top_y_jitter = random.uniform(-crop_jitter_long, crop_jitter_short)
            bot_y_jitter = random.uniform(-crop_jitter_short, crop_jitter_long)
            if i == 0:
                x_jitter = random.uniform(-crop_jitter_long, crop_jitter_short)
            elif i == len(tops) - 1:
                x_jitter = random.uniform(-crop_jitter_short, crop_jitter_long)
            else:
                x_jitter = random.uniform(-crop_jitter_short, crop_jitter_short)

            tops[i, :] += (x_jitter, top_y_jitter)
            bots[i, :] += (x_jitter, bot_y_jitter)

    # polygon_out = np.concatenate((tops, bots[::-1]), axis=0)

    return tops, bots

polygon_cropper

PolygonCropper

PolygonCropper(mode: str = 'center', crop_w: int = 512, crop_h: int = 512, patch_per_polygon: int = 1, random_patch_per_img: int = 1, max_patch_per_img: Optional[int] = None, force_random_patch_normal: bool = False, strict_inner_patch: bool = False, fixed_polygon_order: bool = False)

Bases: BaseCropper

Crop image patches using polygons

Attributes:

mode (str) –

cropping mode. ["center", "defectrandom"] available
crop_w (int) –

cropping width for image patch.
crop_h (int) –

cropping height for image patch.
half_w (int) –

half of cropping width.
half_h (int) –

half of cropping height.
patch_per_polygon (int) –

number of repeat for cropping patch around each polygon.
random_patch_per_img (int) –

number of random patch cropping per image.
force_random_patch_normal (bool) –

whether random patch should not contain polygon area.
strict_inner_patch (bool) –

whether not allowing outer area of image.
fixed_polygon_order (bool) –

whether order of polygons is fixed during cropping.

All input is directly set to class attribute.

Parameters:

mode (str, default: 'center' ) –

Defaults to "center".
crop_w (int, default: 512 ) –

Defaults to 512.
crop_h (int, default: 512 ) –

Defaults to 512.
patch_per_polygon (int, default: 1 ) –

Defaults to 1.
random_patch_per_img (int, default: 1 ) –

Defaults to 1.
force_random_patch_normal (bool, default: False ) –

Defaults to False.
strict_inner_patch (bool, default: False ) –

Defaults to False.
fixed_polygon_order (bool, default: False ) –

Defaults to False.

Source code in SaigeToolkit/data/crop/polygon_cropper.py

def __init__(
    self,
    mode: str = "center",
    crop_w: int = 512,
    crop_h: int = 512,
    patch_per_polygon: int = 1,
    random_patch_per_img: int = 1,
    max_patch_per_img: Optional[int] = None,
    force_random_patch_normal: bool = False,
    strict_inner_patch: bool = False,
    fixed_polygon_order: bool = False,
) -> None:
    """All input is directly set to class attribute.

    Args:
        mode (str, optional): Defaults to "center".
        crop_w (int, optional): Defaults to 512.
        crop_h (int, optional): Defaults to 512.
        patch_per_polygon (int, optional): Defaults to 1.
        random_patch_per_img (int, optional): Defaults to 1.
        force_random_patch_normal (bool, optional): Defaults to False.
        strict_inner_patch (bool, optional): Defaults to False.
        fixed_polygon_order (bool, optional): Defaults to False.
    """
    self.mode = mode
    self.crop_w = crop_w
    self.crop_h = crop_h
    self.patch_per_polygon = patch_per_polygon
    self.random_patch_per_img = random_patch_per_img
    self.max_patch_per_img = max_patch_per_img
    self.force_random_patch_normal = force_random_patch_normal
    self.strict_inner_patch = strict_inner_patch
    self.fixed_polygon_order = fixed_polygon_order

mode `instance-attribute`

mode = mode

patch_per_polygon `instance-attribute`

patch_per_polygon = patch_per_polygon

random_patch_per_img `instance-attribute`

random_patch_per_img = random_patch_per_img

max_patch_per_img `instance-attribute`

max_patch_per_img = max_patch_per_img

force_random_patch_normal `instance-attribute`

force_random_patch_normal = force_random_patch_normal

strict_inner_patch `instance-attribute`

strict_inner_patch = strict_inner_patch

fixed_polygon_order `instance-attribute`

fixed_polygon_order = fixed_polygon_order

crop_w `property` `writable`

crop_w

crop_h `property` `writable`

crop_h

get_n_patch

get_n_patch(polygons: List[ndarray]) -> int

PolygonCropper crops all polygon areas {self.patch_per_polygon} times per polygons, and also crops random position of image {self.random_patch_per_img} times per images. Therefore, resultant number of patches is weighted-sum result as coded below.

Parameters:

polygons (List[ndarray]) –

polygons of single image in dataset.

Returns:

int ( int ) –

number of patches to be cropped in single image

Source code in SaigeToolkit/data/crop/polygon_cropper.py

def get_n_patch(self, polygons: List[np.ndarray]) -> int:
    """PolygonCropper crops all polygon areas {self.patch_per_polygon} times per polygons,
    and also crops random position of image {self.random_patch_per_img} times per images.
    Therefore, resultant number of patches is weighted-sum result as coded below.

    Args:
        polygons (List[np.ndarray]): polygons of single image in dataset.

    Returns:
        int: number of patches to be cropped in single image
    """
    n_patch = len(polygons) * self.patch_per_polygon + self.random_patch_per_img
    if self.max_patch_per_img is not None:
        n_patch = min(n_patch, self.max_patch_per_img)

    return n_patch

pick_point

pick_point(polygon: ndarray) -> Tuple[int, int]

picking cropping center point.

Parameters:

polygon (ndarray) –

original polygon data

Raises:

NotImplementedError –

only two modes ["center", "defectrandom"] available

Returns:

Tuple[int, int] –

Tuple[int, int]: picked point, (h_center, w_center)

Source code in SaigeToolkit/data/crop/polygon_cropper.py

def pick_point(self, polygon: np.ndarray) -> Tuple[int, int]:
    """picking cropping center point.

    Args:
        polygon (np.ndarray): original polygon data

    Raises:
        NotImplementedError: only two modes ["center", "defectrandom"] available

    Returns:
        Tuple[int, int]: picked point, (h_center, w_center)
    """
    plg = list(zip(*polygon))
    pts_w, pts_h = np.array(plg[0]), np.array(plg[1])
    h_min, h_max = np.min(pts_h), np.max(pts_h)
    w_min, w_max = np.min(pts_w), np.max(pts_w)

    if self.mode == "center":
        h_center = int(np.round((h_min + h_max) / 2.0))
        w_center = int(np.round((w_min + w_max) / 2.0))

    elif self.mode == "defectrandom":
        count = 0
        max_count = 10
        while True:
            h_center = np.random.randint(h_min, h_max + 1)
            w_center = np.random.randint(w_min, w_max + 1)

            if cv2.pointPolygonTest(polygon, (w_center, h_center), False) >= 0:
                break

            if count > max_count:
                h_center = int(np.round((h_min + h_max) / 2.0))
                w_center = int(np.round((w_min + w_max) / 2.0))
                break
            count += 1

    else:
        raise NotImplementedError

    return h_center, w_center

get_coordinates_from_center

get_coordinates_from_center(h_center: int, w_center: int, h: int, w: int) -> Tuple[int, int, int, int]

get left/right top/bottom coordinates from picked center point.

Parameters:

h_center (int) –

picked center point h-coordinate
w_center (int) –

picked center point w-coordinate
h (int) –

image size height
w (int) –

image size width

Returns:

Tuple[int, int, int, int] –

Tuple[int, int, int, int]: (crop_left, crop_top, crop_right, crop_bottom)

Source code in SaigeToolkit/data/crop/polygon_cropper.py

def get_coordinates_from_center(
    self, h_center: int, w_center: int, h: int, w: int
) -> Tuple[int, int, int, int]:
    """get left/right top/bottom coordinates from picked center point.

    Args:
        h_center (int): picked center point h-coordinate
        w_center (int): picked center point w-coordinate
        h (int): image size height
        w (int): image size width

    Returns:
        Tuple[int, int, int, int]: (crop_left, crop_top, crop_right, crop_bottom)
    """
    if self.strict_inner_patch:
        w_center = np.clip(w_center, self.half_w, w - self.crop_w + self.half_w)
        h_center = np.clip(h_center, self.half_h, h - self.crop_h + self.half_h)
    crop_left = w_center - self.half_w
    crop_right = crop_left + self.crop_w
    crop_top = h_center - self.half_h
    crop_bottom = crop_top + self.crop_h
    return (crop_left, crop_top, crop_right, crop_bottom)

call

__call__(image: Union[Image, ndarray], mask: Union[Image, ndarray], polygons: Optional[List[ndarray]] = None, **kwargs) -> List[dict]

crop image into image patches.

Parameters:

image (Union[Image, ndarray]) –

original image
polygons (List[ndarray], default: None ) –

polygon data (# of polygons, (4, 2)) polygon should have 4 points
mask (Union[Image, ndarray]) –

segmentation mask image

Returns:

List[dict] –

List[dict]: list of cropped image data dict

Source code in SaigeToolkit/data/crop/polygon_cropper.py

def __call__(
    self,
    image: Union[Image.Image, np.ndarray],
    mask: Union[Image.Image, np.ndarray],
    polygons: Optional[List[np.ndarray]] = None,
    **kwargs,
) -> List[dict]:
    """crop image into image patches.

    Args:
        image (Union[Image.Image, np.ndarray]): original image
        polygons (List[np.ndarray]): polygon data
            (# of polygons, (4, 2)) polygon should have 4 points
        mask (Union[Image.Image, np.ndarray]): segmentation mask image

    Returns:
        List[dict]: list of cropped image data dict
    """

    w, h = read_image_size(image)

    if polygons is None:
        polygons, _ = cv2.findContours(np.array(mask), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
        polygons = [polygon[:, 0] for polygon in polygons]  # TODO: check..

    l_data = []

    # crop defect polygon
    _polygons = polygons if self.fixed_polygon_order else random.sample(polygons, len(polygons))
    for polygon in _polygons:
        for _ in range(self.patch_per_polygon):
            h_center, w_center = self.pick_point(polygon)
            crop_coordinates = self.get_coordinates_from_center(h_center, w_center, h, w)
            l_data.append(
                {
                    "image": crop(image, crop_coordinates),
                    "mask": crop(mask, crop_coordinates),
                    **kwargs,
                }
            )
            if (
                self.max_patch_per_img is not None
                and len(l_data) + self.random_patch_per_img >= self.max_patch_per_img
            ):
                break
        else:
            continue
        break

    # crop undefect patches
    for _ in range(self.random_patch_per_img):
        while True:
            crop_coordinates = self.get_coordinates_from_center(
                np.random.randint(h), np.random.randint(w), h, w
            )

            patch_lbl = crop(mask, crop_coordinates)
            if (np.array(patch_lbl).sum() == 0) or (not self.force_random_patch_normal):
                break

        l_data.append(
            {
                "image": crop(image, crop_coordinates),
                "mask": patch_lbl,
                **kwargs,
            }
        )

    return l_data

dataclass

커스텀 데이터 클래스 구현과 관련 메서드를 포함한 모듈입니다.

box

boxes_datas `module-attribute`

boxes_datas = {'xyxy': [[1, 2, 4, 6], [22, 28, 36, 62], [13, 39, 14, 78], [42, 24, 81, 46]], 'xywh': [[1, 2, 3, 4], [22, 28, 14, 34], [13, 39, 1, 39], [42, 24, 39, 22]], 'ccwh': [[2.5, 4, 3, 4], [29, 45, 14, 34], [13.5, 58.5, 1, 39], [61.5, 35, 39, 22]]}

boxes `module-attribute`

boxes = test_init_box(box_data, coordinate)

NumpyBoxes

Bases: ndarray

coordinate `instance-attribute`

coordinate: str

new

__new__(input_array, coordinate: str, dtype=None) -> NumpyBoxes

Source code in SaigeToolkit/data/dataclass/box.py

def __new__(cls, input_array, coordinate: str, dtype=None) -> NumpyBoxes:
    obj = np.array(input_array).view(cls)

    cls._check_boxes(obj)

    if dtype is not None:
        obj = obj.astype(dtype)
    obj.coordinate = coordinate
    return obj

__array_finalize__

__array_finalize__(obj)

Source code in SaigeToolkit/data/dataclass/box.py

def __array_finalize__(self, obj):
    if obj is None:
        return
    self.coordinate = getattr(obj, "coordinate", None)

__array_function__

__array_function__(func, types, args, kwargs)

Source code in SaigeToolkit/data/dataclass/box.py

def __array_function__(self, func, types, args, kwargs):
    def unwrap(e):
        return np.asarray(e) if isinstance(e, NumpyBoxes) else e

    def wrap(e, coordinate):
        return NumpyBoxes(e, coordinate) if isinstance(e, np.ndarray) else e

    def get_coordinate(args, kwargs):
        flat_args, _ = tree_flatten(args)
        flat_kwargs, _ = tree_flatten(kwargs)
        coordinates = [e.coordinate for e in flat_args + flat_kwargs if isinstance(e, NumpyBoxes)]

        assert len(set(coordinates)) == 1
        coordinate = coordinates[0]

        return coordinate

    kwargs = kwargs or {}
    ret = func(*tree_map(unwrap, args), **tree_map(unwrap, kwargs))
    coordinate = get_coordinate(args, kwargs)
    wrap_with_coordinate = functools.partial(wrap, coordinate=coordinate)
    ret = tree_map(wrap_with_coordinate, ret)

    return ret

convert_coordinate

convert_coordinate(coordinate: str) -> NumpyBoxes

Source code in SaigeToolkit/data/dataclass/box.py

def convert_coordinate(self, coordinate: str) -> NumpyBoxes:
    new_boxes: NumpyBoxes = convert_coordinate(self, self.coordinate, coordinate)
    new_boxes.coordinate = coordinate
    return new_boxes

to_numpy

to_numpy() -> ndarray

Source code in SaigeToolkit/data/dataclass/box.py

def to_numpy(self) -> np.ndarray:
    return np.array(self)

to_tensor

to_tensor() -> Tensor

Source code in SaigeToolkit/data/dataclass/box.py

def to_tensor(self) -> torch.Tensor:
    return torch.from_numpy(self.to_numpy())

_check_boxes `staticmethod`

_check_boxes(boxes: ndarray)

Source code in SaigeToolkit/data/dataclass/box.py

@staticmethod
def _check_boxes(boxes: np.ndarray):
    # 숫자가 아닌 값이 들어오는 경우
    if not np.issubdtype(boxes.dtype, np.number):
        raise BoxValueError

    # box position이 음수가 들어오는 경우
    if np.any(boxes < 0):
        raise BoxValueError

convert_coordinate

convert_coordinate(boxes: Union[ndarray, Tensor], source_coordinate: str, target_coordinate: str) -> Union[ndarray, Tensor]

Source code in SaigeToolkit/data/dataclass/box.py

def convert_coordinate(
    boxes: Union[np.ndarray, torch.Tensor],  # shape: (num_bboxes, 4), dtype: float
    source_coordinate: str,  # coordinate type of input boxes ["xyxy", "xywh", "ccwh"]
    target_coordinate: str,  # coordinate type want to convert ["xyxy", "xywh", "ccwh"]
) -> Union[np.ndarray, torch.Tensor]:
    def _to_xywh(boxes: NumpyBoxes, coordinate: str) -> NumpyBoxes:
        """some coordinate -> (left, top, width, height)"""
        if coordinate == "xywh":
            pass
        elif coordinate == "xyxy":
            boxes[:, [2, 3]] = boxes[:, [2, 3]] - boxes[:, [0, 1]]
        elif coordinate == "ccwh":
            boxes[:, [0, 1]] = boxes[:, [0, 1]] - (boxes[:, [2, 3]] / 2)
        else:
            raise NotImplementedError

        return boxes

    def _from_xywh(boxes: NumpyBoxes, coordinate: str) -> NumpyBoxes:
        """(left, top, width, height) -> some coordinate"""
        if coordinate == "xywh":
            pass
        elif coordinate == "xyxy":
            boxes[:, [2, 3]] = boxes[:, [2, 3]] + boxes[:, [0, 1]]
        elif coordinate == "ccwh":
            boxes[:, [0, 1]] = boxes[:, [0, 1]] + (boxes[:, [2, 3]] / 2)
        else:
            raise NotImplementedError

        return boxes

    if isinstance(boxes, np.ndarray):
        new_boxes = boxes.copy()
    elif isinstance(boxes, torch.Tensor):
        new_boxes = boxes.clone()

    if source_coordinate != target_coordinate:  # if you want to change the coordinate
        new_boxes = _to_xywh(new_boxes, source_coordinate)  # source coordinate -> xywh
        new_boxes = _from_xywh(new_boxes, target_coordinate)  # xywh -> target coordinate

    return new_boxes

test_init_box

test_init_box(box_data, coordinate) -> NumpyBoxes

Source code in SaigeToolkit/data/dataclass/box.py

def test_init_box(box_data, coordinate) -> NumpyBoxes:
    boxes = NumpyBoxes(box_data, coordinate)

    assert boxes.coordinate == coordinate
    assert boxes.dtype == np.float32
    assert boxes.tolist() == box_data

    return boxes

test_base_function

test_base_function(boxes: NumpyBoxes)

Source code in SaigeToolkit/data/dataclass/box.py

def test_base_function(boxes: NumpyBoxes):
    boxes = boxes + 3
    boxes = boxes * 3
    boxes = boxes - 3
    boxes = boxes / 3
    boxes = np.concatenate([boxes] * 4, axis=0)
    boxes = np.split(boxes, 4, axis=0)[0]
    boxes = boxes.astype(np.int32)

    assert boxes.dtype == np.int32

test_convert_coordinate

test_convert_coordinate(boxes: NumpyBoxes, coordinate, answer)

Source code in SaigeToolkit/data/dataclass/box.py

def test_convert_coordinate(boxes: NumpyBoxes, coordinate, answer):
    boxes = boxes.convert_coordinate(coordinate)

    assert boxes.coordinate == coordinate
    assert boxes.dtype == np.float32
    assert boxes.tolist() == answer

test_to_other_data

test_to_other_data(boxes: NumpyBoxes, answer)

Source code in SaigeToolkit/data/dataclass/box.py

def test_to_other_data(boxes: NumpyBoxes, answer):
    new_boxes = boxes.to_tensor()

    assert new_boxes.tolist() == answer

segment

BITMAP_PIXEL_VALUE `module-attribute`

BITMAP_PIXEL_VALUE = 1

Bitmap `module-attribute`

Bitmap = ndarray

Contour `module-attribute`

Contour = ndarray

Contours `module-attribute`

Contours = Sequence[Contour]

contours_area_methods `module-attribute`

contours_area_methods = {'exact': compute_contours_area_exact, 'fast': compute_contours_area_fast, 'fast_plus': compute_contours_area_fast_plus, 'fast_plusplus': compute_contours_area_fast_plusplus}

SegmentBox `dataclass`

SegmentBox(left: int, top: int, width: int, height: int, right: int, bottom: int)

left `instance-attribute`

left: int

top `instance-attribute`

top: int

width `instance-attribute`

width: int

height `instance-attribute`

height: int

right `instance-attribute`

right: int

bottom `instance-attribute`

bottom: int

from_xywh `classmethod`

from_xywh(left, top, width, height) -> SegmentBox

Source code in SaigeToolkit/data/dataclass/segment.py

@classmethod
def from_xywh(cls, left, top, width, height) -> SegmentBox:
    right = left + width
    bottom = top + height
    return cls(left, top, width, height, right, bottom)

from_xyxy `classmethod`

from_xyxy(left, top, right, bottom) -> SegmentBox

Source code in SaigeToolkit/data/dataclass/segment.py

@classmethod
def from_xyxy(cls, left, top, right, bottom) -> SegmentBox:
    width = right - left
    height = bottom - top
    return cls(left, top, width, height, right, bottom)

Segment

Segment(bounding_box: Optional[SegmentBox] = None, bitmap: Optional[ndarray] = None, contours: Optional[Contours] = None, class_index: Optional[int] = None)

Segment 타입을 정의합니다. (= SegmentedObject) Segmentation 라벨링 혹은 모델의 예측 결과로 나오는 연결된 픽셀 덩어리이며, 1개의 outer polygon과 여러개의 inner polygon (도넛 형태인 경우) 으로 구성된 오브젝트입니다.

해당 오브젝트를 표현하는 방식은 2가지가 존재하며, segment를 이용해 어떤 연산을 수행하는가에 따라 다른 표현 방식이 필요합니다. 1. bounding_box & bitmap: SegmentBox & np.ndarray 2. contours: Sequence[np.ndarray]

Segment 오브젝트를 생성하기 위해서는 1가지 표현의 데이터만 필요하고, 다른 표현이 필요한 연산의 경우 lazy 한 방식으로 해당 표현을 계산합니다.

Segment 오브젝트 생성 시 bounding_box, bitmap 과 contours가 모두 주어진 경우, 서로 일치하는지 확인하지 않습니다.

Segment 오브젝트 생성 시 bounding_box, bitmap 표현이 주어진 경우 모든 픽셀이 연결되어 있는지 확인하지 않습니다.

Parameters:

bounding_box (Optional[SegmentBox], default: None ) –

description. Defaults to None.
bitmap (Optional[Bitmap], default: None ) –

description. Defaults to None.
contours (Optional[Contours], default: None ) –

description. Defaults to None.
class_index (Optional[int], default: None ) –

description. Defaults to None.

Source code in SaigeToolkit/data/dataclass/segment.py

def __init__(
    self,
    bounding_box: Optional[SegmentBox] = None,
    bitmap: Optional[np.ndarray] = None,
    contours: Optional[Contours] = None,
    class_index: Optional[int] = None,
) -> None:
    if contours is None:
        assert (
            bitmap is not None and bounding_box is not None
        ), "Either `bitmap` + `bounding_box` or `contours` must be given"
    self._bounding_box = bounding_box
    self._bitmap = bitmap
    self._contours = contours
    self.class_index = class_index

_bounding_box `instance-attribute`

_bounding_box = bounding_box

_bitmap `instance-attribute`

_bitmap = bitmap

_contours `instance-attribute`

_contours = contours

class_index `instance-attribute`

class_index = class_index

contours `property`

contours: Contours

bounding_box `property`

bounding_box: SegmentBox

bitmap `property`

bitmap: Bitmap

from_xyhw_and_bitmap `classmethod`

from_xyhw_and_bitmap(bounding_box: List[int], bitmap: Bitmap, class_index: Optional[int] = None, contours: Optional[Contours] = None, **ignore) -> Segment

Source code in SaigeToolkit/data/dataclass/segment.py

@classmethod
def from_xyhw_and_bitmap(
    cls,
    bounding_box: List[int],
    bitmap: Bitmap,
    class_index: Optional[int] = None,
    contours: Optional[Contours] = None,
    **ignore,
) -> Segment:
    bounding_box = SegmentBox.from_xywh(*bounding_box)
    return cls(bounding_box=bounding_box, bitmap=bitmap, class_index=class_index, contours=contours)

from_any `classmethod`

from_any(segment: Union[Segment, Dict]) -> Segment

Source code in SaigeToolkit/data/dataclass/segment.py

@classmethod
def from_any(cls, segment: Union[Segment, Dict]) -> Segment:
    if isinstance(segment, cls):
        seg_object = segment
    elif "bitmap" in segment:
        seg_object = cls.from_xyhw_and_bitmap(**segment)
    elif "contours" in segment:
        seg_object = cls(
            contours=segment.get("contours"),
            class_index=segment.get("class_index", None),
        )
    else:
        raise NotImplementedError
    return seg_object

get_bounding_box_from_contours

get_bounding_box_from_contours(contours: Contours) -> SegmentBox

contours의 bounding box를 구합니다.

Source code in SaigeToolkit/data/dataclass/segment.py

def get_bounding_box_from_contours(contours: Contours) -> SegmentBox:
    """contours의 bounding box를 구합니다."""
    left, top, width, height = cv2.boundingRect(contours[0])
    return SegmentBox.from_xywh(left, top, width, height)

convert_contours_to_box_and_bitmap

convert_contours_to_box_and_bitmap(contours: Contours, bounding_box: Optional[SegmentBox] = None) -> Tuple[SegmentBox, Bitmap]

contours를 bounding_box 와 bitmap representation으로 변환합니다

Source code in SaigeToolkit/data/dataclass/segment.py

def convert_contours_to_box_and_bitmap(
    contours: Contours,
    bounding_box: Optional[SegmentBox] = None,
) -> Tuple[SegmentBox, Bitmap]:
    """contours를 bounding_box 와 bitmap representation으로 변환합니다"""
    if bounding_box is None:
        bounding_box = get_bounding_box_from_contours(contours)
    bitmap = cv2.drawContours(
        np.zeros((bounding_box.height, bounding_box.width), dtype=np.uint8),
        contours=contours,
        contourIdx=-1,
        color=BITMAP_PIXEL_VALUE,
        thickness=-1,
        offset=[-bounding_box.left, -bounding_box.top],
    )
    return bounding_box, bitmap

convert_box_and_bitmap_to_contours

convert_box_and_bitmap_to_contours(bitmap: Bitmap, bounding_box: Optional[SegmentBox] = None) -> Contours

bounding_box 와 bitmap을 contours representation으로 변환합니다

Source code in SaigeToolkit/data/dataclass/segment.py

def convert_box_and_bitmap_to_contours(
    bitmap: Bitmap,
    bounding_box: Optional[SegmentBox] = None,
) -> Contours:
    """bounding_box 와 bitmap을 contours representation으로 변환합니다"""
    polygons, hierarchy = cv2.findContours(bitmap, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE)
    if not polygons:
        raise SegmentValueError
    parents = hierarchy[0, :, -1]
    outers = np.where(parents == -1)[0]
    if len(outers) != 1:
        raise SegmentValueError
    outer_idx = outers[0]
    contours = [polygons[outer_idx]]
    for idx_inner in np.where(parents == outer_idx)[0]:
        contours.append(polygons[idx_inner])
    if bounding_box is not None:
        contours = [contour + (bounding_box.left, bounding_box.top) for contour in contours]
    return contours

compute_box_intersection

compute_box_intersection(box1: SegmentBox, box2: SegmentBox) -> Optional[SegmentBox]

intersecting box를 계산합니다. 겹치지 않는 경우 None

Source code in SaigeToolkit/data/dataclass/segment.py

def compute_box_intersection(box1: SegmentBox, box2: SegmentBox) -> Optional[SegmentBox]:
    """intersecting box를 계산합니다. 겹치지 않는 경우 None"""
    left = max(box1.left, box2.left)
    top = max(box1.top, box2.top)
    right = min(box1.right, box2.right)
    bottom = min(box1.bottom, box2.bottom)
    intersection = SegmentBox.from_xyxy(left, top, right, bottom)
    if intersection.width <= 0 or intersection.height <= 0:
        return None
    else:
        return intersection

to_segments

to_segments(segments: List[Union[Segment, Dict]]) -> List[Segment]

List[Union[Segment, Dict]]를을 List[Segment]들로 변환합니다

Source code in SaigeToolkit/data/dataclass/segment.py

def to_segments(segments: List[Union[Segment, Dict]]) -> List[Segment]:
    """List[Union[Segment, Dict]]를을 List[Segment]들로 변환합니다"""
    return [Segment.from_any(segment) for segment in segments]

merge_segments

merge_segments(segments: List[Segment]) -> Segment

여러 Segment들을 하나의 Segment로 합칩니다. (union)

Source code in SaigeToolkit/data/dataclass/segment.py

def merge_segments(segments: List[Segment]) -> Segment:
    """여러 Segment들을 하나의 Segment로 합칩니다. (union)"""
    if not segments:
        raise ValueError
    left = min(segment.bounding_box.left for segment in segments)
    top = min(segment.bounding_box.top for segment in segments)
    right = max(segment.bounding_box.right for segment in segments)
    bottom = max(segment.bounding_box.bottom for segment in segments)
    box = SegmentBox.from_xyxy(left, top, right, bottom)
    bitmap = np.zeros((box.height, box.width), dtype=np.uint8)
    for segment in segments:
        offset_x = segment.bounding_box.left - left
        offset_y = segment.bounding_box.top - top
        bitmap[
            offset_y : offset_y + segment.bounding_box.height,
            offset_x : offset_x + segment.bounding_box.width,
        ][segment.bitmap > 0] = BITMAP_PIXEL_VALUE
    return Segment(bounding_box=box, bitmap=bitmap, class_index=segments[0].class_index)

compute_contours_area_exact

compute_contours_area_exact(contours: Contours) -> int

bounding box 크기의 이미지에 contour를 그린 뒤 픽셀 개수 카운트

Source code in SaigeToolkit/data/dataclass/segment.py

def compute_contours_area_exact(contours: Contours) -> int:
    """bounding box 크기의 이미지에 contour를 그린 뒤 픽셀 개수 카운트"""
    _, bitmap = convert_contours_to_box_and_bitmap(contours=contours)
    return int(np.sum(bitmap) / BITMAP_PIXEL_VALUE)

compute_contours_area_fast

compute_contours_area_fast(contours: Contours) -> int

cv2.contourArea() 로 contour 면적 계산: contour 테두리를 0.5 픽셀 제외하고 계산되는 듯. average error: 17.08%

Source code in SaigeToolkit/data/dataclass/segment.py

def compute_contours_area_fast(contours: Contours) -> int:
    """cv2.contourArea() 로 contour 면적 계산: contour 테두리를 0.5 픽셀 제외하고 계산되는 듯.
    average error: 17.08%
    """
    outer = contours[0]
    area = cv2.contourArea(outer)
    for inner in contours[1:]:
        area -= cv2.contourArea(inner)
    return max(int(area), 1)

compute_contours_area_fast_plus

compute_contours_area_fast_plus(contours: Contours) -> int

cv2.contourArea() 로 contour 면적 계산, outer의 경우 cv2.arcLength() 더해줌 average error: 1.50%

Source code in SaigeToolkit/data/dataclass/segment.py

def compute_contours_area_fast_plus(contours: Contours) -> int:
    """cv2.contourArea() 로 contour 면적 계산, outer의 경우 cv2.arcLength() 더해줌
    average error: 1.50%

    """
    outer = contours[0]
    area = cv2.contourArea(outer) + 0.5 * cv2.arcLength(outer, closed=True)
    for inner in contours[1:]:
        area -= cv2.contourArea(inner)
    return max(int(area), 1)

compute_contours_area_fast_plusplus

compute_contours_area_fast_plusplus(contours: Contours) -> int

cv2.contourArea() + cv2.arcLength() 로 contour 면적 계산 average error: 1.58%

Source code in SaigeToolkit/data/dataclass/segment.py

def compute_contours_area_fast_plusplus(contours: Contours) -> int:
    """cv2.contourArea() + cv2.arcLength() 로 contour 면적 계산
    average error: 1.58%
    """
    outer = contours[0]
    area = cv2.contourArea(outer) + 0.5 * cv2.arcLength(outer, closed=True)
    for inner in contours[1:]:
        area -= cv2.contourArea(inner) + 0.5 * cv2.arcLength(inner, closed=True)
    return max(int(area), 1)

compute_contours_area

compute_contours_area(contours: Contours, method: str) -> int

contours의 면적을 계산합니다. 참고: https://www.notion.so/65e5a56b2b8744bea087b1a0d2f9bfbf

Source code in SaigeToolkit/data/dataclass/segment.py

def compute_contours_area(contours: Contours, method: str) -> int:
    """contours의 면적을 계산합니다.
    참고: https://www.notion.so/65e5a56b2b8744bea087b1a0d2f9bfbf
    """
    if method not in contours_area_methods:
        raise KeyError
    return contours_area_methods[method](contours)

compute_segment_intersection_area

compute_segment_intersection_area(segment1: Segment, segment2: Segment) -> int

두 Segment 사이의 겹치는 영역 넓이를 계산합니다. bounding_box를 이용해 겹치는 박스를 먼저 계산한 뒤 해당 박스만 잘라서 겹치는 픽셀 수를 셉니다.

Source code in SaigeToolkit/data/dataclass/segment.py

def compute_segment_intersection_area(segment1: Segment, segment2: Segment) -> int:
    """두 Segment 사이의 겹치는 영역 넓이를 계산합니다.
    bounding_box를 이용해 겹치는 박스를 먼저 계산한 뒤 해당 박스만 잘라서 겹치는 픽셀 수를 셉니다.
    """
    intersection_box = compute_box_intersection(segment1.bounding_box, segment2.bounding_box)
    if intersection_box is None:
        return 0

    left = intersection_box.left - segment1.bounding_box.left
    top = intersection_box.top - segment1.bounding_box.top
    bitmap1_intersection = segment1.bitmap[
        top : top + intersection_box.height,
        left : left + intersection_box.width,
    ]

    left = intersection_box.left - segment2.bounding_box.left
    top = intersection_box.top - segment2.bounding_box.top
    bitmap2_intersection = segment2.bitmap[
        top : top + intersection_box.height,
        left : left + intersection_box.width,
    ]
    return int(np.sum(bitmap1_intersection * bitmap2_intersection))

compute_segment_score

compute_segment_score(segment: Segment, scoremap: ndarray, method: str = 'mean', return_float: bool = False) -> Union[float, int]

scoremap 중 segment 영역의 score를 대표하는 값을 계산합니다.

Source code in SaigeToolkit/data/dataclass/segment.py

def compute_segment_score(
    segment: Segment,
    scoremap: np.ndarray,
    method: str = "mean",
    return_float: bool = False,
) -> Union[float, int]:
    """scoremap 중 segment 영역의 score를 대표하는 값을 계산합니다."""
    bbox = segment.bounding_box
    scoremap_crop = scoremap[bbox.top : bbox.top + bbox.height, bbox.left : bbox.left + bbox.width]
    scoremap_masked = scoremap_crop[segment.bitmap > 0]

    if method == "mean":
        score = scoremap_masked.mean()
    elif method == "max":
        score = scoremap_masked.max()
    else:
        raise ValueError

    if (not return_float) and np.issubdtype(scoremap.dtype, np.integer):
        return int(score)
    else:
        return float(score)

compute_segment_properties_and_apply_threshold

compute_segment_properties_and_apply_threshold(segment: Segment, calc_area_and_apply_threshold: bool = False, area_method: str = 'fast_plus', area_threshold: int = 0, calc_score_and_apply_threshold: bool = False, scoremap: Optional[ndarray] = None, score_method: str = 'mean', score_threshold: Union[float, int] = 0, score_as_float: bool = False) -> Optional[Dict]

API 계산 결과로 필요한 Segment의 property 들을 계산하고 threshold를 적용합니다. threshold에 걸리지 않는 경우 각 property들의 Dict를, threshold 에 걸리는 경우 None을 리턴합니다. 계산 로직은 다음과 순서로 적용됩니다.

calc_object_area_and_apply_threshold=True 인 경우
1. area 계산
2. area_threshold 적용
calc_object_score_and_apply_threshold=True 인 경우
1. score 계산
2. score_threshold 적용
아래 항목들 계산
1. bounding_box
2. bounding_rotated_box
3. fitted_ellipse

Parameters:

segment (Segment) –

segment

Returns:

Optional[Dict] –

Optional[Dict]: segment property dictionary. threshold에 걸려서 필터링 된 경우 None

Source code in SaigeToolkit/data/dataclass/segment.py

def compute_segment_properties_and_apply_threshold(
    segment: Segment,
    calc_area_and_apply_threshold: bool = False,
    area_method: str = "fast_plus",
    area_threshold: int = 0,
    calc_score_and_apply_threshold: bool = False,
    scoremap: Optional[np.ndarray] = None,
    score_method: str = "mean",
    score_threshold: Union[float, int] = 0,
    score_as_float: bool = False,
) -> Optional[Dict]:
    """API 계산 결과로 필요한 Segment의 property 들을 계산하고 threshold를 적용합니다.
    threshold에 걸리지 않는 경우 각 property들의 Dict를, threshold 에 걸리는 경우 None을 리턴합니다.
    계산 로직은 다음과 순서로 적용됩니다.

    1. `calc_object_area_and_apply_threshold=True` 인 경우
        1. area 계산
        2. area_threshold 적용
    2. `calc_object_score_and_apply_threshold=True` 인 경우
        1. score 계산
        2. score_threshold 적용
    3. 아래 항목들 계산
        1. bounding_box
        2. bounding_rotated_box
        3. fitted_ellipse

    Args:
        segment (Segment): segment

    Returns:
        Optional[Dict]: segment property dictionary. threshold에 걸려서 필터링 된 경우 None
    """
    properties = {}

    # area
    if calc_area_and_apply_threshold:
        area = compute_contours_area(contours=segment.contours, method=area_method)
        if area < area_threshold:
            return None
        properties["area"] = area

    # score
    if calc_score_and_apply_threshold:
        assert scoremap is not None
        score = compute_segment_score(
            segment=segment,
            scoremap=scoremap,
            method=score_method,
            return_float=score_as_float,
        )
        if score < score_threshold:
            return None
        properties["score"] = score

    # default properties
    if segment.class_index is not None:
        properties["class_index"] = segment.class_index
    properties["contours"] = segment.contours
    outer = segment.contours[0]

    # bounding_box: v1 legacy logic
    bbox = segment.bounding_box
    properties["bounding_box"] = [bbox.left, bbox.top, bbox.width, bbox.height]

    # bounding_rot_box: v1 legacy logic
    ((center_x, center_y), (width, height), angle) = cv2.minAreaRect(outer)
    rot_box_points = cv2.boxPoints(((center_x, center_y), (width, height), angle)).tolist()
    bounding_rot_box = [[center_x, center_y], [width, height], angle, rot_box_points]
    properties["bounding_rot_box"] = bounding_rot_box

    # fitted_ellipse: v1 legacy logic
    fitted_ellipse = bounding_rot_box[:3]
    if len(outer) >= 5:
        ((center_x, center_y), (width, height), angle) = cv2.fitEllipse(outer)
        if width > 1e-5 and height > 1e-5:
            fitted_ellipse = [[center_x, center_y], [width, height], angle]
    properties["fitted_ellipse"] = fitted_ellipse

    return properties

scale_segments_properties

scale_segments_properties(segments_properties: List[Dict], scale: Sequence[float]) -> List[Dict]

Source code in SaigeToolkit/data/dataclass/segment.py

def scale_segments_properties(segments_properties: List[Dict], scale: Sequence[float]) -> List[Dict]:
    return [
        scale_segment_properties(segment_properties, scale) for segment_properties in segments_properties
    ]

scale_segment_properties

scale_segment_properties(properties: Dict, scale: Sequence[float]) -> Dict

Source code in SaigeToolkit/data/dataclass/segment.py

def scale_segment_properties(properties: Dict, scale: Sequence[float]) -> Dict:
    scale_w, scale_h = scale[:2]

    scaled_properties = properties.copy()

    if "area" in scaled_properties:
        scaled_properties["area"] = int(scale_w * scale_h * scaled_properties["area"])

    if "contours" in scaled_properties:
        scaled_properties["contours"] = [
            (contour * scale).astype(contour.dtype) for contour in scaled_properties["contours"]
        ]

    if "bounding_box" in scaled_properties:
        left_, top_, width_, height_ = scaled_properties["bounding_box"]
        scaled_properties["bounding_box"] = [
            int(left_ * scale_w),
            int(top_ * scale_h),
            int(width_ * scale_w),
            int(height_ * scale_h),
        ]

    if "bounding_rot_box" in scaled_properties:
        ((center_x_, center_y_), (width_, height_), angle_, rot_box_points_) = scaled_properties[
            "bounding_rot_box"
        ]
        scaled_properties["bounding_rot_box"] = [
            [center_x_ * scale_w, center_y_ * scale_h],
            [width_ * scale_w, height_ * scale_h],
            angle_,
            [[rot_box[0] * scale_w, rot_box[1] * scale_h] for rot_box in rot_box_points_],
        ]

    if "fitted_ellipse" in scaled_properties:
        ((center_x_, center_y_), (width_, height_), angle_) = scaled_properties["fitted_ellipse"]
        scaled_properties["fitted_ellipse"] = [
            [center_x_ * scale_w, center_y_ * scale_h],
            [width_ * scale_w, height_ * scale_h],
            angle_,
        ]

    return scaled_properties

translate_segments_properties

translate_segments_properties(segments_properties: List[Dict], left: int, top: int, **kwargs) -> List[Dict]

Source code in SaigeToolkit/data/dataclass/segment.py

def translate_segments_properties(
    segments_properties: List[Dict],
    left: int,
    top: int,
    **kwargs,
) -> List[Dict]:
    return [
        translate_segment_properties(segment_properties, left, top, **kwargs)
        for segment_properties in segments_properties
    ]

translate_segment_properties

translate_segment_properties(properties: Dict, left: int, top: int, **kwargs) -> Dict

Source code in SaigeToolkit/data/dataclass/segment.py

def translate_segment_properties(
    properties: Dict,
    left: int,
    top: int,
    **kwargs,
) -> Dict:
    translated_properties = properties.copy()

    if "contours" in translated_properties:
        translated_properties["contours"] = [
            (contour + (left, top)).astype(contour.dtype)
            for contour in translated_properties["contours"]
        ]

    if "bounding_box" in translated_properties:
        left_, top_, width_, height_ = translated_properties["bounding_box"]
        translated_properties["bounding_box"] = [
            int(left_ + left),
            int(top_ + top),
            int(width_),
            int(height_),
        ]

    if "bounding_rot_box" in translated_properties:
        ((center_x_, center_y_), (width_, height_), angle_, rot_box_points_) = translated_properties[
            "bounding_rot_box"
        ]
        translated_properties["bounding_rot_box"] = [
            [center_x_ + left, center_y_ + top],
            [width_, height_],
            angle_,
            [[rot_box[0] + left, rot_box[1] + top] for rot_box in rot_box_points_],
        ]

    if "fitted_ellipse" in translated_properties:
        ((center_x_, center_y_), (width_, height_), angle_) = translated_properties["fitted_ellipse"]
        translated_properties["fitted_ellipse"] = [
            [center_x_ + left, center_y_ + top],
            [width_, height_],
            angle_,
        ]

    return translated_properties

dataset

커스텀 데이터셋 구현과 각종 데이터 로드 메서드를 제공합니다.

모든 데이터셋 구현은 SaigeDataset 클래스를 상속받아야 합니다.

base_dataset

모든 데이터셋 구현에 사용되는 기본 클래스를 정의합니다.

logger `module-attribute`

logger = getLogger('SaigeResearch')

DummyAttribute

ABCMeta

Bases: ABCMeta

"abstract_attribute" from:\ https://stackoverflow.com/questions/23831510/abstract-attribute-not-property/50381071#50381071

call

__call__(*args, **kwargs)

Source code in SaigeToolkit/data/dataset/base_dataset.py

def __call__(cls, *args, **kwargs):
    instance = NativeABCMeta.__call__(cls, *args, **kwargs)
    abstract_attributes = {
        name
        for name in dir(instance)
        if getattr(getattr(instance, name), "__is_abstract_attribute__", False)
    }
    if abstract_attributes:
        raise NotImplementedError(
            f"Can't instantiate abstract class {cls.__name__} with abstract attributes: {', '.join(abstract_attributes)}"
        )
    return instance

SaigeDataset

SaigeDataset(crop: Optional[dict] = None, transform: Optional[dict] = None, collate: Optional[Callable[[List[dict]], dict]] = None, device: device = torch.device('cpu'), **neglect: dict)

Bases: Dataset

Saige's basic dataset class.

Attributes:

crop_fn (Optional[Callable[[dict], List[dict]]) –

function cropping image data into image patch data.
transform (Type[Transform]) –

transform class for transforming to a single image data.
to_tensor (Callable[[Union[Image.Image, np.ndarray], torch.Tensor]) –

data returning as Tensor type
n_patch (int) –

number of patches when crop_fn is used.
collate_function (Callable[[List[dict]], dict]) –

function list of data collating into one batch data

initializing Saige base dataset.

Parameters:

crop (Optional[dict], default: None ) –

config for crop function. Defaults to None.
transform (Optional[dict], default: None ) –

config for transforming to a single raw data
collate (Optional[Callable[[List[dict]], dict]], default: None ) –

list of data collating into one batch data. if None, torch.utils basic collate function would be used. Defaults to None.
device (device, default: device('cpu') ) –

gpu device

Source code in SaigeToolkit/data/dataset/base_dataset.py

def __init__(
    self,
    crop: Optional[dict] = None,
    transform: Optional[dict] = None,
    collate: Optional[Callable[[List[dict]], dict]] = None,
    device: torch.device = torch.device("cpu"),
    **neglect: dict,
) -> None:
    """initializing Saige base dataset.

    Args:
        crop (Optional[dict], optional):
            config for crop function. Defaults to None.
        transform (Optional[dict], optional):
            config for transforming to a single raw data
        collate (Optional[Callable[[List[dict]], dict]], optional):
            list of data collating into one batch data.
            if None, torch.utils basic collate function would be used. Defaults to None.
        device (torch.device, optional):
            gpu device
    """
    if neglect:
        logger.warning(f"Neglected arguments: {neglect}")

    # Config options
    self.crop_fn = get_crop_fn(**(crop or {}))
    self.has_crop_fn = crop is not None

    self.transform = Transform(**(transform or {}))

    self.device = device

    if collate is not None:
        assert collate in ["resize", "padding"]
        self.collate_function = {
            "resize": self.resize_collate,
            "padding": self.padding_collate,
        }[collate]
        logger.info(f'[{"DATA".center(9)}] [Base dataset collate] {collate}')

crop_fn `instance-attribute`

crop_fn = get_crop_fn(**crop or {})

has_crop_fn `instance-attribute`

has_crop_fn = crop is not None

transform `instance-attribute`

transform = Transform(**transform or {})

device `instance-attribute`

device = device

collate_function `instance-attribute`

collate_function = {'resize': resize_collate, 'padding': padding_collate}[collate]

files `property` `writable`

files

len

__len__()

Source code in SaigeToolkit/data/dataset/base_dataset.py

def __len__(self):
    return len(self.files)

data_on_memory

data_on_memory()

To store data in RAM memory (faster data loading), put all loaded data ( use self.load_raw_data() ) in list self.data_on_memory. Or define self.data_on_memory as empty list to load data from filesystem everytime.

Source code in SaigeToolkit/data/dataset/base_dataset.py

@abstract_attribute
def data_on_memory(self):
    """
    To store data in RAM memory (faster data loading),
    put all loaded data ( use self.load_raw_data() ) in list `self.data_on_memory`.
    Or define self.data_on_memory as empty list to load data from filesystem everytime.
    """
    pass

stack_data_on_memory

stack_data_on_memory() -> List[dict]

Stack all data on RAM memory for quick-loading purpose. output would be saved on class attribute.

Returns:

List[dict] –

List[dict]: Entire data list-dict.

Source code in SaigeToolkit/data/dataset/base_dataset.py

def stack_data_on_memory(self) -> List[dict]:
    """Stack all data on RAM memory for quick-loading purpose.
    output would be saved on class attribute.

    Returns:
        List[dict]: Entire data list-dict.
    """
    data_on_memory = []
    for idx in range(len(self)):
        data_on_memory.append(self.load_raw_data(idx))

    logger.info(f'[{"DATA".center(9)}] [DATA_ON_MEMORY] activated')

    return data_on_memory

load_raw_data

load_raw_data(index)

Source code in SaigeToolkit/data/dataset/base_dataset.py

def load_raw_data(self, index):
    # load image
    file = self.files[index]
    data = self.load_image(file)
    data.update(self.load_label(file))

    return data

load_image

load_image(file)

Source code in SaigeToolkit/data/dataset/base_dataset.py

def load_image(self, file):
    # open image
    if "image_path" in file:
        image = file["image_path"]
    elif "path" in file:
        image = file["path"]
    elif "Path" in file:
        image = file["Path"]
    else:
        raise NotImplementedError(f"no known image path item in {file.keys()}")

    data = self.transform.image_loader(image)

    return data

load_label `abstractmethod`

load_label(file)

Source code in SaigeToolkit/data/dataset/base_dataset.py

@abstractmethod
def load_label(self, file):
    pass

getitem

__getitem__(index: int) -> Union[dict, List[dict]]

dataset default getitem function. data is first loaded, then processed as following order: resize, augmentation, transform to torch.Tensor. data could be loaded from file_system (load_raw_data) or RAM memory (data_on_memory).

Parameters:

index (int) –

data item index.

Returns:

Union[dict, List[dict]] –

Union[dict, List[dict]]: single data, or cropped data list when crop_fn exists.

Source code in SaigeToolkit/data/dataset/base_dataset.py

def __getitem__(self, index: int) -> Union[dict, List[dict]]:
    """dataset default __getitem__ function.
    data is first loaded, then processed as following order:
        resize, augmentation, transform to torch.Tensor.
    data could be loaded from file_system (load_raw_data) or RAM memory (data_on_memory).

    Args:
        index (int): data item index.

    Returns:
        Union[dict, List[dict]]:
            single data, or cropped data list when crop_fn exists.
    """

    # Load Images and Text or Image Labels
    if self.data_on_memory:
        data = self.data_on_memory[index]
    else:
        data = self.load_raw_data(index)

    # ROI
    if self.transform.roi_handler is not None:
        if self.has_crop_fn:
            data = self.transform.roi_handler(**data)
        else:
            data = self.transform.roi_handler.apply_crop(**data)

    assert "image" in data, "SaigeDataset currently only supports image dataset"

    if not self.has_crop_fn:
        data = self.process_data(data)

        return data

    else:
        l_data_raw = self.crop_fn(**data)

        batch = []
        for data_patch in l_data_raw:
            batch.append(self.process_data(data_patch))

        return batch

process_data

process_data(data: dict) -> dict

data processing after raw loading.

- resize: Resize Image and Label
- btw_resize_aug: Dummy function for user customization
- augmentation: Process augmentation defined in util/augmentation
- btw_aug_transform: Dummy function for user customization
- to_tensor: Transform data to torch tensor

Parameters:

data (dict) –

raw data dict

Returns:

dict ( dict ) –

processed data dict

Source code in SaigeToolkit/data/dataset/base_dataset.py

def process_data(self, data: dict) -> dict:
    """data processing after raw loading.

        - resize: Resize Image and Label
        - btw_resize_aug: Dummy function for user customization
        - augmentation: Process augmentation defined in util/augmentation
        - btw_aug_transform: Dummy function for user customization
        - to_tensor: Transform data to torch tensor

    Args:
        data (dict): raw data dict

    Returns:
        dict: processed data dict
    """
    if self.transform.base_resizer is not None:
        data = self.transform.base_resizer(**data)

    if self.transform.roi_handler is not None and not self.has_crop_fn:
        data = self.transform.roi_handler.apply_mask(**data)

    if self.transform.augmentation is not None:
        data = self.transform.augmentation(**data)

    data = self.to_tensor(**data)

    return data

to_tensor

to_tensor(**data: dict) -> dict

to_tensor items in data into torch.Tensor (if convertible)

Parameters:

data (dict, default: {} ) –

raw data dict

Returns:

dict ( dict ) –

tensorized data dict

Source code in SaigeToolkit/data/dataset/base_dataset.py

def to_tensor(self, **data: dict) -> dict:
    """to_tensor items in data into torch.Tensor (if convertible)

    Args:
        data (dict): raw data dict

    Returns:
        dict: tensorized data dict
    """

    def _to_tensor_from_numpy(image: np.ndarray):
        return torch.from_numpy(image).to(self.device).contiguous()

    def _to_tensor_from_pil_image(image: Image.Image):
        return _to_tensor_from_numpy(np.array(image))

    for k, v in data.items():
        if k == "org_image":
            continue

        if isinstance(v, Image.Image):
            data[k] = _to_tensor_from_pil_image(v)

        elif isinstance(v, np.ndarray):
            data[k] = _to_tensor_from_numpy(v)

        elif isinstance(v, int):
            data[k] = torch.tensor(v).to(self.device).contiguous()

        else:
            continue

        if k == "image":
            data[k] = data[k].permute((2, 0, 1)).div(255)
        else:
            data[k] = data[k].long()

    return data

resize_collate

resize_collate(batch: List[dict]) -> dict

Example collate function with resizing items.

Parameters:

batch (List[dict]) –

list of data dicts

Returns:

dict ( dict ) –

resized-and-collated data dict

Source code in SaigeToolkit/data/dataset/base_dataset.py

def resize_collate(self, batch: List[dict]) -> dict:
    """Example collate function with resizing items.

    Args:
        batch (List[dict]): list of data dicts

    Returns:
        dict: resized-and-collated data dict
    """

    img_size = (
        int(np.mean([data["image"].shape[-2] for data in batch])),
        int(np.mean([data["image"].shape[-1] for data in batch])),
    )

    # 이미 tensor 형태로 들어온 상태기 때문에 F.interpolate 함수 사용해보자
    data_out = {key: [] for key in batch[0].keys()}
    for data in batch:
        data_out["image"].append(F.interpolate(data["image"][None], (img_size[0], img_size[1])))

        for k, v in data.items():
            if k == "class":
                data_out[k].append(v.unsqueeze(0))
            elif k == "boxes":
                data_out[k].append(v)
            elif k == "mask":
                data_out[k].append(
                    F.interpolate(v[None, None].float(), (img_size[0], img_size[1]))
                    .long()
                    .squeeze(1)
                )

    for key, value in data_out.items():
        data_out[key] = torch.cat(value)

    return data_out

padding_collate

padding_collate(batch: List[dict]) -> dict

Example collate function with padding items.

Parameters:

batch (List[dict]) –

list of data dicts

Returns:

dict ( dict ) –

padded-and-collated data dict

Source code in SaigeToolkit/data/dataset/base_dataset.py

def padding_collate(self, batch: List[dict]) -> dict:
    """Example collate function with padding items.

    Args:
        batch (List[dict]): list of data dicts

    Returns:
        dict: padded-and-collated data dict
    """

    max_h = np.max([d["image"].shape[-2] for d in batch])
    max_w = np.max([d["image"].shape[-1] for d in batch])

    data_out = {key: [] for key in batch[0].keys()}
    for data in batch:
        data_out["image"].append(
            F.pad(
                data["image"][None],
                (0, max_w - data["image"].shape[-1], 0, max_h - data["image"].shape[-2]),
            )
        )

        for k, v in data.items():
            if k == "class":
                data_out[k].append(v.unsqueeze(0))
            elif k == "boxes":
                data_out[k].append(v)
            elif k == "mask":
                data_out[k].append(F.pad(v[None], (0, max_w - v.shape[-1], 0, max_h - v.shape[-2])))

    for key, value in data_out.items():
        data_out[key] = torch.cat(value)

    return data_out

calculate_patch_number

calculate_patch_number(files: Optional[List[dict]] = None) -> int

When crop_fn is activated, calculate number of text patches.

Parameters:

files (Optional[List[dict]], default: None ) –

list of meta data dict. if None, calculate patch_number from self.files attribute. Defaults to None.

Returns:

int ( int ) –

number of patches in meta data list files

Source code in SaigeToolkit/data/dataset/base_dataset.py

def calculate_patch_number(self, files: Optional[List[dict]] = None) -> int:
    """When crop_fn is activated, calculate number of text patches.

    Args:
        files (Optional[List[dict]], optional): list of meta data dict.
            if None, calculate patch_number from self.files attribute. Defaults to None.

    Returns:
        int: number of patches in meta data list `files`
    """
    if not self.has_crop_fn:
        return len(self)

    if files is None:
        files = self.files

    n_patch = 0
    for file in files:
        labels = self.load_label(file)
        if "polygons" in labels:
            n_patch += self.crop_fn.get_n_patch(labels["polygons"])
        elif "labels" in labels:
            n_patch += len(labels["labels"])
        elif "labels_count" in labels:
            n_patch += labels["labels_count"]
        else:
            n_patch += 1

    logger.info(f"total patch number in files: {n_patch}")

    return n_patch

abstract_attribute

abstract_attribute(obj=None)

Source code in SaigeToolkit/data/dataset/base_dataset.py

def abstract_attribute(obj=None):
    if obj is None:
        obj = DummyAttribute()
    obj.__is_abstract_attribute__ = True
    return obj

builder

DATASET_IMPLEMENTED `module-attribute`

DATASET_IMPLEMENTED = {'srproj': SrprojDataset}

build_dataset

build_dataset(_target_, **cfg_dataset: dict) -> SaigeDataset

build dataset from config["dataset"]

Parameters:

cfg_dataset (dict, default: {} ) –

config dict for building dataset

Returns:

SaigeDataset ( SaigeDataset ) –

dataset object

Source code in SaigeToolkit/data/dataset/builder.py

def build_dataset(_target_, **cfg_dataset: dict) -> SaigeDataset:
    """build dataset from config["dataset"]

    Args:
        cfg_dataset (dict): config dict for building dataset

    Returns:
        SaigeDataset: dataset object
    """

    # Setup Dataset
    dataset_class = DATASET_IMPLEMENTED[_target_]
    dataset: SaigeDataset = dataset_class(**cfg_dataset)

    return dataset

platform_reader

request_vision_projects

request_vision_projects(ip: str, port: int, project_ids: List[int]) -> List[dict]

Data platform으로부터 project 정보들을 가져옵니다.

Parameters:

ip (str) –

API서버에 접근하기 위한 IP 주소입니다.
port (int) –

API서버에 접근하기 위한 PORT 번호입니다.
project_ids (list) –

project 정보를 가져오기 위한 project_id의 list입니다.

Returns:

List[dict] –
List[dict]: project 정보를 dict형태로 저장한 list를 반환합니다.
```
                             
```
name="__codelineno-0-1" href="#__codelineno-0-1">[ { "project_id": int, "class_info": List[str], "dataset": { "train_images": { "{image_id}": { "path": str, "width": int, "height": int, "client": str, # Dataset metadata "end_user": str, # Dataset metadata "domain": str, # Dataset metadata "class_index": int, # CLS only have this key "labels" : [ # DET, SEG only have this key { "class_index": int, "bounding_box": List[int], # DET only have this key "contours": List[List[int]] # SEG only have this key }, ..., # times number of labels ] }, ..., # times number of images }, "validation_images": {...}, "Not split: {...} } }, ..., # times number of projects class="p">]





  Usage
  projects = request_vision_projects("platform.saige.in", 8502, project_ids)


            
              Source code in SaigeToolkit/data/dataset/platform_reader.py
               6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64 def request_vision_projects(ip: str, port: int, project_ids: List[int]) -> List[dict]:
    """Data platform으로부터 project 정보들을 가져옵니다.

    Args:
        ip (str): API서버에 접근하기 위한 IP 주소입니다.
        port (int): API서버에 접근하기 위한 PORT 번호입니다.
        project_ids (list): project 정보를 가져오기 위한 project_id의 list입니다.

    Returns:
        List[dict]: project 정보를 dict형태로 저장한 list를 반환합니다.
            ```python
            [
                {
                    "project_id": int,
                    "class_info": List[str],
                    "dataset": {
                        "train_images": {
                            "{image_id}": {
                                "path": str,
                                "width": int,
                                "height": int,
                                "client": str,    # Dataset metadata
                                "end_user": str,  # Dataset metadata
                                "domain": str,    # Dataset metadata
                                "class_index": int,  # CLS only have this key
                                "labels" : [         # DET, SEG only have this key
                                    {
                                        "class_index": int,
                                        "bounding_box": List[int],   # DET only have this key
                                        "contours": List[List[int]]  # SEG only have this key
                                    },
                                    ..., # times number of labels
                                ]
                            },
                            ..., # times number of images
                        },
                        "validation_images": {...},
                        "Not split: {...}
                    }
                },
                ...,    # times number of projects
            ]
            ```

    Usage:
        ``` python
        projects = request_vision_projects("platform.saige.in", 8502, project_ids)
        ```
    """
    projects = []
    for project_id in project_ids:
        response = requests.get(f"http://{ip}:{port}/get_project/{project_id}")
        if response.status_code == 200:
            exported_project = response.json()
            projects.append(exported_project)
        else:
            print(response.text)

    return projects








            saige_vision_reader




    



  













            load_labels



load_labels(file: Dict) -> List[Dict]


    

            
              Source code in SaigeToolkit/data/dataset/saige_vision_reader.py
              12
13
14
15
16
17
18
19
20
21 def load_labels(file: Dict) -> List[Dict]:
    if "labels" in file:
        labels = file["labels"]
    elif "labels_path" in file:
        with open(file["labels_path"], "rb") as f:
            labels = pickle.load(f)
    else:
        labels = []

    return labels

            
    







            load_label_cls



load_label_cls(file: Dict) -> Dict


    

            
              Source code in SaigeToolkit/data/dataset/saige_vision_reader.py
              24
25 def load_label_cls(file: Dict) -> Dict:
    return {"class": file["class_index"]}

            
    







            load_label_iad



load_label_iad(file: Dict) -> Dict


    

            
              Source code in SaigeToolkit/data/dataset/saige_vision_reader.py
              28
29 def load_label_iad(file: Dict) -> Dict:
    return {"is_ng": file["labels"]["is_ng"]}

            
    







            load_label_det



load_label_det(file: Dict) -> Dict


    

      박스 별 dict를 concat 되어있는 bboxes, labels, scores로 변환합니다.

            
              Source code in SaigeToolkit/data/dataset/saige_vision_reader.py
              32
33
34
35
36
37
38
39
40
41
42
43 def load_label_det(file: Dict) -> Dict:
    """박스 별 dict를 concat 되어있는 bboxes, labels, scores로 변환합니다."""
    bboxes = file["labels"]

    label = {
        "bboxes": [bbox["bounding_box"] for bbox in bboxes],
        "labels": [bbox["class_index"] for bbox in bboxes],
    }
    if bboxes and "score" in bboxes[0]:
        label["scores"] = [bbox["score"] for bbox in bboxes]

    return label

            
    







            load_label_seg



load_label_seg(file: Dict, get_objects: bool = False, n_classes: Optional[int] = None) -> Dict


    

            
              Source code in SaigeToolkit/data/dataset/saige_vision_reader.py
               46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111 def load_label_seg(file: Dict, get_objects: bool = False, n_classes: Optional[int] = None) -> Dict:
    if "labels" in file:
        labels = file["labels"]
    elif "labels_path" in file:
        with open(file["labels_path"], "rb") as f:
            labels = pickle.load(f)
    else:  # unlabeled
        return {}

    w, h = file["width"], file["height"]
    mask = np.zeros((h, w), dtype=np.uint8)

    if get_objects:
        objects = []

    for label in labels:
        class_index = label["class_index"]
        if class_index == 0:
            raise ValueError("segment class_index cannot be 0")
        elif n_classes is not None and class_index >= n_classes:
            raise ValueError(
                f"class_index must be smaller than n_classes: got class_index={class_index} & n_classes={n_classes}"
            )

        bitmap_nonzero = None

        if "contours" in label:
            if not isinstance(label["contours"][0], np.ndarray):
                # NOTE: this is inplace
                label["contours"] = [np.array(contour) for contour in label["contours"]]
            bbox, bitmap = convert_contours_to_box_and_bitmap(label["contours"])
            bbox_xywh = [bbox.left, bbox.top, bbox.width, bbox.height]
        else:
            bbox_xywh = label["bounding_box"]
            bitmap = label["bitmap"]
            if not isinstance(bitmap, np.ndarray):
                bitmap = Image.open(BytesIO(base64.b64decode(bitmap)))
                bitmap = np.array(bitmap)
            bitmap_nonzero = bitmap > 0
            bitmap[bitmap_nonzero] = BITMAP_PIXEL_VALUE  # NOTE: this is inplace

        bbox_x, bbox_y, bbox_w, bbox_h = bbox_xywh
        bbox_bottom = bbox_y + bbox_h
        bbox_right = bbox_x + bbox_w
        if bbox_x < 0 or bbox_y < 0 or bbox_bottom > h or bbox_right > w:
            raise ValueError(f"segment is out of image: image_size={(w,h)}, bbox={(bbox_xywh)}")
        mask_sliced = mask[bbox_y:bbox_bottom, bbox_x:bbox_right]
        if bitmap_nonzero is None:
            bitmap_nonzero = bitmap > 0
        mask_sliced[bitmap_nonzero] = class_index

        if get_objects:
            segment = {
                "bounding_box": bbox_xywh,
                "bitmap": bitmap,
                "class_index": label["class_index"],
            }
            if "contours" in label:
                segment["contours"] = label["contours"]
            objects.append(segment)

    label = {"mask": mask}
    if get_objects:
        label["objects"] = objects

    return label

            
    







            load_label_ocr



load_label_ocr(file: Dict) -> Dict


    

            
              Source code in SaigeToolkit/data/dataset/saige_vision_reader.py
              114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134 def load_label_ocr(file: Dict) -> Dict:
    labels = load_labels(file)

    pols, strs, kies, verts = [], [], [], []
    for label in labels:
        pols.append(np.array(label["polygon"]))
        strs.append(label["text"])
        if "class_index" in label:
            kies.append(label["class_index"])
        if "is_vertical" in label:
            verts.append(label["is_vertical"])

    ignore = [s is None for s in strs]

    label = {"polygons": pols, "strings": strs, "ignore": ignore}
    if len(kies) == len(pols):
        label.update({"kie_labels": kies})
    if len(verts) == len(pols):
        label.update({"is_vertical": verts})

    return label

            
    





  

    








            srproj_dataset




    



  












            logger


  
      module-attribute
  


logger = getLogger('SaigeResearch')


    
    









            SrprojDataset



SrprojDataset(code: Union[str, List[Union[str, dict]]], mode: Optional[str] = None, two_class: bool = False, split: str = 'Training', preload_data_on_memory: bool = False, srproj_params: Optional[dict] = None, **cfg_dataset: dict)


    
            
              Bases: SaigeDataset


      Dataset class with building data from srproj file.
Basic structure of dataset class is defined in SaigeDataset.
SrprojDataset class only defines data loading from srproj file.


Attributes:
    
        
          files
              (List[dict])
          –
          
            meta_data dict list from srproj file.
          
        
        
          n_classes
              (int)
          –
          
            number of classes of data. fix to 2 if two_class mode is on.
          
        
        
          classes
              (List[str])
          –
          
            list of class names for each class index.
meta_data: only contains information about how to load data
          
        
        
          n_patch
              (int)
          –
          
            number of patches when crop_fn is used.
          
        
        
          data_on_memory
              (List[dict])
          –
          
            list of loaded data dicts if preload_data_on_memory is activated
          
        
    

      initializing SrprojDataset


Parameters:
    
        
          code
              (Union[str, List[Union[str, dict]]])
          –
          
            dataset code(s) with srproj params.
                                    여러 srproj를 사용하는 경우, 각 srproj_param을 dictionary 형태로 추가할 수 있습니다.
                                    이 경우, "srproj_params" 파라미터를 각자의 srproj_param으로 업데이트 하여 사용합니다.
          
        
        
          mode
              (Optional[str], default:
                  None
)
          –
          
            data label type. Defaults to None.
          
        
        
          two_class
              (bool, default:
                  False
)
          –
          
            two_class mode selector. Defaults to False.
          
        
        
          split
              (str, default:
                  'Training'
)
          –
          
            ["Training", "Validation"]. Defaults to "Training".
          
        
        
          preload_data_on_memory
              (bool, default:
                  False
)
          –
          
            whether pre-load all data and save on RAM memory. Defaults to False.
          
        
        
          srproj_params
              (dict, default:
                  None
)
          –
          
            read_srproj 함수에 전달하는 추가적인 파라미터들 입니다.
                            현재는 이미지 경로 핸들링을 위한 파라미터들이 있으며, 지속적으로 추가될 수 있습니다.
          
        
        
          cfg_dataset
              (dict, default:
                  {}
)
          –
          
            config dicts for mother class
          
        
    

                  
                    Source code in SaigeToolkit/data/dataset/srproj_dataset.py
                    26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82 def __init__(
    self,
    code: Union[str, List[Union[str, dict]]],
    mode: Optional[str] = None,
    two_class: bool = False,
    split: str = "Training",
    preload_data_on_memory: bool = False,
    srproj_params: Optional[dict] = None,
    **cfg_dataset: dict,
) -> None:
    """initializing SrprojDataset

    Args:
        code (Union[str, List[Union[str, dict]]]): dataset code(s) with srproj params.
                                                여러 srproj를 사용하는 경우, 각 srproj_param을 dictionary 형태로 추가할 수 있습니다.
                                                이 경우, "srproj_params" 파라미터를 각자의 srproj_param으로 업데이트 하여 사용합니다.
        mode (Optional[str], optional): data label type. Defaults to None.
        two_class (bool, optional): two_class mode selector. Defaults to False.
        split (str, optional): ["Training", "Validation"]. Defaults to "Training".
        preload_data_on_memory (bool, optional):
            whether pre-load all data and save on RAM memory. Defaults to False.
        srproj_params (dict, optional): `read_srproj` 함수에 전달하는 추가적인 파라미터들 입니다.
                                        현재는 이미지 경로 핸들링을 위한 파라미터들이 있으며, 지속적으로 추가될 수 있습니다.
        cfg_dataset (dict): config dicts for mother class
    """
    super().__init__(**cfg_dataset)

    if srproj_params is None:
        srproj_params = {}

    if isinstance(code, list):
        self.files = []
        self.classes = []
        for c in code:
            if isinstance(c, dict):
                _c = c.pop("code")
                _srproj_params = deepcopy(srproj_params)
                _srproj_params.update(c)
                files, _, classes = read_srproj(_c, split, two_class, mode, **_srproj_params)
            elif isinstance(c, str):
                files, _, classes = read_srproj(c, split, two_class, mode, **srproj_params)
            else:
                raise NotImplementedError

            self.files.extend(files)
            self.classes = merge_srproj_classes(self.classes, classes)
        self.n_classes = len(self.classes)
    else:
        self.files, self.n_classes, self.classes = read_srproj(
            code, split, two_class, mode, **srproj_params
        )

    self.data_on_memory = self.stack_data_on_memory() if preload_data_on_memory else []

    logger.info(
        f'[{"DATA".center(9)}] [count {split}] {len(self)} [number of classes] {self.n_classes}'
    )

                  



  












            files


  
      instance-attribute
  


files = []


    
    








            classes


  
      instance-attribute
  


classes = merge_srproj_classes(classes, classes)


    
    








            n_classes


  
      instance-attribute
  


n_classes = len(classes)


    
    








            data_on_memory


  
      instance-attribute
  


data_on_memory = stack_data_on_memory() if preload_data_on_memory else []


    
    









            load_label



load_label(file: dict) -> dict


    

      load label data from file-system


Parameters:
    
        
          file
              (dict)
          –
          
            meta data dict
          
        
    


Returns:
    
        
dict (              dict
)          –
          
            label data as dict
          
        
    

            
              Source code in SaigeToolkit/data/dataset/srproj_dataset.py
              84
85
86
87
88
89
90
91
92
93
94
95
96 def load_label(self, file: dict) -> dict:
    """load label data from file-system

    Args:
        file (dict): meta data dict

    Returns:
        dict: label data as dict
    """
    if self.crop_fn is not None:
        return load_srproj_label(file, use_crop_fn=True)
    else:
        return load_srproj_label(file, use_crop_fn=False)

            
    





  

    






  

    








            srproj_reader




    



  













            path_interpreter



path_interpreter(code: str) -> Tuple[str, str, str, str]


    

      data path interpreter


Parameters:
    
        
          code
              (str)
          –
          
            dataset code (rule: {domain}-{source}-{category})
(ex) sample dataset for cls: "test_directory-sample-cls")
          
        
    


Raises:
    
        
              RuntimeError
            –
          
            invalid classifier keys (code) for srproj code.
          
        
        
              Exception
            –
          
            wrong type of input code
          
        
    


Returns:
    
        
              Tuple[str, str, str, str]
          –
          
            Tuple[str, str, str, str]: absolute path for dataset, domain, source, category
          
        
    

            
              Source code in SaigeToolkit/data/dataset/srproj_reader.py
              12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37 def path_interpreter(code: str) -> Tuple[str, str, str, str]:
    """data path interpreter

    Args:
        code (str): dataset code (rule: {domain}-{source}-{category})
            (ex) sample dataset for cls: "test_directory-sample-cls")

    Raises:
        RuntimeError: invalid classifier keys (code) for srproj code.
        Exception: wrong type of input code

    Returns:
        Tuple[str, str, str, str]: absolute path for dataset, domain, source, category
    """

    if os.path.isdir(code) or os.path.isfile(code):
        # correct directory/file
        path = code
        keys = os.path.dirname(os.path.dirname(path)).split(os.sep)
        keys = keys + ["dummy" for _ in range(3 - len(keys))]
        domain, source, category = keys[-3:]
    else:
        # wrong directory/file/code
        raise Exception(f"Wrong Directory / File / Code: {code}")

    return path, domain, source, category

            
    







            read_srproj



read_srproj(code: str, split: str, two_class: bool = False, mode: Optional[str] = None, use_absolute_path: bool = False, srproj_image_directory: Optional[str] = None, system_image_directory: Optional[str] = None, get_class_colors: bool = False, skip_problematic_files: bool = False) -> Tuple[List[Dict], int, Union[List[str], List[Dict]]]


    

      read srproj dataset from file-system.


Parameters:
    
        
          code
              (str)
          –
          
            dataset code.
          
        
        
          split
              (str)
          –
          
            split dataset, "Training" or "Validation".
          
        
        
          two_class
              (bool, default:
                  False
)
          –
          
            load data as two class mode (ex) normal <-> abnormal)
          
        
        
          mode
              (Optional[str], default:
                  None
)
          –
          
            select data label type.
          
        
        
          use_absolute_path
              (bool, default:
                  False
)
          –
          
            use the image path in srproj as is.
          
        
        
          srproj_image_directory
              (Optional[str], default:
                  None
)
          –
          
            srproj 파일에 작성된 이미지 경로를 현재 시스템 상의 이미지 경로로 변환하기 위해
                                    치환해야 하는 이미지 폴더 경로. None이면 SaigeDatabase 규칙 사용.
          
        
        
          system_image_directory
              (Optional[str], default:
                  None
)
          –
          
            코드가 구동되는 시스템 상의 이미지 폴더 경로. None이면 SaigeDatabase 규칙 사용.
          
        
        
          get_class_colors(bool)
          –
          
            srproj에 정의된 각 클래스의 color를 받을지 여부. True이면
          
        
        
          skip_problematic_files(bool)
          –
          
            srproj 파일에 작성된 이미지 경로로부터 이미지들을 읽을 때, 해당 파라미터가 True 라면,
                          파일이 실제 존재하지 않거나, 읽다가 문제가 발생할 경우 해당 파일을 제외하고 나머지 파일을 계속 읽음.
                          만약, False라면 Error를 raise 함.
          
        
    


Returns:
    
        
              Tuple[List[Dict], int, Union[List[str], List[Dict]]]
          –
          
            Tuple[List[Dict], int, Union[List[str], List[Dict]]]:
list of meta data dicts, number of classes, and list of class names or dict
          
        
    



  Note
  .sproj 파일에는 각 이미지들의 경로와 라벨 정보 등이 포함되어 있습니다.
이때 이미지 경로는 해당 파일을 생성한 PC 기준의 절대 경로로 작성되어 있기 때문에, 현재 이 코드가 실행되는 시스템에서의 경로로 변환해 주어야 합니다.
현재 이미지 경로 변환 옵션은 3가지가 존재합니다.
1. sproj를 생성한 PC에서 코드를 실행하는 경우,
    use_absolute_path= True로 세팅하면 srproj에 작성된 이미지 경로를 그대로 사용합니다.
2. 이미지와 srproj가 SaigeDatabase 룰에 맞게 구성된 경우,
    이미지는 images 폴더에 하위에 있고 (root/images/.../xxx.png)
    srproj는 images 폴더보다 한 단계 아래 경로에 있어야 합니다 (root/projects/xxx.srproj)
    이때는srproj_image_directory= None,system_image_directory= None 으로 설정합니다.
3. 이미지와 srproj가 SaigeDatabase 룰을 따르지 않는 경우,srproj_image_directory와system_image_directory`를 설정하면
    srproj에 작성된 이미지 경로를 다음 규칙으로 변환합니다:
    {srproj_image_directory}/.../xxx.png -> {system_image_directory}/.../xxx.png

            
              Source code in SaigeToolkit/data/dataset/srproj_reader.py
               40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253 def read_srproj(
    code: str,
    split: str,
    two_class: bool = False,
    mode: Optional[str] = None,
    use_absolute_path: bool = False,
    srproj_image_directory: Optional[str] = None,
    system_image_directory: Optional[str] = None,
    get_class_colors: bool = False,
    skip_problematic_files: bool = False,
) -> Tuple[List[Dict], int, Union[List[str], List[Dict]]]:
    """read srproj dataset from file-system.

    Args:
        code (str): dataset code.
        split (str): split dataset, "Training" or "Validation".
        two_class (bool): load data as two class mode (ex) normal <-> abnormal)
        mode (Optional[str]): select data label type.
        use_absolute_path (bool): use the image path in srproj as is.
        srproj_image_directory (Optional[str]): srproj 파일에 작성된 이미지 경로를 현재 시스템 상의 이미지 경로로 변환하기 위해
                                                치환해야 하는 이미지 폴더 경로. None이면 SaigeDatabase 규칙 사용.
        system_image_directory (Optional[str]): 코드가 구동되는 시스템 상의 이미지 폴더 경로. None이면 SaigeDatabase 규칙 사용.
        get_class_colors(bool): srproj에 정의된 각 클래스의 color를 받을지 여부. True이면
        skip_problematic_files(bool): srproj 파일에 작성된 이미지 경로로부터 이미지들을 읽을 때, 해당 파라미터가 True 라면,
                                      파일이 실제 존재하지 않거나, 읽다가 문제가 발생할 경우 해당 파일을 제외하고 나머지 파일을 계속 읽음.
                                      만약, False라면 Error를 raise 함.

    Returns:
        Tuple[List[Dict], int, Union[List[str], List[Dict]]]:
            list of meta data dicts, number of classes, and list of class names or dict

    Note:
        .sproj 파일에는 각 이미지들의 경로와 라벨 정보 등이 포함되어 있습니다.
        이때 이미지 경로는 해당 파일을 생성한 PC 기준의 절대 경로로 작성되어 있기 때문에, 현재 이 코드가 실행되는 시스템에서의 경로로 변환해 주어야 합니다.
        현재 이미지 경로 변환 옵션은 3가지가 존재합니다.
        1. sproj를 생성한 PC에서 코드를 실행하는 경우,
            use_absolute_path` = True로 세팅하면 srproj에 작성된 이미지 경로를 그대로 사용합니다.
        2. 이미지와 srproj가 SaigeDatabase 룰에 맞게 구성된 경우,
            이미지는 images 폴더에 하위에 있고 (root/images/.../xxx.png)
            srproj는 images 폴더보다 한 단계 아래 경로에 있어야 합니다 (root/projects/xxx.srproj)
            이때는 `srproj_image_directory` = None, `system_image_directory` = None 으로 설정합니다.
        3. 이미지와 srproj가 SaigeDatabase 룰을 따르지 않는 경우,
            `srproj_image_directory`와 `system_image_directory`를 설정하면
            srproj에 작성된 이미지 경로를 다음 규칙으로 변환합니다:
            {srproj_image_directory}/.../xxx.png -> {system_image_directory}/.../xxx.png

    """

    path, domain, source, category = path_interpreter(code)

    # Check if "path" is directory
    if os.path.isdir(path):
        srproj_list = [os.path.join(path, f) for f in os.listdir(path) if f.endswith(".srproj")]
        path = np.random.choice(srproj_list)

    # Read srproj
    with open(path, encoding="utf-8") as file:
        txt = file.read()
    srproj = xmltodict.parse(txt, dict_constructor=dict)["Project"]

    # Config mode
    if mode is None:
        mode = srproj["Type"]

    # Return empty list when dummy.srproj
    if srproj["ImageGroup"]["Image"] is None:
        return [], 0, []

    # Config files
    image_list = (
        srproj["ImageGroup"]["Image"]
        if isinstance(srproj["ImageGroup"]["Image"], list)
        else [srproj["ImageGroup"]["Image"]]
    )
    assert split in [
        "Training",
        "Validation",
        "All",
    ], "Split for *.srproj Should be 'Training' or 'Validation'"
    if split == "All":
        files = [l for l in image_list]
    else:
        files = [l for l in image_list if l["SplitState"] == split]
    files = check_label(files, mode)

    n_classes = 0

    image_path_converter = lambda srproj_image_path: srproj_image_path
    if not use_absolute_path:
        if srproj_image_directory is None:
            srproj_image_path = (
                files[0]["Path"] if "Path" in files[0] else files[0]["PathGroup"]["Path"][0]
            )
            srproj_image_path = srproj_image_path.replace("\\", os.sep)
            srproj_image_directory = srproj_image_path.split(os.sep + "images" + os.sep)[0]
        srproj_image_directory = srproj_image_directory.replace("\\", os.sep)

        if system_image_directory is None:
            system_image_directory = os.path.dirname(os.path.dirname(path))

        assert os.path.isdir(
            system_image_directory
        ), f"Image data should be in following directory: {system_image_directory}"

        image_path_converter = lambda srproj_image_path: os.path.join(
            system_image_directory,
            os.path.relpath(srproj_image_path.replace("\\", os.sep), srproj_image_directory),
        )

    def _update_file_information(file: Dict) -> bool:
        image_path = file["image_path"]
        if isinstance(image_path, List):
            image_path = image_path[0]

        if os.path.isfile(image_path):
            try:
                with Image.open(image_path) as image_file:
                    # NOTE: https://github.com/python-pillow/Pillow/blob/main/src/PIL/ImageOps.py#LL579C2-L579C2
                    orientation = image_file.getexif().get(0x0112)
                    if orientation in range(2, 9):
                        img_size = list(ImageOps.exif_transpose(image_file).size)
                    else:
                        img_size = list(image_file.size)
            except (IOError, OSError):
                if skip_problematic_files:
                    return False
                raise error.InvalidImageFileError
        else:
            if skip_problematic_files:
                print(f"image not found: {file['image_path']}")
                return False
            raise error.FileNotFoundError

        file.update(
            {
                "domain": domain,
                "source": source,
                "category": category,
                "image_size": img_size,
                "label_extension": "srproj",
                "mode": mode,
            }
        )

        if mode == "Classification":
            lbl = int(file["ClassIndexOfLabel"])
            if two_class:
                lbl = 1 if (lbl > 0) else lbl

            file["ClassIndexOfLabel"] = lbl + n_classes

        elif mode == "MultiLabelClassification":
            lbl = list(file["ClassIndexOfLabel"])
            file["ClassIndexOfLabel"] = [int(l) + n_classes for l in lbl]

        elif mode == "Segmentation":
            if str(file["LabelGroup"]["IsNormal"]) in ["False", "false", "FALSE"]:
                lbl_list = (
                    file["LabelGroup"]["Label"]
                    if isinstance(file["LabelGroup"]["Label"], list)
                    else [file["LabelGroup"]["Label"]]
                )
                for l in lbl_list:
                    lbl = 1 if two_class else int(l["ClassIndex"]) + 1
                    l["ClassIndex"] = lbl + n_classes

        return True

    cleaned_files = []
    for f in files:
        if "Path" in f:
            f["image_path"] = image_path_converter(f["Path"])
        else:
            f["image_path"] = [image_path_converter(_path) for _path in f["PathGroup"]["Path"]]

        is_updated = _update_file_information(f)
        if is_updated:
            cleaned_files.append(f)

    # Config n_classes
    classes = []
    if "ClassGroup" in srproj:
        n_classes = int(srproj["ClassGroup"]["NumberOfClasses"])
        class_list = (
            srproj["ClassGroup"]["Class"]
            if isinstance(srproj["ClassGroup"]["Class"], list)
            else [srproj["ClassGroup"]["Class"]]
        )
        if get_class_colors:
            classes = [
                {
                    "name": class_["Name"],
                    "color": convert_srproj_class_color_to_rgb(int(class_["Color"])),
                }
                for class_ in class_list
            ]
        else:
            classes = [class_["Name"] for class_ in class_list]
    elif "CharacterGroup" in srproj:
        classes = srproj["CharacterGroup"]["Included"]["@xmlns"]
        n_classes = len(classes) + 1

    if mode in ["Segmentation"]:
        if isinstance(classes[0], dict):
            classes.insert(0, {"name": "background", "color": (0, 0, 0)})
        else:
            classes.insert(0, "background")
        n_classes = len(classes)

    if two_class:
        classes = ["Normal", "Defect"]
        n_classes = len(classes)

    return cleaned_files, n_classes, classes

            
    







            check_label



check_label(files: List[Dict], mode: str) -> List[Dict]


    

      check all data label is valid.
If any data is corrupted, pop out from meta data list.


Parameters:
    
        
          files
              (List[Dict])
          –
          
            meta data list to be checked
          
        
        
          mode
              (str)
          –
          
            label data type
          
        
    


Returns:
    
        
              List[Dict]
          –
          
            List[Dict]: cleaned meta data list
          
        
    

            
              Source code in SaigeToolkit/data/dataset/srproj_reader.py
              256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306 def check_label(files: List[Dict], mode: str) -> List[Dict]:
    """check all data label is valid.
    If any data is corrupted, pop out from meta data list.

    Args:
        files (List[Dict]): meta data list to be checked
        mode (str): label data type

    Returns:
        List[Dict]: cleaned meta data list
    """
    for i in range(len(files) - 1, -1, -1):
        if mode == "Classification":
            if int(files[i]["ClassIndexOfLabel"]) == -1:
                files.pop(i)
        elif mode == "MultiLabelClassification":
            if not isinstance(files[i]["ClassIndexOfLabel"], list):
                files[i]["ClassIndexOfLabel"] = [files[i]["ClassIndexOfLabel"]]

        elif mode == "OpticalCharacterRecognition":
            if int(files[i]["LabelGroup"].get("NumberOfLabels", 0)) == 0:
                continue
            labels = (
                files[i]["LabelGroup"]["Label"]
                if isinstance(files[i]["LabelGroup"]["Label"], list)
                else [files[i]["LabelGroup"]["Label"]]
            )
            for idx in range(len(labels) - 1, -1, -1):
                # XXX: Temporary implementation for memory issue
                for key, value in labels[idx]["Coordinate"].items():
                    labels[idx]["Coordinate"][key] = float(value)

                if labels[idx]["Characters"] == '"value4"':
                    labels.pop(idx)
                elif not labels[idx]["Characters"]:
                    labels.pop(idx)
                else:
                    continue

                files[i]["LabelGroup"]["Label"] = labels
                files[i]["LabelGroup"]["NumberOfLabels"] = len(labels)

        else:
            if str(files[i]["LabelGroup"]["IsNormal"]) in [
                "False",
                "false",
                "FALSE",
            ]:
                if int(files[i]["LabelGroup"].get("NumberOfLabels", 0)) == 0:
                    files.pop(i)
    return files

            
    







            load_srproj_label



load_srproj_label(file: Dict, use_crop_fn: Optional[bool] = False, **kwargs) -> Dict


    

      load single data dict from srproj meta data.


Parameters:
    
        
          file
              (Dict)
          –
          
            single meta data dict
          
        
        
          use_crop_fn
              (bool, default:
                  False
)
          –
          
            Whether to use the crop function.
Defaults to False.
          
        
    


Raises:
    
        
              NotImplementedError
            –
          
            only four modes are available.
["Classification", "Detection", "Segmentation", "OpticalCharacterRecognition"]
          
        
    


Returns:
    
        
Dict (              Dict
)          –
          
            label data as dict
          
        
    

            
              Source code in SaigeToolkit/data/dataset/srproj_reader.py
              309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343 def load_srproj_label(file: Dict, use_crop_fn: Optional[bool] = False, **kwargs) -> Dict:
    """load single data dict from srproj meta data.

    Args:
        file (Dict): single meta data dict
        use_crop_fn (bool, optional): Whether to use the crop function.
            Defaults to False.

    Raises:
        NotImplementedError: only four modes are available.
            ["Classification", "Detection", "Segmentation", "OpticalCharacterRecognition"]

    Returns:
        Dict: label data as dict
    """
    mode = file["mode"]

    # make label for the right mode
    if mode == "Classification":
        label = load_label_cls(file, **kwargs)

    elif mode == "Detection":
        label = load_label_det(file, **kwargs)

    elif mode == "Segmentation":
        # In Segmentation task, need polygon data to use the crop function.
        label = load_label_seg(file, return_polygon=use_crop_fn, **kwargs)

    elif mode == "OpticalCharacterRecognition":
        label = load_label_ocr(file, **kwargs)

    else:
        raise NotImplementedError(f"Mode {mode} not implemented")

    return label

            
    







            load_label_cls



load_label_cls(file: Dict) -> Dict


    

            
              Source code in SaigeToolkit/data/dataset/srproj_reader.py
              346
347 def load_label_cls(file: Dict) -> Dict:
    return {"class": file["ClassIndexOfLabel"]}

            
    







            load_label_det



load_label_det(file: Dict) -> Dict


    

      load detection label


Parameters:
    
        
          file
              (Dict)
          –
          
            meta data for detection label
          
        
    


Returns:
    
        
Dict (              Dict
)          –
          
            detection label data dict
{
    "bboxes": [
        [x, y, w, h],
        ...,
    ],
    "labels": List[int],
}

          
        
    

            
              Source code in SaigeToolkit/data/dataset/srproj_reader.py
              350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383 def load_label_det(file: Dict) -> Dict:
    """load detection label

    Args:
        file (Dict): meta data for detection label

    Returns:
        Dict: detection label data dict
            ```python
            {
                "bboxes": [
                    [x, y, w, h],
                    ...,
                ],
                "labels": List[int],
            }
            ```
    """
    srproj_label_group = file["LabelGroup"]
    label = {"bboxes": [], "labels": []}

    if str(srproj_label_group["IsNormal"]).lower() == "false":
        srproj_labels = srproj_label_group["Label"]
        if not isinstance(srproj_labels, list):
            srproj_labels = [srproj_labels]
        for srproj_label in srproj_labels:
            x = int(srproj_label["Coordinate"]["@X"])
            y = int(srproj_label["Coordinate"]["@Y"])
            w = int(srproj_label["Coordinate"]["@Width"])
            h = int(srproj_label["Coordinate"]["@Height"])
            label["bboxes"].append([x, y, w, h])
            label["labels"].append(int(srproj_label["ClassIndex"]))

    return label

            
    







            load_label_seg



load_label_seg(file: Dict, return_polygon: bool = True, mask_to_pil: bool = False) -> Dict


    

      load segmentation label


Parameters:
    
        
          file
              (Dict)
          –
          
            meta data for segmentation label
          
        
        
          return_polygon
              (bool, default:
                  True
)
          –
          
            whether return polygon data. Defaults to True.
          
        
        
          mask_to_pil
              (bool, default:
                  False
)
          –
          
            whether return mask as PIL.Image. Defaults to False.
          
        
    


Returns:
    
        
Dict (              Dict
)          –
          
            segmentation label data dict
          
        
    

            
              Source code in SaigeToolkit/data/dataset/srproj_reader.py
              386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443 def load_label_seg(file: Dict, return_polygon: bool = True, mask_to_pil: bool = False) -> Dict:
    """load segmentation label

    Args:
        file (Dict): meta data for segmentation label
        return_polygon (bool, optional): whether return polygon data. Defaults to True.
        mask_to_pil (bool, optional): whether return mask as PIL.Image. Defaults to False.

    Returns:
        Dict: segmentation label data dict
    """
    w, h = file["image_size"]
    lbl = np.zeros((h, w), dtype=np.uint8)

    lbl_list = file["LabelGroup"]

    if str(lbl_list["IsNormal"]) in ["False", "false", "FALSE"]:
        lbl_list = lbl_list["Label"] if isinstance(lbl_list["Label"], list) else [lbl_list["Label"]]
        contour = []
        for l in lbl_list:
            canvas = np.zeros((h, w), dtype=np.uint8)
            color = l["ClassIndex"]

            contour_list = (
                l["ContourGroup"]["Contour"]
                if isinstance(l["ContourGroup"]["Contour"], list)
                else [l["ContourGroup"]["Contour"]]
            )

            # Contour functions in cv2 gets list type contours
            contours = {"Outer": [], "Inner": []}
            for c_l in contour_list:
                contours[c_l["@Type"]].append(
                    np.array([[int(p["@X"]), int(p["@Y"])] for p in c_l["Point"]])
                )

            # One Outer per One Label
            cv2.fillPoly(canvas, pts=contours["Outer"], color=color)

            # Many Inner could exist in One Label
            if contours["Inner"]:
                cv2.fillPoly(canvas, pts=contours["Inner"], color=0)

            nonzeros = canvas > 0
            lbl[nonzeros] = canvas[nonzeros]
            contour.append(contours["Outer"][0])
    else:
        contour = []

    if mask_to_pil:
        lbl = Image.fromarray(lbl)

    lbl = {"mask": lbl}

    if return_polygon:
        lbl.update({"polygons": contour})

    return lbl

            
    







            load_label_ocr



load_label_ocr(file: Dict) -> Dict


    

      load ocr label


Parameters:
    
        
          file
              (Dict)
          –
          
            meta data for ocr label
          
        
    


Returns:
    
        
Dict (              Dict
)          –
          
            ocr label data dict
          
        
    

            
              Source code in SaigeToolkit/data/dataset/srproj_reader.py
              446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498 def load_label_ocr(file: Dict) -> Dict:
    """load ocr label

    Args:
        file (Dict): meta data for ocr label

    Returns:
        Dict: ocr label data dict
    """
    lbl_list = file["LabelGroup"]

    if int(lbl_list.get("NumberOfLabels", 0)) == 0:
        return {"polygons": [], "strings": [], "ignore": []}

    pols, strs = [], []

    lbl_list = lbl_list["Label"] if isinstance(lbl_list["Label"], list) else [lbl_list["Label"]]
    for l in lbl_list:
        if not l["Characters"]:
            continue
        # if self.ignore_whitespace:
        #     l["Characters"] = l["Characters"].replace(" ", "")
        strs.append(l["Characters"])
        n_point = max(
            [
                int(key.replace("@Vertex", "").replace("X", "").replace("Y", ""))
                for key in l["Coordinate"].keys()
                if "@Vertex" in key
            ]
        )
        pols.append(
            np.array(
                [
                    [
                        float(l["Coordinate"][f"@Vertex{idx + 1}X"]),
                        float(l["Coordinate"][f"@Vertex{idx + 1}Y"]),
                    ]
                    for idx in range(n_point)
                ]
            )
        )

    strings, kie_labels = [], []
    for string in strs:
        string, kie_label = _refine_kie_labels(string)
        strings.append(string)
        kie_labels.append(kie_label)

    ignore = [s is None for s in strs]

    lbl = {"polygons": pols, "strings": strings, "kie_labels": kie_labels, "ignore": ignore}

    return lbl

            
    







            _refine_kie_labels



_refine_kie_labels(string)


    

            
              Source code in SaigeToolkit/data/dataset/srproj_reader.py
              501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521 def _refine_kie_labels(string):
    # split kie_label and string_label
    if string.startswith('"key'):
        index = string[1:].find('"') + 1

        kie_label = 2 * int(string[4:index]) + 1 if index > 4 else 0
        string = string[index + 1 :]

    elif string.startswith('"value'):
        index = string[1:].find('"') + 1

        kie_label = 2 * int(string[6:index]) + 2 if index > 6 else 0
        string = string[index + 1 :]

    else:
        kie_label = 0

    if kie_label < 0:
        kie_label = 0

    return string, kie_label

            
    







            merge_srproj_classes



merge_srproj_classes(classes1, classes2)


    

            
              Source code in SaigeToolkit/data/dataset/srproj_reader.py
              524
525
526
527
528
529
530
531
532
533
534 def merge_srproj_classes(classes1, classes2):
    if classes1 == classes2:
        return classes1

    if len(classes1) > len(classes2):
        classes1, classes2 = classes2, classes1

    if classes2[: len(classes1)] != classes1:
        raise RuntimeError("two srproj cannot be mixed")

    return classes2

            
    







            convert_srproj_class_color_to_rgb



convert_srproj_class_color_to_rgb(argb: int) -> Tuple[int, int, int]


    

      srproj의 각 클래스 색 코드를 rgb 값으로 변환합니다.

            
              Source code in SaigeToolkit/data/dataset/srproj_reader.py
              537
538
539
540
541
542
543 def convert_srproj_class_color_to_rgb(argb: int) -> Tuple[int, int, int]:
    """srproj의 각 클래스 색 코드를 rgb 값으로 변환합니다."""
    a = (argb >> 24) & 255
    r = (argb >> 16) & 255
    g = (argb >> 8) & 255
    b = argb & 255
    return (r, g, b)








            process_config




    



  












            srproj_split


  
      module-attribute
  


srproj_split = {'training': 'Training', 'validation': 'Validation'}


    
    









            process_data_config



process_data_config(cfg_data: dict) -> Tuple[dict, dict]


    

      split training/validation configs from entier data config dict.
you can edit cfg by split to override some configs in cfg_data
entire config example)
    data:
        code: A.srproj
        validation: <-
            code: B.srproj <- this will override base config {"code": "A.srproj"}


Parameters:
    
        
          cfg_data
              (dict)
          –
          
            entire config
          
        
    


Returns:
    
        
              Tuple[dict, dict]
          –
          
            Tuple[dict, dict]: training and validation configs
          
        
    

            
              Source code in SaigeToolkit/data/process_config.py
              12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51 def process_data_config(cfg_data: dict) -> Tuple[dict, dict]:
    """split training/validation configs from entier data config dict.
    you can edit cfg by split to override some configs in cfg_data
    entire config example)
        data:
            code: A.srproj
            validation: <-
                code: B.srproj <- this will override base config {"code": "A.srproj"}

    Args:
        cfg_data (dict): entire config

    Returns:
        Tuple[dict, dict]: training and validation configs
    """
    cfg_data_copy = cfg_data.copy()
    cfg_training = cfg_data_copy.pop("training", {})
    cfg_validation = cfg_data_copy.pop("validation", {})

    # update config for training
    if cfg_training != "NO_TRAINING":
        assert isinstance(
            cfg_training, dict
        ), f"config for training data should be Dict, not {type(cfg_training)}"

        cfg_training = override_dict(deepcopy(cfg_data_copy), cfg_training)  # TODO:
        if "split" not in cfg_training["dataset"]:
            cfg_training["dataset"].update({"split": srproj_split["training"]})

    # update config for validation
    if cfg_validation != "NO_VALIDATION":
        assert isinstance(
            cfg_validation, dict
        ), f"config for validation data should be Dict, not {type(cfg_validation)}"

        cfg_validation = override_dict(deepcopy(cfg_data_copy), cfg_validation)  # TODO:
        if "split" not in cfg_validation["dataset"]:
            cfg_validation["dataset"].update({"split": srproj_split["validation"]})

    return cfg_training, cfg_validation

            
    





  

    








            sampler




    

      Pytorch dataloader와 호환 가능한 커스텀 sampler 클래스를 제공합니다. 모든 구현은 torch.utils.data.Sampler 및 그 하위 구현의 인터페이스를 따릅니다.



  















            builder




    



  












            logger


  
      module-attribute
  


logger = getLogger('SaigeResearch')


    
    








            SAMPLER_IMPLEMENTATION


  
      module-attribute
  


SAMPLER_IMPLEMENTATION = {'InfiniteRandomSampler': InfiniteRandomSampler}


    
    









            build_sampler



build_sampler(_target_: Optional[str], data_source: Optional[Sized], **cfg_sampler: dict) -> Optional[Sampler]


    



Parameters:
    
        
          cfg_sampler
              (dict, default:
                  {}
)
          –
          
            config dict for building sampler
          
        
    


Returns:
    
        
              Optional[Sampler]
          –
          
            Optional[Sampler]: sampler object instance.
if cfg_sampler is None, return None
          
        
    



  Notes
  Follows the interface of torch.utils.data.Sampler.

            
              Source code in SaigeToolkit/data/sampler/builder.py
              15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33 def build_sampler(
    _target_: Optional[str], data_source: Optional[Sized], **cfg_sampler: dict
) -> Optional[Sampler]:
    """
    Args:
        cfg_sampler (dict): config dict for building sampler

    Returns:
        Optional[Sampler]: sampler object instance.
            if cfg_sampler is None, return None

    Notes:
        Follows the interface of torch.utils.data.Sampler.
    """
    if _target_ is None:
        return None
    sampler_class = get_sampler_class(_target_)
    logger.info(f"[{'SAMPLER'.center(9)}] {_target_} [params] {cfg_sampler}")
    return sampler_class(data_source=data_source, **cfg_sampler)

            
    







            get_sampler_class



get_sampler_class(cfg_sampler_name: str) -> Type[Sampler]


    

            
              Source code in SaigeToolkit/data/sampler/builder.py
              36
37
38
39
40
41
42
43
44
45 def get_sampler_class(cfg_sampler_name: str) -> Type[Sampler]:
    try:
        return SAMPLER_IMPLEMENTATION[cfg_sampler_name]
    except KeyError as e:
        raise RuntimeError(
            f"Sampler {cfg_sampler_name} not implemented. Supported sampler list: {SAMPLER_IMPLEMENTATION.keys()}"
        ) from e
    except Exception as e:
        logger.error(f"Error: {e}")
        raise e

            
    





  

    








            infinite_random_sampler




    



  













            InfiniteRandomSampler





    
            
              Bases: RandomSampler


      Infinitely samples elements randomly. If without replacement, then sample from a shuffled dataset.
If with replacement, then user can specify :attr:num_samples to draw.


Parameters:
    
        
          data_source
              (Dataset)
          –
          
            dataset to sample from
          
        
        
          replacement
              (bool)
          –
          
            samples are drawn on-demand with replacement if True, default=False
          
        
        
          num_samples
              (int)
          –
          
            number of samples to draw, default=len(dataset).
          
        
        
          generator
              (Generator)
          –
          
            Generator used in sampling.
          
        
    



  Assume that this DataLoader is used for training with shuffle=True.
  We use InfiniteRandomSampler to make the DataLoader to infinitely sample the dataset.
This prevents the "drop_last" and the "prefeching" problem across epochs.
Be careful that you should stop the training loop by counting the number of steps manually.
The DataLoader will never stop by itself.
      NOTE: Note that this sampler has infinite length and thus you should be careful when calculating the current epoch.
      We recommend you to use step//steps_per_epoch to calculate the current epoch.




  













            __iter__



__iter__() -> Iterator[int]


    

            
              Source code in SaigeToolkit/data/sampler/infinite_random_sampler.py
              26
27
28
29
30
31
32
33
34
35
36
37
38
39 def __iter__(self) -> Iterator[int]:
    n = len(self.data_source)
    if self.generator is None:
        seed = int(torch.empty((), dtype=torch.int64).random_().item())
        rng = torch.Generator()
        rng.manual_seed(seed)
    else:
        rng = self.generator

    while True:
        if self.replacement:
            yield from torch.randint(high=n, size=(32,), dtype=torch.int64, generator=rng).tolist()
        else:
            yield from torch.randperm(n, generator=rng).tolist()

            
    







            __len__



__len__() -> int


    

            
              Source code in SaigeToolkit/data/sampler/infinite_random_sampler.py
              41
42 def __len__(self) -> int:
    return 100_000_000_000_000

            
    





  

    






  

    




  

    








            transform




    

      End-to-end 데이터 변환을 지원하는 Transform 클래스를 제공하는 모듈입니다.
Transfrom 클래스는 다음과 같은 순서로 transform을 적용합니다.
1. load PIL Image
2. 원본 이미지가 inspection_size_wh를 넘지 않도록 resize 했을 때의 image scale 계산
3. ROI 적용 (crop)
@. roi_mask_first=True인 경우 ROI 적용 (blind mask)
4. 2번과 resize_factor를 하나로 묶어서 resize
@. roi_mask_first=False인 경우 ROI 적용 (blind mask)
5. data augmentation



  Note
  roi_mask_first 옵션에 따라서 ROI의 blind mask를 적용하는 시점이 달라집니다.
- roi_mask_first=True: ROI crop -> ROI mask -> resize
- roi_mask_first=False: ROI crop -> resize -> ROI mask
일반적으로 resize 후에 mask를 적용하는 것이 더 효율적입니다.



  















            augmentation




    

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



  















            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
              63
64
65
66
67
68
69
70
71
72 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
              74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89 @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
               91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111 @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
              140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168 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
              170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198 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
              200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240 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
              242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276 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
              278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334 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
              336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366 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
              368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398 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
              400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433 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
              435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465 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
              467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497 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
              499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529 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
              531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561 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
              563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602 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
              604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643 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
              645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724 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
              726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768 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
              770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834 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
              836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869 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
              871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981 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
              42
43 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
              46
47
48
49
50
51
52 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
               55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107 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
              110
111
112
113
114
115 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
              118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145 @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
              148
149
150
151 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
              154
155
156
157
158
159
160
161 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
              164
165
166
167
168
169 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
              172
173
174
175
176
177
178
179
180
181 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
              184
185
186
187
188
189
190
191
192 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
              195
196
197
198
199
200
201 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
              204
205
206
207
208
209
210
211
212
213 @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
              216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246 @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
              249
250
251
252
253
254
255
256
257
258
259
260 @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
              263
264
265
266
267
268
269
270 @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
              273
274
275
276
277
278
279 @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
              282
283
284
285
286
287
288 @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
              291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344 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
              347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372 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
              375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411 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
              414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450 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
              453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496 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
              499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552 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
              555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589 @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
              592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625 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
              628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697 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
              700
701
702
703
704
705
706
707
708
709
710
711 @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
              714
715
716
717
718
719
720 @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
                    14
15
16 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
              48
49 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
              51
52 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
              54
55 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
              57
58 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
              75
76
77
78
79
80 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
                    14
15
16 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
              84
85 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
              87
88 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
                    14
15
16 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
              92
93 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
              95
96 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
                    14
15
16 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
              100
101 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
              103
104 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
              106
107 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
              109
110 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
                    14
15
16 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
              114
115 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
              117
118 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
              120
121 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
              123
124 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
                    128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150 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
              152
153 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
              155
156
157
158
159
160
161
162
163 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
              165
166
167
168
169
170
171
172
173 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
              175
176
177
178
179
180
181
182 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
              184
185
186
187
188
189
190
191 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
                    195
196 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
              198
199 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
              201
202
203
204
205 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
              207
208
209
210
211 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
              213
214
215
216
217
218
219
220 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
              222
223
224
225
226
227
228
229 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
                    233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260 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
              262
263
264
265
266
267
268
269
270
271
272 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
              274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291 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
                    295
296
297
298
299
300
301
302
303 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
              305
306 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
              308
309 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
                    313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330 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
              332
333
334
335
336 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
              338
339
340
341 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
                    345
346
347
348
349
350
351
352
353 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
              355
356 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
              358
359 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
                    363
364
365
366
367
368
369
370
371 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
              373
374 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
              376
377 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
                    381
382
383
384
385
386
387
388
389 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
              391
392 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
              394
395 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
                    399
400
401
402
403
404
405
406
407 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
              409
410 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
              412
413 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
                    417
418
419
420
421
422
423
424
425 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
              427
428 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
              430
431 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
                    435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454 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
              456
457
458
459
460 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
              462
463
464
465
466
467
468
469
470 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
                    474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491 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
              493
494
495
496
497
498 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
              500
501
502
503
504
505
506
507
508
509
510 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
                    514
515
516
517
518
519
520
521
522
523
524
525
526 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
              528
529 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
              531
532
533
534
535
536 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
                    540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558 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
              560
561
562
563
564
565
566
567 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
              569
570
571
572
573 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
              575
576
577
578
579
580 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
                    584
585
586
587
588
589
590
591
592
593
594
595
596
597
598 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
              600
601
602
603
604
605
606
607
608
609
610
611
612 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
              614
615
616
617
618
619
620
621
622
623 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
              625
626
627 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
                    633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661 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
              663
664
665
666
667
668
669 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
              671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689 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
              691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709 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
              711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728 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
              730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747 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
                    751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771 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
              773
774
775
776
777
778
779 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
              781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797 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
              799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815 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
              817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832 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
              834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849 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
                    855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880 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
              882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900 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
              902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918 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
              920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936 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
              938
939 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
              941
942 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
                    955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984 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
              986
987
988
989
990
991
992
993 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
               995
 996
 997
 998
 999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015 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
              1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037 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
              1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058 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
              1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077 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
                    1081
1082
1083
1084
1085
1086
1087
1088
1089 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
              1091
1092
1093
1094
1095
1096
1097
1098 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
              1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112 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
                    1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128 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
              1130
1131
1132
1133
1134
1135
1136
1137 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
              1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155 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
              1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173 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
              1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192 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
              1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211 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
                    1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227 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
              1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253 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
              1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273 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
              1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304 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
                    1308
1309 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
              1311
1312 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
                    14
15
16 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
              18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33 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
              35
36 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
              42
43
44
45
46
47
48
49
50
51 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
              53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80 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
              86
87 def add_targets(self, additional_targets: Dict[str, str]) -> None:
    self._additional_targets = additional_targets

            
    





  

    






  

    








            builder




    



  












            _types


  
      module-attribute
  


_types = {None: {__name__: _nCiEfor _type in _types}, None: {pascal_to_snake(__name__): _WFj4for _type in _types}}


    
    








            logger


  
      module-attribute
  


logger = getLogger('SaigeResearch')


    
    









            Augmentation



Augmentation(transform)


    


                  
                    Source code in SaigeToolkit/data/transform/augmentation/builder.py
                    85
86
87
88 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
               90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109 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
              112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138 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
              141
142
143 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
                    14
15
16
17
18 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
              20
21
22
23
24
25
26
27 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
              29
30 def apply(self, **data) -> Dict:
    raise NotImplementedError

            
    







            __len__



__len__() -> int


    

            
              Source code in SaigeToolkit/data/transform/augmentation/compose/base_compose.py
              32
33 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
              35
36 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
              38
39
40 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__: _FLqTfor _type in _types}, None: {pascal_to_snake(__name__): _iky6for _type in _types}}


    
    









            build_compose



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


    

            
              Source code in SaigeToolkit/data/transform/augmentation/compose/builder.py
              23
24 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
                    14
15
16
17
18 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
               8
 9
10
11
12 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
                    16
17
18
19 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
              21
22
23
24
25
26
27
28
29
30 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

            
    





  

    






  

    




  

    




  

    








            box_function




    



  













            preserve_coordinates



preserve_coordinates(func)


    

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


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


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



            
              Source code in SaigeToolkit/data/transform/box_function.py
              12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59 def preserve_coordinates(func):
    """
    Box augmentation이 (left, top, right, bottom) coordinate system을 기반으로 구현 되어있기 때문에,
    input bboxes의 coordinate system을 확인하고 augmentation에 맞는 coordinate system으로 변환하고,
    augmentation이 끝나면 다시 기존 coordinate system으로 변경하여 출력합니다.

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

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

    """
    _FUNCTIONAL_BBOX_COORDINATE = "xyxy"

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

        return new_bboxes

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

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

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

        return new_bboxes

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

        return new_bboxes

    return wrapped_function

            
    







            resize_box



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


    

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

            
              Source code in SaigeToolkit/data/transform/box_function.py
              62
63
64
65
66
67
68
69
70
71
72 @preserve_coordinates
def resize_box(bboxes: BBoxesType, image_size: Tuple[int], tw: int, th: int) -> BBoxesType:
    """bbox resize from (w, h) to (tw, th)"""
    dtype = bboxes.dtype
    w, h = image_size
    if w == tw and h == th:
        return bboxes
    else:
        w_scale = tw / w
        h_scale = th / h
        return (bboxes * (w_scale, h_scale, w_scale, h_scale)).astype(dtype)

            
    







            crop_box



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


    

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

            
              Source code in SaigeToolkit/data/transform/box_function.py
              75
76
77
78
79
80
81
82
83
84 @preserve_coordinates
def crop_box(bboxes: BBoxesType, cropping_box: Union[np.ndarray, List[int]]) -> BBoxesType:
    """bbox crop. An image is cropped at (new_left, new_top, new_right, new_bottom)"""
    dtype = bboxes.dtype
    new_left, new_top, new_right, new_bottom = map(round, cropping_box)
    new_h = new_bottom - new_top
    new_bboxes = bboxes - (new_left, new_top, new_left, new_top)
    new_bboxes[:, [0, 1]] = np.maximum(new_bboxes[:, [0, 1]], 0)
    new_bboxes[:, [2, 3]] = np.minimum(new_bboxes[:, [2, 3]], (new_right - new_left, new_h))
    return new_bboxes.astype(dtype)

            
    







            hflip_box



hflip_box(bboxes: BBoxesType, image_size: Tuple[int]) -> BBoxesType


    

            
              Source code in SaigeToolkit/data/transform/box_function.py
              87
88
89
90
91
92 @preserve_coordinates
def hflip_box(bboxes: BBoxesType, image_size: Tuple[int]) -> BBoxesType:
    w, h = image_size
    bboxes = bboxes.copy()
    bboxes[:, [0, 2]] = w - bboxes[:, [2, 0]]
    return bboxes

            
    







            vflip_box



vflip_box(bboxes: BBoxesType, image_size: Tuple[int]) -> BBoxesType


    

            
              Source code in SaigeToolkit/data/transform/box_function.py
               95
 96
 97
 98
 99
100 @preserve_coordinates
def vflip_box(bboxes: BBoxesType, image_size: Tuple[int]) -> BBoxesType:
    w, h = image_size
    bboxes = bboxes.copy()
    bboxes[:, [1, 3]] = h - bboxes[:, [3, 1]]
    return bboxes

            
    







            rotate



rotate(bboxes: BBoxesType, angle: Union[float, int], image_size: Tuple[int], target_size: Optional[Tuple[int]] = None, clipping: bool = True) -> BBoxesType


    

            
              Source code in SaigeToolkit/data/transform/box_function.py
              103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145 @preserve_coordinates
def rotate(
    bboxes: BBoxesType,
    angle: Union[float, int],
    image_size: Tuple[int],
    target_size: Optional[Tuple[int]] = None,
    clipping: bool = True,
) -> BBoxesType:
    dtype = bboxes.dtype
    w, h = image_size

    def _bboxes_to_polygons(bboxes: BBoxesType) -> PolygonType:
        polygons = []
        for bbox in bboxes:
            x1, y1, x2, y2 = bbox
            polygon = np.array([[x1, y1], [x1, y2], [x2, y2], [x2, y1]]).astype(dtype)
            polygons.append(polygon)
        return polygons

    def _polygons_to_bboxes(polygons: PolygonType) -> BBoxesType:
        bboxes = []
        for polygon in polygons:
            # Extract the bounding box from the rotated polygon
            x1, y1 = np.min(polygon, axis=0)
            x2, y2 = np.max(polygon, axis=0)
            bboxes.append([x1, y1, x2, y2])

        bboxes = np.array(bboxes).reshape(-1, 4)
        return bboxes

    if bboxes.size == 0:
        return bboxes

    polygons = _bboxes_to_polygons(bboxes)
    rotated_polygons = rotate_polygons(
        polygons=polygons, angle=angle, image_size=image_size, target_size=target_size
    )
    rotated_bboxes = _polygons_to_bboxes(rotated_polygons)

    if clipping:
        rotated_bboxes[:, [0, 2]] = np.clip(rotated_bboxes[:, [0, 2]], 0, w - 1)
        rotated_bboxes[:, [1, 3]] = np.clip(rotated_bboxes[:, [1, 3]], 0, h - 1)
    return rotated_bboxes.astype(dtype)

            
    







            rotate90



rotate90(bboxes: BBoxesType, factor: int, image_size: Tuple[int], clipping: bool = True) -> BBoxesType


    

            
              Source code in SaigeToolkit/data/transform/box_function.py
              148
149
150
151
152
153
154
155
156
157
158
159
160
161
162 @preserve_coordinates
def rotate90(
    bboxes: BBoxesType,
    factor: int,
    image_size: Tuple[int],
    clipping: bool = True,
) -> BBoxesType:
    angle = factor * 90.0
    if factor % 2 == 0:
        target_size = image_size
    else:
        target_size = (image_size[1], image_size[0])
    return rotate(
        bboxes=bboxes, angle=angle, image_size=image_size, target_size=target_size, clipping=clipping
    )

            
    







            translate_box



translate_box(bboxes: BBoxesType, offset: Tuple[int], image_size: Tuple[int]) -> BBoxesType


    

            
              Source code in SaigeToolkit/data/transform/box_function.py
              165
166
167
168
169
170
171
172
173
174 @preserve_coordinates
def translate_box(bboxes: BBoxesType, offset: Tuple[int], image_size: Tuple[int]) -> BBoxesType:
    w, h = image_size
    x_offset, y_offset = offset
    new_bboxes = bboxes.copy()
    new_bboxes[:, 0] = np.maximum(np.minimum(bboxes[:, 0] - x_offset, w), 0)
    new_bboxes[:, 1] = np.maximum(np.minimum(bboxes[:, 1] - y_offset, h), 0)
    new_bboxes[:, 2] = np.minimum(np.maximum(bboxes[:, 2] - x_offset, 0), w)
    new_bboxes[:, 3] = np.minimum(np.maximum(bboxes[:, 3] - y_offset, 0), h)
    return new_bboxes

            
    







            ratio_jitter



ratio_jitter(bboxes: BBoxesType, image_size: Tuple[int], proportion_left: float = 0.0, proportion_right: float = 0.0, proportion_top: float = 0.0, proportion_bottom: float = 0.0) -> BBoxesType


    

            
              Source code in SaigeToolkit/data/transform/box_function.py
              177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217 @preserve_coordinates
def ratio_jitter(
    bboxes: BBoxesType,
    image_size: Tuple[int],
    proportion_left: float = 0.0,
    proportion_right: float = 0.0,
    proportion_top: float = 0.0,
    proportion_bottom: float = 0.0,
) -> BBoxesType:
    w, h = image_size

    left = int(w * proportion_left)
    right = int(w * proportion_right)
    top = int(h * proportion_top)
    bottom = int(h * 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 - crop_left - crop_right, 1)
    crop_h = max(h - crop_top - crop_bottom, 1)

    bboxes = crop_box(bboxes, [crop_left, crop_top, crop_left + crop_w, crop_top + crop_h])

    # 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

    bboxes = resize_box(bboxes, (crop_w + pad_left + pad_right, crop_h + pad_top + pad_bottom), w, h)

    # Translate
    w_scale = (crop_w + pad_left + pad_right) / w
    h_scale = (crop_h + pad_top + pad_bottom) / h
    bboxes = translate_box(bboxes, [-pad_left / w_scale, -pad_top / h_scale], image_size)

    return bboxes

            
    







            zoom



zoom(bboxes: BBoxesType, image_size: Tuple[int], ratio: float = 1.0, h_start: float = 0.0, w_start: float = 0.0) -> BBoxesType


    

            
              Source code in SaigeToolkit/data/transform/box_function.py
              220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244 @preserve_coordinates
def zoom(
    bboxes: BBoxesType,
    image_size: Tuple[int],
    ratio: float = 1.0,
    h_start: float = 0.0,
    w_start: float = 0.0,
) -> BBoxesType:
    w, h = image_size
    if ratio == 1.0:
        return bboxes
    target_size = (int(w * ratio), int(h * ratio))
    bboxes = resize_box(bboxes, image_size, target_size[0], target_size[1])
    if ratio > 1.0:
        h_start = min(h_start, 1.0 - 1e-5)
        w_start = min(w_start, 1.0 - 1e-5)
        x1 = int((target_size[0] - w + 1) * w_start)
        y1 = int((target_size[1] - h + 1) * h_start)
        bboxes = crop_box(bboxes, [x1, y1, x1 + w, y1 + h])
    elif ratio < 1.0:
        x1 = int((w - target_size[0] + 1) * w_start)
        y1 = int((h - target_size[1] + 1) * h_start)
        bboxes = translate_box(bboxes, [-x1, -y1], image_size)

    return bboxes

            
    







            random_resized_crop_and_pad



random_resized_crop_and_pad(bboxes: BBoxesType, image_size: Tuple[int], 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) -> BBoxesType


    

            
              Source code in SaigeToolkit/data/transform/box_function.py
              247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290 @preserve_coordinates
def random_resized_crop_and_pad(
    bboxes: BBoxesType,
    image_size: Tuple[int],
    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,
) -> BBoxesType:
    w_original, h_original = image_size
    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)))

    w_start = min(w_start, 1.0 - 1e-5)
    h_start = min(h_start, 1.0 - 1e-5)

    # Padding
    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)

    padded_image_size = [w_original + pad_left + pad_right, h_original + pad_top + pad_bottom]
    bboxes = translate_box(bboxes, [-pad_left, -pad_top], padded_image_size)

    # Crop
    x1 = int((padded_image_size[0] - crop_width + 1) * w_start)
    y1 = int((padded_image_size[1] - crop_height + 1) * h_start)
    bboxes = crop_box(bboxes, [x1, y1, x1 + crop_width, y1 + crop_height])

    # Resize
    bboxes = resize_box(
        bboxes,
        [crop_width, crop_height],
        width or w_original,
        height or h_original,
    )

    return bboxes

            
    







            perspective_transform



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


    

            
              Source code in SaigeToolkit/data/transform/box_function.py
              293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352 @preserve_coordinates
def perspective_transform(
    bboxes: BBoxesType,
    image_size: Tuple[int],
    offset_top_left: OffsetType,
    offset_top_right: OffsetType,
    offset_bottom_right: OffsetType,
    offset_bottom_left: OffsetType,
) -> BBoxesType:
    width, height = image_size

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

    new_bboxes = bboxes.copy()
    for idx_box, bbox in enumerate(bboxes):
        # [(x1, y1), (x2, y1), (x2, y2), (x1, y2)]
        points = [(bbox[0], bbox[1]), (bbox[2], bbox[1]), (bbox[2], bbox[3]), (bbox[0], bbox[3])]

        dtype_max_value = np.iinfo(np.int32).max
        min_x, min_y = dtype_max_value, dtype_max_value
        max_x, max_y = 0, 0

        for point in points:
            x, y, scaling_factor = np.dot(transform_matrix, np.append(point, 1))
            x = int(x / scaling_factor)
            y = int(y / scaling_factor)

            if x < min_x:
                min_x = x

            elif x > max_x:
                max_x = x

            if y < min_y:
                min_y = y

            elif y > max_y:
                max_y = y

        new_bboxes[idx_box] = [min_x, min_y, max_x, max_y]

    return new_bboxes

            
    





  

    








            function_util




    

      Define utility functions for data augmentation.



  













            check_value



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


    

            
              Source code in SaigeToolkit/data/transform/function_util.py
              13
14
15
16
17
18 def check_value(data: Union[int, float], min_value: Union[int, float], max_value: Union[int, float]):
    if not (isinstance(data, (int, float))):
        raise AugmentationParameterTypeError

    if not (min_value <= data <= max_value):
        raise AugmentationParameterRangeError

            
    







            check_range



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


    

            
              Source code in SaigeToolkit/data/transform/function_util.py
              21
22
23
24
25
26
27
28
29
30
31
32
33 def check_range(
    data: Union[Sequence[int], Sequence[float]],
    min_value: Union[int, float],
    max_value: Union[int, float],
):
    if not (isinstance(data, Sequence) and len(data) == 2):
        raise AugmentationParameterTypeError

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

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

            
    







            ratio_to_value



ratio_to_value(ratio: float, min_value: Union[int, float], max_value: Union[int, float])


    

            
              Source code in SaigeToolkit/data/transform/function_util.py
              36
37
38
39
40
41 def ratio_to_value(ratio: float, min_value: Union[int, float], max_value: Union[int, float]):
    check_value(ratio, 0.0, 1.0)

    min_value, max_value = min(min_value, max_value), max(min_value, max_value)

    return (ratio * (max_value - min_value)) + min_value

            
    







            support_gray



support_gray(function)


    

            
              Source code in SaigeToolkit/data/transform/function_util.py
              44
45
46
47
48
49
50
51
52
53
54
55
56
57
58 def support_gray(function):
    @wraps(function)
    def wrapper(image: ImageType, *args, **kwargs):
        is_gray = image.ndim == 2
        if is_gray:
            image = np.stack([image, image, image], axis=-1)

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

        if is_gray:
            image = image[:, :, 0]

        return image

    return wrapper

            
    







            support_rgba



support_rgba(function)


    

            
              Source code in SaigeToolkit/data/transform/function_util.py
              61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76 def support_rgba(function):
    @wraps(function)
    def wrapper(image: ImageType, *args, **kwargs):
        is_rgba = image.ndim == 3 and image.shape[2] == 4
        if is_rgba:
            mask = image[:, :, 3:4]
            image = image[:, :, :3]

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

        if is_rgba:
            image = np.concatenate([image, mask], axis=2)

        return image

    return wrapper

            
    







            support_3dim_gray_image



support_3dim_gray_image(function)


    

            
              Source code in SaigeToolkit/data/transform/function_util.py
              79
80
81
82
83
84
85
86
87
88
89
90
91
92 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]

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

        if is_3dim_gray:
            result = result[:, :, np.newaxis]
        return result

    return decorator

            
    







            support_multi_image



support_multi_image(function)


    

            
              Source code in SaigeToolkit/data/transform/function_util.py
               95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108 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]

        results = [function(image=image_i, *args, **kwargs) for image_i in image]

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

    return decorator

            
    





  

    








            image_function




    



  












            RESAMPLE_PIL


  
      module-attribute
  


RESAMPLE_PIL = {'nearest': NEAREST, 'bilinear': BILINEAR, 'bicubic': BICUBIC}


    
    








            RESAMPLE_CV2


  
      module-attribute
  


RESAMPLE_CV2 = {'nearest': INTER_NEAREST, 'bilinear': INTER_LINEAR, 'bicubic': INTER_CUBIC}


    
    








            RESAMPLE_TORCH


  
      module-attribute
  


RESAMPLE_TORCH = {'nearest': 'nearest-exact', 'bilinear': 'bilinear', 'bicubic': 'bicubic'}


    
    








            IMAGE_MODES


  
      module-attribute
  


IMAGE_MODES = ('RGB', 'L')


    
    









            read_image_size



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


    

      image size: (W, H)

            
              Source code in SaigeToolkit/data/transform/image_function.py
              11
12
13
14
15
16
17
18
19
20 def read_image_size(image: Union[Image.Image, torch.Tensor, np.ndarray]) -> ImageSizeType:
    """image size: (W, H)"""
    if isinstance(image, Image.Image):
        return image.size
    elif isinstance(image, torch.Tensor) and image.ndim in (2, 3, 4):  # HW, CHW, BCHW
        return (image.shape[-1], image.shape[-2])
    elif isinstance(image, np.ndarray) and image.ndim in (2, 3):  # HW, HWC
        return (image.shape[1], image.shape[0])
    else:
        raise NotImplementedError

            
    







            resize_image



resize_image(image: Union[Image, Tensor, ndarray], target_size: ImageSizeType, resampling: str = 'bilinear', use_cv2_for_numpy: bool = True) -> Union[Image, Tensor, ndarray]


    

      이미지를 resize합니다.


Parameters:
    
        
          image
              (Union[Image, Tensor, ndarray])
          –
          
            image data
          
        
        
          target_size
              (ImageSizeType)
          –
          
            [W, H]
          
        
        
          resampling
              (str, default:
                  'bilinear'
)
          –
          
            resampling method. Defaults to "bilinear".
          
        
        
          use_cv2_for_numpy
              (bool, default:
                  True
)
          –
          
            use cv2 instead of PIL for faster numpy array image resizing. Defaults to True.
          
        
    


Returns:
    
        
              Union[Image, Tensor, ndarray]
          –
          
            Union[Image.Image, torch.Tensor, np.ndarray]: resized image
          
        
    

            
              Source code in SaigeToolkit/data/transform/image_function.py
              44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88 def resize_image(
    image: Union[Image.Image, torch.Tensor, np.ndarray],
    target_size: ImageSizeType,
    resampling: str = "bilinear",
    use_cv2_for_numpy: bool = True,
) -> Union[Image.Image, torch.Tensor, np.ndarray]:
    """이미지를 resize합니다.

    Args:
        image (Union[Image.Image, torch.Tensor, np.ndarray]): image data
        target_size (ImageSizeType): [W, H]
        resampling (str): resampling method. Defaults to "bilinear".
        use_cv2_for_numpy (bool): use cv2 instead of PIL for faster numpy array image resizing. Defaults to True.

    Returns:
        Union[Image.Image, torch.Tensor, np.ndarray]: resized image
    """
    if isinstance(image, Image.Image):
        image = image.resize(target_size, RESAMPLE_PIL[resampling])
    elif isinstance(image, torch.Tensor):  # CHW, BCHW
        is_three_dim = image.ndim == 3
        if is_three_dim:  # CHW -> 1CHW
            image = image.unsqueeze(0)
        image = torch.nn.functional.interpolate(
            image,
            size=(target_size[1], target_size[0]),
            mode=RESAMPLE_TORCH[resampling],
            antialias=None if resampling == "nearest" else True,
        )
        if is_three_dim:
            image = image.squeeze(0)
    elif isinstance(image, np.ndarray):  # HWC, HW
        if use_cv2_for_numpy:
            # NOTE: cv2 resize is different from PIL/torch (inaccurate but fast)
            image = cv2.resize(image, dsize=target_size, interpolation=RESAMPLE_CV2[resampling])
        else:
            is_single_channel = image.ndim == 3 and image.shape[-1] == 1
            if is_single_channel:
                image = image[:, :, 0]
            image = Image.fromarray(image)
            image = image.resize(target_size, RESAMPLE_PIL[resampling])
            image = np.array(image)
            if is_single_channel:
                image = image[:, :, np.newaxis]
    return image

            
    







            resize_mask



resize_mask(mask: Union[Image, Tensor, ndarray], target_size: ImageSizeType) -> Union[Image, Tensor, ndarray]


    

      mask 이미지를 resize합니다. (NEAREST resampling)


Parameters:
    
        
          mask
              (Union[Image, Tensor, ndarray])
          –
          
            mask image
          
        
        
          target_size
              (ImageSizeType)
          –
          
            [W, H]
          
        
    


Returns:
    
        
              Union[Image, Tensor, ndarray]
          –
          
            Union[Image.Image, torch.Tensor, np.ndarray]: resized mask image
          
        
    

            
              Source code in SaigeToolkit/data/transform/image_function.py
               91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121 def resize_mask(
    mask: Union[Image.Image, torch.Tensor, np.ndarray],
    target_size: ImageSizeType,
) -> Union[Image.Image, torch.Tensor, np.ndarray]:
    """mask 이미지를 resize합니다. (NEAREST resampling)

    Args:
        mask (Union[Image.Image, torch.Tensor, np.ndarray]): mask image
        target_size (ImageSizeType): [W, H]

    Returns:
        Union[Image.Image, torch.Tensor, np.ndarray]: resized mask image
    """
    if isinstance(mask, Image.Image):
        mask = mask.resize(target_size, Image.Resampling.NEAREST)
    elif isinstance(mask, torch.Tensor):  # HW, BHW
        is_two_dim = mask.ndim == 2
        if is_two_dim:  # HW -> 1HW
            mask = mask.unsqueeze(0)
        mask = torch.nn.functional.interpolate(
            mask.unsqueeze(1),  # BHW -> B1HW
            size=(target_size[1], target_size[0]),
            mode="nearest-exact",
        ).squeeze(1)
        if is_two_dim:
            mask = mask.squeeze(0)
    elif isinstance(mask, np.ndarray):  # HW
        mask = Image.fromarray(mask)
        mask = mask.resize(target_size, Image.Resampling.NEAREST)
        mask = np.array(mask)
    return mask

            
    







            resize_array



resize_array(array: Union[Tensor, ndarray], target_size: ImageSizeType, resampling: str = 'nearest') -> Union[Tensor, ndarray]


    

      [HW, BHW]의 array를 resize합니다.


Parameters:
    
        
          array
              (Union[Tensor, ndarray])
          –
          
            array data [HW, BHW]
          
        
        
          target_size
              (ImageSizeType)
          –
          
            [W, H]
          
        
        
          resampling
              (str, default:
                  'nearest'
)
          –
          
            resampling method. Defaults to "nearest".
          
        
    


Returns:
    
        
              Union[Tensor, ndarray]
          –
          
            Union[torch.Tensor, np.ndarray]: resized array
          
        
    

            
              Source code in SaigeToolkit/data/transform/image_function.py
              124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160 def resize_array(
    array: Union[torch.Tensor, np.ndarray],
    target_size: ImageSizeType,
    resampling: str = "nearest",
) -> Union[torch.Tensor, np.ndarray]:
    """[HW, BHW]의 array를 resize합니다.

    Args:
        array (Union[torch.Tensor, np.ndarray]): array data [HW, BHW]
        target_size (ImageSizeType): [W, H]
        resampling (str, optional): resampling method. Defaults to "nearest".

    Returns:
        Union[torch.Tensor, np.ndarray]: resized array
    """
    is_np_array = isinstance(array, np.ndarray)
    if is_np_array:  # np.ndarray -> torch.Tensor
        array = torch.tensor(array)

    is_two_dim = array.ndim == 2
    if is_two_dim:  # HW -> 1HW
        array = array.unsqueeze(0)

    array = torch.nn.functional.interpolate(
        array.unsqueeze(1),  # BHW -> B1HW
        size=(target_size[1], target_size[0]),
        mode=RESAMPLE_TORCH[resampling],
        antialias=None if resampling == "nearest" else True,
    ).squeeze(1)

    if is_two_dim:  # 1HW -> HW
        array = array.squeeze(0)

    if is_np_array:  # torch.Tensor -> np.ndarray
        array = array.numpy()

    return array

            
    







            crop



crop(image: Union[Image, Tensor, ndarray], coordinates: Union[List[int], Tuple[int, int, int, int]]) -> Union[Image, Tensor, ndarray]


    

      이미지의 coordinates 좌표영역을 크롭합니다. coordinates가 이미지를 벗어나는 경우 zero padding 합니다.


Parameters:
    
        
          image
              (Union[Image, Tensor, ndarray])
          –
          
            image
          
        
        
          coordinates
              (Union[List[int], Tuple[int, int, int, int]])
          –
          
            [left, top, right, bottom]
          
        
    


Returns:
    
        
              Union[Image, Tensor, ndarray]
          –
          
            Union[Image.Image, torch.Tensor, np.ndarray]: cropped image
          
        
    

            
              Source code in SaigeToolkit/data/transform/image_function.py
              163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195 def crop(
    image: Union[Image.Image, torch.Tensor, np.ndarray],
    coordinates: Union[List[int], Tuple[int, int, int, int]],
) -> Union[Image.Image, torch.Tensor, np.ndarray]:
    """이미지의 coordinates 좌표영역을 크롭합니다. coordinates가 이미지를 벗어나는 경우 zero padding 합니다.

    Args:
        image (Union[Image.Image, torch.Tensor, np.ndarray]): image
        coordinates (Union[List[int], Tuple[int, int, int, int]]): [left, top, right, bottom]

    Returns:
        Union[Image.Image, torch.Tensor, np.ndarray]: cropped image
    """
    if isinstance(image, Image.Image):
        return image.crop(coordinates)
    else:
        left, top, right, bottom = coordinates
        image_w, image_h = read_image_size(image)
        cropped_shape = (bottom - top, right - left)
        if image.ndim == 3:
            cropped_shape = (*cropped_shape, image.shape[2])
        if isinstance(image, torch.Tensor):
            cropped_image = torch.zeros(*cropped_shape, dtype=image.dtype, device=image.device)
        else:
            cropped_image = np.zeros(cropped_shape, dtype=image.dtype)
        cropped_image[
            np.clip(0, top, bottom) - top : np.clip(image_h, top, bottom) - top,
            np.clip(0, left, right) - left : np.clip(image_w, left, right) - left,
        ] = image[
            np.clip(top, 0, image_h) : np.clip(bottom, 0, image_h),
            np.clip(left, 0, image_w) : np.clip(right, 0, image_w),
        ]
        return cropped_image

            
    







            add_constant_margin



add_constant_margin(image: Union[Image, Tensor, ndarray], left: int, top: int, right: int, bottom: int, value: Union[float, int]) -> Union[Image, Tensor, ndarray]


    

      image에 left, top, right, bottom 만큼 constant value로 padding 합니다.


Parameters:
    
        
          image
              (Union[Image, Tensor, ndarray])
          –
          
            image
          
        
        
          left
              (int)
          –
          
            image의 왼쪽 padding size 입니다.
          
        
        
          top
              (int)
          –
          
            image의 위쪽 padding size 입니다.
          
        
        
          right
              (int)
          –
          
            image의 오른쪽 padding size 입니다.
          
        
        
          bottom
              (int)
          –
          
            image의 아래쪽 padding size 입니다.
          
        
        
          value
              (Union[float, int])
          –
          
            padding된 영역에 들어갈 value 입니다.
          
        
    

            
              Source code in SaigeToolkit/data/transform/image_function.py
              198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239 def add_constant_margin(
    image: Union[Image.Image, torch.Tensor, np.ndarray],
    left: int,
    top: int,
    right: int,
    bottom: int,
    value: Union[float, int],
) -> Union[Image.Image, torch.Tensor, np.ndarray]:
    """image에 left, top, right, bottom 만큼 constant value로 padding 합니다.

    Args:
        image (Union[Image.Image, torch.Tensor, np.ndarray]): image
        left (int): image의 왼쪽 padding size 입니다.
        top (int): image의 위쪽 padding size 입니다.
        right (int): image의 오른쪽 padding size 입니다.
        bottom (int): image의 아래쪽 padding size 입니다.
        value (Union[float, int]): padding된 영역에 들어갈 value 입니다.
    """
    width, height = read_image_size(image)
    new_width = width + left + right
    new_height = height + top + bottom
    if isinstance(image, Image.Image):
        if image.mode == "RGB":
            value = [int(value)] * 3
        elif image.mode == "L":
            value = [int(value)]
        else:
            raise NotImplementedError
        result = Image.new(image.mode, (new_width, new_height), tuple(value))
        result.paste(image, (left, top))
    elif isinstance(image, np.ndarray):
        result = np.ones((new_height, new_width) + image.shape[2:]) * value
        result = result.astype(image.dtype)
        result[top : top + height, left : left + width] = image
    elif isinstance(image, torch.Tensor):
        result = torch.ones(image.shape[:-2] + (new_height, new_width), device=image.device) * value
        result = result.to(image.dtype)
        result[..., top : top + height, left : left + width] = image
    else:
        raise NotImplementedError

    return result

            
    







            add_constant_margin_array



add_constant_margin_array(array: Union[Tensor, ndarray], left: int, top: int, right: int, bottom: int, value: Union[float, int]) -> Union[Tensor, ndarray]


    

      array에 left, top, right, bottom 만큼 constant value로 padding 합니다.


Parameters:
    
        
          array
              (Union[Tensor, ndarray])
          –
          
            array data [HW, BHW]
          
        
        
          left
              (int)
          –
          
            array의 왼쪽 padding size 입니다.
          
        
        
          top
              (int)
          –
          
            array의 위쪽 padding size 입니다.
          
        
        
          right
              (int)
          –
          
            array의 오른쪽 padding size 입니다.
          
        
        
          bottom
              (int)
          –
          
            array의 아래쪽 padding size 입니다.
          
        
        
          value
              (Union[float, int])
          –
          
            padding된 영역에 들어갈 value 입니다.
          
        
    

            
              Source code in SaigeToolkit/data/transform/image_function.py
              242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271 def add_constant_margin_array(
    array: Union[torch.Tensor, np.ndarray],
    left: int,
    top: int,
    right: int,
    bottom: int,
    value: Union[float, int],
) -> Union[torch.Tensor, np.ndarray]:
    """array에 left, top, right, bottom 만큼 constant value로 padding 합니다.

    Args:
        array (Union[torch.Tensor, np.ndarray]): array data [HW, BHW]
        left (int): array의 왼쪽 padding size 입니다.
        top (int): array의 위쪽 padding size 입니다.
        right (int): array의 오른쪽 padding size 입니다.
        bottom (int): array의 아래쪽 padding size 입니다.
        value (Union[float, int]): padding된 영역에 들어갈 value 입니다.
    """
    if isinstance(array, np.ndarray):
        is_ndarray = True
        array = torch.from_numpy(array)
    else:
        is_ndarray = False

    result = torch.nn.functional.pad(array, (left, right, top, bottom), value=value)

    if is_ndarray:
        result = result.numpy(force=True)

    return result

            
    







            fill_pixels_with_mask



fill_pixels_with_mask(image: Union[Image, ndarray], bool_mask: ndarray, value: Union[int, float] = 0) -> Union[Image, ndarray]


    

      image 중 bool_mask=True인 픽셀들을 value로 채웁니다.


Parameters:
    
        
          image
              (Union[Image, ndarray])
          –
          
            image (HW or HWC)
          
        
        
          bool_mask
              (ndarray)
          –
          
            boolean mask (HW)
          
        
        
          value
              (Union[int, float], default:
                  0
)
          –
          
            . Defaults to 0.
          
        
    


Returns:
    
        
              Union[Image, ndarray]
          –
          
            Union[Image.Image, np.ndarray]: 결과 이미지
          
        
    



  Note
  
image가 Image.Image인 경우, 결과 이미지도 Image.Image로 반환합니다.
image의 값이 inplace로 변경됩니다. 값이 변경되지 않길 원한다면, copy를 해주세요.


            
              Source code in SaigeToolkit/data/transform/image_function.py
              274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306 def fill_pixels_with_mask(
    image: Union[Image.Image, np.ndarray],
    bool_mask: np.ndarray,
    value: Union[int, float] = 0,
) -> Union[Image.Image, np.ndarray]:
    """image 중 bool_mask=True인 픽셀들을 value로 채웁니다.

    Args:
        image (Union[Image.Image, np.ndarray]): image (HW or HWC)
        bool_mask (np.ndarray): boolean mask (HW)
        value (Union[int, float], optional): . Defaults to 0.

    Returns:
        Union[Image.Image, np.ndarray]: 결과 이미지

    Note:
        - image가 Image.Image인 경우, 결과 이미지도 Image.Image로 반환합니다.
        - image의 값이 inplace로 변경됩니다. 값이 변경되지 않길 원한다면, copy를 해주세요.
    """
    is_pil = isinstance(image, Image.Image)
    image = np.asarray(image)

    assert image.ndim in [2, 3] and image.shape[:2] == bool_mask.shape  # HW or HWC

    if image.ndim > bool_mask.ndim:  # max ndim difference is 1
        bool_mask = np.expand_dims(bool_mask, axis=-1)

    image = np.where(bool_mask, value, image)

    if is_pil:
        image = Image.fromarray(image)

    return image

            
    







            to_numpy



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


    

            
              Source code in SaigeToolkit/data/transform/image_function.py
              309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332 def to_numpy(image: Union[Image.Image, torch.Tensor, np.ndarray], copy: bool = False) -> np.ndarray:
    if isinstance(image, Image.Image):
        image = np.array(image)  # Image.Image -> np.ndarray
    elif isinstance(image, torch.Tensor):
        assert image.ndim in [3, 4]  # BCHW / CHW

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

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

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

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

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

            
    







            to_pil



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


    

            
              Source code in SaigeToolkit/data/transform/image_function.py
              335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352 def to_pil(image: Union[Image.Image, torch.Tensor, np.ndarray], copy: bool = False) -> Image.Image:
    if isinstance(image, Image.Image):
        if copy:
            image = image.copy()
    elif isinstance(image, torch.Tensor):
        image = to_numpy(image)  # torch.Tensor -> np.ndarray
        image = Image.fromarray(image)  # np.ndarray -> Image.Image
    elif isinstance(image, np.ndarray):
        assert image.ndim in [2, 3]  # HW / HWC

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

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

    return image

            
    







            convert_image_mode



convert_image_mode(image: Union[Image, ndarray], mode: str, copy: bool = False) -> Union[Image, ndarray]


    

      convert image mode


Parameters:
    
        
          image
              (Union[Image, ndarray])
          –
          
            image
          
        
        
          mode
              (str)
          –
          
            "RGB" or "L"
          
        
        
          copy
              (bool, default:
                  False
)
          –
          
            to copy data. Defaults to False.
          
        
    


Returns:
    
        
              Union[Image, ndarray]
          –
          
            Union[Image.Image, np.ndarray]: converted image
          
        
    



  Note
  RGB -> L 변환 시 Image.Image와 np.ndarray 연산 결과가 다를 수 있음.
(PIL과 cv2 에서 변환식은 L = R * 299/1000 + G * 587/1000 + B * 114/1000 로 동일하나 소숫점 처리 방식이 다름)

            
              Source code in SaigeToolkit/data/transform/image_function.py
              358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409 def convert_image_mode(
    image: Union[Image.Image, np.ndarray], mode: str, copy: bool = False
) -> Union[Image.Image, np.ndarray]:
    """convert image mode

    Args:
        image (Union[Image.Image, np.ndarray]): image
        mode (str): "RGB" or "L"
        copy (bool, optional): to copy data. Defaults to False.

    Returns:
        Union[Image.Image, np.ndarray]: converted image

    Note:
        RGB -> L 변환 시 Image.Image와 np.ndarray 연산 결과가 다를 수 있음.
        (PIL과 cv2 에서 변환식은 L = R * 299/1000 + G * 587/1000 + B * 114/1000 로 동일하나 소숫점 처리 방식이 다름)
    """
    if mode not in IMAGE_MODES:
        raise NotImplementedError

    if isinstance(image, Image.Image):
        if image.mode != mode:
            image = image.convert(mode)
        elif copy:
            image = image.copy()
    elif isinstance(image, np.ndarray):
        # check original mode & regularize (RGB: HW3 / L: HW)
        if image.ndim == 3:
            if image.shape[2] == 3:
                original_mode = "RGB"
            elif image.shape[2] == 1:
                original_mode = "L"
                image = image[:, :, 0]  # HW1 -> HW (no copy)
            elif image.shape[2] == 4:
                original_mode = "RGB"
                image = image[:, :, :3]  # RGBA -> RGB (no copy)
            else:
                raise NotImplementedError
        elif image.ndim == 2:
            original_mode = "L"
        else:
            raise NotImplementedError
        # convert
        if original_mode == "RGB" and mode == "L":
            image = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
        elif original_mode == "L" and mode == "RGB":
            image = cv2.cvtColor(image, cv2.COLOR_GRAY2RGB)
        elif copy:
            image = image.copy()
    else:
        raise NotImplementedError
    return image

            
    





  

    








            image_load




    



  













            ImageLoader



ImageLoader(image_mode: Union[str, List[str]] = 'RGB', to_numpy: bool = True)


    


      여러 형태의 데이터를 입력으로 받아, 전처리 과정을 거쳐 PIL Image 혹은 np.ndarray 로 return 합니다.
현재 지원하는 데이터는 다음과 같습니다.
- 데이터 타입: [image path, np.ndarray, PIL Image]
- color: ["RGB", "Gray"]
- bit: [8, 16]
입력으로 받은 데이터에 따른 출력값은 다음과 같습니다.
        | image path | np.ndarray |     PIL    |
 RGB; 8 | PIL(RGB;8) | PIL(RGB;8) | PIL(RGB;8) |
 RGB;16 | PIL(RGB;8) | PIL(RGB;8) |     -      |
Gray; 8 |  PIL(L;8)  |  PIL(L;8)  |  PIL(L;8)  |
Gray;16 |  PIL(L;8)  |  PIL(L;8)  |  PIL(L;8)  |



  Note1
  PIL은 RGB;16을 지원하지 않습니다. 따라서 PIL(RGB;16)은 입력으로 들어올 수 없습니다.



  Note2
  PIL은 "I;16" 모드로 Gray;16을 지원하지만, PIL 내부의 convert 함수를 써서 Gray;8로 변환시
 값이 overflow 나는 issue가 있습니다.



  Note3
  이미지는 기본적으로 np.ndarray로 로드되며, PIL.Image.Image로 로드하려면 to_numpy=False를 세팅하세요.



  Note4
  image_mode는 "RGB", "L" 중 하나를 지원하며, multipage (이미지 리스트) 인 경우 각 페이지의 모드를 리스트로 입력하세요.
예시: 1, 3번째 페이지는 RGB 이고 2번째 페이지는 L 인 경우 image_mode = ["RGB", "L", "RGB"]

                  
                    Source code in SaigeToolkit/data/transform/image_load.py
                    41
42
43
44
45
46
47 def __init__(self, image_mode: Union[str, List[str]] = "RGB", to_numpy: bool = True) -> None:
    if isinstance(image_mode, str):
        image_mode = [image_mode]
    elif not set(image_mode).issubset(set(IMAGE_MODES)):
        raise ValueError
    self.image_mode = image_mode
    self.to_numpy = to_numpy

                  



  












            image_mode


  
      instance-attribute
  


image_mode = image_mode


    
    








            to_numpy


  
      instance-attribute
  


to_numpy = to_numpy


    
    









            __call__



__call__(image: Union[Image, ndarray, str, List], **data) -> Dict


    

            
              Source code in SaigeToolkit/data/transform/image_load.py
              49
50 def __call__(self, image: Union[Image.Image, np.ndarray, str, List], **data) -> Dict:
    return self.call_method(image=image, **data)

            
    







            call_method



call_method(image: Union[Image, ndarray, str, List], **data) -> Dict


    

      make [PIL Image or np.ndarray] from PIL.Image, np.ndarray, or path string


Parameters:
    
        
          image
              (Union[Image, ndarray, str, List])
          –
          
            PIL.Image, array, path string or list of it.
          
        
    


Returns:
    
        
Dict (              Dict
)          –
          
            {
    "image": Union[PIL.Image.Image, np.ndarray, List[PIL.Image.Image], List[np.ndarray]],
    **input_dict,
}
          
        
    

            
              Source code in SaigeToolkit/data/transform/image_load.py
              52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88 def call_method(self, image: Union[Image.Image, np.ndarray, str, List], **data) -> Dict:
    """make [PIL Image or np.ndarray] from PIL.Image, np.ndarray, or path string

    Args:
        image (Union[Image.Image, np.ndarray, str, List]): PIL.Image, array, path string or list of it.

    Returns:
        Dict:
            {
                "image": Union[PIL.Image.Image, np.ndarray, List[PIL.Image.Image], List[np.ndarray]],
                **input_dict,
            }
    """
    multipage = isinstance(image, List)
    if not multipage:
        image = [image]

    if len(image) != len(self.image_mode):
        raise ValueError("number of images should match len(image_mode)")

    # 이미지들을 각자의 모드로 로드 (RGB 또는 L).
    loaded_images = []
    for image_i, image_mode_i in zip(image, self.image_mode):
        image_i = self.load(image_i)
        image_i = convert_image_mode(image=image_i, mode=image_mode_i, copy=False)
        loaded_images.append(image_i)

    if multipage:
        # multipage 이미지들의 사이즈가 모두 동일해야함.
        image_sizes = set(read_image_size(item) for item in loaded_images)
        if len(image_sizes) > 1:
            raise ValueError("sizef of images in multipage should be identical")
    else:
        loaded_images = loaded_images[0]

    data["image"] = loaded_images
    return data

            
    







            load



load(image: Union[Image, ndarray, str]) -> Union[Image, ndarray]


    

            
              Source code in SaigeToolkit/data/transform/image_load.py
              90
91
92
93
94
95
96
97 def load(self, image: Union[Image.Image, np.ndarray, str]) -> Union[Image.Image, np.ndarray]:
    if isinstance(image, Image.Image):
        image = self.load_from_pil(image)
    elif isinstance(image, np.ndarray):
        image = self.load_from_array(image)
    elif isinstance(image, str):
        image = self.load_from_path(image)
    return image

            
    







            load_from_path



load_from_path(path: str) -> Union[Image, ndarray]


    

      Loading function using PIL.Image library.
This function is introduced because {exif_transpose} must be processed.
{exif_transpose} fix rotated image binary data using {EXIF} information.
Without {exif_transpose}, network would accidently learn randomly rotated image data.


Parameters:
    
        
          path
              (str)
          –
          
            path to image file
          
        
    


Returns:
    
        
              Union[Image, ndarray]
          –
          
            Union[Image.Image, np.ndarray]: image
          
        
    

            
              Source code in SaigeToolkit/data/transform/image_load.py
               99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121 def load_from_path(self, path: str) -> Union[Image.Image, np.ndarray]:
    """Loading function using PIL.Image library.
    This function is introduced because {exif_transpose} must be processed.
    {exif_transpose} fix rotated image binary data using {EXIF} information.
    Without {exif_transpose}, network would accidently learn randomly rotated image data.

    Args:
        path (str): path to image file

    Returns:
        Union[Image.Image, np.ndarray]: image
    """
    with open(path, "rb") as f:
        image = Image.open(f)
        image = ImageOps.exif_transpose(image)

    if self.to_numpy:
        image = np.array(image, dtype=np.uint16 if self._is_16bit(image) else np.uint8)

    if self._is_16bit(image):
        image = self._convert_16_to_8(image)

    return image

            
    







            load_from_array



load_from_array(array: ndarray) -> Union[Image, ndarray]


    

            
              Source code in SaigeToolkit/data/transform/image_load.py
              123
124
125
126
127
128
129
130
131
132
133
134
135 def load_from_array(self, array: np.ndarray) -> Union[Image.Image, np.ndarray]:
    if array.ndim == 3 and array.shape[-1] == 1:  # grayscale shape HW1 -> HW
        array = np.squeeze(array, axis=2)

    if self._is_16bit(array):
        array = self._convert_16_to_8(array)

    if self.to_numpy:
        out = array
    else:
        out = Image.fromarray(array)

    return out

            
    







            load_from_pil



load_from_pil(image: Image) -> Union[Image, ndarray]


    

            
              Source code in SaigeToolkit/data/transform/image_load.py
              137
138
139
140
141
142
143
144 def load_from_pil(self, image: Image.Image) -> Union[Image.Image, np.ndarray]:
    if self.to_numpy:
        image = np.array(image, dtype=np.uint16 if self._is_16bit(image) else np.uint8)

    if self._is_16bit(image):
        image = self._convert_16_to_8(image)

    return image

            
    







            _convert_16_to_8


  
      staticmethod
  


_convert_16_to_8(image: Union[Image, ndarray]) -> Union[Image, ndarray]


    

      이미지 픽셀당 비트수를 16에서 8로 변화합니다.
입출력 데이터 타입이 같습니다. (pil로 받으면 pil을 ndarray로 받을 시 ndarray를 출력합니다.)

            
              Source code in SaigeToolkit/data/transform/image_load.py
              146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167 @staticmethod
def _convert_16_to_8(image: Union[Image.Image, np.ndarray]) -> Union[Image.Image, np.ndarray]:
    """
    이미지 픽셀당 비트수를 16에서 8로 변화합니다.
    입출력 데이터 타입이 같습니다. (pil로 받으면 pil을 ndarray로 받을 시 ndarray를 출력합니다.)
    """

    def _convert_16_to_8_np(array: np.ndarray) -> np.ndarray:
        return (array >> 8).astype(np.uint8)

    if isinstance(image, Image.Image):
        assert "I" in image.mode
        array_16bit = np.array(image, dtype=np.uint16)
        array_8bit = _convert_16_to_8_np(array_16bit)
        ret_image = Image.fromarray(array_8bit)
    elif isinstance(image, np.ndarray):
        assert image.dtype == np.uint16
        ret_image = _convert_16_to_8_np(image)
    else:
        raise NotImplementedError

    return ret_image

            
    







            _is_16bit


  
      staticmethod
  


_is_16bit(image: Union[Image, ndarray]) -> bool


    

            
              Source code in SaigeToolkit/data/transform/image_load.py
              169
170
171
172
173
174
175 @staticmethod
def _is_16bit(image: Union[Image.Image, np.ndarray]) -> bool:
    if isinstance(image, Image.Image) and "I" in image.mode:
        return True
    elif isinstance(image, np.ndarray) and image.dtype == np.uint16:
        return True
    return False

            
    





  

    






  

    








            polygon_function




    



  













            vertical_flip



vertical_flip(polygons: PolygonType, image_size: Tuple[int]) -> PolygonType


    

            
              Source code in SaigeToolkit/data/transform/polygon_function.py
              11
12
13
14
15
16 def vertical_flip(polygons: PolygonType, image_size: Tuple[int]) -> PolygonType:
    _, h = image_size
    polygons = deepcopy(polygons)
    for polygon in polygons:
        polygon[:, 1] = h - polygon[:, 1]
    return polygons

            
    







            horizontal_flip



horizontal_flip(polygons: PolygonType, image_size: Tuple[int]) -> PolygonType


    

            
              Source code in SaigeToolkit/data/transform/polygon_function.py
              19
20
21
22
23
24 def horizontal_flip(polygons: PolygonType, image_size: Tuple[int]) -> PolygonType:
    w, _ = image_size
    polygons = deepcopy(polygons)
    for polygon in polygons:
        polygon[:, 0] = w - polygon[:, 0]
    return polygons

            
    







            rotate



rotate(polygons: PolygonType, angle: float, image_size: Tuple[int], target_size: Optional[Tuple[int]] = None) -> PolygonType


    

            
              Source code in SaigeToolkit/data/transform/polygon_function.py
              27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62 def rotate(
    polygons: PolygonType,
    angle: float,
    image_size: Tuple[int],
    target_size: Optional[Tuple[int]] = None,
) -> PolygonType:
    if len(polygons) == 0:
        return polygons

    dtype = polygons[0].dtype
    w, h = image_size

    anchor_origin = np.array([w // 2, h // 2]).astype(dtype)

    if target_size is None:
        anchor_target = anchor_origin
    else:
        anchor_target = np.array([target_size[0] // 2, target_size[1] // 2]).astype(dtype)

    theta = np.deg2rad(angle)
    rotation_matrix = [[np.cos(theta), -np.sin(theta)], [np.sin(theta), np.cos(theta)]]

    rotated_polygons = []
    for polygon in polygons:
        # Translate polygon so that the rotation point is at the origin
        rotated_polygon = polygon - anchor_origin

        # Rotate the polygon
        rotated_polygon = np.dot(rotated_polygon, rotation_matrix)

        # Translate the polygon back
        rotated_polygon += anchor_target

        rotated_polygons.append(rotated_polygon)

    return rotated_polygons

            
    







            rotate90



rotate90(polygons: PolygonType, factor: int, image_size: Tuple[int]) -> PolygonType


    

            
              Source code in SaigeToolkit/data/transform/polygon_function.py
              65
66
67
68
69
70
71
72
73
74
75 def rotate90(
    polygons: PolygonType,
    factor: int,
    image_size: Tuple[int],
) -> PolygonType:
    angle = factor * 90.0
    if factor % 2 == 0:
        target_size = image_size
    else:
        target_size = (image_size[1], image_size[0])
    return rotate(polygons=polygons, angle=angle, image_size=image_size, target_size=target_size)

            
    







            ratio_jitter



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


    

            
              Source code in SaigeToolkit/data/transform/polygon_function.py
               78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118 def ratio_jitter(
    polygons: PolygonType,
    image_size: Tuple[int],
    proportion_left: float,
    proportion_right: float,
    proportion_top: float,
    proportion_bottom: float,
) -> PolygonType:
    w, h = image_size

    left = int(w * proportion_left)
    right = int(w * proportion_right)
    top = int(h * proportion_top)
    bottom = int(h * 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 - crop_left - crop_right, 1)
    crop_h = max(h - crop_top - crop_bottom, 1)
    polygons = translate_polygon(polygons, [crop_left, crop_top])

    # 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

    polygons = resize_polygon(
        polygons, (crop_w + pad_left + pad_right, crop_h + pad_top + pad_bottom), w, h
    )

    # Translate
    w_scale = (crop_w + pad_left + pad_right) / w
    h_scale = (crop_h + pad_top + pad_bottom) / h
    polygons = translate_polygon(polygons, [-int(pad_left / w_scale), -int(pad_top / h_scale)])

    return polygons

            
    







            zoom



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


    

            
              Source code in SaigeToolkit/data/transform/polygon_function.py
              121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151 def zoom(
    polygons: PolygonType,
    image_size: Tuple[int],
    ratio: float,
    h_start: float,
    w_start: float,
) -> PolygonType:
    w, h = image_size

    if ratio == 1.0:
        return polygons

    target_size = (int(w * ratio), int(h * ratio))
    polygons = resize_polygon(polygons, image_size, target_size[0], target_size[1])

    x1 = 0
    y1 = 0

    if ratio > 1.0:
        h_start = min(h_start, 1.0 - 1e-5)
        w_start = min(w_start, 1.0 - 1e-5)
        x1 = int((target_size[0] - w + 1) * w_start)
        y1 = int((target_size[1] - h + 1) * h_start)

    elif ratio < 1.0:
        x1 = -int((w - target_size[0] + 1) * w_start)
        y1 = -int((h - target_size[1] + 1) * h_start)

    polygons = translate_polygon(polygons, [x1, y1])

    return polygons

            
    







            random_resized_crop_and_pad



random_resized_crop_and_pad(polygons: PolygonType, image_size: Tuple[int], scale: float, aspect_ratio: float, h_start: float, w_start: float, h_target: Optional[int] = None, w_target: Optional[int] = None, **params) -> PolygonType


    

            
              Source code in SaigeToolkit/data/transform/polygon_function.py
              154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196 def random_resized_crop_and_pad(
    polygons: PolygonType,
    image_size: Tuple[int],
    scale: float,
    aspect_ratio: float,
    h_start: float,
    w_start: float,
    h_target: Optional[int] = None,
    w_target: Optional[int] = None,
    **params
) -> PolygonType:
    w_original, h_original = image_size
    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)))

    # Padding
    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)

    padded_image_size = [w_original + pad_left + pad_right, h_original + pad_top + pad_bottom]
    polygons = translate_polygon(
        polygons,
        [-(pad_left), -(pad_top)],
    )

    # Crop
    x1 = int((padded_image_size[0] - crop_width + 1) * w_start)
    y1 = int((padded_image_size[1] - crop_height + 1) * h_start)
    polygons = translate_polygon(polygons, [x1, y1])

    # Resize
    polygons = resize_polygon(
        polygons,
        [crop_width, crop_height],
        w_target or w_original,
        h_target or h_original,
    )
    return polygons

            
    







            perspective_transform



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


    

            
              Source code in SaigeToolkit/data/transform/polygon_function.py
              199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236 def perspective_transform(
    polygons: PolygonType,
    image_size: Tuple[int],
    offset_top_left: OffsetType,
    offset_top_right: OffsetType,
    offset_bottom_right: OffsetType,
    offset_bottom_left: OffsetType,
) -> PolygonType:
    width, height = image_size

    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,
    )
    new_polygons = deepcopy(polygons)
    for idx_poly, polygon in enumerate(polygons):
        for idx_pt, point in enumerate(polygon):
            x, y, scaling_factor = np.dot(transform_matrix, np.append(point, 1))

            new_polygons[idx_poly][idx_pt][0] = int(x / scaling_factor)
            new_polygons[idx_poly][idx_pt][1] = int(y / scaling_factor)

    return new_polygons

            
    







            resize_polygon



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


    

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

            
              Source code in SaigeToolkit/data/transform/polygon_function.py
              239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260 def resize_polygon(polygons: PolygonType, image_size: Tuple[int], tw: int, th: int) -> PolygonType:
    """Resize polygon from (w, h) to (tw, th)"""
    if len(polygons) == 0:
        return polygons

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

    dtype = polygons[0].dtype

    w_scale = tw / w
    h_scale = th / h

    new_polygons = deepcopy(polygons)

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

    return new_polygons

            
    







            translate_polygon



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


    

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

            
              Source code in SaigeToolkit/data/transform/polygon_function.py
              263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284 def translate_polygon(
    polygons: PolygonType,
    offset: Tuple[int],
) -> PolygonType:
    """Translate polyfon from [(x1, y1), ... ] to [(x1 - x_offset), (y1 - y_offset), ...]"""
    if len(polygons) == 0:
        return polygons

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

    dtype = polygons[0].dtype

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

    new_polygons = deepcopy(polygons)

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

    return new_polygons

            
    





  

    








            resize




    



  













            Resizer



Resizer(size: Optional[Union[ImageSizeType, int]] = None, scale: Optional[Union[int, float]] = None, area_sqrt: Optional[Union[int, float]] = None, max_size: Optional[Union[ImageSizeType, int]] = None, round: Optional[int] = None, round_type: str = 'round', resampling: str = 'bilinear', image_only: bool = False, use_cv2_for_numpy: bool = True)


    


      Module for resizing PIL, torch, numpy images
Resizer의 작동 방식은 다음과 같습니다.
1. target size 계산
2. target size 미세 조정
3. 데이터에 resize 적용
Args에 따라 1, 2번의 작동 방식이 달라집니다.
1. target size 계산
- resize 될 target size를 계산합니다.
- target size는 4개의 args에 영향을 받을 수 있습니다. (size, scale, area_sqrt, max_size)
  하나의 Resizer는 4개중 하나의 args만 사용할 수 있으며, 2개 이상의 args가 None이 아닐시 error를 raise 합니다.
    1-1. size: image를 size로 resize 합니다. aspect ratio가 변경될 수 있습니다.
    1-2. scale: image를 scale배로 늘리거나 줄입니다. aspect ratio는 유지됩니다.
    1-3. area_sqrt: image의 면적이 area_sqrt^2이 되도록 이미지를 늘리거나 줄입니다. aspect ratio는 유지됩니다.
    1-4. max_size: image의 size가 max_size보다 클 경우 max_size로 resize 합니다.
                    aspect ratio를 유지하기 위해, width/height중 더 많이 줄어야 하는 비율에 맞추어 전체를 resize합니다.

target size 미세 조정
resize된 이미지가 특정 값의 배수가 되도록 target size를 미세 조정 합니다.
  model의 입력으로 넣을 때, image size가 특정 값의 배수가 되어야 하기 때문에 필요합니다.


target size 계산의 size parameter와 함께 사용할 수 없습니다. (고정 size이기 때문)


target size 미세 조정은 총 2개의 args에 영향을 받을 수 있습니다. (round, round_type)
  round가 None이면 미세 조정을 하지 않습니다, round_type에 따라 다른 방식의 미세 조정을 적용합니다.
    2-1. round: 미세 조정시 반올림합니다. (target size보다 작거나 크거나 같습니다.)
    2-2. floor: 미세 조정시 내림합니다. (target size보다 작거나 같습니다.)
    2-3. ceil: 미세 조정시 올림합니다. (target size보다 크거나 같습니다.)
미세 조정된 target_size의 width혹은 height가 0이 될 경우, round 값으로 변경해줍니다.
  (ex. size=(3, 3), round=8이면 round_type에 상관없이 size=(8, 8)이 됨.)



Parameters:
    
        
          size
              (Optional[Union[ImageSizeType, int]], default:
                  None
)
          –
          
            target image size. Defaults to None.
          
        
        
          scale
              (Optional[Union[int, float]], default:
                  None
)
          –
          
            target image scale. Defaults to None.
          
        
        
          area_sqrt
              (Optional[Union[int, float]], default:
                  None
)
          –
          
            target image sqrt area. Defaults to None.
          
        
        
          max_size
              (Optional[Union[ImageSizeType, int]], default:
                  None
)
          –
          
            target maximum image size. Defaults to None.
          
        
        
          round
              (Optional[int], default:
                  None
)
          –
          
            round image size. Defaults to None.
          
        
        
          round_type
              (Optional[str], default:
                  'round'
)
          –
          
            type of round image. One of ["round", "floor", "ceil"]. Defaults to "round".
          
        
        
          resampling
              (str, default:
                  'bilinear'
)
          –
          
            One of ["nearest", "bilinear", "bicubic"]. Defaults to "bilinear".
          
        
        
          image_only
              (bool, default:
                  False
)
          –
          
            to resize image only. Defaults to False.
          
        
        
          use_cv2_for_numpy
              (bool, default:
                  True
)
          –
          
            use cv2 instead of PIL for faster numpy array image resizing. Defaults to True.
          
        
    


Raises:
    
        
              ResizerParameterValueError
            –
          
            target size parameter가 2개 이상 들어오면 error를 raise 합니다.
                        round_type이 ["round", "floor", "ceil"]안에 없으면 error를 raise 합니다.
                        size와 미세조정 parameter가 함께 들어오면 error를 raise 합니다.
          
        
    

                  
                    Source code in SaigeToolkit/data/transform/resize.py
                     25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110 def __init__(
    self,
    size: Optional[Union[ImageSizeType, int]] = None,
    scale: Optional[Union[int, float]] = None,
    area_sqrt: Optional[Union[int, float]] = None,
    max_size: Optional[Union[ImageSizeType, int]] = None,
    round: Optional[int] = None,
    round_type: str = "round",
    resampling: str = "bilinear",
    image_only: bool = False,
    use_cv2_for_numpy: bool = True,
) -> None:
    """Module for resizing PIL, torch, numpy images
    Resizer의 작동 방식은 다음과 같습니다.
    1. target size 계산
    2. target size 미세 조정
    3. 데이터에 resize 적용

    Args에 따라 1, 2번의 작동 방식이 달라집니다.
    1. target size 계산
    - resize 될 target size를 계산합니다.
    - target size는 4개의 args에 영향을 받을 수 있습니다. (size, scale, area_sqrt, max_size)
      하나의 Resizer는 4개중 하나의 args만 사용할 수 있으며, 2개 이상의 args가 None이 아닐시 error를 raise 합니다.
        1-1. size: image를 size로 resize 합니다. aspect ratio가 변경될 수 있습니다.
        1-2. scale: image를 scale배로 늘리거나 줄입니다. aspect ratio는 유지됩니다.
        1-3. area_sqrt: image의 면적이 area_sqrt^2이 되도록 이미지를 늘리거나 줄입니다. aspect ratio는 유지됩니다.
        1-4. max_size: image의 size가 max_size보다 클 경우 max_size로 resize 합니다.
                        aspect ratio를 유지하기 위해, width/height중 더 많이 줄어야 하는 비율에 맞추어 전체를 resize합니다.

    2. target size 미세 조정
    - resize된 이미지가 특정 값의 배수가 되도록 target size를 미세 조정 합니다.
      model의 입력으로 넣을 때, image size가 특정 값의 배수가 되어야 하기 때문에 필요합니다.
    - 1. target size 계산의 size parameter와 함께 사용할 수 없습니다. (고정 size이기 때문)
    - target size 미세 조정은 총 2개의 args에 영향을 받을 수 있습니다. (round, round_type)
      round가 None이면 미세 조정을 하지 않습니다, round_type에 따라 다른 방식의 미세 조정을 적용합니다.
        2-1. round: 미세 조정시 반올림합니다. (target size보다 작거나 크거나 같습니다.)
        2-2. floor: 미세 조정시 내림합니다. (target size보다 작거나 같습니다.)
        2-3. ceil: 미세 조정시 올림합니다. (target size보다 크거나 같습니다.)
    - 미세 조정된 target_size의 width혹은 height가 0이 될 경우, round 값으로 변경해줍니다.
      (ex. size=(3, 3), round=8이면 round_type에 상관없이 size=(8, 8)이 됨.)

    Args:
        size (Optional[Union[ImageSizeType, int]], optional): target image size. Defaults to None.
        scale (Optional[Union[int, float]], optional): target image scale. Defaults to None.
        area_sqrt (Optional[Union[int, float]], optional): target image sqrt area. Defaults to None.
        max_size (Optional[Union[ImageSizeType, int]], optional): target maximum image size. Defaults to None.
        round (Optional[int], optional): round image size. Defaults to None.
        round_type (Optional[str], optional): type of round image. One of ["round", "floor", "ceil"]. Defaults to "round".
        resampling (str): One of ["nearest", "bilinear", "bicubic"]. Defaults to "bilinear".
        image_only (bool): to resize image only. Defaults to False.
        use_cv2_for_numpy (bool): use cv2 instead of PIL for faster numpy array image resizing. Defaults to True.

    Raises:
        ResizerParameterValueError: target size parameter가 2개 이상 들어오면 error를 raise 합니다.
                                    round_type이 ["round", "floor", "ceil"]안에 없으면 error를 raise 합니다.
                                    size와 미세조정 parameter가 함께 들어오면 error를 raise 합니다.
    """

    self._check_parameter(
        size=size,
        scale=scale,
        area_sqrt=area_sqrt,
        max_size=max_size,
        round=round,
        round_type=round_type,
    )

    size = self._preprocess_size(size)
    max_size = self._preprocess_size(max_size)

    if scale == 1:
        scale = None

    self.size = size
    self.scale = scale
    self.area_sqrt = area_sqrt
    self.max_size = max_size
    self.round = round
    self.round_type = round_type

    if resampling not in RESAMPLE_PIL or resampling not in RESAMPLE_TORCH:
        raise ValueError
    self.resampling = resampling

    self.image_only = image_only
    self.use_cv2_for_numpy = use_cv2_for_numpy

                  



  












            round_functions


  
      class-attribute
      instance-attribute
  


round_functions = {'round': round, 'floor': floor, 'ceil': ceil}


    
    








            size


  
      instance-attribute
  


size = size


    
    








            scale


  
      instance-attribute
  


scale = scale


    
    








            area_sqrt


  
      instance-attribute
  


area_sqrt = area_sqrt


    
    








            max_size


  
      instance-attribute
  


max_size = max_size


    
    








            round


  
      instance-attribute
  


round = round


    
    








            round_type


  
      instance-attribute
  


round_type = round_type


    
    








            resampling


  
      instance-attribute
  


resampling = resampling


    
    








            image_only


  
      instance-attribute
  


image_only = image_only


    
    








            use_cv2_for_numpy


  
      instance-attribute
  


use_cv2_for_numpy = use_cv2_for_numpy


    
    









            __call__



__call__(return_revert_params: bool = False, **data) -> Union[Dict, Tuple[Dict, Dict]]


    

            
              Source code in SaigeToolkit/data/transform/resize.py
              112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133 def __call__(self, return_revert_params: bool = False, **data) -> Union[Dict, Tuple[Dict, Dict]]:
    input_size = self.compute_input_size(data)
    target_size = self.compute_target_size(input_size)
    data = self.apply_with_params(
        data=data,
        input_size=input_size,
        target_size=target_size,
        resampling=self.resampling,
        image_only=self.image_only,
        use_cv2_for_numpy=self.use_cv2_for_numpy,
    )

    if return_revert_params:
        revert_params = {
            "image_size_before_resize": input_size,
            "image_size_after_resize": target_size,
        }
        return_value = (data, revert_params)
    else:
        return_value = data

    return return_value

            
    







            compute_input_size


  
      staticmethod
  


compute_input_size(data: Dict) -> ImageSizeType


    

      target size를 계산하기 위해 input size를 가져옵니다.
Note: data에 image 혹은 mask data는 있다고 가정하며, 둘의 size는 같다고 가정합니다.

            
              Source code in SaigeToolkit/data/transform/resize.py
              135
136
137
138
139
140
141
142
143
144
145
146
147
148 @staticmethod
def compute_input_size(data: Dict) -> ImageSizeType:
    """target size를 계산하기 위해 input size를 가져옵니다.
    Note: data에 image 혹은 mask data는 있다고 가정하며, 둘의 size는 같다고 가정합니다.
    """
    if "image" in data:
        multipage = isinstance(data["image"], List)
        input_size = read_image_size(data["image"][0] if multipage else data["image"])
    elif "mask" in data:
        input_size = read_image_size(data["mask"])
    else:
        raise NotImplementedError

    return input_size

            
    







            compute_target_size



compute_target_size(input_size: Union[ImageSizeType, ndarray]) -> ImageSizeType


    

      compute resize target size from input image size


Parameters:
    
        
          input_size
              (Union[ImageSizeType, ndarray])
          –
          
            (width, height)
          
        
    


Returns:
    
        
ImageSizeType (              ImageSizeType
)          –
          
            (width, height)
          
        
    

            
              Source code in SaigeToolkit/data/transform/resize.py
              150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167 def compute_target_size(self, input_size: Union[ImageSizeType, np.ndarray]) -> ImageSizeType:
    """compute resize target size from input image size

    Args:
        input_size (Union[ImageSizeType, np.ndarray]): (width, height)

    Returns:
        ImageSizeType: (width, height)
    """
    return self._compute_target_size(
        input_size=input_size,
        size=self.size,
        scale=self.scale,
        area_sqrt=self.area_sqrt,
        max_size=self.max_size,
        round=self.round,
        round_type=self.round_type,
    )

            
    







            apply_with_params


  
      classmethod
  


apply_with_params(data: Dict, input_size: ImageSizeType, target_size: ImageSizeType, resampling: str, image_only: bool, use_cv2_for_numpy: bool = True) -> Dict


    

            
              Source code in SaigeToolkit/data/transform/resize.py
              169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203 @classmethod
def apply_with_params(
    cls,
    data: Dict,
    input_size: ImageSizeType,
    target_size: ImageSizeType,
    resampling: str,
    image_only: bool,
    use_cv2_for_numpy: bool = True,
) -> Dict:
    if "image" in data:
        data["image"] = cls.apply_to_image(
            image=data["image"],
            target_size=target_size,
            resampling=resampling,
            use_cv2_for_numpy=use_cv2_for_numpy,
        )

    if image_only:
        return data

    if "mask" in data:
        data["mask"] = cls.apply_to_mask(mask=data["mask"], target_size=target_size)

    if "bboxes" in data:
        data["bboxes"] = cls.apply_to_bboxes(
            bboxes=data["bboxes"], input_size=input_size, target_size=target_size
        )

    if "polygons" in data:
        data["polygons"] = cls.apply_to_polygons(
            polygons=data["polygons"], input_size=input_size, target_size=target_size
        )

    return data

            
    







            apply_to_image


  
      staticmethod
  


apply_to_image(image, target_size: ImageSizeType, resampling: str, use_cv2_for_numpy: bool = True)


    

            
              Source code in SaigeToolkit/data/transform/resize.py
              205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227 @staticmethod
def apply_to_image(
    image,
    target_size: ImageSizeType,
    resampling: str,
    use_cv2_for_numpy: bool = True,
):
    multipage = isinstance(image, List)
    input_size = read_image_size(image[0] if multipage else image)
    if list(target_size) != list(input_size):
        if multipage:
            image = [
                resize_image(
                    image_, target_size, resampling=resampling, use_cv2_for_numpy=use_cv2_for_numpy
                )
                for image_ in image
            ]
        else:
            image = resize_image(
                image, target_size, resampling=resampling, use_cv2_for_numpy=use_cv2_for_numpy
            )

    return image

            
    







            apply_to_mask


  
      staticmethod
  


apply_to_mask(mask, target_size: ImageSizeType)


    

            
              Source code in SaigeToolkit/data/transform/resize.py
              229
230
231
232
233
234 @staticmethod
def apply_to_mask(mask, target_size: ImageSizeType):
    input_size = read_image_size(mask)
    if list(target_size) != list(input_size):
        mask = resize_mask(mask, target_size)
    return mask

            
    







            apply_to_bboxes


  
      staticmethod
  


apply_to_bboxes(bboxes, input_size: ImageSizeType, target_size: ImageSizeType)


    

            
              Source code in SaigeToolkit/data/transform/resize.py
              236
237
238
239 @staticmethod
def apply_to_bboxes(bboxes, input_size: ImageSizeType, target_size: ImageSizeType):
    bboxes = resize_box(bboxes, input_size, target_size[0], target_size[1])
    return bboxes

            
    







            apply_to_polygons


  
      staticmethod
  


apply_to_polygons(polygons, input_size: ImageSizeType, target_size: ImageSizeType)


    

            
              Source code in SaigeToolkit/data/transform/resize.py
              241
242
243
244
245
246
247
248
249 @staticmethod
def apply_to_polygons(polygons, input_size: ImageSizeType, target_size: ImageSizeType):
    polygons = resize_polygon(
        polygons=polygons,
        image_size=input_size,
        tw=target_size[0],
        th=target_size[1],
    )
    return polygons

            
    







            _compute_target_size


  
      classmethod
  


_compute_target_size(input_size: Union[ImageSizeType, ndarray], size: Optional[Union[ImageSizeType, int]] = None, scale: Optional[Union[int, float]] = None, area_sqrt: Optional[Union[int, float]] = None, max_size: Optional[Union[ImageSizeType, int]] = None, round: Optional[int] = None, round_type: str = 'round') -> ImageSizeType


    

            
              Source code in SaigeToolkit/data/transform/resize.py
              251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283 @classmethod
def _compute_target_size(
    cls,
    input_size: Union[ImageSizeType, np.ndarray],
    size: Optional[Union[ImageSizeType, int]] = None,
    scale: Optional[Union[int, float]] = None,
    area_sqrt: Optional[Union[int, float]] = None,
    max_size: Optional[Union[ImageSizeType, int]] = None,
    round: Optional[int] = None,
    round_type: str = "round",
) -> ImageSizeType:
    input_size = np.array(input_size)

    if size is not None:
        target_size = np.array(size)
    elif scale is not None:
        target_size = (input_size * scale).astype(int)
    elif area_sqrt is not None:
        scale = area_sqrt / sqrt(input_size[0] * input_size[1])
        target_size = (input_size * scale).astype(int)
    elif max_size is not None:
        max_size = np.array(max_size)
        scale = min(np.min(max_size / input_size), 1)
        target_size = (input_size * scale).astype(int)
    else:
        target_size = input_size

    if size is None and round is not None:
        round_func = cls.round_functions[round_type]
        target_size = (round * round_func(target_size / round)).astype(int)
        target_size = np.clip(a=target_size, a_min=round, a_max=None)

    return tuple(target_size)

            
    







            _preprocess_size


  
      staticmethod
  


_preprocess_size(size: Optional[Union[ImageSizeType, int]] = None) -> ImageSizeType


    

            
              Source code in SaigeToolkit/data/transform/resize.py
              285
286
287
288
289
290
291
292 @staticmethod
def _preprocess_size(size: Optional[Union[ImageSizeType, int]] = None) -> ImageSizeType:
    if isinstance(size, int):
        size = (size, size)
    elif isinstance(size, Sequence):
        size = (size[0], size[1])

    return size

            
    







            _check_parameter


  
      classmethod
  


_check_parameter(size: Optional[Union[ImageSizeType, int]], scale: Optional[Union[int, float]], area_sqrt: Optional[Union[int, float]], max_size: Optional[Union[ImageSizeType, int]], round: Optional[int], round_type: str) -> None


    

            
              Source code in SaigeToolkit/data/transform/resize.py
              294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315 @classmethod
def _check_parameter(
    cls,
    size: Optional[Union[ImageSizeType, int]],
    scale: Optional[Union[int, float]],
    area_sqrt: Optional[Union[int, float]],
    max_size: Optional[Union[ImageSizeType, int]],
    round: Optional[int],
    round_type: str,
) -> None:
    num_of_not_none = 0
    for arg in [size, scale, area_sqrt, max_size]:
        if arg is not None:
            num_of_not_none += 1
    if num_of_not_none > 1:
        raise ResizerParameterValueError

    if round_type not in cls.round_functions:
        raise ResizerParameterValueError

    if (size is not None) and (round is not None):
        raise ResizerParameterValueError

            
    





  

    








            InspectionSizeResizer



InspectionSizeResizer(inspection_size_wh: Optional[ImageSizeType] = None, resizer: Optional[Resizer] = None)


    
            
              Bases: Resizer


      원본 이미지가 inspection_size를 넘지 않도록 resize 했을 때의 image scale만큼
resize를 해주는 resizer를 생성하는 class 입니다.
inspection_size는 원본 이미지에 대해 적용하지만, 실제 연산은 ROI가 먼저 계산되기 때문에,
원본 이미지가 inspection_size를 넘지 않도록 resize 했을 때의 image scale을 미리 계산해두고,
해당 scale만큼 resize를 하는 resizer를 생성하여 계산합니다.

                  
                    Source code in SaigeToolkit/data/transform/resize.py
                    328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343 def __init__(
    self,
    inspection_size_wh: Optional[ImageSizeType] = None,
    resizer: Optional[Resizer] = None,
) -> None:
    self._check_inspection_size_type(inspection_size_wh)
    self._check_inspection_size_value(inspection_size_wh)

    initial_params = {}
    if resizer is not None:
        initial_params["resampling"] = resizer.resampling
        initial_params["image_only"] = resizer.image_only

    super().__init__(**initial_params)

    self.inspection_size_wh = self._preprocess_size(inspection_size_wh)

                  



  












            inspection_size_wh


  
      instance-attribute
  


inspection_size_wh = _preprocess_size(inspection_size_wh)


    
    









            _check_inspection_size_type



_check_inspection_size_type(inspection_size_wh: Optional[ImageSizeType]) -> None


    

            
              Source code in SaigeToolkit/data/transform/resize.py
              345
346
347
348
349
350
351
352
353 def _check_inspection_size_type(self, inspection_size_wh: Optional[ImageSizeType]) -> None:
    # 타입 체크
    valid_type = (
        inspection_size_wh is None
        or len(inspection_size_wh) == 2
        and all(isinstance(v, int) for v in inspection_size_wh)
    )
    if not valid_type:
        raise InspectionSizeTypeError

            
    







            _check_inspection_size_value



_check_inspection_size_value(inspection_size_wh: Optional[ImageSizeType]) -> None


    

            
              Source code in SaigeToolkit/data/transform/resize.py
              355
356
357
358
359 def _check_inspection_size_value(self, inspection_size_wh: Optional[ImageSizeType]) -> None:
    # 값 체크, inspection_size_wh의 값은 모두 1 이상이어야 한다.
    valid_value = inspection_size_wh is None or all(value >= 1 for value in inspection_size_wh)
    if not valid_value:
        raise InspectionSizeValueError

            
    







            set_scale_from_data



set_scale_from_data(**data) -> None


    

            
              Source code in SaigeToolkit/data/transform/resize.py
              361
362
363
364
365 def set_scale_from_data(self, **data) -> None:
    if self.inspection_size_wh is not None:
        input_size = np.array(self.compute_input_size(data))
        inspection_size_wh = np.array(self.inspection_size_wh)
        self.scale = min(np.min(inspection_size_wh / input_size), 1)

            
    





  

    








            StackedResizerHandler



StackedResizerHandler(resizer_list: List[Optional[Resizer]])


    


      같은 image에 대해 여러번의 resize가 연속적으로 적용될 때,
여러개의 resize를 하나로 묶어서 최종 target size로 한번에 resize를 해주는 class입니다.

                  
                    Source code in SaigeToolkit/data/transform/resize.py
                    374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396 def __init__(
    self,
    resizer_list: List[Optional[Resizer]],
) -> None:
    self.resizer_list = resizer_list
    self.is_empty = len(resizer_list) == 0 or all(x is None for x in resizer_list)

    if not self.is_empty:
        resampling = set()
        image_only = set()
        use_cv2_for_numpy = set()
        for resizer in resizer_list:
            if resizer is not None:
                resampling.add(resizer.resampling)
                image_only.add(resizer.image_only)
                use_cv2_for_numpy.add(resizer.use_cv2_for_numpy)

        if len(resampling) > 1 or len(image_only) > 1 or len(use_cv2_for_numpy) > 1:
            raise StackedResizerHandlerParameterValueError

        self.resampling = resampling.pop()
        self.image_only = image_only.pop()
        self.use_cv2_for_numpy = use_cv2_for_numpy.pop()

                  



  












            resizer_list


  
      instance-attribute
  


resizer_list = resizer_list


    
    








            is_empty


  
      instance-attribute
  


is_empty = len(resizer_list) == 0 or all(x is None for x in resizer_list)


    
    








            resampling


  
      instance-attribute
  


resampling = pop()


    
    








            image_only


  
      instance-attribute
  


image_only = pop()


    
    








            use_cv2_for_numpy


  
      instance-attribute
  


use_cv2_for_numpy = pop()


    
    









            __call__



__call__(return_revert_params: bool = False, **data) -> Union[Dict, Tuple[Dict, Dict]]


    

            
              Source code in SaigeToolkit/data/transform/resize.py
              398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434 def __call__(self, return_revert_params: bool = False, **data) -> Union[Dict, Tuple[Dict, Dict]]:
    if return_revert_params:
        revert_params = []

    if self.is_empty:
        revert_params = [None] * len(self.resizer_list)
    else:
        input_size = Resizer.compute_input_size(data)
        target_size = input_size

        for resizer in self.resizer_list:
            if resizer is None:
                if return_revert_params:
                    revert_params.append(None)
            else:
                revert_param = {"image_size_before_resize": target_size}
                target_size = resizer.compute_target_size(target_size)
                revert_param["image_size_after_resize"] = target_size
                if return_revert_params:
                    revert_params.append(revert_param)

        if list(input_size) != list(target_size):
            data = Resizer.apply_with_params(
                data=data,
                input_size=input_size,
                target_size=target_size,
                resampling=self.resampling,
                image_only=self.image_only,
                use_cv2_for_numpy=self.use_cv2_for_numpy,
            )

    if return_revert_params:
        return_value = (data, revert_params)
    else:
        return_value = data

    return return_value

            
    





  

    






  

    








            roi




    

      ROI 좌표 계산 및 ROI 크롭, blind_mask 적용을 수행하는 ROIHandler 클래스를 제공합니다. Set-ROI 기능을 위한 API 클래스인 ROIHandlerAPI도 제공합니다.



  















            api




    



  












            error_handler


  
      module-attribute
  


error_handler = get_error_handler(SaigeToolkitError)


    
    









            ROIHandlerAPI



ROIHandlerAPI(**kwargs)


    


      Set-ROI 기능을 위한 API입니다.



  Usage
  # 핸들러 빌드. 아래는 simple mode의 예제 config이며, 자세한 설명은 ROIHandlerAPI.set() 함수 참고.
config = {
    "mode": "simple",
    "left": 0.0,
    "top": 0.0,
    "right": 1.0,
    "bottom": 1.0,
    "blind_mask": None,
}
error, roi_hander = ROIHandlerAPI.build(config)

# image에 대한 roi 계산. 리턴 결과 설명은 ROIHandlerAPI.apply() 함수 참고.
image = np.zeros((100, 100, 3), dtype=np.unit8)
error, roi_results = roi_handler.apply(image)

# roi 파라미터 변경
config["left"] = 0.1
error, _  = roi_handler.set(config)

# 변경된 파라미터로 roi 다시 계산
error, roi_results = roi_handler.apply(image)


                  
                    Source code in SaigeToolkit/data/transform/roi/api.py
                    44
45 def __init__(self, **kwargs) -> None:
    self.handler = ROIHandler(**kwargs)

                  



  












            handler


  
      instance-attribute
  


handler = ROIHandler(**kwargs)


    
    









            build


  
      classmethod
  


build(config: Dict) -> ROIHandlerAPI


    

      ROIHandlerAPI를 빌드합니다.
Args:
    config (Dict): ROIHandlerAPI.set의 파라미터와 동일합니다.


Returns:
    
        
ROIHandlerAPI (              ROIHandlerAPI
)          –
          
            빌드된 ROIHandlerAPI
          
        
    

            
              Source code in SaigeToolkit/data/transform/roi/api.py
              47
48
49
50
51
52
53
54
55
56
57 @classmethod
@error_handler
def build(cls, config: Dict) -> ROIHandlerAPI:
    """ROIHandlerAPI를 빌드합니다.
    Args:
        config (Dict): ROIHandlerAPI.set의 파라미터와 동일합니다.

    Returns:
        ROIHandlerAPI: 빌드된 ROIHandlerAPI
    """
    return cls(**config)

            
    







            set



set(config: Dict) -> None


    

      ROI 파라미터를 변경합니다.


Parameters:
    
        
          config
              (Dict)
          –
          
            ROI 파라미터의 dict입니다. mode에 따라 다른 파라미터를 가집니다.
# simple mode:
{
    "mode": "simple",  # Simple ROI 모드.
    "left": float,  # ROI의 왼쪽 경계. [0.0, 1.0) 범위의 실수.
    "top": float,  # ROI의 위쪽 경계. [0.0, 1.0) 범위의 실수.
    "right": float,  # ROI의 오른쪽 경계. (right, 1.0] 범위의 실수.
    "bottom": float,  # ROI의 아래쪽 경계. (top, 1.0] 범위의 실수.
    "blind_mask": Optional[np.ndarray],  # blind mask 이미지. None인 경우 blind 적용 안함.
                                         # np.ndarray인 경우 (dtype=uint8, shape=(H_roi, W_roi))이며 픽셀 값은 0 또는 1.
                                         # mask의 값이 1인 영역이 학습/검사 시 마스킹됩니다.
                                         # polygons에는 blind_mask가 적용되지 않습니다.
}
# advanced mode:
{
    "mode": "advanced",  # Advanced ROI 모드.
    "intensity": List[int],  # 필터링할 [최소, 최대] 픽셀값 범위. 각 값은 [0, 255] 범위의 정수.
    "expansion": int,  # 필터링된 픽셀 영역에 대한 확장/축소 정도. [-10, 10] 범위의 정수.
    "inversion": bool,  # True인 경우 필터링된 픽셀 영역을 반전.
    "offset_left": float,  # ROI 박스의 왼쪽 사이즈. [0.0, 2.0] 범위의 실수 이며, 1인 경우 기본 크기.
    "offset_right": float,  # ROI 박스의 오른쪽 사이즈. [0.0, 2.0] 범위의 실수 이며, 1인 경우 기본 크기.
    "offset_top": float,  # ROI 박스의 위쪽 사이즈. [0.0, 2.0] 범위의 실수 이며, 1인 경우 기본 크기.
    "offset_bottom": float,  # ROI 박스의 아래쪽 사이즈. [0.0, 2.0] 범위의 실수 이며, 1인 경우 기본 크기.
    "blind_mask": Optional[np.ndarray],  # blind mask 이미지. None인 경우 blind 적용 안함.
                                         # np.ndarray인 경우 (dtype=uint8, shape=(H_roi, W_roi))이며 픽셀 값은 0 또는 1.
                                         # mask의 값이 1인 영역이 학습/검사 시 마스킹됩니다.
                                         # polygons에는 blind_mask가 적용되지 않습니다.
}

          
        
    

            
              Source code in SaigeToolkit/data/transform/roi/api.py
              59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95 @error_handler
def set(self, config: Dict) -> None:
    """ROI 파라미터를 변경합니다.

    Args:
        config (Dict): ROI 파라미터의 dict입니다. mode에 따라 다른 파라미터를 가집니다.
            ```python
            # simple mode:
            {
                "mode": "simple",  # Simple ROI 모드.
                "left": float,  # ROI의 왼쪽 경계. [0.0, 1.0) 범위의 실수.
                "top": float,  # ROI의 위쪽 경계. [0.0, 1.0) 범위의 실수.
                "right": float,  # ROI의 오른쪽 경계. (right, 1.0] 범위의 실수.
                "bottom": float,  # ROI의 아래쪽 경계. (top, 1.0] 범위의 실수.
                "blind_mask": Optional[np.ndarray],  # blind mask 이미지. None인 경우 blind 적용 안함.
                                                     # np.ndarray인 경우 (dtype=uint8, shape=(H_roi, W_roi))이며 픽셀 값은 0 또는 1.
                                                     # mask의 값이 1인 영역이 학습/검사 시 마스킹됩니다.
                                                     # polygons에는 blind_mask가 적용되지 않습니다.
            }
            # advanced mode:
            {
                "mode": "advanced",  # Advanced ROI 모드.
                "intensity": List[int],  # 필터링할 [최소, 최대] 픽셀값 범위. 각 값은 [0, 255] 범위의 정수.
                "expansion": int,  # 필터링된 픽셀 영역에 대한 확장/축소 정도. [-10, 10] 범위의 정수.
                "inversion": bool,  # True인 경우 필터링된 픽셀 영역을 반전.
                "offset_left": float,  # ROI 박스의 왼쪽 사이즈. [0.0, 2.0] 범위의 실수 이며, 1인 경우 기본 크기.
                "offset_right": float,  # ROI 박스의 오른쪽 사이즈. [0.0, 2.0] 범위의 실수 이며, 1인 경우 기본 크기.
                "offset_top": float,  # ROI 박스의 위쪽 사이즈. [0.0, 2.0] 범위의 실수 이며, 1인 경우 기본 크기.
                "offset_bottom": float,  # ROI 박스의 아래쪽 사이즈. [0.0, 2.0] 범위의 실수 이며, 1인 경우 기본 크기.
                "blind_mask": Optional[np.ndarray],  # blind mask 이미지. None인 경우 blind 적용 안함.
                                                     # np.ndarray인 경우 (dtype=uint8, shape=(H_roi, W_roi))이며 픽셀 값은 0 또는 1.
                                                     # mask의 값이 1인 영역이 학습/검사 시 마스킹됩니다.
                                                     # polygons에는 blind_mask가 적용되지 않습니다.
            }
            ```
    """
    self.handler.set(**config)

            
    







            apply



apply(image: ndarray) -> Dict


    

      image에 대한 ROI 좌표 및 기타 결과를 계산합니다.


Parameters:
    
        
          image
              (ndarray)
          –
          
            ROI를 적용할 입력 이미지.
          
        
    


Returns:
    
        
Dict (              Dict
)          –
          
            ROI 계산 결과 dict 입니다. mode에 따라 다른 결과 값들을 가집니다.
# simple mode:
{
    "roi_coordinates": List[int],  # [left, top, right, bottom].
}
# advanced mode:
{
    "roi_coordinates": List[int],  # [left, top, right, bottom].
    "filtered_image": np.ndarray(uint8, shape=(H, W)),  # intensity, expansion, inversion이 적용된 중간 결과 이미지 입니다. (픽셀값: 0 or 1)
}

          
        
    

            
              Source code in SaigeToolkit/data/transform/roi/api.py
               97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118 @error_handler
def apply(self, image: np.ndarray) -> Dict:
    """`image`에 대한 ROI 좌표 및 기타 결과를 계산합니다.

    Args:
        image (np.ndarray): ROI를 적용할 입력 이미지.

    Returns:
        Dict: ROI 계산 결과 dict 입니다. mode에 따라 다른 결과 값들을 가집니다.
            ```python
            # simple mode:
            {
                "roi_coordinates": List[int],  # [left, top, right, bottom].
            }
            # advanced mode:
            {
                "roi_coordinates": List[int],  # [left, top, right, bottom].
                "filtered_image": np.ndarray(uint8, shape=(H, W)),  # intensity, expansion, inversion이 적용된 중간 결과 이미지 입니다. (픽셀값: 0 or 1)
            }
            ```
    """
    return self.handler.roi_calculator(image=image, get_intermediate_results=True)

            
    





  

    






  

    








            roi_calculator




    



  












            logger


  
      module-attribute
  


logger = getLogger('SaigeResearch')


    
    









            ROICalculator





    
            
              Bases: ABC


      ROI 좌표 계산을 위한 추상 클래스입니다.




  













            set


  
      abstractmethod
  


set(**kwargs) -> None


    

            
              Source code in SaigeToolkit/data/transform/roi/roi_calculator.py
              25
26
27 @abstractmethod
def set(self, **kwargs) -> None:
    pass

            
    







            __call__


  
      abstractmethod
  


__call__(image: Union[Image, ndarray], get_intermediate_results: bool = False, warmup: bool = False, **data) -> Dict


    

            
              Source code in SaigeToolkit/data/transform/roi/roi_calculator.py
              29
30
31
32
33
34
35
36
37 @abstractmethod
def __call__(
    self,
    image: Union[Image.Image, np.ndarray],
    get_intermediate_results: bool = False,
    warmup: bool = False,
    **data,
) -> Dict:
    pass

            
    





  

    








            RelativeBoxROI



RelativeBoxROI(**kwargs)


    
            
              Bases: ROICalculator


      이미지 크기에 비례하는 상대좌표 박스로 ROI를 계산합니다.

                  
                    Source code in SaigeToolkit/data/transform/roi/roi_calculator.py
                    43
44 def __init__(self, **kwargs) -> None:
    self.set(**kwargs)

                  



  













            set



set(left: float, top: float, right: float, bottom: float) -> None


    

            
              Source code in SaigeToolkit/data/transform/roi/roi_calculator.py
              46
47
48
49
50
51
52
53 def set(self, left: float, top: float, right: float, bottom: float) -> None:
    if not (0.0 <= left < right <= 1.0) or not (0.0 <= top < bottom <= 1.0):
        raise SimpleROIParameterValueError

    self.left = left
    self.top = top
    self.right = right
    self.bottom = bottom

            
    







            __call__



__call__(image: Union[Image, ndarray], get_intermediate_results: bool = False, warmup: bool = False, **data) -> Dict


    

            
              Source code in SaigeToolkit/data/transform/roi/roi_calculator.py
              55
56
57
58
59
60
61
62
63
64
65
66
67 def __call__(
    self,
    image: Union[Image.Image, np.ndarray],
    get_intermediate_results: bool = False,
    warmup: bool = False,
    **data,
) -> Dict:
    w, h = read_image_size(image)
    left = int(self.left * w)
    right = max(int(self.right * w), left + 1)
    top = int(self.top * h)
    bottom = max(int(self.bottom * h), top + 1)
    return {"roi_coordinates": [left, top, right, bottom]}

            
    





  

    








            PixelIntensityROI



PixelIntensityROI(**kwargs)


    
            
              Bases: ROICalculator


      픽셀값이 intensity 범위에 들어오는 픽셀만 필터링한 뒤, 필터링 된 픽셀들의 컨투어를 찾고,
가장 면적이 큰 컨투어를 감싸는 최소 박스로 ROI를 계산합니다.

                  
                    Source code in SaigeToolkit/data/transform/roi/roi_calculator.py
                    74
75 def __init__(self, **kwargs) -> None:
    self.set(**kwargs)

                  



  













            set



set(intensity: Union[Tuple[int, int], List[int]], expansion: int, inversion: bool, offset_left: float, offset_right: float, offset_top: float, offset_bottom: float) -> None


    

            
              Source code in SaigeToolkit/data/transform/roi/roi_calculator.py
               77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110 def set(
    self,
    intensity: Union[Tuple[int, int], List[int]],
    expansion: int,
    inversion: bool,
    offset_left: float,
    offset_right: float,
    offset_top: float,
    offset_bottom: float,
) -> None:
    if (
        not len(intensity) == 2
        or not isinstance(intensity[0], int)
        or not isinstance(intensity[1], int)
        or not (0 <= intensity[0] < intensity[1] <= 255)
    ):
        raise AdvancedROIParameterValueError

    if not (-10 <= expansion <= 10):
        raise AdvancedROIParameterValueError

    for offset in (offset_left, offset_right, offset_top, offset_bottom):
        if not (0 <= offset <= 2):
            raise AdvancedROIParameterValueError
    if not (offset_left + offset_right >= 0.1) or not (offset_top + offset_bottom >= 0.1):
        raise AdvancedROIParameterValueError

    self.intensity = intensity
    self.expansion = expansion
    self.inversion = inversion
    self.offset_left = offset_left
    self.offset_right = offset_right
    self.offset_top = offset_top
    self.offset_bottom = offset_bottom

            
    







            __call__



__call__(image: Union[Image, ndarray], get_intermediate_results: bool = False, warmup: bool = False, **data) -> Dict


    

            
              Source code in SaigeToolkit/data/transform/roi/roi_calculator.py
              112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177 def __call__(
    self,
    image: Union[Image.Image, np.ndarray],
    get_intermediate_results: bool = False,
    warmup: bool = False,
    **data,
) -> Dict:
    w, h = read_image_size(image)

    # PixelIntensityROI의 경우 input image size가 같더라도 output image size가 계속해서 달라질 수 있으며,
    # output image size의 최대 값은 input image size이기 때문에, warmup 시에 input image size를 return 함.
    if warmup:
        output = {"roi_coordinates": [0, 0, w, h]}
        return output

    # 후속 연산을 위해 grayscale numpy array 이미지로 변환
    filtered_image = to_numpy(image, copy=False)
    filtered_image = convert_image_mode(filtered_image, "L", copy=False)

    # intensity 범위에 들어오는 픽셀을 찾고, 해당 픽셀들을 expand & inverse
    filtered_image = cv2.inRange(filtered_image, lowerb=self.intensity[0], upperb=self.intensity[1])

    expansion_kernel = cv2.getStructuringElement(shape=cv2.MORPH_RECT, ksize=(3, 3), anchor=(1, 1))
    if self.expansion > 0:
        filtered_image = cv2.dilate(
            filtered_image, kernel=expansion_kernel, anchor=(-1, -1), iterations=2 * self.expansion
        )
    elif self.expansion < 0:
        filtered_image = cv2.erode(
            filtered_image, kernel=expansion_kernel, anchor=(-1, -1), iterations=2 * self.expansion
        )

    if self.inversion:
        filtered_image = cv2.bitwise_not(filtered_image)

    contours, _ = cv2.findContours(
        filtered_image, mode=cv2.RETR_LIST, method=cv2.CHAIN_APPROX_SIMPLE
    )
    if contours:
        # contour 중 면적 가장 큰 것 선택 & bounding box 계산
        contour_areas = list(map(cv2.contourArea, contours))
        max_area_contour = contours[np.argmax(contour_areas)]
        left, top, roi_width, roi_height = cv2.boundingRect(max_area_contour)

        # bounding box에 offset 적용 & 이미지 내부로 clip
        roi_center_x = left + (roi_width / 2)
        roi_center_y = top + (roi_height / 2)

        roi_left = roi_center_x - (self.offset_left * roi_width / 2)
        roi_right = roi_center_x + (self.offset_right * roi_width / 2)
        roi_top = roi_center_y - (self.offset_top * roi_height / 2)
        roi_bottom = roi_center_y + (self.offset_bottom * roi_height / 2)

        roi_left = int(np.clip(roi_left, 0, w - 1))
        roi_right = int(np.clip(roi_right, roi_left + 1, w))
        roi_top = int(np.clip(roi_top, 0, h - 1))
        roi_bottom = int(np.clip(roi_bottom, roi_top + 1, h))

        roi_coordinates = [roi_left, roi_top, roi_right, roi_bottom]
    else:
        roi_coordinates = [0, 0, w, h]

    output = {"roi_coordinates": roi_coordinates}
    if get_intermediate_results:
        output["filtered_image"] = filtered_image // 255
    return output

            
    





  

    








            AutoRelativeBoxROI



AutoRelativeBoxROI(padding: str = 'medium')


    
            
              Bases: RelativeBoxROI


      RelativeBoxROI class with automatic coordinate calculation.
Monostate pattern applied to prevent ROI coordinate mismatch between
train ~ validation dataset.


Attributes:
    
        
          left
              (float)
          –
          
            ROI coordinates.
          
        
        
          top
              (float)
          –
          
            ROI coordinates.
          
        
        
          right
              (float)
          –
          
            ROI coordinates.
          
        
        
          bottom
              (float)
          –
          
            ROI coordinates.
          
        
        
          is_ready
              (bol)
          –
          
            Whether auto ROI coordinates is set.
          
        
        
          image_hw
              (Optional[List[int]])
          –
          
            dataset image size.
          
        
        
          discard_outer_polygons
              (bool)
          –
          
            Flag for discarding polygons outside of current ROI region.
          
        
        
          expand_ratio
          –
          
            Ratio for expanding ROI region. Larger value means more padding.
          
        
    



  Example
  # in dataset building...
@property
def files(self):
    return self._files

@files.setter
def files(self, value):
    self._files = value

    if isinstance(self.transform.roi_handler.roi_calculator, AutoRelativeBoxROI):
        self.transform.roi_handler.roi_calculator.autoupdate_roi_coordinate(self)
                                                                          # self is dataset


                  
                    Source code in SaigeToolkit/data/transform/roi/roi_calculator.py
                    230
231
232
233
234
235
236 def __init__(self, padding: str = "medium"):
    self.__dict__ = self.__shared_state

    if padding not in self.REGION_EXPAND_RATIO.keys():
        raise AutoROIParameterValueError(f"AutoROI mode {padding} not available.")

    self.expand_ratio = self.REGION_EXPAND_RATIO[padding]

                  



  












            __shared_state


  
      class-attribute
      instance-attribute
  


__shared_state = {'_is_ready': False, '_image_hw': None, '_left': -1.0, '_top': -1.0, '_right': -1.0, '_bottom': -1.0}


    
    








            REGION_EXPAND_RATIO


  
      class-attribute
      instance-attribute
  


REGION_EXPAND_RATIO = {'small': 0.05, 'medium': 0.1, 'large': 0.2}


    
    








            __dict__


  
      instance-attribute
  


__dict__ = __shared_state


    
    








            expand_ratio


  
      instance-attribute
  


expand_ratio = REGION_EXPAND_RATIO[padding]


    
    








            is_ready


  
      property
      writable
  


is_ready


    
    








            image_hw


  
      property
      writable
  


image_hw


    
    








            left


  
      property
      writable
  


left


    
    








            top


  
      property
      writable
  


top


    
    








            right


  
      property
      writable
  


right


    
    








            bottom


  
      property
      writable
  


bottom


    
    









            _check_auto_roi_is_ready



_check_auto_roi_is_ready(function)


    

            
              Source code in SaigeToolkit/data/transform/roi/roi_calculator.py
              246
247
248
249
250
251
252
253
254
255 def _check_auto_roi_is_ready(function):
    def wrapper(self, *args, **kwargs):
        if self.is_ready:
            return function(self, *args, **kwargs)
        else:
            raise AutoROIParameterRuntimeError(
                "AutoROI not avaliable. Check log and dataset config."
            )

    return wrapper

            
    







            __call__



__call__(*args, **kwargs)


    

            
              Source code in SaigeToolkit/data/transform/roi/roi_calculator.py
              257
258
259 @_check_auto_roi_is_ready
def __call__(self, *args, **kwargs):
    return super().__call__(*args, **kwargs)

            
    







            autoupdate_roi_coordinate



autoupdate_roi_coordinate(dataset: Dataset) -> bool


    

      Automatically update ROI coordinate using dataset information.
Returns success flag.

            
              Source code in SaigeToolkit/data/transform/roi/roi_calculator.py
              301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369 def autoupdate_roi_coordinate(self, dataset: Dataset) -> bool:
    """Automatically update ROI coordinate using dataset information.

    Returns success flag.
    """

    # XXX: only called once
    if self.is_ready:
        logger.info("ROI coordinate already set. Update only once")
        return True

    marginal_label_region_xyxy = np.array([np.inf, np.inf, 0, 0])

    for data_idx in range(len(dataset)):
        file = dataset.files[data_idx]
        data_dict = dataset.load_image(file)
        data_dict.update(dataset.load_label(file))

        data_image: Union[Image.Image, np.ndarray] = data_dict["image"]
        current_img_hw = list(read_image_size(data_image))[::-1]

        if self.image_hw:
            if self.image_hw != current_img_hw:
                logger.warn("Variation in image size detected.. autoROI update aborted.")
                logger.warn(
                    f"Expected image size: {self.image_hw} / Given image size: {current_img_hw}"
                )
                return False

        self.image_hw = current_img_hw

        for polygon in data_dict["polygons"]:
            x_min, x_max = np.min(polygon[:, 0]), np.max(polygon[:, 0])
            y_min, y_max = np.min(polygon[:, 1]), np.max(polygon[:, 1])

            if x_min < marginal_label_region_xyxy[0]:
                marginal_label_region_xyxy[0] = x_min

            if y_min < marginal_label_region_xyxy[1]:
                marginal_label_region_xyxy[1] = y_min

            if x_max > marginal_label_region_xyxy[2]:
                marginal_label_region_xyxy[2] = x_max

            if y_max > marginal_label_region_xyxy[3]:
                marginal_label_region_xyxy[3] = y_max

    if not _check_region_xyxy_is_valid(marginal_label_region_xyxy):
        logger.warning(
            "AutoROI setting update failed. Needs at least one training data & valid polygon."
        )
        return False

    marginal_label_region_xyxy = _expand_region_xyxy(marginal_label_region_xyxy, self.expand_ratio)
    marginal_label_region_xyxy = _fit_region_into_img_size(
        marginal_label_region_xyxy,
        self.image_hw,
    )

    self.left = marginal_label_region_xyxy[0] / self.image_hw[1]
    self.top = marginal_label_region_xyxy[1] / self.image_hw[0]
    self.right = marginal_label_region_xyxy[2] / self.image_hw[1]
    self.bottom = marginal_label_region_xyxy[3] / self.image_hw[0]

    self.is_ready = True
    marginal_label_region_ratio = [self.left, self.top, self.right, self.bottom]
    logger.info(f"AutoROI setting success. ROI coordinates: {marginal_label_region_ratio}")

    return True

            
    





  

    








            _expand_region_xyxy



_expand_region_xyxy(region_xyxy: ndarray, expand_ratio: float) -> ndarray


    

            
              Source code in SaigeToolkit/data/transform/roi/roi_calculator.py
              372
373
374
375
376
377
378
379
380 def _expand_region_xyxy(region_xyxy: np.ndarray, expand_ratio: float) -> np.ndarray:
    min_loc = region_xyxy[:2]
    max_loc = region_xyxy[2:]
    w, h = max_loc - min_loc
    offset_w: float = w * expand_ratio / 2
    offset_h: float = h * expand_ratio / 2
    offset = np.array([-offset_w, -offset_h, offset_w, offset_h])
    new_region_xyxy = (region_xyxy + offset).astype(int)
    return new_region_xyxy

            
    







            _fit_region_into_img_size



_fit_region_into_img_size(region_xyxy: ndarray, img_shape_hw: Tuple[int, int]) -> ndarray


    

            
              Source code in SaigeToolkit/data/transform/roi/roi_calculator.py
              383
384
385
386
387
388 def _fit_region_into_img_size(region_xyxy: np.ndarray, img_shape_hw: Tuple[int, int]) -> np.ndarray:
    H, W = img_shape_hw
    clipped_region_xyxy = region_xyxy.copy()
    clipped_region_xyxy[[0, 2]] = np.clip(region_xyxy[[0, 2]], 0, W)
    clipped_region_xyxy[[1, 3]] = np.clip(region_xyxy[[1, 3]], 0, H)
    return clipped_region_xyxy

            
    







            _check_region_xyxy_is_valid



_check_region_xyxy_is_valid(region_xyxy: ndarray) -> bool


    

            
              Source code in SaigeToolkit/data/transform/roi/roi_calculator.py
              391
392 def _check_region_xyxy_is_valid(region_xyxy: np.ndarray) -> bool:
    return region_xyxy[0] < region_xyxy[2] and region_xyxy[1] < region_xyxy[3]

            
    





  

    








            roi_handler




    



  













            ROIHandler



ROIHandler(**kwargs)


    


      ROI 기능을 수행합니다.
이미지에 대한 ROI 좌표를 계산해 크롭하고, 크롭된 이미지에 blind_mask를 적용해 마스크 영역의 픽셀 값을 0으로 치환합니다.

                  
                    Source code in SaigeToolkit/data/transform/roi/roi_handler.py
                    27
28 def __init__(self, **kwargs) -> None:
    self.set(**kwargs)

                  



  












            roi_calculator_types


  
      class-attribute
      instance-attribute
  


roi_calculator_types = {'simple': RelativeBoxROI, 'advanced': PixelIntensityROI, 'auto': AutoRelativeBoxROI}


    
    








            roi_calculator


  
      instance-attribute
  


roi_calculator: ROICalculator


    
    









            set



set(mode: str, blind_mask: Union[None, ndarray, str], image_only: bool = False, discard_outer_polygons: bool = False, det_blind_mask_threshold: float = 0.5, **kwargs)


    

            
              Source code in SaigeToolkit/data/transform/roi/roi_handler.py
              30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59 def set(
    self,
    mode: str,
    blind_mask: Union[None, np.ndarray, str],
    image_only: bool = False,
    discard_outer_polygons: bool = False,
    det_blind_mask_threshold: float = 0.5,
    **kwargs,
):
    if mode not in self.roi_calculator_types:
        raise ROIModeError

    # mode 변경된 경우 roi_calculator 인스턴스 새로 생성, 그렇지 않은 경우 set 호출
    if not hasattr(self, "mode") or self.mode != mode:
        self.mode = mode
        self.roi_calculator = self.roi_calculator_types[mode](**kwargs)
    else:
        self.roi_calculator.set(**kwargs)

    if isinstance(blind_mask, str):
        blind_mask = np.array(Image.open(blind_mask))
    if blind_mask is not None and (blind_mask.dtype != np.uint8 or blind_mask.ndim != 2):
        raise ROIBlindMaskValueError
    self.blind_mask = blind_mask

    self.image_only = image_only

    self.discard_outer_polygons = discard_outer_polygons

    self.det_blind_mask_threshold = det_blind_mask_threshold

            
    







            apply_crop



apply_crop(image: Union[Image, ndarray, List[Union[Image, ndarray]]], return_revert_params: bool = False, warmup: bool = False, **data) -> Union[Dict, Tuple[Dict, Dict]]


    

            
              Source code in SaigeToolkit/data/transform/roi/roi_handler.py
               61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128 def apply_crop(
    self,
    image: Union[Image.Image, np.ndarray, List[Union[Image.Image, np.ndarray]]],
    return_revert_params: bool = False,
    warmup: bool = False,
    **data,
) -> Union[Dict, Tuple[Dict, Dict]]:
    multipage = isinstance(image, list)

    roi_info = self.roi_calculator(
        image=image[0] if multipage else image,
        get_intermediate_results=False,
        warmup=warmup,
        **data,
    )
    roi_coordinates = roi_info["roi_coordinates"]  # [left, top, right, bottom]

    if multipage:
        image_size_before_roi = read_image_size(image[0])
        cropped_image = [crop(image_i, roi_coordinates) for image_i in image]
        image_size_after_roi = read_image_size(cropped_image[0])
    else:
        image_size_before_roi = read_image_size(image)
        cropped_image = crop(image, roi_coordinates)
        image_size_after_roi = read_image_size(cropped_image)

    data["image"] = cropped_image

    revert_params = {
        "image_size_before_roi": image_size_before_roi,
        "roi_coordinates": roi_coordinates,
        "image_size_after_roi": image_size_after_roi,
    }

    if self.image_only:
        return (data, revert_params) if return_revert_params else data

    # 라벨 크롭 & 마스킹
    if "mask" in data:
        data["mask"] = crop(data["mask"], roi_coordinates)

    if "bboxes" in data:
        data["bboxes"] = crop_box(data["bboxes"], roi_coordinates)

    if "polygons" in data:
        # NOTE: polygons에는 blind_mask가 적용되지 않습니다.
        new_polygons = []
        new_data = {key: [] for key in ["strings", "ignore"] if key in data}
        # TODO: add any keys to be updated which should have same length with polygons.

        for idx, polygon in enumerate(data["polygons"]):
            if self.discard_outer_polygons and not self._check_polygon_within_box(
                polygon, roi_coordinates
            ):
                continue

            new_polygons.append(polygon)
            for k, v in new_data.items():
                v.append(data[k][idx])

        new_polygons = translate_polygon(
            polygons=new_polygons,
            offset=roi_coordinates[:2],
        )

        data.update({"polygons": new_polygons, **new_data})

    return (data, revert_params) if return_revert_params else data

            
    







            apply_mask



apply_mask(image: Union[Image, ndarray, List], **data)


    

            
              Source code in SaigeToolkit/data/transform/roi/roi_handler.py
              130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178 def apply_mask(
    self,
    image: Union[Image.Image, np.ndarray, List],
    **data,
):
    if self.blind_mask is None:
        data["image"] = image
        return data

    multipage = isinstance(image, List)

    # cv2 resize: 약간 부정확하지만 빠름. 여기서는 아주 정확할 필요없음.
    image_size = read_image_size(image[0] if multipage else image)
    blind_mask = cv2.resize(self.blind_mask, dsize=image_size, interpolation=cv2.INTER_NEAREST)
    bool_mask = blind_mask > 0

    if multipage:
        data["image"] = [fill_pixels_with_mask(image_i, bool_mask, value=0) for image_i in image]
    else:
        data["image"] = fill_pixels_with_mask(image, bool_mask, value=0)

    if self.image_only:
        return data

    # 라벨 크롭 & 마스킹
    if "mask" in data:
        data["mask"] = fill_pixels_with_mask(data["mask"], bool_mask, value=0)

    if "bboxes" in data:
        indices_alive = []

        if len(data["bboxes"]):
            xyxy_bboxes = data["bboxes"].convert_coordinate("xyxy")

            for i, bbox in enumerate(xyxy_bboxes):
                x0, y0, x1, y1 = bbox

                label_area = (x1 - x0) * (y1 - y0)
                overlapping_area = np.sum(blind_mask[int(y0) : int(y1), int(x0) : int(x1)])

                if overlapping_area / label_area < self.det_blind_mask_threshold:
                    indices_alive.append(i)

        data["bboxes"] = data["bboxes"][indices_alive]

        if "labels" in data:
            data["labels"] = data["labels"][indices_alive]

    return data

            
    







            __call__



__call__(return_revert_params: bool = False, warmup: bool = False, **data) -> Union[Dict, Tuple[Dict, Dict]]


    

            
              Source code in SaigeToolkit/data/transform/roi/roi_handler.py
              180
181
182
183
184
185
186
187
188
189
190
191
192
193 def __call__(
    self,
    return_revert_params: bool = False,
    warmup: bool = False,
    **data,
) -> Union[Dict, Tuple[Dict, Dict]]:
    if return_revert_params:
        data, revert_params = self.apply_crop(return_revert_params=True, warmup=warmup, **data)
        data = self.apply_mask(**data)
        return data, revert_params
    else:
        data = self.apply_crop(return_revert_params=False, warmup=warmup, **data)
        data = self.apply_mask(**data)
        return data

            
    







            _check_polygon_within_box



_check_polygon_within_box(polygon: List[List[float]], roi_coordinates: List[int]) -> bool


    

            
              Source code in SaigeToolkit/data/transform/roi/roi_handler.py
              195
196
197
198
199
200
201
202
203
204
205
206
207
208 def _check_polygon_within_box(self, polygon: List[List[float]], roi_coordinates: List[int]) -> bool:
    left, top, right, bottom = roi_coordinates

    def check_x_cord(p):
        return p >= left and p < right

    def check_y_cord(p):
        return p >= top and p < bottom

    def check_point_within_box(point_xy):
        x, y = point_xy
        return check_x_cord(x) and check_y_cord(y)

    return all(check_point_within_box(p) for p in polygon)

            
    





  

    






  

    




  

    








            transform




    

      End-to-end 데이터 변환을 지원하는 모듈입니다.



  













            Transform



Transform(image_mode: Union[str, List[str]] = 'RGB', inspection_size_wh: Optional[ImageSizeType] = None, roi: Optional[Dict] = None, resize: Optional[Dict] = None, augmentation: Optional[Dict] = None, roi_mask_first: bool = True)


    


                  
                    Source code in SaigeToolkit/data/transform/transform.py
                    44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70 def __init__(
    self,
    image_mode: Union[str, List[str]] = "RGB",
    inspection_size_wh: Optional[ImageSizeType] = None,
    roi: Optional[Dict] = None,
    resize: Optional[Dict] = None,
    augmentation: Optional[Dict] = None,
    roi_mask_first: bool = True,  # 하위 호환성을 위해 roi_mask_first=True를 기본값으로 설정
):
    self.roi_mask_first = roi_mask_first
    self.image_loader = ImageLoader(image_mode=image_mode)
    self.roi_handler = ROIHandler(**roi) if roi is not None else None
    self.base_resizer = Resizer(**resize) if resize is not None else None

    # inspection_size_wh 설정 시 그 값에 따라 초기화
    self.inspection_size_resizer: Optional[InspectionSizeResizer] = None
    self.stacked_resizer_handler: StackedResizerHandler = None

    # inspection_size_wh setter에서 inspection_size_resizer와 stacked_resizer_handler 생성
    self.inspection_size_wh = inspection_size_wh

    if augmentation is None:
        self.augmentation = None
    elif "_target_" in augmentation:
        self.augmentation = build_augmentation(augmentation)
    else:
        raise NotImplementedError("Old version of augmentation config is not supported.")

                  



  












            roi_mask_first


  
      instance-attribute
  


roi_mask_first = roi_mask_first


    
    








            image_loader


  
      instance-attribute
  


image_loader = ImageLoader(image_mode=image_mode)


    
    








            roi_handler


  
      instance-attribute
  


roi_handler = ROIHandler(**roi) if roi is not None else None


    
    








            base_resizer


  
      instance-attribute
  


base_resizer = Resizer(**resize) if resize is not None else None


    
    








            inspection_size_resizer


  
      instance-attribute
  


inspection_size_resizer: Optional[InspectionSizeResizer] = None


    
    








            stacked_resizer_handler


  
      instance-attribute
  


stacked_resizer_handler: StackedResizerHandler = None


    
    








            augmentation


  
      instance-attribute
  


augmentation = None


    
    








            inspection_size_wh


  
      property
      writable
  


inspection_size_wh: Optional[ImageSizeType]


    
    









            Operation





    
            
              Bases: str, Enum





  












            ROI


  
      class-attribute
      instance-attribute
  


ROI = auto()


    
    








            InspectionSize


  
      class-attribute
      instance-attribute
  


InspectionSize = auto()


    
    








            Resize


  
      class-attribute
      instance-attribute
  


Resize = auto()


    
    







  

    








            __call__



__call__(data: Dict, warmup: bool = False) -> Dict


    

      data Dict에 transform을 적용합니다.


Parameters:
    
        
          data
              (Dict)
          –
          
            data Dictionary
          
        
        
          warmup
              (bool, default:
                  False
)
          –
          
            InferenceHandler warmup시에 사용하는 파라미터 입니다. True일 경우,
                        현재 transform을 적용했을 때 나올 수 있는 가장 큰 image size로
                        transform을 적용합니다.
                     Transform operation 중 ROI의 경우 input image에 따라 output size가
                        매번 바뀔 수 있기 때문에 해당 옵션이 추가되었습니다.
                     Defaults to False.
          
        
    


Returns:
    
        
Dict (              Dict
)          –
          
            transform이 적용된 데이터 Dict입니다.
          
        
    

            
              Source code in SaigeToolkit/data/transform/transform.py
               92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161 def __call__(self, data: Dict, warmup: bool = False) -> Dict:
    """data Dict에 transform을 적용합니다.

    Args:
        data (Dict): data Dictionary
        warmup (bool, optional): InferenceHandler warmup시에 사용하는 파라미터 입니다. True일 경우,
                                    현재 transform을 적용했을 때 나올 수 있는 가장 큰 image size로
                                    transform을 적용합니다.
                                 Transform operation 중 ROI의 경우 input image에 따라 output size가
                                    매번 바뀔 수 있기 때문에 해당 옵션이 추가되었습니다.
                                 Defaults to False.

    Returns:
        Dict: transform이 적용된 데이터 Dict입니다.
    """
    # transform_params 설정
    if "transform_params" not in data:
        data["transform_params"] = {
            "operation_stack": [
                self.Operation.ROI,
                self.Operation.InspectionSize,
                self.Operation.Resize,
            ],
            "operation_params": {},
        }

    operation_params: Dict = data["transform_params"]["operation_params"]

    # load PIL Image
    data = self.image_loader(**data)

    # 원본 이미지가 inspection_size를 넘지 않도록 resize 했을 때의 image scale 계산
    if self.inspection_size_resizer is not None:
        self.inspection_size_resizer.set_scale_from_data(**data)

    # ROI crop 적용
    if self.roi_handler is not None:
        data, roi_revert_params = self.roi_handler.apply_crop(
            return_revert_params=True, warmup=warmup, **data
        )
        if self.roi_mask_first:
            data = self.roi_handler.apply_mask(**data)

        if self.Operation.ROI in operation_params:
            raise KeyError
        operation_params[self.Operation.ROI] = roi_revert_params

    # inspection_size와 resize_factor를 하나로 묶어서 resize
    data, revert_param_list = self.stacked_resizer_handler(return_revert_params=True, **data)
    inspection_size_revert_params, resizer_revert_params = revert_param_list

    if inspection_size_revert_params is not None:
        if self.Operation.InspectionSize in operation_params:
            raise KeyError
        operation_params[self.Operation.InspectionSize] = inspection_size_revert_params

    if resizer_revert_params is not None:
        if self.Operation.Resize in operation_params:
            raise KeyError
        operation_params[self.Operation.Resize] = resizer_revert_params

    # # ROI blind mask 적용
    if self.roi_handler is not None and not self.roi_mask_first:
        data = self.roi_handler.apply_mask(**data)

    # data augmentation
    if self.augmentation is not None:
        data = self.augmentation(**data)

    return data

            
    







            get_resize_scale


  
      classmethod
  


get_resize_scale(transform_params: Dict) -> List[float]


    

      before_transform_image_size -> after_transform_input_size가 되기 위한 scale을 구합니다.
before_transform_image_size * scale = after_transform_input_size


Parameters:
    
        
          transform_params
              (Dict)
          –
          
            transform시에 저장해둔 parameter 입니다.
          
        
    


Returns:
    
        
              List[float]
          –
          
            List[float]: before_transform_image_size * scale = after_transform_input_size인 scale
         scale: [scale_width, scale_height]
          
        
    

            
              Source code in SaigeToolkit/data/transform/transform.py
              163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196 @classmethod
def get_resize_scale(cls, transform_params: Dict) -> List[float]:
    """before_transform_image_size -> after_transform_input_size가 되기 위한 scale을 구합니다.
    before_transform_image_size * scale = after_transform_input_size

    Args:
        transform_params (Dict): transform시에 저장해둔 parameter 입니다.

    Returns:
        List[float]: before_transform_image_size * scale = after_transform_input_size인 scale
                     scale: [scale_width, scale_height]
    """
    operation_params: Dict = transform_params["operation_params"]
    inspection_size_revert_params = operation_params.get(cls.Operation.InspectionSize, None)
    resizer_revert_params = operation_params.get(cls.Operation.Resize, None)

    if inspection_size_revert_params is None and resizer_revert_params is None:
        resize_scale = [1.0, 1.0]
    else:
        if inspection_size_revert_params is None:
            image_size_before_resize = resizer_revert_params["image_size_before_resize"]
            image_size_after_resize = resizer_revert_params["image_size_after_resize"]
        elif resizer_revert_params is None:
            image_size_before_resize = inspection_size_revert_params["image_size_before_resize"]
            image_size_after_resize = inspection_size_revert_params["image_size_after_resize"]
        else:
            image_size_before_resize = inspection_size_revert_params["image_size_before_resize"]
            image_size_after_resize = resizer_revert_params["image_size_after_resize"]

        resize_scale = (
            np.array(image_size_after_resize) / np.array(image_size_before_resize)
        ).tolist()

    return resize_scale

            
    







            _get_next_revert_operation


  
      staticmethod
  


_get_next_revert_operation(transform_params: Dict) -> Optional[Operation]


    

      다음으로 할 revert operation을 가져옵니다. operation_stack에서 operation이 제거되지는 않습니다.


Parameters:
    
        
          transform_params
              (Dict)
          –
          
            transform시에 저장해둔 parameter 입니다.
          
        
    


Returns:
    
        
              Optional[Operation]
          –
          
            Optional[Operation]: 남아있는 revert operation이 있으면 operation을 없으면 None을 반환합니다.
          
        
    

            
              Source code in SaigeToolkit/data/transform/transform.py
              198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213 @staticmethod
def _get_next_revert_operation(transform_params: Dict) -> Optional[Operation]:
    """다음으로 할 revert operation을 가져옵니다. operation_stack에서 operation이 제거되지는 않습니다.

    Args:
        transform_params (Dict): transform시에 저장해둔 parameter 입니다.

    Returns:
        Optional[Operation]: 남아있는 revert operation이 있으면 operation을 없으면 None을 반환합니다.
    """
    operation_stack: List = transform_params["operation_stack"]
    next_operation = None
    if len(operation_stack) > 0:
        next_operation = operation_stack[-1]

    return next_operation

            
    







            revert


  
      classmethod
  


revert(data: Dict, transform_params: Dict, operation: Optional[Operation] = None) -> Dict


    

      summary


Parameters:
    
        
          data
              (Dict)
          –
          
            revert operation을 적용할 data dictionary입니다. data는 다음과 같은 구조를 지닙니다.
{
    "key1": {
        "data" (Union[np.ndarray, torch.Tensor, List[Dict]]): 실제 data입니다.
        "data_type" (str): 해당 data의 type 입니다. 현재 ["array", "objects"]를 지원합니다.
    },
    "key2": {
        "data" (Union[np.ndarray, torch.Tensor, List[Dict]]): 실제 data입니다.
        "data_type" (str): 해당 data의 type 입니다. 현재 ["array", "objects"]를 지원합니다.
    },
    ...
}
          
        
        
          transform_params
              (Dict)
          –
          
            transform시에 저장해둔 parameter 입니다.
          
        
        
          operation
              (Optional[Operation], default:
                  None
)
          –
          
            transform에서 revert가 가능한 operation 입니다.
                                        Enum class인 Transform.Operation에 있는 항목들을 지원합니다.
                                        operation이 None이 아닐 시, 해당 operation 까지 revert를 적용하고,
                                        None일 시, 그 다음 revert operation을 적용합니다.
                                        Defaults to None.
          
        
    


Raises:
    
        
              RevertOperationNotFoundError
            –
          
            args로 넣은 operation이 남은 revert operation 중에 없을 때 에러를 발생합니다.
          
        
    


Returns:
    
        
Dict (              Dict
)          –
          
            revert operation이 적용된 data dictionary 입니다. 구조는 Args의 data와 같습니다.
          
        
    

            
              Source code in SaigeToolkit/data/transform/transform.py
              215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264 @classmethod
def revert(
    cls,
    data: Dict,
    transform_params: Dict,
    operation: Optional[Operation] = None,
) -> Dict:
    """_summary_

    Args:
        data (Dict): revert operation을 적용할 data dictionary입니다. data는 다음과 같은 구조를 지닙니다.
            {
                "key1": {
                    "data" (Union[np.ndarray, torch.Tensor, List[Dict]]): 실제 data입니다.
                    "data_type" (str): 해당 data의 type 입니다. 현재 ["array", "objects"]를 지원합니다.
                },
                "key2": {
                    "data" (Union[np.ndarray, torch.Tensor, List[Dict]]): 실제 data입니다.
                    "data_type" (str): 해당 data의 type 입니다. 현재 ["array", "objects"]를 지원합니다.
                },
                ...
            }
        transform_params (Dict): transform시에 저장해둔 parameter 입니다.
        operation (Optional[Operation], optional): transform에서 revert가 가능한 operation 입니다.
                                                    Enum class인 Transform.Operation에 있는 항목들을 지원합니다.
                                                    operation이 None이 아닐 시, 해당 operation 까지 revert를 적용하고,
                                                    None일 시, 그 다음 revert operation을 적용합니다.
                                                    Defaults to None.

    Raises:
        RevertOperationNotFoundError: args로 넣은 operation이 남은 revert operation 중에 없을 때 에러를 발생합니다.

    Returns:
        Dict: revert operation이 적용된 data dictionary 입니다. 구조는 Args의 data와 같습니다.
    """
    # operation이 None인 경우 다음 revert operation 하나를 진행
    if operation is None:
        data = cls._revert(data=data, transform_params=transform_params)
    # operation이 None이 아닌 경우
    else:
        # 해당 operation이 operation_stack에 있는지 확인
        operation_stack: List = transform_params["operation_stack"]
        if operation not in operation_stack:
            raise RevertOperationNotFoundError
        # 해당 operation까지 revert를 적용
        while cls._get_next_revert_operation(transform_params=transform_params) != operation:
            data = cls._revert(data=data, transform_params=transform_params)
        data = cls._revert(data=data, transform_params=transform_params)

    return data

            
    







            _revert


  
      classmethod
  


_revert(data: Dict, transform_params: Dict) -> Dict


    

            
              Source code in SaigeToolkit/data/transform/transform.py
              266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294 @classmethod
def _revert(
    cls,
    data: Dict,
    transform_params: Dict,
) -> Dict:
    operation_stack: List = transform_params["operation_stack"]
    operation_params: Dict = transform_params["operation_params"]

    if cls._get_next_revert_operation(transform_params) is None:
        raise RevertOperationStackEmptyError

    next_revert_operation = operation_stack.pop()
    revert_params = operation_params.pop(next_revert_operation, None)

    next_revert_operation = {
        cls.Operation.ROI: cls._revert_roi,
        cls.Operation.Resize: cls._revert_resize,
        cls.Operation.InspectionSize: cls._revert_resize,
    }[next_revert_operation]

    result = {}
    for k, v in data.items():
        result[k] = {
            "data": next_revert_operation(revert_params=revert_params, **v),
            "data_type": v["data_type"],
        }

    return result

            
    







            _revert_resize


  
      staticmethod
  


_revert_resize(data: Optional[Union[Tensor, ndarray, List[Dict]]], revert_params: Optional[Dict], data_type: str) -> Union[Tensor, ndarray, List[Dict]]


    

            
              Source code in SaigeToolkit/data/transform/transform.py
              296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324 @staticmethod
def _revert_resize(
    data: Optional[Union[torch.Tensor, np.ndarray, List[Dict]]],
    revert_params: Optional[Dict],
    data_type: str,
) -> Union[torch.Tensor, np.ndarray, List[Dict]]:
    if data is not None and revert_params is not None:
        image_size_before_resize = revert_params["image_size_before_resize"]
        image_size_after_resize = revert_params["image_size_after_resize"]

        if list(image_size_after_resize) != list(image_size_before_resize):
            if data_type == "array":
                data = resize_array(array=data, target_size=image_size_before_resize)
            elif data_type == "objects":
                resize_scale = (
                    np.array(image_size_before_resize) / np.array(image_size_after_resize)
                ).tolist()
                data = scale_segments_properties(segments_properties=data, scale=resize_scale)
            elif data_type == "polygons":
                data = resize_polygon(
                    polygons=data,
                    image_size=image_size_after_resize,
                    tw=image_size_before_resize[0],
                    th=image_size_before_resize[1],
                )
            else:
                raise NotImplementedError

    return data

            
    







            _revert_roi


  
      staticmethod
  


_revert_roi(data: Optional[Union[Tensor, ndarray, List[Dict]]], revert_params: Optional[Dict], data_type: str) -> Union[Tensor, ndarray, List[Dict]]


    

            
              Source code in SaigeToolkit/data/transform/transform.py
              326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367 @staticmethod
def _revert_roi(
    data: Optional[Union[torch.Tensor, np.ndarray, List[Dict]]],
    revert_params: Optional[Dict],
    data_type: str,
) -> Union[torch.Tensor, np.ndarray, List[Dict]]:
    if data is not None and revert_params is not None:
        image_size_before_roi = revert_params["image_size_before_roi"]
        image_size_after_roi = revert_params["image_size_after_roi"]

        if list(image_size_before_roi) != list(image_size_after_roi):
            image_width, image_height = image_size_before_roi
            roi_left, roi_top, roi_right, roi_bottom = revert_params["roi_coordinates"]
            pad_left = roi_left
            pad_top = roi_top
            pad_right = image_width - roi_right
            pad_bottom = image_height - roi_bottom

            if data_type == "array":
                data = add_constant_margin_array(
                    array=data,
                    left=pad_left,
                    top=pad_top,
                    right=pad_right,
                    bottom=pad_bottom,
                    value=0,
                )
            elif data_type == "objects":
                data = translate_segments_properties(
                    segments_properties=data,
                    left=pad_left,
                    top=pad_top,
                )
            elif data_type == "polygons":
                data = translate_polygon(
                    polygons=data,
                    offset=(-pad_left, -pad_top),
                )
            else:
                raise NotImplementedError

    return data

            
    







            is_oversized


  
      staticmethod
  


is_oversized(transform_params: Optional[Dict]) -> bool


    

      InspectionSize 연산에서 resize 되었는지 여부를 판단

            
              Source code in SaigeToolkit/data/transform/transform.py
              369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387 @staticmethod
def is_oversized(transform_params: Optional[Dict]) -> bool:
    """InspectionSize 연산에서 resize 되었는지 여부를 판단"""
    if transform_params is None:
        return False

    inspection_size_params = get_tree_node_with_default(
        transform_params, ["operation_params", Transform.Operation.InspectionSize], None
    )
    if inspection_size_params is None:
        return False

    size1 = tuple(inspection_size_params["image_size_before_resize"])
    size2 = tuple(inspection_size_params["image_size_after_resize"])

    if size1 != size2:
        return True
    else:
        return False

            
    





  

    






  

    








            typevar




    



  












            ImageSizeType


  
      module-attribute
  


ImageSizeType = Sequence[int]


    
    








            ParamsType


  
      module-attribute
  


ParamsType = Dict[str, Any]


    
    








            ImageType


  
      module-attribute
  


ImageType = ndarray


    
    








            MaskType


  
      module-attribute
  


MaskType = ndarray


    
    








            BBoxesType


  
      module-attribute
  


BBoxesType = Union[ndarray, NumpyBoxes]


    
    








            PolygonType


  
      module-attribute
  


PolygonType = List[ndarray]


    
    








            OffsetType


  
      module-attribute
  


OffsetType = Tuple[float, float]

data

Module diagram

data

batch_sampler

balanced_sampler

BalancedSampler

calculate_patch_number instance-attribute

balance_state instance-attribute

_build_default_balance_keys

_extract_domain_source_category_from_key

_split_dataset_indices_using_keys

match_identifier

_update_subset_sizes

_calculate_subset_weights

generate_buffer

_update_dataset_num_patch

base_sampler

logger module-attribute

BatchSampler

registry instance-attribute

dataset instance-attribute

batch_size instance-attribute

repeat instance-attribute

shuffle instance-attribute

drop_last instance-attribute

_n_repeat instance-attribute

_buffer_length instance-attribute

buffer_length property

n_repeat property

__iter__

_get_processed_buffer

_shuffle_and_repeat_buffer

_batch_buffer

__len__

generate_buffer abstractmethod

NaiveSampler

generate_buffer

builder

build_batch_sampler

class_sampler

ClassBalancedSampler

MAX_NUM_CLS class-attribute instance-attribute

_make_weights_for_balanced_classes

generate_buffer

collate

default_device module-attribute

images_to_4d_tensor

_contiguous_div255

_merge_multipage_to_n_channel_array

crop

base_cropper

BaseCropper

get_n_patch abstractmethod

__call__ abstractmethod

builder

logger module-attribute

CROPPER_IMPLEMENTATION module-attribute

get_crop_fn

get_crop_class

edge_cropper

logger module-attribute

WindowState

IN class-attribute instance-attribute

WIDTH_POSITIVE_OUT class-attribute instance-attribute

WIDTH_NEGATIVE_OUT class-attribute instance-attribute

HEIGHT_POSITIVE_OUT class-attribute instance-attribute

HEIGHT_NEGATIVE_OUT class-attribute instance-attribute

WindowManager

width instance-attribute

half_width instance-attribute

height instance-attribute

half_height instance-attribute

strict_inner_patch instance-attribute

check_window

is_in_window

is_in_any_window

get_coordinates_from_center

CenterWithSatellite dataclass

coordinate instance-attribute

window_manager instance-attribute

calculate_patch_number `instance-attribute`

balance_state `instance-attribute`

logger `module-attribute`

registry `instance-attribute`

dataset `instance-attribute`

batch_size `instance-attribute`

repeat `instance-attribute`

shuffle `instance-attribute`

drop_last `instance-attribute`

_n_repeat `instance-attribute`

_buffer_length `instance-attribute`

buffer_length `property`

n_repeat `property`

iter

len

generate_buffer `abstractmethod`

MAX_NUM_CLS `class-attribute` `instance-attribute`

default_device `module-attribute`

get_n_patch `abstractmethod`

call `abstractmethod`

logger `module-attribute`

CROPPER_IMPLEMENTATION `module-attribute`

logger `module-attribute`

IN `class-attribute` `instance-attribute`

WIDTH_POSITIVE_OUT `class-attribute` `instance-attribute`

WIDTH_NEGATIVE_OUT `class-attribute` `instance-attribute`

HEIGHT_POSITIVE_OUT `class-attribute` `instance-attribute`

HEIGHT_NEGATIVE_OUT `class-attribute` `instance-attribute`

width `instance-attribute`

half_width `instance-attribute`

height `instance-attribute`

half_height `instance-attribute`

strict_inner_patch `instance-attribute`

CenterWithSatellite `dataclass`

coordinate `instance-attribute`

window_manager `instance-attribute`

max_width_distance `instance-attribute`

max_height_distance `instance-attribute`

min_width_distance `instance-attribute`

min_height_distance `instance-attribute`

satellite_points `instance-attribute`

crop_w `instance-attribute`

crop_h `instance-attribute`

window_manager `instance-attribute`

random_sample `instance-attribute`

patch_per_polygon `instance-attribute`

ok_patch_prob `instance-attribute`

n_defect_patch_made `instance-attribute`

call

logger `module-attribute`

chr_height `instance-attribute`

crop_jitter `instance-attribute`

crop_jitter_rate `instance-attribute`

save_polygons `instance-attribute`

call

mode `instance-attribute`

patch_per_polygon `instance-attribute`

random_patch_per_img `instance-attribute`

max_patch_per_img `instance-attribute`

force_random_patch_normal `instance-attribute`

strict_inner_patch `instance-attribute`

fixed_polygon_order `instance-attribute`

crop_w `property` `writable`

crop_h `property` `writable`

call

boxes_datas `module-attribute`

boxes `module-attribute`

coordinate `instance-attribute`

new

_check_boxes `staticmethod`