# Fast Gaussian Filter Approximations Comparison on SIMD Computing Platforms
###### Abstract  
Gaussian filtering, being a convolution with a Gaussian kernel, is a widespread technique in image analysis and computer vision applications. It is the traditional approach for noise reduction. In some cases, performing the exact convolution can be computationally expensive and time-consuming. To address this problem, approximations of the convolution are often used to achieve a balance between accuracy and computational efficiency, such as with running sums, Bell blur, Deriche approximation, etc. At the same time, modern computing devices support data parallelism (vectorization) via Single Instruction Multiple Data (SIMD) and can process integer numbers faster than floating-point approaches. In this paper, we describe several methods for approximating a Gaussian filter, implement the SIMD and quantized versions, and compare them in terms of speed and accuracy. The experiments were performed on central processing units with a \(\times\)86_64 architecture using a family of SSE SIMD extensions and an ARMv8 architecture using the NEON SIMD extension. All the optimized approximations demonstrated 10-20\(\times\) speedup while maintaining the accuracy in the range of \(1\times 10^{-5}\) or higher. The fastest method is a trivial Stack blur with a relatively high error, so we recommend using the second-order Vliet-Young-Verbeek filter and quantized Bell blur and running sums as more accurate and still computationally efficient alternatives. s +
Footnote †: journal: Applied  
1  
approach can depend on the size of the convolution kernel and the dimensions of the input image. Larger kernels and high-resolution images often require more processing power and can noticeably slow down the image processing algorithm. Various optimizations can be employed to mitigate the computational cost. Advancements in hardware, such as the utilization of multi-core architectures [6] or exploiting GPU capabilities [7; 8; 9], producing high-performance implementations [10], have contributed to reducing the impact of the computational cost and improving the efficiency of Gaussian filtering. Another approach for acceleration is to approximate the Gaussian filter with a simpler filter that provides a similar smoothing effect. Such methods significantly reduce the computational complexity compared to traditional Gaussian filtering, making it suitable for real-time image processing applications (for example, at the image preprocessing stage in unmanned aerial vehicle position detection [11]). The appeal of these approximations lies in their ability to strike a balance between computational efficiency and accuracy. Many applications of Gaussian filtering use central processing units (CPUs) for data handling. Modern CPUs come with the Single Instruction Multiple Data (SIMD) architecture, which allows them to process multiple data items simultaneously using SIMD extensions. This is completed by placing the data in vectors of 128, 256, or 512 bits wide and processed by specialized instructions (SSE, AVX, AVX-512, and AMX for x86/x64; NEON and SVE for ARM). This approach accelerates the computations by several times, which leads to a significant increase in the performance. CPUs and SIMD extensions also process integer data more efficiently, so the floating-point values are often quantized to achieve computation speedup. However, quantization can affect the accuracy of the algorithm and requires careful examination. The paper overviews several fast and computationally efficient methods that approximate Gaussian filtering and compares their complexity and precision. In the experimental part, we describe the floating-point and integer-quantized implementations of the considered approximations and examine their SIMD versions. Our contributions are as follows:  
* We provide a compact but sufficient description of the seven methods proposed in the literature for approximating a Gaussian filter.