
    ^Mh,                     f    d dl Zd dlmZ ddlmZ ddlmZ g dZd Zd Z	dd
Z
ddZddZddZdS )    N)normalize_axis_index   )_ni_support)	_nd_image)fourier_gaussianfourier_uniformfourier_ellipsoidfourier_shiftc                    | v|j         j        t          j        t          j        t          j        fv r!t          j        |j        |j                   } nt          j        |j        t          j                  } nt          |           t          u r[| t          j        t          j        t          j        t          j        fvrt          d          t          j        |j        |           } n| j        |j        k    rt          d          | S Ndtypezoutput type not supportedzoutput shape not correct)
r   typenp	complex64
complex128float32zerosshapefloat64RuntimeErroroutputinputs     V/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/scipy/ndimage/_fourier.py_get_output_fourierr   (   s    ~;bmRZHHHXek===FFXek<<<FF	f		",*bj2 2 2:;;;%+V444		$	$5666M    c                    | k|j         j        t          j        t          j        fv r!t          j        |j        |j                   } nt          j        |j        t          j                  } nzt          |           t          u rE| t          j        t          j        fvrt          d          t          j        |j        |           } n| j        |j        k    rt          d          | S r   )r   r   r   r   r   r   r   r   r   s     r   _get_output_fourier_complexr   8   s    ~;bm<<<Xek===FFXek???FF	f		",666:;;;%+V444		$	$5666Mr   c                 ^   t          j        |           } t          ||           }t          || j                  }t          j        || j                  }t          j        |t           j                  }|j        j	        s|
                                }t          j        | ||||d           |S )a  
    Multidimensional Gaussian fourier filter.

    The array is multiplied with the fourier transform of a Gaussian
    kernel.

    Parameters
    ----------
    input : array_like
        The input array.
    sigma : float or sequence
        The sigma of the Gaussian kernel. If a float, `sigma` is the same for
        all axes. If a sequence, `sigma` has to contain one value for each
        axis.
    n : int, optional
        If `n` is negative (default), then the input is assumed to be the
        result of a complex fft.
        If `n` is larger than or equal to zero, the input is assumed to be the
        result of a real fft, and `n` gives the length of the array before
        transformation along the real transform direction.
    axis : int, optional
        The axis of the real transform.
    output : ndarray, optional
        If given, the result of filtering the input is placed in this array.

    Returns
    -------
    fourier_gaussian : ndarray
        The filtered input.

    Examples
    --------
    >>> from scipy import ndimage, datasets
    >>> import numpy.fft
    >>> import matplotlib.pyplot as plt
    >>> fig, (ax1, ax2) = plt.subplots(1, 2)
    >>> plt.gray()  # show the filtered result in grayscale
    >>> ascent = datasets.ascent()
    >>> input_ = numpy.fft.fft2(ascent)
    >>> result = ndimage.fourier_gaussian(input_, sigma=4)
    >>> result = numpy.fft.ifft2(result)
    >>> ax1.imshow(ascent)
    >>> ax2.imshow(result.real)  # the imaginary part is an artifact
    >>> plt.show()
    r   r   r   asarrayr   r   ndimr   _normalize_sequencer   flags
contiguouscopyr   fourier_filter)r   sigmanaxisr   sigmass         r   r   r   G   s    \ JuE //Fej11D,UEJ??FZbj111F<" UFAtVQ???Mr   c                 ^   t          j        |           } t          ||           }t          || j                  }t          j        || j                  }t          j        |t           j                  }|j        j	        s|
                                }t          j        | ||||d           |S )a  
    Multidimensional uniform fourier filter.

    The array is multiplied with the Fourier transform of a box of given
    size.

    Parameters
    ----------
    input : array_like
        The input array.
    size : float or sequence
        The size of the box used for filtering.
        If a float, `size` is the same for all axes. If a sequence, `size` has
        to contain one value for each axis.
    n : int, optional
        If `n` is negative (default), then the input is assumed to be the
        result of a complex fft.
        If `n` is larger than or equal to zero, the input is assumed to be the
        result of a real fft, and `n` gives the length of the array before
        transformation along the real transform direction.
    axis : int, optional
        The axis of the real transform.
    output : ndarray, optional
        If given, the result of filtering the input is placed in this array.

    Returns
    -------
    fourier_uniform : ndarray
        The filtered input.

    Examples
    --------
    >>> from scipy import ndimage, datasets
    >>> import numpy.fft
    >>> import matplotlib.pyplot as plt
    >>> fig, (ax1, ax2) = plt.subplots(1, 2)
    >>> plt.gray()  # show the filtered result in grayscale
    >>> ascent = datasets.ascent()
    >>> input_ = numpy.fft.fft2(ascent)
    >>> result = ndimage.fourier_uniform(input_, size=20)
    >>> result = numpy.fft.ifft2(result)
    >>> ax1.imshow(ascent)
    >>> ax2.imshow(result.real)  # the imaginary part is an artifact
    >>> plt.show()
    r   r   r"   r   sizer+   r,   r   sizess         r   r   r      s    \ JuE //Fej11D+D%*==EJuBJ///E;! 

UE1dFA>>>Mr   c                    t          j        |           } | j        dk    rt          d          t	          ||           }|j        dk    r|S t          || j                  }t          j        || j                  }t          j        |t           j	                  }|j
        j        s|                                }t          j        | ||||d           |S )ah  
    Multidimensional ellipsoid Fourier filter.

    The array is multiplied with the fourier transform of an ellipsoid of
    given sizes.

    Parameters
    ----------
    input : array_like
        The input array.
    size : float or sequence
        The size of the box used for filtering.
        If a float, `size` is the same for all axes. If a sequence, `size` has
        to contain one value for each axis.
    n : int, optional
        If `n` is negative (default), then the input is assumed to be the
        result of a complex fft.
        If `n` is larger than or equal to zero, the input is assumed to be the
        result of a real fft, and `n` gives the length of the array before
        transformation along the real transform direction.
    axis : int, optional
        The axis of the real transform.
    output : ndarray, optional
        If given, the result of filtering the input is placed in this array.

    Returns
    -------
    fourier_ellipsoid : ndarray
        The filtered input.

    Notes
    -----
    This function is implemented for arrays of rank 1, 2, or 3.

    Examples
    --------
    >>> from scipy import ndimage, datasets
    >>> import numpy.fft
    >>> import matplotlib.pyplot as plt
    >>> fig, (ax1, ax2) = plt.subplots(1, 2)
    >>> plt.gray()  # show the filtered result in grayscale
    >>> ascent = datasets.ascent()
    >>> input_ = numpy.fft.fft2(ascent)
    >>> result = ndimage.fourier_ellipsoid(input_, size=20)
    >>> result = numpy.fft.ifft2(result)
    >>> ax1.imshow(ascent)
    >>> ax2.imshow(result.real)  # the imaginary part is an artifact
    >>> plt.show()
       z'Only 1d, 2d and 3d inputs are supportedr   r      )r   r#   r$   NotImplementedErrorr   r0   r   r   r%   r   r&   r'   r(   r   r)   r/   s         r   r	   r	      s    d JuEzA~~!"KLLL //F{a ej11D+D%*==EJuBJ///E;! 

UE1dFA>>>Mr   c                 \   t          j        |           } t          ||           }t          || j                  }t          j        || j                  }t          j        |t           j                  }|j        j	        s|
                                }t          j        | ||||           |S )a  
    Multidimensional Fourier shift filter.

    The array is multiplied with the Fourier transform of a shift operation.

    Parameters
    ----------
    input : array_like
        The input array.
    shift : float or sequence
        The size of the box used for filtering.
        If a float, `shift` is the same for all axes. If a sequence, `shift`
        has to contain one value for each axis.
    n : int, optional
        If `n` is negative (default), then the input is assumed to be the
        result of a complex fft.
        If `n` is larger than or equal to zero, the input is assumed to be the
        result of a real fft, and `n` gives the length of the array before
        transformation along the real transform direction.
    axis : int, optional
        The axis of the real transform.
    output : ndarray, optional
        If given, the result of shifting the input is placed in this array.

    Returns
    -------
    fourier_shift : ndarray
        The shifted input.

    Examples
    --------
    >>> from scipy import ndimage, datasets
    >>> import matplotlib.pyplot as plt
    >>> import numpy.fft
    >>> fig, (ax1, ax2) = plt.subplots(1, 2)
    >>> plt.gray()  # show the filtered result in grayscale
    >>> ascent = datasets.ascent()
    >>> input_ = numpy.fft.fft2(ascent)
    >>> result = ndimage.fourier_shift(input_, shift=200)
    >>> result = numpy.fft.ifft2(result)
    >>> ax1.imshow(ascent)
    >>> ax2.imshow(result.real)  # the imaginary part is an artifact
    >>> plt.show()
    r   )r   r#   r   r   r$   r   r%   r   r&   r'   r(   r   r
   )r   shiftr+   r,   r   shiftss         r   r
   r
      s    Z JuE(77Fej11D,UEJ??FZbj111F<" E61dF;;;Mr   )r    r    N)numpyr   scipy._lib._utilr    r   r   __all__r   r   r   r   r	   r
    r   r   <module>r>      s   >     1 1 1 1 1 1                   7 7 7 7t6 6 6 6r@ @ @ @F5 5 5 5 5 5r   