File size: 3,130 Bytes
5ccd75a | 1 2 3 4 5 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 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 | # Copyright 2020 MONAI Consortium
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
# http://www.apache.org/licenses/LICENSE-2.0
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import Sequence, Tuple, Union
import numpy as np
__all__ = ["same_padding", "calculate_out_shape", "gaussian_1d"]
def same_padding(
kernel_size: Union[Sequence[int], int], dilation: Union[Sequence[int], int] = 1
) -> Union[Tuple[int, ...], int]:
"""
Return the padding value needed to ensure a convolution using the given kernel size produces an output of the same
shape as the input for a stride of 1, otherwise ensure a shape of the input divided by the stride rounded down.
Raises:
NotImplementedError: When ``np.any((kernel_size - 1) * dilation % 2 == 1)``.
"""
kernel_size_np = np.atleast_1d(kernel_size)
dilation_np = np.atleast_1d(dilation)
if np.any((kernel_size_np - 1) * dilation % 2 == 1):
raise NotImplementedError(
f"Same padding not available for kernel_size={kernel_size_np} and dilation={dilation_np}."
)
padding_np = (kernel_size_np - 1) / 2 * dilation_np
padding = tuple(int(p) for p in padding_np)
return padding if len(padding) > 1 else padding[0]
def calculate_out_shape(
in_shape: Union[Sequence[int], int],
kernel_size: Union[Sequence[int], int],
stride: Union[Sequence[int], int],
padding: Union[Sequence[int], int],
) -> Union[Tuple[int, ...], int]:
"""
Calculate the output tensor shape when applying a convolution to a tensor of shape `inShape` with kernel size
`kernel_size`, stride value `stride`, and input padding value `padding`. All arguments can be scalars or multiple
values, return value is a scalar if all inputs are scalars.
"""
in_shape_np = np.atleast_1d(in_shape)
kernel_size_np = np.atleast_1d(kernel_size)
stride_np = np.atleast_1d(stride)
padding_np = np.atleast_1d(padding)
out_shape_np = ((in_shape_np - kernel_size_np + padding_np + padding_np) // stride_np) + 1
out_shape = tuple(int(s) for s in out_shape_np)
return out_shape if len(out_shape) > 1 else out_shape[0]
def gaussian_1d(sigma: float, truncated: float = 4.0) -> np.ndarray:
"""
one dimensional gaussian kernel.
Args:
sigma: std of the kernel
truncated: tail length
Raises:
ValueError: When ``sigma`` is nonpositive.
Returns:
1D numpy array
"""
if sigma <= 0:
raise ValueError(f"sigma must be positive, got {sigma}.")
tail = int(sigma * truncated + 0.5)
sigma2 = sigma * sigma
x = np.arange(-tail, tail + 1)
out = np.exp(-0.5 / sigma2 * x ** 2)
out /= out.sum()
return out
|