def __init__(
self,
keys: KeysCollection,
range_x: Union[Tuple[float, float], float] = 0.0,
range_y: Union[Tuple[float, float], float] = 0.0,
range_z: Union[Tuple[float, float], float] = 0.0,
prob: float = 0.1,
keep_size: bool = True,
mode: GridSampleModeSequence = GridSampleMode.BILINEAR,
padding_mode: GridSamplePadModeSequence = GridSamplePadMode.BORDER,
align_corners: Union[Sequence[bool], bool] = False,
):
super().__init__(keys)
self.range_x = ensure_tuple(range_x)
if len(self.range_x) == 1:
self.range_x = tuple(sorted([-self.range_x[0], self.range_x[0]]))
self.range_y = ensure_tuple(range_y)
if len(self.range_y) == 1:
self.range_y = tuple(sorted([-self.range_y[0], self.range_y[0]]))
self.range_z = ensure_tuple(range_z)
if len(self.range_z) == 1:
self.range_z = tuple(sorted([-self.range_z[0], self.range_z[0]]))
self.prob = prob
self.keep_size = keep_size
self.mode = ensure_tuple_rep(mode, len(self.keys))
self.padding_mode = ensure_tuple_rep(padding_mode, len(self.keys))
self.align_corners = ensure_tuple_rep(align_corners, len(self.keys))
self._do_transform = False
self.x = 0.0
self.y = 0.0
self.z = 0.0
def __init__(
self,
keys: KeysCollection,
output_postfixes: Sequence[str],
to_onehot: Union[Sequence[bool], bool] = False,
num_classes: Optional[Union[Sequence[int], int]] = None,
):
"""
Args:
keys: keys of the corresponding items to be transformed.
See also: :py:class:`ponai.transforms.compose.MapTransform`
output_postfixes: the postfixes to construct keys to store split data.
for example: if the key of input data is `pred` and split 2 classes, the output
data keys will be: pred_(output_postfixes[0]), pred_(output_postfixes[1])
to_onehot: whether to convert the data to One-Hot format, default is False.
it also can be a sequence of bool, each element corresponds to a key in ``keys``.
num_classes: the class number used to convert to One-Hot format
if `to_onehot` is True. it also can be a sequence of int, each element corresponds
to a key in ``keys``.
Raises:
ValueError: must specify key postfixes to store splitted data.
"""
super().__init__(keys)
self.output_postfixes = output_postfixes
self.to_onehot = ensure_tuple_rep(to_onehot, len(self.keys))
self.num_classes = ensure_tuple_rep(num_classes, len(self.keys))
self.splitter = SplitChannel()
def __init__(
self,
keys: KeysCollection,
argmax: Union[Sequence[bool], bool] = False,
to_onehot: Union[Sequence[bool], bool] = False,
n_classes: Optional[Union[Sequence[int], int]] = None,
threshold_values: Union[Sequence[bool], bool] = False,
logit_thresh: Union[Sequence[float], float] = 0.5,
):
"""
Args:
keys: keys of the corresponding items to model output and label.
See also: :py:class:`ponai.transforms.compose.MapTransform`
argmax: whether to execute argmax function on input data before transform.
it also can be a sequence of bool, each element corresponds to a key in ``keys``.
to_onehot: whether to convert input data into the one-hot format. Defaults to False.
it also can be a sequence of bool, each element corresponds to a key in ``keys``.
n_classes: the number of classes to convert to One-Hot format. it also can be a
sequence of int, each element corresponds to a key in ``keys``.
threshold_values: whether threshold the float value to int number 0 or 1, default is False.
it also can be a sequence of bool, each element corresponds to a key in ``keys``.
logit_thresh: the threshold value for thresholding operation, default is 0.5.
it also can be a sequence of float, each element corresponds to a key in ``keys``.
"""
super().__init__(keys)
self.argmax = ensure_tuple_rep(argmax, len(self.keys))
self.to_onehot = ensure_tuple_rep(to_onehot, len(self.keys))
self.n_classes = ensure_tuple_rep(n_classes, len(self.keys))
self.threshold_values = ensure_tuple_rep(threshold_values,
len(self.keys))
self.logit_thresh = ensure_tuple_rep(logit_thresh, len(self.keys))
self.converter = AsDiscrete()
def __init__(
self,
keys: KeysCollection,
sigmoid: Union[Sequence[bool], bool] = False,
softmax: Union[Sequence[bool], bool] = False,
other: Optional[Union[Sequence[Callable], Callable]] = None,
):
"""
Args:
keys: keys of the corresponding items to model output and label.
See also: :py:class:`ponai.transforms.compose.MapTransform`
sigmoid: whether to execute sigmoid function on model output before transform.
it also can be a sequence of bool, each element corresponds to a key in ``keys``.
softmax: whether to execute softmax function on model output before transform.
it also can be a sequence of bool, each element corresponds to a key in ``keys``.
other: callable function to execute other activation layers,
for example: `other = lambda x: torch.tanh(x)`. it also can be a sequence of Callable, each
element corresponds to a key in ``keys``.
"""
super().__init__(keys)
self.sigmoid = ensure_tuple_rep(sigmoid, len(self.keys))
self.softmax = ensure_tuple_rep(softmax, len(self.keys))
self.other = ensure_tuple_rep(other, len(self.keys))
self.converter = Activations()
def __init__(
self,
keys: KeysCollection,
spatial_size: Union[Sequence[int], int],
mode: InterpolateModeSequence = InterpolateMode.AREA,
align_corners=None,
):
super().__init__(keys)
self.mode = ensure_tuple_rep(mode, len(self.keys))
self.align_corners = ensure_tuple_rep(align_corners, len(self.keys))
self.resizer = Resize(spatial_size=spatial_size)
def __init__(
self,
keys: KeysCollection,
pixdim,
diagonal: bool = False,
mode: GridSampleModeSequence = GridSampleMode.BILINEAR,
padding_mode: GridSamplePadModeSequence = GridSamplePadMode.BORDER,
dtype: Optional[Union[Sequence[np.dtype], np.dtype]] = None,
meta_key_postfix: str = "meta_dict",
):
"""
Args:
pixdim (sequence of floats): output voxel spacing.
diagonal: whether to resample the input to have a diagonal affine matrix.
If True, the input data is resampled to the following affine::
np.diag((pixdim_0, pixdim_1, pixdim_2, 1))
This effectively resets the volume to the world coordinate system (RAS+ in nibabel).
The original orientation, rotation, shearing are not preserved.
If False, the axes orientation, orthogonal rotation and
translations components from the original affine will be
preserved in the target affine. This option will not flip/swap
axes against the original ones.
mode: {``"bilinear"``, ``"nearest"``}
Interpolation mode to calculate output values. Defaults to ``"bilinear"``.
See also: https://pytorch.org/docs/stable/nn.functional.html#grid-sample
It also can be a sequence of string, each element corresponds to a key in ``keys``.
padding_mode: {``"zeros"``, ``"border"``, ``"reflection"``}
Padding mode for outside grid values. Defaults to ``"border"``.
See also: https://pytorch.org/docs/stable/nn.functional.html#grid-sample
It also can be a sequence of string, each element corresponds to a key in ``keys``.
dtype (None or np.dtype or sequence of np.dtype): output array data type.
Defaults to None to use input data's dtype. It also can be a sequence of np.dtype,
each element corresponds to a key in ``keys``.
meta_key_postfix: use `key_{postfix}` to to fetch the meta data according to the key data,
default is `meta_dict`, the meta data is a dictionary object.
For example, to handle key `image`, read/write affine matrices from the
metadata `image_meta_dict` dictionary's `affine` field.
Raises:
ValueError: meta_key_postfix must be a string.
"""
super().__init__(keys)
self.spacing_transform = Spacing(pixdim, diagonal=diagonal)
self.mode = ensure_tuple_rep(mode, len(self.keys))
self.padding_mode = ensure_tuple_rep(padding_mode, len(self.keys))
self.dtype = ensure_tuple_rep(dtype, len(self.keys))
if not isinstance(meta_key_postfix, str):
raise ValueError("meta_key_postfix must be a string.")
self.meta_key_postfix = meta_key_postfix
def __init__(
self,
keys: KeysCollection,
zoom: Union[Sequence[float], float],
mode: InterpolateModeSequence = InterpolateMode.AREA,
align_corners=None,
keep_size: bool = True,
):
super().__init__(keys)
self.mode = ensure_tuple_rep(mode, len(self.keys))
self.align_corners = ensure_tuple_rep(align_corners, len(self.keys))
self.zoomer = Zoom(zoom=zoom, keep_size=keep_size)
def __init__(
self,
keys: KeysCollection,
angle: Union[Sequence[float], float],
keep_size: bool = True,
mode: GridSampleModeSequence = GridSampleMode.BILINEAR,
padding_mode: GridSamplePadModeSequence = GridSamplePadMode.BORDER,
align_corners: Union[Sequence[bool], bool] = False,
):
super().__init__(keys)
self.rotator = Rotate(angle=angle, keep_size=keep_size)
self.mode = ensure_tuple_rep(mode, len(self.keys))
self.padding_mode = ensure_tuple_rep(padding_mode, len(self.keys))
self.align_corners = ensure_tuple_rep(align_corners, len(self.keys))
def __init__(
self,
keys: KeysCollection,
spatial_border,
mode: NumpyPadModeSequence = NumpyPadMode.CONSTANT,
):
"""
Args:
keys: keys of the corresponding items to be transformed.
See also: :py:class:`ponai.transforms.compose.MapTransform`
spatial_border (int or sequence of int): specified size for every spatial border. it can be 3 shapes:
- single int number, pad all the borders with the same size.
- length equals the length of image shape, pad every spatial dimension separately.
for example, image shape(CHW) is [1, 4, 4], spatial_border is [2, 1],
pad every border of H dim with 2, pad every border of W dim with 1, result shape is [1, 8, 6].
- length equals 2 x (length of image shape), pad every border of every dimension separately.
for example, image shape(CHW) is [1, 4, 4], spatial_border is [1, 2, 3, 4], pad top of H dim with 1,
pad bottom of H dim with 2, pad left of W dim with 3, pad right of W dim with 4.
the result shape is [1, 7, 11].
mode: {``"constant"``, ``"edge"``, ``"linear_ramp"``, ``"maximum"``, ``"mean"``,
``"median"``, ``"minimum"``, ``"reflect"``, ``"symmetric"``, ``"wrap"``, ``"empty"``}
One of the listed string values or a user supplied function. Defaults to ``"constant"``.
See also: https://numpy.org/doc/1.18/reference/generated/numpy.pad.html
It also can be a sequence of string, each element corresponds to a key in ``keys``.
"""
super().__init__(keys)
self.mode = ensure_tuple_rep(mode, len(self.keys))
self.padder = BorderPad(spatial_border=spatial_border)
def __init__(
self,
keys: KeysCollection,
spatial_size,
method: Union[Method, str] = Method.SYMMETRIC,
mode: NumpyPadModeSequence = NumpyPadMode.CONSTANT,
):
"""
Args:
keys: keys of the corresponding items to be transformed.
See also: :py:class:`ponai.transforms.compose.MapTransform`
spatial_size (list): the spatial size of output data after padding.
If its components have non-positive values, the corresponding size of input image will be used.
method: {``"symmetric"``, ``"end"``}
Pad image symmetric on every side or only pad at the end sides. Defaults to ``"symmetric"``.
mode: {``"constant"``, ``"edge"``, ``"linear_ramp"``, ``"maximum"``, ``"mean"``,
``"median"``, ``"minimum"``, ``"reflect"``, ``"symmetric"``, ``"wrap"``, ``"empty"``}
One of the listed string values or a user supplied function. Defaults to ``"constant"``.
See also: https://numpy.org/doc/1.18/reference/generated/numpy.pad.html
It also can be a sequence of string, each element corresponds to a key in ``keys``.
"""
super().__init__(keys)
self.mode = ensure_tuple_rep(mode, len(self.keys))
self.padder = SpatialPad(spatial_size, method)
def __init__(
self,
keys: KeysCollection,
prefix: Union[Sequence[str], str] = "Data",
data_shape: Union[Sequence[bool], bool] = True,
value_range: Union[Sequence[bool], bool] = True,
data_value: Union[Sequence[bool], bool] = False,
additional_info: Optional[Union[Sequence[Callable], Callable]] = None,
logger_handler: Optional[Handler] = None,
):
"""
Args:
keys: keys of the corresponding items to be transformed.
See also: :py:class:`ponai.transforms.compose.MapTransform`
prefix: will be printed in format: "{prefix} statistics".
it also can be a sequence of string, each element corresponds to a key in ``keys``.
data_shape: whether to show the shape of input data.
it also can be a sequence of bool, each element corresponds to a key in ``keys``.
value_range: whether to show the value range of input data.
it also can be a sequence of bool, each element corresponds to a key in ``keys``.
data_value: whether to show the raw value of input data.
it also can be a sequence of bool, each element corresponds to a key in ``keys``.
a typical example is to print some properties of Nifti image: affine, pixdim, etc.
additional_info: user can define callable function to extract
additional info from input data. it also can be a sequence of string, each element
corresponds to a key in ``keys``.
logger_handler: add additional handler to output data: save to file, etc.
add existing python logging handlers: https://docs.python.org/3/library/logging.handlers.html
"""
super().__init__(keys)
self.prefix = ensure_tuple_rep(prefix, len(self.keys))
self.data_shape = ensure_tuple_rep(data_shape, len(self.keys))
self.value_range = ensure_tuple_rep(value_range, len(self.keys))
self.data_value = ensure_tuple_rep(data_value, len(self.keys))
self.additional_info = ensure_tuple_rep(additional_info,
len(self.keys))
self.logger_handler = logger_handler
self.printer = DataStats(logger_handler=logger_handler)
def __init__(
self,
keys: KeysCollection,
prob: float = 0.1,
min_zoom: Union[Sequence[float], float] = 0.9,
max_zoom: Union[Sequence[float], float] = 1.1,
mode: InterpolateModeSequence = InterpolateMode.AREA,
align_corners=None,
keep_size: bool = True,
):
super().__init__(keys)
if isinstance(min_zoom, Iterable) and isinstance(max_zoom, Iterable):
assert len(min_zoom) == len(max_zoom), "min_zoom and max_zoom must have same length."
self.min_zoom = min_zoom
self.max_zoom = max_zoom
self.prob = prob
self.mode = ensure_tuple_rep(mode, len(self.keys))
self.align_corners = ensure_tuple_rep(align_corners, len(self.keys))
self.keep_size = keep_size
self._do_transform = False
self._zoom: Union[Sequence[float], float]
def __init__(self,
keys: KeysCollection,
delay_time: Union[Sequence[float], float] = 0.0):
"""
Args:
keys: keys of the corresponding items to be transformed.
See also: :py:class:`ponai.transforms.compose.MapTransform`
delay_time: The minimum amount of time, in fractions of seconds, to accomplish this identity task.
It also can be a sequence of string, each element corresponds to a key in ``keys``.
"""
super().__init__(keys)
self.delay_time = ensure_tuple_rep(delay_time, len(self.keys))
self.delayer = SimulateDelay()
def __init__(self,
keys: KeysCollection,
dtype: Union[Sequence[np.dtype], np.dtype] = np.float32):
"""
Args:
keys: keys of the corresponding items to be transformed.
See also: :py:class:`ponai.transforms.compose.MapTransform`
dtype: convert image to this data type, default is `np.float32`.
it also can be a sequence of np.dtype, each element corresponds to a key in ``keys``.
"""
MapTransform.__init__(self, keys)
self.dtype = ensure_tuple_rep(dtype, len(self.keys))
self.converter = CastToType()
def get_valid_patch_size(image_size, patch_size):
"""
Given an image of dimensions `image_size`, return a patch size tuple taking the dimension from `patch_size` if this is
not 0/None. Otherwise, or if `patch_size` is shorter than `image_size`, the dimension from `image_size` is taken. This ensures
the returned patch size is within the bounds of `image_size`. If `patch_size` is a single number this is interpreted as a
patch of the same dimensionality of `image_size` with that size in each dimension.
"""
ndim = len(image_size)
try:
# if a single value was given as patch size, treat this as the size of the patch over all dimensions
single_patch_size = int(patch_size)
patch_size = ensure_tuple_rep(single_patch_size, ndim)
except TypeError: # raised if the patch size is multiple values
# ensure patch size is at least as long as number of dimensions
patch_size = ensure_tuple_size(patch_size, ndim)
# ensure patch size dimensions are not larger than image dimension, if a dimension is None or 0 use whole dimension
return tuple(min(ms, ps or ms) for ms, ps in zip(image_size, patch_size))
def __init__(self, spatial_dims: int, sigma, truncated: float = 4.0):
"""
Args:
spatial_dims: number of spatial dimensions of the input image.
must have shape (Batch, channels, H[, W, ...]).
sigma (float or sequence of floats): std.
truncated: spreads how many stds.
"""
super().__init__()
self.spatial_dims = int(spatial_dims)
_sigma = ensure_tuple_rep(sigma, self.spatial_dims)
self.kernel = [
torch.nn.Parameter(
torch.as_tensor(gaussian_1d(s, truncated), dtype=torch.float),
False) for s in _sigma
]
self.padding = [same_padding(k.size()[0]) for k in self.kernel]
self.conv_n = [F.conv1d, F.conv2d, F.conv3d][spatial_dims - 1]
for idx, param in enumerate(self.kernel):
self.register_parameter(f"kernel_{idx}", param)
def __init__(self,
keys: KeysCollection,
k,
mode: NumpyPadModeSequence = NumpyPadMode.CONSTANT):
"""
Args:
keys: keys of the corresponding items to be transformed.
See also: :py:class:`ponai.transforms.compose.MapTransform`
k (int or sequence of int): the target k for each spatial dimension.
if `k` is negative or 0, the original size is preserved.
if `k` is an int, the same `k` be applied to all the input spatial dimensions.
mode: {``"constant"``, ``"edge"``, ``"linear_ramp"``, ``"maximum"``, ``"mean"``,
``"median"``, ``"minimum"``, ``"reflect"``, ``"symmetric"``, ``"wrap"``, ``"empty"``}
One of the listed string values or a user supplied function. Defaults to ``"constant"``.
See also: https://numpy.org/doc/1.18/reference/generated/numpy.pad.html
It also can be a sequence of string, each element corresponds to a key in ``keys``.
See also :py:class:`ponai.transforms.SpatialPad`
"""
super().__init__(keys)
self.mode = ensure_tuple_rep(mode, len(self.keys))
self.padder = DivisiblePad(k=k)
def __init__(
self,
keys: KeysCollection,
sigma_range: Tuple[float, float],
magnitude_range: Tuple[float, float],
spatial_size: Optional[Union[Sequence[int], int]] = None,
prob: float = 0.1,
rotate_range: Optional[Union[Sequence[float], float]] = None,
shear_range: Optional[Union[Sequence[float], float]] = None,
translate_range: Optional[Union[Sequence[float], float]] = None,
scale_range: Optional[Union[Sequence[float], float]] = None,
mode: GridSampleModeSequence = GridSampleMode.BILINEAR,
padding_mode: GridSamplePadModeSequence = GridSamplePadMode.REFLECTION,
as_tensor_output: bool = False,
device: Optional[torch.device] = None,
):
"""
Args:
keys: keys of the corresponding items to be transformed.
sigma_range: a Gaussian kernel with standard deviation sampled from
``uniform[sigma_range[0], sigma_range[1])`` will be used to smooth the random offset grid.
magnitude_range: the random offsets on the grid will be generated from
``uniform[magnitude[0], magnitude[1])``.
spatial_size: specifying output image spatial size [h, w, d].
if `spatial_size` and `self.spatial_size` are not defined, or smaller than 1,
the transform will use the spatial size of `img`.
if the components of the `spatial_size` are non-positive values, the transform will use the
corresponding components of img size. For example, `spatial_size=(32, 32, -1)` will be adapted
to `(32, 32, 64)` if the third spatial dimension size of img is `64`.
prob: probability of returning a randomized affine grid.
defaults to 0.1, with 10% chance returns a randomized grid,
otherwise returns a ``spatial_size`` centered area extracted from the input image.
rotate_range: angle range in radians. rotate_range[0] with be used to generate the 1st rotation
parameter from `uniform[-rotate_range[0], rotate_range[0])`. Similarly, `rotate_range[1]` and
`rotate_range[2]` are used in 3D affine for the range of 2nd and 3rd axes.
shear_range: shear_range[0] with be used to generate the 1st shearing parameter from
`uniform[-shear_range[0], shear_range[0])`. Similarly, `shear_range[1]` and `shear_range[2]`
controls the range of the uniform distribution used to generate the 2nd and 3rd parameters.
translate_range : translate_range[0] with be used to generate the 1st shift parameter from
`uniform[-translate_range[0], translate_range[0])`. Similarly, `translate_range[1]` and
`translate_range[2]` controls the range of the uniform distribution used to generate
the 2nd and 3rd parameters.
scale_range: scaling_range[0] with be used to generate the 1st scaling factor from
`uniform[-scale_range[0], scale_range[0]) + 1.0`. Similarly, `scale_range[1]` and `scale_range[2]`
controls the range of the uniform distribution used to generate the 2nd and 3rd parameters.
mode: {``"bilinear"``, ``"nearest"``}
Interpolation mode to calculate output values. Defaults to ``"bilinear"``.
See also: https://pytorch.org/docs/stable/nn.functional.html#grid-sample
It also can be a sequence of string, each element corresponds to a key in ``keys``.
padding_mode: {``"zeros"``, ``"border"``, ``"reflection"``}
Padding mode for outside grid values. Defaults to ``"reflection"``.
See also: https://pytorch.org/docs/stable/nn.functional.html#grid-sample
It also can be a sequence of string, each element corresponds to a key in ``keys``.
as_tensor_output: the computation is implemented using pytorch tensors, this option specifies
whether to convert it back to numpy arrays.
device: device on which the tensor will be allocated.
See also:
- :py:class:`RandAffineGrid` for the random affine parameters configurations.
- :py:class:`Affine` for the affine transformation parameters configurations.
"""
super().__init__(keys)
self.rand_3d_elastic = Rand3DElastic(
sigma_range=sigma_range,
magnitude_range=magnitude_range,
prob=prob,
rotate_range=rotate_range,
shear_range=shear_range,
translate_range=translate_range,
scale_range=scale_range,
spatial_size=spatial_size,
as_tensor_output=as_tensor_output,
device=device,
)
self.mode = ensure_tuple_rep(mode, len(self.keys))
self.padding_mode = ensure_tuple_rep(padding_mode, len(self.keys))
def __init__(self, keys: KeysCollection, func: Callable) -> None:
super().__init__(keys)
self.func = ensure_tuple_rep(func, len(self.keys))
self.lambd = Lambda()
def write_png(
data,
file_name: str,
output_spatial_shape=None,
mode: Union[InterpolateMode, str] = InterpolateMode.BICUBIC,
scale=None,
):
"""
Write numpy data into png files to disk.
Spatially it supports HW for 2D.(H,W) or (H,W,3) or (H,W,4).
If `scale` is None, expect the input data in `np.uint8` or `np.uint16` type.
It's based on the Image module in PIL library:
https://pillow.readthedocs.io/en/stable/reference/Image.html
Args:
data (numpy.ndarray): input data to write to file.
file_name: expected file name that saved on disk.
output_spatial_shape (None or tuple of ints): spatial shape of the output image.
mode: {``"nearest"``, ``"linear"``, ``"bilinear"``, ``"bicubic"``, ``"trilinear"``, ``"area"``}
The interpolation mode. Defaults to ``"bicubic"``.
See also: https://pytorch.org/docs/stable/nn.functional.html#interpolate
scale (255, 65535): postprocess data by clipping to [0, 1] and scaling to
[0, 255] (uint8) or [0, 65535] (uint16). Default is None to disable scaling.
Raises:
ValueError: unsupported scale value: {scale}.
"""
assert isinstance(data, np.ndarray), "input data must be numpy array."
if len(
data.shape
) == 3 and data.shape[2] == 1: # PIL Image can't save image with 1 channel
data = data.squeeze(2)
if output_spatial_shape is not None:
output_spatial_shape = ensure_tuple_rep(output_spatial_shape, 2)
mode = InterpolateMode(mode)
align_corners = None if mode in (InterpolateMode.NEAREST,
InterpolateMode.AREA) else False
xform = Resize(spatial_size=output_spatial_shape,
mode=mode,
align_corners=align_corners)
_min, _max = np.min(data), np.max(data)
if len(data.shape) == 3:
data = np.moveaxis(data, -1, 0) # to channel first
data = xform(data)
data = np.moveaxis(data, 0, -1)
else: # (H, W)
data = np.expand_dims(data, 0) # make a channel
data = xform(data)[0] # first channel
if mode != InterpolateMode.NEAREST:
data = np.clip(data, _min, _max)
if scale is not None:
data = np.clip(data, 0.0,
1.0) # png writer only can scale data in range [0, 1]
if scale == np.iinfo(np.uint8).max:
data = (scale * data).astype(np.uint8)
elif scale == np.iinfo(np.uint16).max:
data = (scale * data).astype(np.uint16)
else:
raise ValueError(f"unsupported scale value: {scale}.")
img = Image.fromarray(data)
img.save(file_name, "PNG")
return