|
|
import cupy |
|
|
|
|
|
from cupy import _core |
|
|
from cupy.cuda import texture |
|
|
from cupy.cuda import runtime |
|
|
|
|
|
|
|
|
_affine_transform_2d_array_kernel = _core.ElementwiseKernel( |
|
|
'U texObj, raw float32 m, uint64 width', 'T transformed_image', |
|
|
''' |
|
|
float3 pixel = make_float3( |
|
|
(float)(i / width), |
|
|
(float)(i % width), |
|
|
1.0f |
|
|
); |
|
|
float x = dot(pixel, make_float3(m[0], m[1], m[2])) + .5f; |
|
|
float y = dot(pixel, make_float3(m[3], m[4], m[5])) + .5f; |
|
|
transformed_image = tex2D<T>(texObj, y, x); |
|
|
''', |
|
|
'cupyx_texture_affine_transformation_2d_array', |
|
|
preamble=''' |
|
|
inline __host__ __device__ float dot(float3 a, float3 b) |
|
|
{ |
|
|
return a.x * b.x + a.y * b.y + a.z * b.z; |
|
|
} |
|
|
''') |
|
|
|
|
|
|
|
|
_affine_transform_3d_array_kernel = _core.ElementwiseKernel( |
|
|
'U texObj, raw float32 m, uint64 height, uint64 width', |
|
|
'T transformed_volume', |
|
|
''' |
|
|
float4 voxel = make_float4( |
|
|
(float)(i / (width * height)), |
|
|
(float)((i % (width * height)) / width), |
|
|
(float)((i % (width * height)) % width), |
|
|
1.0f |
|
|
); |
|
|
float x = dot(voxel, make_float4(m[0], m[1], m[2], m[3])) + .5f; |
|
|
float y = dot(voxel, make_float4(m[4], m[5], m[6], m[7])) + .5f; |
|
|
float z = dot(voxel, make_float4(m[8], m[9], m[10], m[11])) + .5f; |
|
|
transformed_volume = tex3D<T>(texObj, z, y, x); |
|
|
''', |
|
|
'cupyx_texture_affine_transformation_3d_array', |
|
|
preamble=''' |
|
|
inline __host__ __device__ float dot(float4 a, float4 b) |
|
|
{ |
|
|
return a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w; |
|
|
} |
|
|
''') |
|
|
|
|
|
|
|
|
def _create_texture_object(data, |
|
|
address_mode: str, |
|
|
filter_mode: str, |
|
|
read_mode: str, |
|
|
border_color=0): |
|
|
|
|
|
if cupy.issubdtype(data.dtype, cupy.unsignedinteger): |
|
|
fmt_kind = runtime.cudaChannelFormatKindUnsigned |
|
|
elif cupy.issubdtype(data.dtype, cupy.integer): |
|
|
fmt_kind = runtime.cudaChannelFormatKindSigned |
|
|
elif cupy.issubdtype(data.dtype, cupy.floating): |
|
|
fmt_kind = runtime.cudaChannelFormatKindFloat |
|
|
else: |
|
|
raise ValueError(f'Unsupported data type {data.dtype}') |
|
|
|
|
|
if address_mode == 'nearest': |
|
|
address_mode = runtime.cudaAddressModeClamp |
|
|
elif address_mode == 'constant': |
|
|
address_mode = runtime.cudaAddressModeBorder |
|
|
else: |
|
|
raise ValueError( |
|
|
f'Unsupported address mode {address_mode} ' |
|
|
'(supported: constant, nearest)') |
|
|
|
|
|
if filter_mode == 'nearest': |
|
|
filter_mode = runtime.cudaFilterModePoint |
|
|
elif filter_mode == 'linear': |
|
|
filter_mode = runtime.cudaFilterModeLinear |
|
|
else: |
|
|
raise ValueError( |
|
|
f'Unsupported filter mode {filter_mode} ' |
|
|
f'(supported: nearest, linear)') |
|
|
|
|
|
if read_mode == 'element_type': |
|
|
read_mode = runtime.cudaReadModeElementType |
|
|
elif read_mode == 'normalized_float': |
|
|
read_mode = runtime.cudaReadModeNormalizedFloat |
|
|
else: |
|
|
raise ValueError( |
|
|
f'Unsupported read mode {read_mode} ' |
|
|
'(supported: element_type, normalized_float)') |
|
|
|
|
|
texture_fmt = texture.ChannelFormatDescriptor( |
|
|
data.itemsize * 8, 0, 0, 0, fmt_kind) |
|
|
|
|
|
array = texture.CUDAarray(texture_fmt, *data.shape[::-1]) |
|
|
res_desc = texture.ResourceDescriptor( |
|
|
runtime.cudaResourceTypeArray, cuArr=array) |
|
|
|
|
|
|
|
|
tex_desc = texture.TextureDescriptor( |
|
|
(address_mode, ) * data.ndim, filter_mode, read_mode, |
|
|
borderColors=(border_color, )) |
|
|
tex_obj = texture.TextureObject(res_desc, tex_desc) |
|
|
array.copy_from(data) |
|
|
|
|
|
return tex_obj |
|
|
|
|
|
|
|
|
def affine_transformation(data, |
|
|
transformation_matrix, |
|
|
output_shape=None, |
|
|
output=None, |
|
|
interpolation: str = 'linear', |
|
|
mode: str = 'constant', |
|
|
border_value=0): |
|
|
""" |
|
|
Apply an affine transformation. |
|
|
|
|
|
The method uses texture memory and supports only 2D and 3D float32 arrays |
|
|
without channel dimension. |
|
|
|
|
|
Args: |
|
|
data (cupy.ndarray): The input array or texture object. |
|
|
transformation_matrix (cupy.ndarray): Affine transformation matrix. |
|
|
Must be a homogeneous and have shape ``(ndim + 1, ndim + 1)``. |
|
|
output_shape (tuple of ints): Shape of output. If not specified, |
|
|
the input array shape is used. Default is None. |
|
|
output (cupy.ndarray or ~cupy.dtype): The array in which to place the |
|
|
output, or the dtype of the returned array. If not specified, |
|
|
creates the output array with shape of ``output_shape``. Default is |
|
|
None. |
|
|
interpolation (str): Specifies interpolation mode: ``'linear'`` or |
|
|
``'nearest'``. Default is ``'linear'``. |
|
|
mode (str): Specifies addressing mode for points outside of the array: |
|
|
(`'constant'``, ``'nearest'``). Default is ``'constant'``. |
|
|
border_value: Specifies value to be used for coordinates outside |
|
|
of the array for ``'constant'`` mode. Default is 0. |
|
|
|
|
|
Returns: |
|
|
cupy.ndarray: |
|
|
The transformed input. |
|
|
|
|
|
.. seealso:: :func:`cupyx.scipy.ndimage.affine_transform` |
|
|
""" |
|
|
|
|
|
ndim = data.ndim |
|
|
if (ndim < 2) or (ndim > 3): |
|
|
raise ValueError( |
|
|
'Texture memory affine transformation is defined only for ' |
|
|
'2D and 3D arrays without channel dimension.') |
|
|
|
|
|
dtype = data.dtype |
|
|
if dtype != cupy.float32: |
|
|
raise ValueError(f'Texture memory affine transformation is available ' |
|
|
f'only for float32 data type (not {dtype})') |
|
|
|
|
|
if interpolation not in ['linear', 'nearest']: |
|
|
raise ValueError( |
|
|
f'Unsupported interpolation {interpolation} ' |
|
|
f'(supported: linear, nearest)') |
|
|
|
|
|
if transformation_matrix.shape != (ndim + 1, ndim + 1): |
|
|
raise ValueError('Matrix must be have shape (ndim + 1, ndim + 1)') |
|
|
|
|
|
texture_object = _create_texture_object(data, |
|
|
address_mode=mode, |
|
|
filter_mode=interpolation, |
|
|
read_mode='element_type', |
|
|
border_color=border_value) |
|
|
|
|
|
if ndim == 2: |
|
|
kernel = _affine_transform_2d_array_kernel |
|
|
else: |
|
|
kernel = _affine_transform_3d_array_kernel |
|
|
|
|
|
if output_shape is None: |
|
|
output_shape = data.shape |
|
|
|
|
|
if output is None: |
|
|
output = cupy.zeros(output_shape, dtype=dtype) |
|
|
elif isinstance(output, (type, cupy.dtype)): |
|
|
if output != cupy.float32: |
|
|
raise ValueError(f'Texture memory affine transformation is ' |
|
|
f'available only for float32 data type (not ' |
|
|
f'{output})') |
|
|
output = cupy.zeros(output_shape, dtype=output) |
|
|
elif isinstance(output, cupy.ndarray): |
|
|
if output.shape != output_shape: |
|
|
raise ValueError('Output shapes do not match') |
|
|
else: |
|
|
raise ValueError('Output must be None, cupy.ndarray or cupy.dtype') |
|
|
|
|
|
kernel(texture_object, transformation_matrix, *output_shape[1:], output) |
|
|
return output |
|
|
|
