original_docstring: 
      Apply an affine transformation.
  
      The given matrix and offset are used to find for each point in the
      output the corresponding coordinates in the input by an affine
      transformation. The value of the input at those coordinates is
      determined by spline interpolation of the requested order. Points
      outside the boundaries of the input are filled according to the given
      mode.
  
      Given an output image pixel index vector ``o``, the pixel value
      is determined from the input image at position ``np.dot(matrix,o) + offset``.
  
      A diagonal matrix can be specified by supplying a one-dimensional
      array-like to the matrix parameter, in which case a more efficient
      algorithm is applied.
  
      .. versionchanged:: 0.18.0
          Previously, the exact interpretation of the affine transformation
          depended on whether the matrix was supplied as a one-dimensional or
          two-dimensional array. If a one-dimensional array was supplied
          to the matrix parameter, the output pixel value at index ``o``
          was determined from the input image at position ``matrix * (o + offset)``.
  
      Parameters
      ----------
      input : ndarray
          The input array.
      matrix : ndarray
          The matrix must be two-dimensional or can also be given as a
          one-dimensional sequence or array. In the latter case, it is assumed
          that the matrix is diagonal. A more efficient algorithms is then
          applied that exploits the separability of the problem.
      offset : float or sequence, optional
          The offset into the array where the transform is applied. If a float,
          `offset` is the same for each axis. If a sequence, `offset` should
          contain one value for each axis.
      output_shape : tuple of ints, optional
          Shape tuple.
      output : ndarray or dtype, optional
          The array in which to place the output, or the dtype of the returned
          array.
      order : int, optional
          The order of the spline interpolation, default is 3.
          The order has to be in the range 0-5.
      mode : str, optional
          Points outside the boundaries of the input are filled according
          to the given mode ('constant', 'nearest', 'reflect' or 'wrap').
          Default is 'constant'.
      cval : scalar, optional
          Value used for points outside the boundaries of the input if
          ``mode='constant'``. Default is 0.0
      prefilter : bool, optional
          The parameter prefilter determines if the input is pre-filtered with
          `spline_filter` before interpolation (necessary for spline
          interpolation of order > 1).  If False, it is assumed that the input is
          already filtered. Default is True.
  
      Returns
      -------
      affine_transform : ndarray or None
          The transformed input. If `output` is given as a parameter, None is
          returned.
  
      
docstring: Apply an affine transformation.
  The given matrix and offset are used to find for each point in the
  output the corresponding coordinates in the input by an affine
  transformation. The value of the input at those coordinates is
  determined by spline interpolation of the requested order. Points
  outside the boundaries of the input are filled according to the given
  mode.
  
  
  
  A diagonal matrix can be specified by supplying a one-dimensional
  array-like to the matrix parameter, in which case a more efficient
  algorithm is applied.
  
  : 0.18.0
  Previously, the exact interpretation of the affine transformation
  depended on whether the matrix was supplied as a one-dimensional or
  two-dimensional array.
  
  Parameters
  
  input : ndarray
  The input array.
  matrix : ndarray
  The matrix must be two-dimensional or can also be given as a
  one-dimensional sequence or array. In the latter case, it is assumed
  that the matrix is diagonal. A more efficient algorithms is then
  applied that exploits the separability of the problem.
  offset : float or sequence, optional
  The offset into the array where the transform is applied. If a float,
  `offset` is the same for each axis. If a sequence, `offset` should
  contain one value for each axis.
  output_shape : tuple of ints, optional
  Shape tuple.
  output : ndarray or dtype, optional
  The array in which to place the output, or the dtype of the returned
  array.
  order : int, optional
  The order of the spline interpolation, default is 3.
  The order has to be in the range 0-5.
  
  Returns
  
  affine_transform : ndarray or None
  The transformed input. If `output` is given as a parameter, None is
  returned.
docstring_tokens: Apply an affine transformation . The given matrix and offset are used to find for each point in the output the corresponding coordinates in the input by an affine transformation . The value of the input at those coordinates is determined by spline interpolation of the requested order . Points outside the boundaries of the input are filled according to the given mode . A diagonal matrix can be specified by supplying a one - dimensional array - like to the matrix parameter in which case a more efficient algorithm is applied . : 0 . 18 . 0 Previously the exact interpretation of the affine transformation depended on whether the matrix was supplied as a one - dimensional or two - dimensional array . Parameters input : ndarray The input array . matrix : ndarray The matrix must be two - dimensional or can also be given as a one - dimensional sequence or array . In the latter case it is assumed that the matrix is diagonal . A more efficient algorithms is then applied that exploits the separability of the problem . offset : float or sequence optional The offset into the array where the transform is applied . If a float ` offset ` is the same for each axis . If a sequence ` offset ` should contain one value for each axis . output_shape : tuple of ints optional Shape tuple . output : ndarray or dtype optional The array in which to place the output or the dtype of the returned array . order : int optional The order of the spline interpolation default is 3 . The order has to be in the range 0 - 5 . Returns affine_transform : ndarray or None The transformed input . If ` output ` is given as a parameter None is returned .
code: def affine_transform(input, matrix, offset=0.0, output_shape=None,
                       output=None, order=3,
                       mode='constant', cval=0.0, prefilter=True):
      """
      Apply an affine transformation.
  
      The given matrix and offset are used to find for each point in the
      output the corresponding coordinates in the input by an affine
      transformation. The value of the input at those coordinates is
      determined by spline interpolation of the requested order. Points
      outside the boundaries of the input are filled according to the given
      mode.
  
      Given an output image pixel index vector ``o``, the pixel value
      is determined from the input image at position ``np.dot(matrix,o) + offset``.
  
      A diagonal matrix can be specified by supplying a one-dimensional
      array-like to the matrix parameter, in which case a more efficient
      algorithm is applied.
  
      .. versionchanged:: 0.18.0
          Previously, the exact interpretation of the affine transformation
          depended on whether the matrix was supplied as a one-dimensional or
          two-dimensional array. If a one-dimensional array was supplied
          to the matrix parameter, the output pixel value at index ``o``
          was determined from the input image at position ``matrix * (o + offset)``.
  
      Parameters
      ----------
      input : ndarray
          The input array.
      matrix : ndarray
          The matrix must be two-dimensional or can also be given as a
          one-dimensional sequence or array. In the latter case, it is assumed
          that the matrix is diagonal. A more efficient algorithms is then
          applied that exploits the separability of the problem.
      offset : float or sequence, optional
          The offset into the array where the transform is applied. If a float,
          `offset` is the same for each axis. If a sequence, `offset` should
          contain one value for each axis.
      output_shape : tuple of ints, optional
          Shape tuple.
      output : ndarray or dtype, optional
          The array in which to place the output, or the dtype of the returned
          array.
      order : int, optional
          The order of the spline interpolation, default is 3.
          The order has to be in the range 0-5.
      mode : str, optional
          Points outside the boundaries of the input are filled according
          to the given mode ('constant', 'nearest', 'reflect' or 'wrap').
          Default is 'constant'.
      cval : scalar, optional
          Value used for points outside the boundaries of the input if
          ``mode='constant'``. Default is 0.0
      prefilter : bool, optional
          The parameter prefilter determines if the input is pre-filtered with
          `spline_filter` before interpolation (necessary for spline
          interpolation of order > 1).  If False, it is assumed that the input is
          already filtered. Default is True.
  
      Returns
      -------
      affine_transform : ndarray or None
          The transformed input. If `output` is given as a parameter, None is
          returned.
  
      """
      if order < 0 or order > 5:
          raise RuntimeError('spline order not supported')
      input = numpy.asarray(input)
      if numpy.iscomplexobj(input):
          raise TypeError('Complex type not supported')
      if output_shape is None:
          output_shape = input.shape
      if input.ndim < 1 or len(output_shape) < 1:
          raise RuntimeError('input and output rank must be > 0')
      mode = _extend_mode_to_code(mode)
      if prefilter and order > 1:
          filtered = spline_filter(input, order, output=numpy.float64)
      else:
          filtered = input
      output, return_value = _ni_support._get_output(output, input,
                                                     shape=output_shape)
      matrix = numpy.asarray(matrix, dtype=numpy.float64)
      if matrix.ndim not in [1, 2] or matrix.shape[0] < 1:
          raise RuntimeError('no proper affine matrix provided')
      if matrix.shape[0] != input.ndim:
          raise RuntimeError('affine matrix has wrong number of rows')
      if matrix.ndim == 2 and matrix.shape[1] != output.ndim:
          raise RuntimeError('affine matrix has wrong number of columns')
      if not matrix.flags.contiguous:
          matrix = matrix.copy()
      offset = _ni_support._normalize_sequence(offset, input.ndim)
      offset = numpy.asarray(offset, dtype=numpy.float64)
      if offset.ndim != 1 or offset.shape[0] < 1:
          raise RuntimeError('no proper offset provided')
      if not offset.flags.contiguous:
          offset = offset.copy()
      if matrix.ndim == 1:
          warnings.warn(
              "The behaviour of affine_transform with a one-dimensional "
              "array supplied for the matrix parameter has changed in "
              "scipy 0.18.0."
          )
          _nd_image.zoom_shift(filtered, matrix, offset/matrix, output, order,
                               mode, cval)
      else:
          _geometric_transform(filtered, None, None, matrix, offset,
                               output, order, mode, cval, None, None)
      return return_value
code_tokens: def affine_transform ( input , matrix , offset = 0.0 , output_shape = None , output = None , order = 3 , mode = 'constant' , cval = 0.0 , prefilter = True ) : if order < 0 or order > 5 : raise RuntimeError ( 'spline order not supported' ) input = numpy . asarray ( input ) if numpy . iscomplexobj ( input ) : raise TypeError ( 'Complex type not supported' ) if output_shape is None : output_shape = input . shape if input . ndim < 1 or len ( output_shape ) < 1 : raise RuntimeError ( 'input and output rank must be > 0' ) mode = _extend_mode_to_code ( mode ) if prefilter and order > 1 : filtered = spline_filter ( input , order , output = numpy . float64 ) else : filtered = input output , return_value = _ni_support . _get_output ( output , input , shape = output_shape ) matrix = numpy . asarray ( matrix , dtype = numpy . float64 ) if matrix . ndim not in [ 1 , 2 ] or matrix . shape [ 0 ] < 1 : raise RuntimeError ( 'no proper affine matrix provided' ) if matrix . shape [ 0 ] != input . ndim : raise RuntimeError ( 'affine matrix has wrong number of rows' ) if matrix . ndim == 2 and matrix . shape [ 1 ] != output . ndim : raise RuntimeError ( 'affine matrix has wrong number of columns' ) if not matrix . flags . contiguous : matrix = matrix . copy ( ) offset = _ni_support . _normalize_sequence ( offset , input . ndim ) offset = numpy . asarray ( offset , dtype = numpy . float64 ) if offset . ndim != 1 or offset . shape [ 0 ] < 1 : raise RuntimeError ( 'no proper offset provided' ) if not offset . flags . contiguous : offset = offset . copy ( ) if matrix . ndim == 1 : warnings . warn ( "The behaviour of affine_transform with a one-dimensional " "array supplied for the matrix parameter has changed in " "scipy 0.18.0." ) _nd_image . zoom_shift ( filtered , matrix , offset / matrix , output , order , mode , cval ) else : _geometric_transform ( filtered , None , None , matrix , offset , output , order , mode , cval , None , None ) return return_value
short_docstring: Apply an affine transformation.
short_docstring_tokens: Apply an affine transformation .
comment: """
      Apply an affine transformation.
  
      The given matrix and offset are used to find for each point in the
      output the corresponding coordinates in the input by an affine
      transformation. The value of the input at those coordinates is
      determined by spline interpolation of the requested order. Points
      outside the boundaries of the input are filled according to the given
      mode.
  
      Given an output image pixel index vector ``o``, the pixel value
      is determined from the input image at position ``np.dot(matrix,o) + offset``.
  
      A diagonal matrix can be specified by supplying a one-dimensional
      array-like to the matrix parameter, in which case a more efficient
      algorithm is applied.
  
      .. versionchanged:: 0.18.0
          Previously, the exact interpretation of the affine transformation
          depended on whether the matrix was supplied as a one-dimensional or
          two-dimensional array. If a one-dimensional array was supplied
          to the matrix parameter, the output pixel value at index ``o``
          was determined from the input image at position ``matrix * (o + offset)``.
  
      Parameters
      ----------
      input : ndarray
          The input array.
      matrix : ndarray
          The matrix must be two-dimensional or can also be given as a
          one-dimensional sequence or array. In the latter case, it is assumed
          that the matrix is diagonal. A more efficient algorithms is then
          applied that exploits the separability of the problem.
      offset : float or sequence, optional
          The offset into the array where the transform is applied. If a float,
          `offset` is the same for each axis. If a sequence, `offset` should
          contain one value for each axis.
      output_shape : tuple of ints, optional
          Shape tuple.
      output : ndarray or dtype, optional
          The array in which to place the output, or the dtype of the returned
          array.
      order : int, optional
          The order of the spline interpolation, default is 3.
          The order has to be in the range 0-5.
      mode : str, optional
          Points outside the boundaries of the input are filled according
          to the given mode ('constant', 'nearest', 'reflect' or 'wrap').
          Default is 'constant'.
      cval : scalar, optional
          Value used for points outside the boundaries of the input if
          ``mode='constant'``. Default is 0.0
      prefilter : bool, optional
          The parameter prefilter determines if the input is pre-filtered with
          `spline_filter` before interpolation (necessary for spline
          interpolation of order > 1).  If False, it is assumed that the input is
          already filtered. Default is True.
  
      Returns
      -------
      affine_transform : ndarray or None
          The transformed input. If `output` is given as a parameter, None is
          returned.
  
      """