File size: 7,477 Bytes
995244d |
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 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 |
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)
# CUDAArray: last dimension is the fastest changing dimension
array = texture.CUDAarray(texture_fmt, *data.shape[::-1])
res_desc = texture.ResourceDescriptor(
runtime.cudaResourceTypeArray, cuArr=array)
# TODO(the-lay): each dimension can have a different addressing mode
# TODO(the-lay): border color/value can be defined for up to 4 channels
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
|