Ctrl+K

convolve_fft#

astropy.convolution.convolve_fft(array, kernel, boundary='fill', fill_value=0.0, nan_treatment='interpolate', normalize_kernel=True, normalization_zero_tol=1e-08, preserve_nan=False, mask=None, crop=True, return_fft=False, fft_pad=None, psf_pad=None, min_wt=0.0, allow_huge=False, fftn=<function fftn>, ifftn=<function ifftn>, complex_dtype=<class 'complex'>, dealias=False)[源代码]#

用nd核卷积ndarray。返回包含 shape = array.shape . 假设内核居中。

convolve_fft 非常类似于 convolve 因为它取代了 NaN 在原始图像中使用核函数作为插值函数的插值值。但是，它还包括许多特定于实现的附加选项。

convolve_fft 不同于 scipy.signal.fftconvolve 在一些方面：

  • 它可以治疗 NaN 值为零或对其进行插值。

  • inf values are treated as NaN

  • 它可以选择填充到最近的更快的大小，以提高FFT速度。这些大小针对Numpy和Scipy实现进行了优化，并且 fftconvolve 默认情况下也会使用它们；当使用其他外部函数时(见下文)，结果可能会有所不同。

  • 只有它有效 mode “相同”（即返回相同的形状数组）

  • 它允许您使用自己的FFT，例如， pyFFTW 或 pyFFTW3 ，这可能会提高性能，具体取决于您的系统配置。pyFFTW3是线程化的，因此可能会在多核计算机上产生显著的性能优势，但代价是需要更多的内存。指定 fftn 和 ifftn 关键字来覆盖默认值，即 numpy.fft.fftn 和 numpy.fft.ifftn 。这个 scipy.fft 函数还提供稍好的性能和多线程选项。

参数:
数组 ： numpy.ndarraynumpy.ndarray

要卷积的数组 kernel . 它可以是任何维度的，尽管只有1，2和3d阵列已经过测试。

内核 ： numpy.ndarray 或 astropy.convolution.Kernel努比·恩达雷或者astropy.convolution.Kernel

卷积核。维度的数量应该与数组的维数相匹配。尺寸 不 在所有方向上都是奇数，不像在非fft中 convolve 功能。如果 normalize_kernel 已设置。假设它是居中的（也就是说，如果内核是非对称的，可能会导致移位）

boundary{'fill'，'wrap'}，可选

指示如何处理边界的标志：

  • “fill”：将数组边界外的值设置为填充_值（默认）

  • “wrap”：周期边界

这个 None 基于FFT的卷积不支持‘EXTEND’参数。

fill_value : float ，可选Python：Float，可选

使用BORDINE=‘FILL’时在数组外部使用的值。

nan_treatment{‘内插’，‘填充’}，可选
用于处理输入中的NAN的方法 array ：

  • 'interpolate' ： NaN 使用核作为内插函数，将值替换为内插值。请注意，如果内核的总和等于零，NaN插补是不可能的，并且会引发异常。

  • 'fill' ： NaN 值被替换为 fill_value 在卷积之前。

normalize_kernel : callable() 或 bool ，可选Python：Callable()或bool，可选

如果指定了这个函数，它将内核除以以规范化它。例如。， normalize_kernel=np.sum 内核将被修改： kernel = kernel / np.sum(kernel) . 如果为True，则默认为 normalize_kernel = np.sum .

normalization_zero_tol : float ，可选Python：Float，可选

核是否不同于零的绝对容差。如果内核的和为0到这个精度范围内，它就不能被规范化。默认值为“1e-8”。

preserve_nan : bool ，可选可选的布尔

在执行卷积之后，原本为NaN的像素是否应该再次变为NaN？

mask : None 或 ndarray ，可选PYTHON：无或ndarray，可选

A "mask" array. Shape must match array, and anything that is masked (i.e., not 0/False) will be set to NaN for the convolution. If None, no masking will be performed unless array is a masked array. If mask is not None and array is a masked array, a pixel is masked if it is masked in either mask or array.mask.

crop : bool ，可选可选的布尔

默认打开。返回输入图像和内核中较大的一个图像。如果图像和内核的方向相反，则返回两个方向上最大的图像。例如，如果输入图像具有形状 [100,3个] 但是有形状的核 [6,6] 如果使用，则输出将为 [100,6个] .

return_fft : bool ，可选可选的布尔

返回 fft(image)*fft(kernel) 而不是卷积 ifft(fft(image)*fft(kernel)) ). 对制作psd很有用。

fft_pad : bool ，可选可选的布尔

默认启用。零填充图像到最接近的大小，支持更有效地执行FFT，通常值可因式分解为前3-5个素数。使用 boundary='wrap' ，这将被禁用。

psf_pad : bool ，可选可选的布尔

零填充图像至少是图像大小的总和，以避免平滑时出现边缘缠绕。默认情况下，这是通过 boundary='fill' ，但可以用布尔选项重写它。 boundary='wrap' 和 psf_pad=True 不兼容。

min_wt : float ，可选Python：Float，可选

如果忽略 NaN /零，强制权重小于此值的所有网格点 NaN （网格点的权重 no 忽略的邻居为1.0）。如果 min_wt 为零，则所有零权重点将被设置为零，而不是 NaN （否则会是这样，因为1/0=nan）。请参阅下面的示例。

allow_huge : bool ，可选可选的布尔

允许在FFT中使用大型数组？如果为False，则在数组或内核大小大于1 GB时引发异常。

fftn : callable() ，可选Python：Callable()，可选

fft函数。可以重写以使用您自己的fft，例如fftw3包装器或scipy的fftn， fft=scipy.fftpack.fftn .

ifftn : callable() ，可选Python：Callable()，可选

逆fft函数。可以以相同的方式重写 fttn .

complex_dtype : complex 类型，可选复杂类型，可选

要使用的复杂数据类型。 numpy 有一系列选项，从64到256。

dealias: bool, optional

默认关闭。零填充图像以启用卷积的显式去锯齿。使用 boundary='wrap' ，这将被禁用。请注意，对于ND维的输入，这将使临时数组的大小至少增加 1.5**nd 。这可能会显著增加内存使用量。

返回:
default : ndarray恩达雷

array 与…缠绕在一起 kernel 。如果 return_fft 已设置，则返回 fft(array) * fft(kernel) 。如果未设置裁剪，则返回图像，但使用FFT填充大小而不是输入大小。

加薪:
ValueError

如果填充后数组大于1 GB，则将引发此异常，除非 allow_huge 是真的。

参见

convolve

卷积是此代码的非fft版本。它的内存效率更高，而且对于小内核来说速度更快。

笔记

使用 psf_pad=True 和较大的PSF，因此产生的数据可能会变得很大，并消耗大量内存。有关详细信息，请参阅问题https://github.com/astropy/astropy/pull/4366和https://github.com/astropy/astropy/pull/11533中的更新。

伪谱卷积的去混叠对于基本算法的数值稳定性是必要的。处理这一问题的一种常见方法是对图像进行至少1/2的零填充，以消除通过卷积而产生混叠的波数。这使得可以丢弃卷积计算结果的混叠1/3。请参阅https://doi.org/10.1175/1520-0469(1971)028%3C1074:OTEOAI%3E2.0.CO；2 https://iopscience.iop.org/article/10.1088/1742-6596/318/7/072037

请注意，如果您的应用程序需要消除别名，但您的进程受内存限制，则可能需要考虑使用FFTW++：dealias/fftwpp.它包括伪谱卷积的Python包装器，它将隐式地消除卷积的混叠，而不需要额外的填充。注意，不能在此方法中直接使用FFTW++的卷积，因为在内部处理整个卷积过程。此外，FFTW++还包括其他可供考虑的有用的伪谱方法。

实例

>>> convolve_fft([1, 0, 3], [1, 1, 1])
array([0.33333333, 1.33333333, 1.        ])

>>> convolve_fft([1, np.nan, 3], [1, 1, 1])
array([0.5, 2. , 1.5])

>>> convolve_fft([1, 0, 3], [0, 1, 0])  
array([ 1.00000000e+00, -3.70074342e-17,  3.00000000e+00])

>>> convolve_fft([1, 2, 3], [1])
array([1., 2., 3.])

>>> convolve_fft([1, np.nan, 3], [0, 1, 0], nan_treatment='interpolate')
array([1., 0., 3.])

>>> convolve_fft([1, np.nan, 3], [0, 1, 0], nan_treatment='interpolate',
...              min_wt=1e-8)
array([ 1., nan,  3.])

>>> convolve_fft([1, np.nan, 3], [1, 1, 1], nan_treatment='interpolate')
array([0.5, 2. , 1.5])

>>> convolve_fft([1, np.nan, 3], [1, 1, 1], nan_treatment='interpolate',
...               normalize_kernel=True)
array([0.5, 2. , 1.5])

>>> import scipy.fft  # optional - requires scipy
>>> convolve_fft([1, np.nan, 3], [1, 1, 1], nan_treatment='interpolate',
...               normalize_kernel=True,
...               fftn=scipy.fft.fftn, ifftn=scipy.fft.ifftn)
array([0.5, 2. , 1.5])

>>> fft_mp = lambda a: scipy.fft.fftn(a, workers=-1)  # use all available cores
>>> ifft_mp = lambda a: scipy.fft.ifftn(a, workers=-1)
>>> convolve_fft([1, np.nan, 3], [1, 1, 1], nan_treatment='interpolate',
...               normalize_kernel=True, fftn=fft_mp, ifftn=ifft_mp)
array([0.5, 2. , 1.5])
Edit on GitHub