#### Previous topic

scipy.ndimage.gaussian_laplace

#### Next topic

scipy.ndimage.generic_filter1d

# scipy.ndimage.generic_filter

`scipy.ndimage.``generic_filter`(input, function, size=None, footprint=None, output=None, mode='reflect', cval=0.0, origin=0, extra_arguments=(), extra_keywords=None)

  Calculates a multi-dimensional filter using the given function.

  At each element the provided function is called. The input values within the filter footprint at that element are passed to the function as a 1D array of double values.

  Parameters:

  input : array_like

  > Input array to filter.

  function : {callable, scipy.LowLevelCallable}

  > Function to apply at each element.

  size : scalar or tuple, optional

  > See footprint, below

  footprint : array, optional

  > Either size or footprint must be defined. size gives the shape that is taken from the input array, at every element position, to define the input to the filter function. footprint is a boolean array that specifies (implicitly) a shape, but also which of the elements within this shape will get passed to the filter function. Thus `size=(n,m)` is equivalent to `footprint=np.ones((n,m))`. We adjust size to the number of dimensions of the input array, so that, if the input array is shape (10,10,10), and size is 2, then the actual size used is (2,2,2).

  output : array, optional

  > The output parameter passes an array in which to store the filter output. Output array should have different name as compared to input array to avoid aliasing errors.

  mode : {‘reflect’, ‘constant’, ‘nearest’, ‘mirror’, ‘wrap’}, optional

  > The mode parameter determines how the array borders are handled, where cval is the value when mode is equal to ‘constant’. Default is ‘reflect’

  cval : scalar, optional

  > Value to fill past edges of input if mode is ‘constant’. Default is 0.0

  origin : scalar, optional

  > The origin parameter controls the placement of the filter. Default 0.0.

  extra_arguments : sequence, optional

  > Sequence of extra positional arguments to pass to passed function

  extra_keywords : dict, optional

  > dict of extra keyword arguments to pass to passed function

  Notes

  This function also accepts low-level callback functions with one of the following signatures and wrapped in `scipy.LowLevelCallable`:

      int callback(double *buffer, npy_intp filter_size,
                   double *return_value, void *user_data)
      int callback(double *buffer, intptr_t filter_size,
                   double *return_value, void *user_data)

  The calling function iterates over the elements of the input and output arrays, calling the callback function at each element. The elements within the footprint of the filter at the current element are passed through the `buffer` parameter, and the number of elements within the footprint through `filter_size`. The calculated value is returned in `return_value`. `user_data` is the data pointer provided to `scipy.LowLevelCallable` as-is.

  The callback function must return an integer error status that is zero if something went wrong and one otherwise. If an error occurs, you should normally set the python error status with an informative message before returning, otherwise a default error message is set by the calling function.

  In addition, some other low-level function pointer specifications are accepted, but these are for backward compatibility only and should not be used in new code.