resize_array

odl.util.numerics.resize_array(arr, newshp, offset=None, pad_mode='constant', pad_const=0, direction='forward', out=None)

Return the resized version of arr with shape newshp.

In axes where newshp > arr.shape, padding is applied according to the supplied options. Where newshp < arr.shape, the array is cropped to the new size.

See the online documentation on resizing operators for mathematical details.

Parameters

arrarray-like

Array to be resized.

newshpsequence of ints

Desired shape of the output array.

offsetsequence of ints, optional

Specifies how many entries are added to/removed from the “left” side (corresponding to low indices) of arr.

pad_modestring, optional

Method to be used to fill in missing values in an enlarged array.

'constant': Fill with pad_const.

'symmetric': Reflect at the boundaries, not doubling the outmost values. This requires left and right padding sizes to be strictly smaller than the original array shape.

'periodic': Fill in values from the other side, keeping the order. This requires left and right padding sizes to be at most as large as the original array shape.

'order0': Extend constantly with the outmost values (ensures continuity).

'order1': Extend with constant slope (ensures continuity of the first derivative). This requires at least 2 values along each axis where padding is applied.

pad_constscalar, optional

Value to be used in the 'constant' padding mode.

direction{‘forward’, ‘adjoint’}

Determines which variant of the resizing is applied.

‘forward’ : in axes where out is larger than arr, apply padding. Otherwise, restrict to the smaller size.

‘adjoint’ : in axes where out is larger than arr, apply zero-padding. Otherwise, restrict to the smaller size and add the outside contributions according to pad_mode.

outnumpy.ndarray, optional

Array to write the result to. Must have shape newshp and be able to hold the data type of the input array.

Returns

resizednumpy.ndarray

Resized array created according to the above rules. If out was given, the returned object is a reference to it.

Examples

The input can be shrunk by simply providing a smaller size. By default, values are removed from the right. When enlarging, zero-padding is applied by default, and the zeros are added to the right side. That behavior can be changed with the offset parameter:

>>> from odl.util.numerics import resize_array
>>> resize_array([1, 2, 3], (1,))
array([1])
>>> resize_array([1, 2, 3], (1,), offset=2)
array([3])
>>> resize_array([1, 2, 3], (6,))
array([1, 2, 3, 0, 0, 0])
>>> resize_array([1, 2, 3], (7,), offset=2)
array([0, 0, 1, 2, 3, 0, 0])

The padding constant can be changed, as well as the padding mode:

>>> resize_array([1, 2, 3], (7,), pad_const=-1, offset=2)
array([-1, -1,  1,  2,  3, -1, -1])
>>> resize_array([1, 2, 3], (7,), pad_mode='periodic', offset=2)
array([2, 3, 1, 2, 3, 1, 2])
>>> resize_array([1, 2, 3], (7,), pad_mode='symmetric', offset=2)
array([3, 2, 1, 2, 3, 2, 1])
>>> resize_array([1, 2, 3], (7,), pad_mode='order0', offset=2)
array([1, 1, 1, 2, 3, 3, 3])
>>> resize_array([1, 2, 3], (7,), pad_mode='order1', offset=2)
array([-1,  0,  1,  2,  3,  4,  5])

Everything works for arbitrary number of dimensions:

>>> # Take the middle two columns and extend rows symmetrically
>>> resize_array([[1, 2, 3, 4],
...               [5, 6, 7, 8],
...               [9, 10, 11, 12]],
...               (5, 2), pad_mode='symmetric', offset=[1, 1])
array([[ 6,  7],
       [ 2,  3],
       [ 6,  7],
       [10, 11],
       [ 6,  7]])
>>> # Take the rightmost two columns and extend rows symmetrically
>>> # downwards
>>> resize_array([[1, 2, 3, 4],
...               [5, 6, 7, 8],
...               [9, 10, 11, 12]], (5, 2), pad_mode='symmetric',
...              offset=[0, 2])
array([[ 3,  4],
       [ 7,  8],
       [11, 12],
       [ 7,  8],
       [ 3,  4]])