def generic_filter1d(input, function, filter_size, axis = -1,
output = None, mode = "reflect", cval = 0.0, origin = 0,
extra_arguments = (), extra_keywords = {}):
"""Calculate a one-dimensional filter along the given axis.
The function iterates over the lines of the array, calling the given
function at each line. The arguments of the line are the input line,
and the output line. The input and output lines are 1D double arrays.
The input line is extended appropiately according to the filter size
and origin. The output line must be modified in-place with the result.
The origin parameter controls the placement of the filter. The mode
parameter determines how the array borders are handled, where cval is
the value when mode is equal to 'constant'. The extra_arguments and
extra_keywords arguments can be used to pass extra arguments and
keywords that are passed to the function at each call."""
input = numpy.asarray(input)
if numpy.iscomplexobj(input):
raise TypeError, 'Complex type not supported'
output, return_value = _ni_support._get_output(output, input)
if filter_size < 1:
raise RuntimeError, 'invalid filter size'
axis = _ni_support._check_axis(axis, input.ndim)
if ((filter_size // 2 + origin < 0) or
(filter_size // 2 + origin > filter_size)):
raise ValueError, 'invalid origin'
mode = _ni_support._extend_mode_to_code(mode)
_nd_image.generic_filter1d(input, function, filter_size, axis, output,
mode, cval, origin, extra_arguments, extra_keywords)
return return_value
def generic_filter1d(input,
function,
filter_size,
axis=-1,
output=None,
mode="reflect",
cval=0.0,
origin=0,
extra_arguments=(),
extra_keywords=None):
"""Calculate a one-dimensional filter along the given axis.
generic_filter1d iterates over the lines of the array, calling the
given function at each line. The arguments of the line are the
input line, and the output line. The input and output lines are 1D
double arrays. The input line is extended appropriately according
to the filter size and origin. The output line must be modified
in-place with the result.
Parameters
----------
%(input)s
function : callable
function to apply along given axis
filter_size : scalar
length of the filter
%(axis)s
%(output)s
%(mode)s
%(cval)s
%(origin)s
%(extra_arguments)s
%(extra_keywords)s
"""
if extra_keywords is None:
extra_keywords = {}
input = numpy.asarray(input)
if numpy.iscomplexobj(input):
raise TypeError, 'Complex type not supported'
output, return_value = _ni_support._get_output(output, input)
if filter_size < 1:
raise RuntimeError, 'invalid filter size'
axis = _ni_support._check_axis(axis, input.ndim)
if ((filter_size // 2 + origin < 0)
or (filter_size // 2 + origin > filter_size)):
raise ValueError, 'invalid origin'
mode = _ni_support._extend_mode_to_code(mode)
_nd_image.generic_filter1d(input, function, filter_size, axis, output,
mode, cval, origin, extra_arguments,
extra_keywords)
return return_value
def generic_filter1d(input, function, filter_size, axis = -1,
output = None, mode = "reflect", cval = 0.0, origin = 0,
extra_arguments = (), extra_keywords = None):
"""Calculate a one-dimensional filter along the given axis.
generic_filter1d iterates over the lines of the array, calling the
given function at each line. The arguments of the line are the
input line, and the output line. The input and output lines are 1D
double arrays. The input line is extended appropriately according
to the filter size and origin. The output line must be modified
in-place with the result.
Parameters
----------
%(input)s
function : callable
function to apply along given axis
filter_size : scalar
length of the filter
%(axis)s
%(output)s
%(mode)s
%(cval)s
%(origin)s
%(extra_arguments)s
%(extra_keywords)s
"""
if extra_keywords is None:
extra_keywords = {}
input = numpy.asarray(input)
if numpy.iscomplexobj(input):
raise TypeError('Complex type not supported')
output, return_value = _ni_support._get_output(output, input)
if filter_size < 1:
raise RuntimeError('invalid filter size')
axis = _ni_support._check_axis(axis, input.ndim)
if ((filter_size // 2 + origin < 0) or
(filter_size // 2 + origin > filter_size)):
raise ValueError('invalid origin')
mode = _ni_support._extend_mode_to_code(mode)
_nd_image.generic_filter1d(input, function, filter_size, axis, output,
mode, cval, origin, extra_arguments, extra_keywords)
return return_value
def generic_filter1d(input,
function,
filter_size,
axis=-1,
output=None,
mode="reflect",
cval=0.0,
origin=0,
extra_arguments=(),
extra_keywords={}):
"""Calculate a one-dimensional filter along the given axis.
The function iterates over the lines of the array, calling the given
function at each line. The arguments of the line are the input line,
and the output line. The input and output lines are 1D double arrays.
The input line is extended appropiately according to the filter size
and origin. The output line must be modified in-place with the result.
The origin parameter controls the placement of the filter. The mode
parameter determines how the array borders are handled, where cval is
the value when mode is equal to 'constant'. The extra_arguments and
extra_keywords arguments can be used to pass extra arguments and
keywords that are passed to the function at each call."""
input = numarray.asarray(input)
if isinstance(input.type(), numarray.ComplexType):
raise TypeError, 'Complex type not supported'
output, return_value = _ni_support._get_output(output, input)
if filter_size < 1:
raise RuntimeError, 'invalid filter size'
axis = _ni_support._check_axis(axis, input.rank)
if ((filter_size // 2 + origin < 0)
or (filter_size // 2 + origin > filter_size)):
raise ValueError, 'invalid origin'
mode = _ni_support._extend_mode_to_code(mode)
_nd_image.generic_filter1d(input, function, filter_size, axis, output,
mode, cval, origin, extra_arguments,
extra_keywords)
return return_value
