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 x86_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× speedup while maintaining the accuracy in the range of 1 × ${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.

1. Introduction

Image processing is widely used in various fields, such as computer vision, medical imaging, and remote sensing. It includes various techniques for analyzing digital images to balance color, reduce image noise, and sharpen the image. A fundamental procedure here is Gaussian smoothing, which aims to enhance the image by applying a Gaussian filter. The Gaussian filter is a weighted moving average filter that provides more weight to the central pixel, gradually decreasing the weight as it moves away from the center. It creates a smoothing effect, blurring the image slightly. Gaussian smoothing is essential because of its ability to increase the image quality by reducing the high-frequency noise and removing unwanted artifacts. It can improve the visibility of important image features and make the subsequent image-processing tasks more accurate and reliable [1,2,3,4]. These properties make Gaussian smoothing indispensable for many applications, including neural network training [5].

However, Gaussian filtering comes at a computational cost that is negligible for single-filter applications but may be noticeable for multiple processing, especially on edge devices requiring real-time performance. Most methods (namely Finite Impulse Response filters; see Section 4.1) are based on convolving the image with some kernel, requiring numerous multiplications and additions for each pixel. The computational complexity of such an 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.
• We estimate the accuracy using the same notation for all the methods and present their computational complexity calculated in terms of the amount of additive and multiplicative operations.
• We compute and provide the parameters for lower-order Deriche and Vliet–Young–Verbeek filters in addition to those that had previously been considered in the original papers, following the authors’ methodologies.
• We consider quantized versions for the described methods except for the Deriche and Vliet–Young–Verbeek filters and describe the approach to vectorizing all the methods using SIMD extensions.
• We conduct experiments on CPUs with x86_64 and ARMv8 architectures and measure the processing time for the methods under consideration.

In Section 3, we describe the procedure of Gaussian filtering and its most basic optimizations. In Section 4, we provide a comparative overview of several methods proposed in the literature to approximate the Gaussian filter, and, in Section 5, we compare them in terms of speed and accuracy. Section 6 outlines our implementation of the considered methods. The results of the computational experiments are presented and discussed in Section 7. The paper is concluded in Section 8.

2. Related Work

The optimization of Gaussian filtering algorithms has a long history, starting with the appearance of the earliest techniques for applying blurring in computer graphics. Various approaches have been developed, including algorithmic improvements, numerous filter approximations, and the utilization of specialized hardware to speed up the blurring process.

In the early papers, the researchers proposed various algorithmic optimizations, like approximations to Gaussian filtering, that reduce the computational effort using fewer and simpler arithmetic operations. They considered Finite Impulse Response (FIR) [12,13,14] and Infinite Impulse Response (IIR) [15,16,17] digital filters. These approximations are described in detail below.

Gaussian blur optimizations are still developing and incorporate various programming strategies, such as parallel computing, special hardware use, efficient device-specific algorithms, and use scenarios. Currently, the single-threaded solutions cannot keep up with the performance and speed required for image processing techniques. Orders of magnitude speedup can be achieved with the help of high parallelism. Researchers have suggested parallel solutions for fast blurring on central processing units (CPUs) and graphics processing units (GPUs) [18,19].

Solutions supporting thread-level parallelism and a data-level approach utilizing specialized vector instructions have also been proposed [20,21]. Computer vision libraries are being developed to provide many practical high-performance algorithms for image processing. Some include optimized implementations of Gaussian blur using parallel solutions [22,23].

The data type also affects the efficiency of computation. For this reason, quantization is a widespread technique for reducing the runtime of various image processing methods [24,25,26] by translating the calculations from a floating-point data type to a fixed-point one stored in integers. For instance, regarding digital filtering, the authors in [27] proposed fast and accurate blurring by the Look-Up Table technique and using coefficients rounded to integers. Methods for digital image filtering using the residue number system were described in [28,29], where the idea was to perform all the computations on fixed-point numbers by replacing the division with the multiplication of all the fractions by a power of two and rounding to integers.

All these optimizations led to substantial improvements in the computational performance, making it a valuable tool for real-time image processing, computer vision, and graphics applications.

3. Gaussian Filtering

The Gaussian kernel, hereinafter denoted by $g_{\sigma }$, is a continuous function defined by the following equation:

$${\displaystyle g_{\sigma }[m,n]=\frac{1}{2\pi {\sigma }^2}{e}^{-\frac{1}{2}\left(\frac{m^2+n^2}{{\sigma }^2}\right)},}$$

(1)

where $\sigma$ is the standard deviation. It is important to note that the Gaussian kernel is always normalized.

The procedure of Gaussian filtering is based on applying the kernel defined in (1) to an image. It works by convolving the image with a Gaussian kernel, determining the weights with which pixels affect the filtering result.

Basic Optimizations

One can see that the values of the Gaussian kernel decrease as the argument moves away from zero, and this kernel goes to zero at infinity. However, an infinite-size mask cannot be used in computations. For very large positive or negative arguments, the values of the Gaussian kernel become so small that they can be ignored, and the computations can be focused only in the neighborhood of zero; such an optimization is called “truncation of the tails”. A three-sigma rule of thumb states that, if the mask is of size $K\times K$, then K should roughly equal $2\pi \sigma \approx 6\sigma$. That would capture about $99.73\%$ of the non-zero values of the Gaussian function. Then, convolution will have the following form:

$$y[i,j]=\sum _{m=-M}^M\sum _{n=-M}^M{g}_{\sigma }[m,n]x[i-m,j-n],$$

(2)

where $x[i,j]$ denotes the value of $(i,j)$-th pixel of image x, $y[i,j]$ is the resulting value of $(i,j)$-th pixel of output image y, and $K=2M+1$. The illustration of how discrete convolution works is provided below (Figure 1).

Applying this operation to each image pixel x, we obtain the values of output image y, the convolution result. There will be a problem related to boundary pixels: the closer a pixel is to the image boundaries, the more of the mask lies outside the image. There are two standard solutions to deal with such a border issue. The first variant ignores border pixels and performs convolution only for those pixels for which this is possible. The second one is to define boundary pixel neighborhoods or by some extrapolation. It can be set to constant values, mirrored, etc.

The important thing that makes the Gaussian mask attractive is the fact that it is separable. It is illustrated by the following expression:

$$\begin{array}{cc}\hfill y[i,j]& =\frac{1}{2\pi {\sigma }^2}\sum _{m=-M}^M\sum _{n=-M}^M{e}^{-\frac{1}{2}\left(\frac{m^2+n^2}{{\sigma }^2}\right)}x[i-m,j-n]=\hfill \\ \hfill & =\sum _{m=-M}^M\frac{1}{\sqrt{2\pi }\sigma }{e}^{-\frac{1}{2}\left(\frac{m^2}{{\sigma }^2}\right)}·\sum _{n=-M}^M\frac{1}{\sqrt{2\pi }\sigma }{e}^{-\frac{1}{2}\left(\frac{n^2}{{\sigma }^2}\right)}x[i-m,j-n]=\hfill \\ \hfill & =\sum _{m=-M}^M{g}_{\sigma }\left[m\right]·\sum _{n=-M}^M{g}_{\sigma }\left[n\right]x[i-m,j-n].\hfill \end{array}$$

(3)

So, the convolution with a 2D Gaussian kernel can be decomposed into a pair of convolutions with 1D Gaussian kernels: one vertical and one horizontal. It is important to note that this decomposition is not itself an approximation and still provides an exact result.

The representation provided by (3) renders applying the Gaussian filtering much computationally cheaper. If we do not consider the Gaussian kernel’s separability, we will perform $K^2$ multiplications and $K^2-1$ additions per pixel to convolve a 2D image with a 2D kernel. Convolution with a 1D kernel requires K multiplications and $(K-1)$ additions per pixel, and filtering with a separable 2D kernel only doubles the cost of the 1D case. So, utilizing the separability property, the computational cost is reduced to $2K$ multiplications and $2(K-1)$ additions per pixel. The kernel separability already allows us to reduce the computational complexity by one order.

In the following, we will use the separability property throughout, so all further description is limited to the consideration of one-dimensional filters.

4. Approximations

There are two main types of approximations for Gaussian convolution filters: Finite Impulse Response (FIR) filters and Infinite Impulse Response (IIR) filters. Each of these types has distinct characteristics and trade-offs that affect their performance and implementation complexity. FIR filters are often desirable when exact precision is required as they provide a closer approximation to the Gaussian kernel. It makes them well-suited for applications that demand accurate filtering, such as image enhancement and feature extraction. IIR filters are more suitable for applications where computational efficiency is of primary concern. Their recursive nature allows for efficient computation, making IIR filters appealing for real-time applications or scenarios where processing power is limited. They find applications in real-time video processing, audio signal processing, and communication systems.

In this section, we describe several of the best-known FIR and IIR filters proposed over the last few decades.

4.1. FIR Approximations

The Finite Impulse Response (FIR) filters use a finite number of input samples to produce each output sample. In the context of our paper, FIR filters use an approximated version of the truncated Gaussian function as the impulse response and can be expressed in the following form:

$$y\left[i\right]=\sum _{n=i-M}^{i+M}h[i-n]x\left[n\right],i=0,\dots ,N,$$

(4)

where $2M+1$ is the size of the mask, and N hereinafter is the length of the signal. So, in a general case, exploiting symmetry in the filter h, FIR approximation to Gaussian filtering requires roughly $1+M$ multiplications and $2M$ additions per output sample. Researchers suggested different methods to reduce the computational complexity by specifying a special kind of h. Below, we describe some of the approximations presented in various sources.

4.1.1. DFT-Based Convolution

The discrete Fourier transform (DFT) is a powerful mathematical tool for computing the convolution of a 1D signal. A signal’s DFT represents it in the frequency domain, where each frequency component is quantified by its magnitude and phase, making it useful for analyzing and manipulating signals.

In mathematical language, the Fourier transform is expressed as follows:

$${\displaystyle F\left(x\right)\left[k\right]=\sum _{n=0}^{N-1}x\left[n\right]{\mathrm{e}}^{-\frac{2\pi ink}{N}},}$$

(5)

where N is the size of the input signal. Utilizing the convolution–multiplication property of the DFT, we can compute the convolution via the sequence of discrete Fourier transformations:

$$y=F^{-1}\left(F\left(g_{\sigma }\right)·F\left(x\right)\right).$$

(6)

So, to convolve the image with Gaussian kernel, we can compute the DFT of both signals, perform the element-wise multiplication, and compute the inverse DFT of the result. Note that both signals must be of the same length; if this is not the case, the shorter one must be complemented. Also, DFT (or inverse DFT) should be normalized.

The computational complexity of the DFT-based convolution (using a fast Fourier transform algorithm [30]) of a 1D signal is typically $O\left(N\log N\right)$.

4.1.2. Stack Blur and Bell Blur

The Stack blur algorithm was proposed in [13] to approximate the Gaussian-blurred value of a pixel by a composition of 1D box blurs with increasing radius that simulates the effect of applying the Gaussian kernel. It uses a moving stack of pixels while scanning the image row. The expression of the Stack blur algorithm in one direction is defined as follows:

$${\displaystyle y_s\left[i\right]=\sum _{n=i-r}^{i+r}\left(r-|n-i|+1\right)x\left[n\right],}$$

(7)

where $r=r\left(\sigma \right)=\left[C\sigma \right]$ is the radius of the box blur and C is some constant value. So, the 1D Gaussian kernel (1) is approximated by a piecewise linear function

$$S_{\sigma }\left[m\right]=r-\left|m\right|+1=\left\{\begin{array}{cc}r-m+1,\hfill & \mathrm{if}m>0,\hfill \\ r+m+1,\hfill & \mathrm{otherwise}.\hfill \end{array}\right.$$

(8)

The illustration is provided in Figure 2.

The idea of fast computation ensues from the following representations:

$$\begin{array}{cc}\hfill {\displaystyle y_s\left[i\right]=y_s[i-1]}& -\underset{s_i^{out}}{\underbrace{\left(x\right[i-r-1]+x[i-r]+\dots +x[i-1\left]\right)}}+\hfill \\ \hfill & +\underset{s_i^{in}}{\underbrace{\left(x\right[i]+x[i+1]+\dots +x[i+r\left]\right)}},\hfill \end{array}$$

(9)

$$\begin{array}{cc}\hfill {\displaystyle y_s[i+1]=}& \sum _{n=(i-r)+1}^{(i+r)+1}\left(r-|n-i-1|+1\right)x\left[n\right]=\hfill \\ \hfill =& y_s\left[i\right]-\underset{s_{i+1}^{out}}{\underbrace{\left(x\right[i-r]+\dots +x[i-1]+x[i\left]\right)}}+\hfill \\ \hfill & +\underset{s_{i+1}^{in}}{\underbrace{\left(x\right[i+1]+\dots +x[i+r]+x[i+r+1\left]\right)}},\hfill \end{array}$$

(10)

$$\begin{array}{cc}\hfill s_{i+1}^{out}& =s_i^{out}-x[i-r-1]+x\left[i\right],\hfill \\ \hfill s_{i+1}^{in}& =s_i^{in}-x\left[i\right]+x[i+r+1].\hfill \end{array}$$

(11)

Once we have calculated the value $y_s\left[i\right]$ for the i-th element, the value $y_s[i+1]$ for the $(i+1)$-th element, due to the form of the kernel, can be obtained just in $r+1$ subtractions and $r+1$ additions. Storing the values of $s^{out}$ and $s^{in}$, we can obtain the result for $(i+1)$-th element just by 3 additions and 3 subtractions. Therefore, not considering the initial element in a row (the value for which can be calculated with $2r+1$ multiplications and $2r$ additions), computing the Stack blur for a pixel requires 6 additive operations. Note also that the Stack blur result should be normalized by ${(r+1)}^2$.

A further extension of the Stack blur idea was described in [14] as Quadratic Stack blur, or Bell blur. It operates as follows:

$$\begin{array}{cc}\hfill {\displaystyle y_b[i+1]}& =y_b\left[i\right]-y_s[i-r]+y_s[i+r+1]=\hfill \\ \hfill & =y_b\left[i\right]-\left(y_s[i-r-1]-s_{i-r}^{out}+s_{i-r}^{in}\right)+\left(y_s[i+r]-s_{i+r+1}^{out}+s_{i+r+1}^{in}\right).\hfill \end{array}$$

(12)

Computing $y_s[i-r]$ and $y_s[i+r+1]$ according to (9) and (10) requires 6 subtractions and 6 additions in total. Computing the whole result for $(i+1)$-th element requires 1 more subtraction and 1 more addition, so the total cost is 14 additive operations per element (except for initialization). The result should be normalized by $(2r+1){(r+1)}^2$.

The general expression for Bell blur is more complicated:

$${\displaystyle y_b\left[i\right]=\sum _{n=i-2r}^{i+2r}\left(\sum _{m=-r}^{r-|i-n|}\left(r-\left|m\right|+1\right)\right)x\left[n\right],}$$

(13)

where $r=r\left(\sigma \right)=\left[C\sigma \right]$ is the radius of the Stack blur and $2r$ is the radius of the Bell blur. The kernel (1) is approximated by a piecewise constant function with integer values

$$B_{\sigma }\left[n\right]=\sum _{m=-r}^{r-\left|n\right|}\left(r-\left|m\right|+1\right)=\left(r+1\right)\left(2r-\left|n\right|+1\right)-\sum _{m=-r}^{r-\left|n\right|}\left|m\right|.$$

(14)

The illustration of this approximation is also provided in Figure 2.

4.1.3. Running Sums

The running sums method, proposed by Elboher and Werman in [12], is the approximation of Gaussian kernel based on the idea of computing a running sum of pixel values within a rectangular region. As in the case of Bell blur, running sums is a piecewise constant approximation but already with real rather than integer values. The fast computation uses the concept of integral images and cumulates the sum of pixel values along the image rows and columns.

The authors defined k constant functions with values $c_i\in \mathbb{R},i=1,\dots ,k$ and divided the segment $[-3\sigma ;3\sigma ]$ into the nested segments defined by the partition indices $[-p_i,p_i],i=1,\dots ,k$, so the expression of the proposed approximation is

$${\displaystyle y_{rs}\left[i\right]=\sum _{n=i-p_k}^{i+p_k}R[i-n]x\left[n\right],}$$

(15)

where

$$R\left[n\right]=\left\{\begin{array}{cc}{c}_1,\hfill & \mathrm{if}n\in [-p_1;p_1],\hfill \\ c_2,\hfill & \mathrm{if}n\in [-p_2;-p_1)\cup (p_1;p_2],\hfill \\ ⋮\hfill \\ c_k,\hfill & \mathrm{if}n\in [-p_k;-p_{k-1})\cup (p_{k-1};p_k].\hfill \end{array}\right.$$

(16)

The illustration is provided in Figure 3.

An approach called integral images is used for fast computation of (15). It is proposed to compute and store the cumulative sums preliminarily

$${\displaystyle I\left[i\right]=\sum _{n=0}^{i}x\left[n\right]}$$

(17)

for all pixels in an image row so that

$${\displaystyle \sum _{n=i-p_k}^{i+p_k}x\left[n\right]=I[i+p_k]-I[i-p_k-1].}$$

(18)

Let us set $c_{k+1}=0$ and denote $w_i=c_i-c_{i+1}\in \mathbb{R},i=1,\dots ,k$. Then, we can rewrite the expression (15) as follows:

$${\displaystyle y_{rs}\left[i\right]=\sum _{n=1}^k{w}_n\left(I[i+p_n]-I[i-p_n-1]\right),}$$

(19)

which means that the sum is accumulated by areas of horizontal rectangles, not vertical, as in (15).

For given k, the weights $w_1,\dots ,w_k$ and partition indices $p_1,\dots ,p_k$ are chosen to optimize the approximation of the Gaussian kernel. The authors provided the following values for cases with ${\sigma }_0=\frac{100}{\pi }$ and $k\in \{3,4,5\}$:

$$\begin{array}{cc}\hfill k=3:& p_i=\{23,46,76\},w_i=\{0.9495,0.5502,0.1618\};\hfill \\ \hfill k=4:& p_i=\{19,37,56,82\},w_i=\{0.9649,0.6700,0.3376,0.0976\};\hfill \\ \hfill k=5:& p_i=\{16,30,44,61,85\},w_i=\{0.9738,0.7596,0.5031,0.2534,0.0739\};\hfill \end{array}$$

(20)

and described how we can scale them for other $\sigma$ values [12]:

$$p_i^{\left(\sigma \right)}=⌊\frac{\sigma }{{\sigma }_0}·p_i⌋,w_i^{\left(\sigma \right)}=⌊\frac{p_i}{2p_i^{\left(\sigma \right)}+1}·w_i⌋.$$

(21)

The number of arithmetic operations depends on k. The method generally requires $2k$ additions and k multiplications per image pixel. Note also that it requires extra memory. For storing the cumulative sum of a single row or column, the method requires $O\left(\max \right\{h,w\left\}\right)$ additional space over the input and the output images, where h and w are linear sizes of the image (height and width).

4.1.4. Piecewise Parabolic Approximation

This approach is based on the piecewise polynomial kernel approximation. The convolution can be decomposed into a sum of convolutions, each of which is different from zero only in a part of the window. Such a convolution is equivalent to a convolution with a reduced shifted window whose center no longer coincides with the target pixel. This method will be abbreviated below as PcParab.

Each polynomial can be represented as the sum of terms; i.e., the problem is reduced to calculating convolutions with a constant, x, $x^2$, etc. The important thing is that the product of the number of sites in the piecewise approximation and the number of terms is not large. For approximating the Gaussian kernel, the idea is to divide the segment $[-3\sigma ;3\sigma ]$ into three non-intersecting sub-segments $p_k,k=1,2,3$ such that $\cup p_k=[-3\sigma ;3\sigma ]$ and approximate the parts of Gaussian kernel on each sub-segment by a parabola. The parabola can be described by a quadratic equation of the form $y=a{x}^2+bx+c$ with real coefficients $a,b$, and c. By choosing three different points on each sub-segment $p_k$, we can solve a system of three equations

$$a_k{x}_i^2+b_k{x}_i+c_k=g_{\sigma }\left[x_i\right],i=1,2,3,x_i\in p_k,$$

(22)

to determine the coefficients $a_k,b_k,c_k$ of the corresponding parabola. An example of the obtained approximation is provided in Figure 4.

In our experiments, we divided the segment at the Gaussian inflection points $\pm \sigma$ and took the ends and the middle of the sub-segment to construct the parabola. Alternatively, partition points can be found using the least squares method.

To compute convolutions with terms fast, we use the following technique. Convolution (4) with constant function $h\left[n\right]\equiv 1$ is defined as

$$\begin{array}{c}\hfill y^C\left[i\right]=\sum _{j=i-M}^{i+M}x\left[j\right],i=M,\dots ,N-M-1.\end{array}$$

(23)

Hence, we have

$$\begin{array}{c}\hfill y^C[i+1]=y^C\left[i\right]-x[i-M]+x[i+M+1].\end{array}$$

(24)

First, the value for the left-most pixel $i=M$ is computed according to (23), and then, given (24), the values for each $i=M+1,\dots ,N-M-1$ are obtained with 1 additive and 1 multiplicative operation.

For the convolution with $h\left[n\right]=n$, we can rewrite (4) as follows:

$$\begin{array}{c}\hfill y^F[i+1]=y^F\left[i\right]-M·\left(x[i-M]+x[i+M+1]\right)+\underset{y^C\left[i\right]-x[i-M]}{\underbrace{\sum _{j=i-M+1}^{i+M}x\left[j\right]}},\end{array}$$

(25)

so the result is

$$\begin{array}{c}\hfill y^F[i+1]=y^F\left[i\right]+y^C\left[i\right]-\left(M+1\right)·x[i-M]-M·x[i+M+1]\end{array}$$

(26)

and can be easily obtained from the already computed values for $y^C$. All convolutions with n are computed in this way. Furthermore, to convolve with $h\left[n\right]=n^2$, we use the following representation:

$$\begin{array}{c}\hfill y^{F2}[i+1]=y^{F2}\left[i\right]-M^2·\left(x[i-M]+x[i+M+1]\right)+2\underset{y^F\left[i\right]-M·x[i-M]}{\underbrace{\sum _{j=i-M+1}^{i+M}(i-j)x\left[j\right]}}+\underset{y^C\left[i\right]-x[i-M]}{\underbrace{\sum _{j=i-M+1}^{i+M}x\left[j\right]}},\end{array}$$

(27)

so the final expression comes as follows:

$$\begin{array}{c}\hfill y^{F2}[i+1]=y^{F2}\left[i\right]+2·y^F\left[i\right]+y^C\left[i\right]-{(M+1)}^2·x[i-M]-M^2·x[i+M+1].\end{array}$$

(28)

The full result of convolution with a parabola $h\left[n\right]=a_k{n}^2+b_{k}n+c_k$ therefore becomes

$$\begin{array}{cc}\hfill y\left[i\right]=& \sum _{j=i-M}^{i+M}\left(a_k{(i-j)}^2+b_k(i-j)+c_k\right)x\left[j\right]=\hfill \\ \hfill =& a_k\sum _{j=i-M}^{i+M}{(i-j)}^{2}x\left[j\right]+b_k\sum _{j=i-M}^{i+M}(i-j)x\left[j\right]+c_k\sum _{j=i-M}^{i+M}x\left[j\right]=\hfill \\ \hfill =& a_k{y}^{F2}\left[i\right]+b_k{y}^{F1}\left[i\right]+c_k{y}^C\left[i\right],\hfill \end{array}$$

(29)

which can be computed in 11 additions and 8 multiplications according to (24), (26), and (28). On each of three sub-segments $p_k,k=1,2,3,$ we approximate the Gaussian kernel by a fragment of a parabola, so each sub-segment corresponds to a limited range j in (29). Initialization requires $3K$ additions and $2K$ multiplications in total, where $K=2M+1$ is the window size.

4.2. IIR Approximations

The Infinite Impulse Response (IIR) filters use current input and previous input and output samples to compute each output sample. In the case of approximating Gaussian convolution, IIR filters employ recursive expressions that allow for iterative computations.

IIR filter recursively solves a sequence of difference equations like the following one:

$$\begin{array}{cc}\hfill y\left[n\right]=b_{0}x\left[n\right]& +b_{1}x[n-1]+\dots +b_{P}x[n-P]\hfill \\ \hfill & -a_{1}y[n-1]-\dots -a_{Q}y[n-Q],\hfill \end{array}$$

(30)

where the filter coefficients $b_i,i=0,\dots ,P,$ and $a_j,j=1,\dots ,Q$ are some functions of the Gaussian half-width $\sigma$. The cost of such an approximation is independent of $\sigma$. By considering the z-transform of the IIR filter and combining causal and anti-causal parts, researchers constructed recursive systems with symmetric impulse responses that closely approximate the Gaussian filtering.

Several state-of-the-art forms of IIR approximations are described below.

4.2.1. Deriche Form

This method was described in 1993 by R Deriche [15] and improved in 2006 by Farnebäck and Westin [16]. Here, we only focus on Deriche’s original approach. In his work, the recursive Gaussian filter of the fourth order was constructed as a sum of causal and anti-causal systems:

$$H\left(z\right)=H^{+}\left(z\right)+H^{-}\left(z\right),$$

(31)

where causal part $H^{+}$ and anti-causal part $H^{-}$ are as follows:

$$\begin{array}{c}{H}^{+}\left(z\right)=\frac{b_0^{+}+b_1^{+}{z}^{-1}+b_2^{+}{z}^{-2}+b_3^{+}{z}^{-3}}{1+a_1{z}^{-1}+a_2{z}^{-2}+a_3{z}^{-3}+a_4{z}^{-4}},\\ H^{-}\left(z\right)=\frac{b_1^{-}z+b_2^{-}{z}^2+b_3^{-}{z}^3+b_4^{-}{z}^4}{1+a_{1}z+a_2{z}^2+a_3{z}^3+a_4{z}^4}.\end{array}$$

(32)

To implement the composite system $H\left(z\right)$, one needs to apply both causal and anti-causal filters to an input sequence $x\left[n\right]$ and accumulate the results in an output sequence $y\left[n\right]$.

To obtain coefficients $a_1,a_2,a_3$, and $a_4$, Deriche noted that they depend only on the locations of the filter poles and are the same for both the causal part $H^{+}$ and the anti-causal part $H^{-}$. Coefficients $b_1^{+},b_2^{+},b_3^{+}$, and $b_4^{+}$ in the causal system $H^{+}$ depend on the locations of the filter zeros. The coefficients $b_1^{-},b_2^{-},b_3^{-}$, and $b_4^{-}$ in $H^{-}\left(z\right)$ are computed from others as the composite filter $H\left(z\right)$ must be symmetric. Thus, $H\left(z\right)=H\left(z^{-1}\right)$ is satisfied and we have the following expressions:

$$\begin{array}{cc}\hfill & b_1^{-}=b_1^{+}-b_0^{+}{a}_1,\hfill \\ \hfill & b_2^{-}=b_2^{+}-b_0^{+}{a}_2,\hfill \\ \hfill & b_3^{-}=b_3^{+}-b_0^{+}{a}_3,\hfill \\ \hfill & b_4^{-}=-b_0^{+}{a}_4.\hfill \end{array}$$

(33)

With these relations, the eight coefficients of the causal system $H^{+}$ completely determine the symmetric impulse response $h\left[n\right]$ of the composite system $H\left(z\right)$. Those eight coefficients, in turn, depend on the poles and zeros of the causal system $H^{+}$.

Deriche computed poles and zeros to minimize a normalized mean square error

$${\epsilon }^2=\frac{{\sum }_{n=0}^S{\left(g_{{\sigma }_0}\left[n\right]-h\left[n\right]\right)}^2}{{\sum }_{n=0}^S{\left(g_{{\sigma }_0}\left[n\right]\right)}^2}$$

(34)

of squared differences between the sampled Gaussian function with half-width ${\sigma }_0$ and the impulse response h that was taken in the form

$$h\left[n\right]=\sum _{i=0}^m{\alpha }_i{e}^{-\frac{{\lambda }_{i}n}{\sigma }}.$$

(35)

The author chose $S=10{\sigma }_0$ with ${\sigma }_0=100$. A solution to this non-linear least-squares minimization problem requires to be computed only once for ${\sigma }_0$, and, due to the scaling properties, it can be extended to other $\sigma$. Finally, to deal with normalized filters for Gaussian smoothing, Deriche suggested scaling the operators by the normalization factor C such that

$$C\sum _{n=-\infty }^{+\infty }h\left[n\right]=1,$$

(36)

which provides

$$C=\frac{1}{H^{+}\left(1\right)+H^{-}\left(1\right)}.$$

(37)

This paper only includes the first-order and the second-order Deriche-style filters in the comparison as the most computationally efficient options. They both come from the sum

$$y\left[k\right]=C(y^{+}\left[k\right]+y^{-}\left[k\right]).$$

(38)

The first-order filter has the following expression for $y_k^{+}$ and $y_k^{-}$:

$$\begin{array}{c}{y}^{+}\left[k\right]=b_0^{+}x\left[k\right]-a_1^{+}{y}^{+}[k-1],\\ y^{-}\left[k\right]=b_1^{-}x[k+1]-a_1^{-}{y}^{-}[k+1],\end{array}$$

(39)

and approximates the causal part of Gaussian kernel by a simple exponential function

$$h_1\left(x\right)=\alpha e^{-\frac{\lambda x}{\sigma }},\alpha ,\lambda \in \mathbb{R}.$$

(40)

Minimizing the mean square error (34), we obtained the following values for $\alpha$ and $\lambda$:

$$\alpha =1.25841931,\lambda =0.92261977,$$

(41)

by which the coefficients of filter and normalization factor are expressed as follows:

$$\begin{array}{c}{b}_0^{+}=\alpha ,a_1^{+}=-e^{-\frac{\lambda }{\sigma }},\\ b_1^{-}=-a_1^{+}{b}_0^{+},a_1^{-}=a_1^{+},\\ C=\frac{1+a_1^{+}}{b_0^{+}+b_1^{-}}.\end{array}$$

(42)

An example of the approximation with the first-order Deriche-style filter is provided in Figure 5. Same expressions as (39)–(42) corresponding to the second-order filter are provided below:

$$\begin{array}{c}{y}^{+}\left[k\right]=b_0^{+}x\left[k\right]+b_1^{+}x[k-1]-a_1^{+}{y}^{+}[k-1]-a_2^{+}{y}^{+}[k-2],\\ y^{-}\left[k\right]=b_1^{-}x[k+1]+b_2^{-}x[k+2]-a_1^{-}{y}^{-}[k+1]-a_2^{-}{y}^{-}[k+2],\end{array}$$

(43)

$$h_2\left(x\right)=\left({\gamma }_{1}cos\left(\frac{\omega x}{\sigma }\right)+{\gamma }_{2}sin\left(\frac{\omega x}{\sigma }\right)\right)·e^{-\frac{bx}{\sigma }},{\gamma }_1,{\gamma }_2,\omega ,b\in \mathbb{R},$$

(44)

$${\gamma }_1=0.9629,{\gamma }_2=1.942,\omega =0.8448,b=1.26,$$

(45)

$$\begin{array}{c}{b}_0^{+}={\gamma }_1,b_1^{+}=\left(-{\gamma }_{1}cos\left(\frac{\omega }{\sigma }\right)+{\gamma }_{2}sin\left(\frac{\omega }{\sigma }\right)\right)·e^{-\frac{b}{\sigma }},\\ a_1^{+}=-2cos\left(\frac{\omega }{\sigma }\right)·e^{-\frac{b}{\sigma }},a_2^{+}=e^{-\frac{2b}{\sigma }},\\ b_1^{-}=b_1^{+}-a_1^{+}{b}_0^{+},b_2^{-}=-a_2^{+}{b}_0^{+},\\ a_1^{-}=a_1^{+},a_2^{-}=a_2^{+},\\ C=\frac{1+a_1^{+}+a_2^{+}}{b_0^{+}+b_1^{+}+b_1^{-}+b_2^{-}}.\end{array}$$

(46)

Note that values of ${\gamma }_1,{\gamma }_2,\omega$, and b have already been reported in [15], and our result of minimizing the error of the form (34) exactly agrees with them.

These low-order filters require a small fixed number of arithmetic operations. Applying the first-order Deriche-style filter requires 3 additions and 4 multiplications per item, and the second-order filter 7 additions and 8 multiplications.

4.2.2. Vliet–Young–Verbeek Form

Another IIR filter was proposed in 1998 by van Vliet, Young, and Verbeek [17] and will be abbreviated in the paper as the VYV filter. While Deriche’s filter consists of the sum of the causal and anti-causal parts, the VYV filter is the product

$$\begin{array}{c}H\left(z\right)=H^{+}\left(z\right)·H^{-}\left(z\right),\\ H^{+}\left(z\right)={\displaystyle \prod _{i=1}^p}\frac{d_i-1}{d_i-z^{-1}},H^{-}\left(z\right)={(-1)}^p{\displaystyle \prod _{i=1}^p}\frac{d_i-1}{z-d_i},\end{array}$$

(47)

where p is the order of the filter, $d_i\in \mathbb{C}$ are the poles of $H\left(z\right)$. For $p=3$, the causal and anti-causal systems take the following form:

$$H^{+}\left(z\right)=\frac{\alpha }{1+b_1{z}^{-1}+b_2{z}^{-2}+b_3{z}^{-3}},H^{-}\left(z\right)=\frac{\alpha }{1+b_{1}z+b_2{z}^2+b_3{z}^3}$$

(48)

with $\alpha ,b_i\in \mathbb{R}$, so the expressions for the third-order filter are as follows:

$$\begin{array}{c}{y}^{+}\left[k\right]=\alpha x\left[k\right]-b_1{y}^{+}[k-1]-b_2{y}^{+}[k-2]-b_3{y}^{+}[k-3],\\ y^{-}\left[k\right]=\alpha y^{+}\left[k\right]-b_1{y}^{-}[k+1]-b_2{y}^{-}[k+2]-b_3{y}^{-}[k+3].\end{array}$$

(49)

To implement the composite system $H\left(z\right)$, the authors applied the causal filter to an input sequence $x\left[k\right]$ to obtain an intermediate output sequence $y^{+}\left[k\right]$. Then, they applied the anti-causal filter to that sequence to obtain a final output $y\left[k\right]$. The same as Deriche’s method, coefficients $b_1,b_2,b_3$ depend only on the locations of filter poles $d_1,d_2\in \mathbb{C}$, and $d_3\in \mathbb{R}$, and these coefficients are the same for both the causal part $H^{+}$ and the anti-causal part $H^{-}$. They can be derived by minimizing the root mean square error

$$L^2=\sqrt{\frac{1}{2\pi }{\int }_{-\pi }^{\pi }{\left(H\left(\omega ;{\sigma }_0\right)-G\left(\omega ;{\sigma }_0\right)\right)}^2\mathrm{d}\omega }=\sqrt{\sum _{n=-\infty }^{+\infty }{(g_{\sigma }\left[n\right]-h\left[n\right])}^2}.$$

(50)

The authors obtained the following poles for ${\sigma }_0=2$:

$$d_1=1.41656+1.00832i,d_2=\overline{d_1},d_3=1.86548065,$$

(51)

and filter coefficients are related to poles $d_1,d_2,d_3$ as

$$\begin{array}{cc}\hfill & b=\frac{1}{d_1{d}_2{d}_3},\hfill \\ \hfill & b_1=-b\left(d_1{d}_2+d_1{d}_3+d_2{d}_3\right),b_2=b\left(d_1+d_2+d_3\right),b_3=-b,\hfill \\ \hfill & \alpha =1+b_1+b_2+b_3.\hfill \end{array}$$

(52)

Note that value of error (50) for the third-order VYV filter was provided in the original paper, and our result agreed with it to a margin of error. Finally, the authors scaled poles to obtain Gaussian filters for other $\sigma$ using

$$d_i\to d_i^{\frac{1}{q}},{\sigma }^2=\sum _{i=1}^p\frac{2d_i^{\frac{1}{q}}}{{\left(d_i^{\frac{1}{q}}-1\right)}^2}$$

(53)

and determining the relationship between q and $\sigma$. For the third-order filter, examining a set of $(q,{\sigma }^2)$ pairs, we approximated this relation by the least squares method as in [31] but with the second-order polynomial as in [32]

$${\sigma }^2=1.06042809q^2+4.62413131q+4.56081613.$$

(54)

In this paper, in addition to the third-order filter, we also include the second-order VYV-style filter in comparison. It performs as follows:

$$\begin{array}{c}{y}^{+}\left[k\right]=\alpha x\left[k\right]-b_1{y}^{+}[k-1]-b_2{y}^{+}[k-2],\\ y^{-}\left[k\right]=\alpha y^{+}\left[k\right]-b_1{y}^{-}[k+1]-b_2{y}^{-}[k+2].\end{array}$$

(55)

Minimizing (50) for ${\sigma }_0=2$, we obtained the pair of complex-conjugate poles

$$\begin{array}{c}{d}_1=1.69593+0.5996i,d_2=\overline{d_1}.\end{array}$$

(56)

The filter coefficients are

$$\begin{array}{cc}\hfill & b=\frac{1}{d_1{d}_2},\hfill \\ \hfill & b_1=-b\left(d_1+d_2\right),b_2=b,\hfill \\ \hfill & \alpha =1+b_1+b_2,\hfill \end{array}$$

(57)

and, according to (53), we scaled them to $\frac{1}{q}$ power with q computed from

$${\sigma }^2=1.02158395q^2+4.44944206q+4.53954235.$$

(58)

An example of the approximation with the second-order and the third-order VYV filters is provided in Figure 6.

Applying the VYV filter is computationally less expensive than Deriche’s one. Whereas Deriche’s second-order filter requires 7 additions and 8 multiplications per pixel, the second-order VYV filter requires 4 additions and 6 multiplications and the third-order one 6 additions and 8 multiplications.

5. Complexity and Accuracy Comparison

The comparison of the methods in terms of computational complexity, accuracy, and extra memory is summarized in

Table 1. Comparison of the considered methods for Gaussian filtering image with size $h\times w$ in terms of the number of additions (# +) and multiplications (# ·) per pixel, error, and extra memory. For FIR filters, we use kernel of size $K\times K$.

Method	# +	# ·	Error (FP)	Error (Quant.)	Extra Memory
Direct Gaussian	$2(K-1)$	$2K$	depends on K	depends on K	$O\left(1\right)$
DFT-based convolution (FFT)	$O\left(\log K^2\right)$	$O\left(\log K^2\right)$	depends on K	-	impl. defined
Stack blur	12	0	9.35 × ${10}^{-6}$	9.35 × ${10}^{-6}$	$O\left(1\right)$
Bell blur	28	0	4.40 × ${10}^{-6}$	4.40 × ${10}^{-6}$	$O\left(1\right)$
Running sums, $k=3$	12	6	1.43 × ${10}^{-5}$	1.43 × ${10}^{-5}$	$O\left(\max \right\{h;w\left\}\right)$
Running sums, $k=4$	16	8	7.91 × ${10}^{-6}$	7.91 × ${10}^{-6}$	$O\left(\max \right\{h;w\left\}\right)$
Running sums, $k=5$	20	10	5.11 × ${10}^{-6}$	5.11 × ${10}^{-6}$	$O\left(\max \right\{h;w\left\}\right)$
PcParab	22	16	1.92 × ${10}^{-7}$	5.22 × ${10}^{-6}$	$O\left(\max \right\{h;w\left\}\right)$
Deriche (1st order)	6	8	1.39 × ${10}^{-5}$	-	$O\left(1\right)$
Deriche (2nd order)	14	16	1.80 × ${10}^{-7}$	-	$O\left(1\right)$
VYV (2nd order)	8	12	1.39 × ${10}^{-7}$	-	$O\left(1\right)$
VYV (3rd order)	12	16	5.01 × ${10}^{-8}$	-	$O\left(1\right)$

. The complexity is the number of required operations per pixel for 2D image filtering with a Gaussian kernel. Note that the number of required arithmetic operations is presented per pixel. For several methods, it depends on their internal parameters, the meaning of which can be clarified in the subsection with a description of the corresponding approximation.

The accuracy of methods was computed by us independently by minimizing the mean square error (MSE) provided by the expression

$$MSE=\frac{1}{S}\sum _{n=1}^S{\left(g_{{\sigma }_0}\left[n\right]-h\left[n\right]\right)}^2$$

(59)

for $S=500$ points uniformly taken on the interval $[-3{\sigma }_0;3{\sigma }_0]$ with ${\sigma }_0=10$. The original Deriche paper contained values of error provided by (34) for the second-order filter and $\sigma =100$, so we re-estimated its error. The PcParab method is the only method that did not require any parameter adjustment by minimizing any function because the coefficients of the parabolas were obtained by solving a system of linear equations. As a result, the obtained $h\left[n\right]$ was just substituted into expression (59) for this method.

The third-order VYV filter proved to be the most accurate of all the approximations considered. The second-order VYV and the second-order Deriche ones, as well as the PcParab method, were slightly less accurate. At the same time, these approximations are the most computationally expensive. Running sums method with $k=5$ has almost identical computational complexity but shows an order of magnitude lower accuracy. The first-order Deriche and second-order VYV filters require few operations but show lower accuracy than the others. The Stack and Bell blur approximations do not require multiplicative operations, while the accuracy is acceptable. Among the approximations with piecewise constant functions, the accuracy of Bell blur was higher than all the running sums ones since the number of steps used in Bell blur notation is not limited and is shown (Figure 2 and Figure 3) to be significantly greater than for running sums. Nevertheless, for $k=5$, the accuracy of the running sums method is very close to Bell blur.

6. Quantization and SIMD Implementation

Modern computers employ either integer or floating-point format to store numbers. Both formats use a specific number of bits for value storage, with more bits equating to higher precision. In integer representation, the discrete values are evenly spaced. In floating-point methods, the discrete values near one another are uniform; however, the step size increases exponentially as the value’s magnitude increases. This results in a vast dynamic range, enabling storage of both very large and very small values in memory. While floating-point representation is prevalent, it does come with a computational cost. A floating-point processing unit requires more logic and transistors than an integer one. So, using an integer format can be advantageous: the resulting values require less memory storage and can be processed faster. Furthermore, quantization enables the implementation on devices with no floating point unit support.

We conducted our experiments with floating-point and low-precision integer representations. Let us describe our quantization approach. In running sums and PcParab methods, the coefficients are real-valued, and we quantized them to round them into integer ones. Mathematically, it is written as

$$\widehat{a}=round(a·2^b),$$

(60)

where $a\in [0;1]$ is the coefficient to be rounded and b denotes the number of bits in fixed-point representation.

We ran the experiments on Intel Core i9-9900KF (with x86_64 architecture) and ARM Cortex-A73 (with ARMv8 architecture) CPUs. For DFT-based convolution, we used the implementation from fftw3 open-source library [33]. Methods except DFT-based convolution and direct Gaussian filtering were vectorized.

We utilized SIMD vectorization using intrinsics of SSE family for x86_64 and NEON intrinsics for ARMv8. We operated with 128-bit registers storing 4 single-precision floating-point values or 16 unsigned integer values. Approximations except for the running sums method compute the answer recurrently; i.e., the result for the current element is based on the result for the previous one. Thus, direct vectorization would not be efficient and meaningful. In vectorized implementations, the image was preliminarily transposed (Figure 7) so that we go through the columns of the original image, writing the answer in 4 or 16 elements at a time if 32-bit floating-point or 8-bit unsigned integer types, correspondingly, were used.

Details of quantized implementations can be clarified below. The division to normalize the result for all the quantized implementations is performed in integers with appropriate rounding to the nearest value.

• Stack blur and Bell blur

These are the only approximations that do not involve multiplications and construct the answer by special summation of the input image pixels. Their only parameter is the radius, which defines the lengths of the summation regions. So, there is nothing to apply Equation (60) to. Obtained sums for outgoing and incoming pixels stored in $s^{out}$ and $s^{in}$ accumulators, correspondingly, may be negative, so we use 32-bit integer type for operating on them. The normalizing factor was not modified.

• Running sums

The method sequentially sums the pixels and stores them in an array called an integral row. The range of possible intensity values for the 8-bit image is $[0;2^8-1]$; hence, the values of the integral row are greater than or equal to 0. We stored them in 32-bit unsigned integer type. Real-valued steps of piecewise constant functions were quantized by specifying $b=8$ in Equation (60). The normalizing factor was modified in the same way.

• PcParab

The method operates with arrays $y^C,y^F,$ and $y^{F2}$ accumulating integer linear combinations of image pixels and then multiplies their elements on real coefficients of the parabolas. For these purposes, we used 32-bit integer type for accumulator arrays and obtained quantized coefficients according to Equation (60) for $b=9$ and with preliminary division by the minimum absolute value coefficient. The normalizing factor was modified in the same way.

• Deriche and VYV filters

For IIR filters, quantized implementations were not successful as the values accumulated along the image rows were too large to fit into an appropriate accumulator type.

For FIR filters, we considered both floating-point and quantized implementations. All of them were vectorized. For IIR filters, the paper includes floating-point implementations and their vectorized variants.

7. Experimental Comparison

In this section, we present the results of our experimental comparison. In our computational experiments, we ran each method on 1000 randomly generated gray images of the size $1024\times 1024$. The quantized methods obtained 8-bit unsigned integer data as inputs. The non-quantized methods operated on 32-bit floating-point data, and their input was in the $[0,1]$ range. The numerical values of the runtime are presented in

Table 2. Average runtime of the considered methods for $\sigma =10$. Bold corresponds to the lowest value in the column.

Method	Runtime, ns (x86)		Runtime, ns (ARMv8)
	no SIMD	with SIMD	no SIMD	with SIMD
Direct Gaussian	81.3	-	281.5	-
Direct Gaussian (quant.)	12.0	-	128.0	-
DFT-based convolution (FFT)	10.7	-	86.1	-
Stack blur	6.0	3.5	20.4	17.7
Stack blur (quant.)	3.8	1.6	15.5	14.7
Bell blur	6.7	4.3	31.6	26.8
Bell blur (quant.)	5.7	2.6	22.5	22.0
Running sums, $k=3$	8.3	5.6	40.7	23.2
Running sums, $k=3$ (quant.)	7.0	2.7	32.9	14.1
Running sums, $k=4$	9.7	5.9	46.8	25.0
Running sums, $k=4$ (quant.)	8.3	3.0	39.4	15.7
Running sums, $k=5$	11.3	6.2	53.2	27.2
Running sums, $k=5$ (quant.)	10.1	3.4	46.2	17.3
PcParab	20.0	5.8	47.9	34.8
PcParab (quant.)	15.0	4.9	65.2	29.8
Deriche (1st order)	9.1	3.5	31.3	20.4
Deriche (2nd order)	12.5	4.2	38.2	22.7
VYV (2nd order)	12.2	3.4	36.0	18.9
VYV (3rd order)	15.5	3.7	44.1	19.2

. We also added illustrations to demonstrate the visual effects of applying the considered approximations. One can see them in Figure 8, Figure 9 and Figure 10. Analyzing these illustrations shows that all the considered implementations demonstrate an acceptable visual effect.

Examining the numerical results, we can deduce the following conclusions. Looking at the speedup from the vectorization of the computations, we can notice that the vectorization significantly affects the approximations that require multiplicative operations. Thus, it enabled speeding up the Deriche filters by almost 3 times and the VYV filters nearly 4 times. Furthermore, in the quantized implementations, the vectorization demonstrated a more substantial speedup than the floating-point implementations. This is due to the fact that vectorization processes a larger number of elements at a time. For instance, a 128-bit register can accommodate 16 8-bit items. However, to prevent overflow, we need to convert the numbers into a 32-bit integer format for intermediate computations. Despite this constraint, the speedup was still significant, highlighting the advantage of vectorization in quantized filters. We can also see that direct Gaussian filtering quantized implementation already enables a significant reduction in the running time.

The results in a more demonstrable form are presented in Figure 8. Here, the MSE is plotted along the x-axis and the running time along the y-axis. We also added the results for the case with $\sigma =5$ in Figure 8. Analyzing the plots, one can choose a method based on the priority of higher accuracy or lower running time:

• The Stack blur quantized implementation showed the lowest running time on x86, although, on ARM, the quantized implementation of running sums with $k=3$ appeared to be slightly faster. However, these approximations have relatively low accuracy.
• Among the IIR filters, the second-order VYV filter demonstrated the best running time both on x86 and ARM and slightly outperformed Deriche’s approximations in terms of accuracy. The third-order VYV filter works more slowly on x86 and faster on ARM, providing the most accurate results.
• The IIR filters outperformed almost all the floating-point methods except Stack blur on ARM for $\sigma =10$.
• All in all, the second-order VYV filter has the best balance between speed and accuracy. Moreover, it requires a constant amount of additional memory. However, it uses floating-point input and computations, which can be inappropriate for some cases.
• Among the integer-only methods, the quantized Bell blur and quantized running sums ($k=4$ and $k=5$) have the best balance between the speed and accuracy on x86 and ARM, respectively. The Bell blur requires a constant amount of additional memory, while, for running sums, the additional memory depends linearly on the image size.

8. Conclusions

Approximations of convolution with Gaussian filters offer a practical alternative to the computationally expensive approach of exact Gaussian smoothing. In this paper, we compared several of these methods in terms of computational complexity and accuracy. All the considered approximations demonstrated acceptable results and 10–20× times speedup compared to the naive approach. The choice between these approximations depends on the specific requirements of the application and hardware, striking a balance between precision and efficiency.

For floating-point input data and implementations, we recommend using the second-order Vliet–Young–Verbeek filter since the other methods superior to it in time or accuracy are significantly inferior in other aspects. However, in cases where accuracy is unimportant, one can use Stack blur as the fastest method.

For integer inputs, we recommend quantized methods. Bell blur or running sums are the most effective variants depending on the platform and additional memory use restrictions. These methods provide a combination of reasonably high accuracy and speed. Quantized Stack blur also works faster but is inferior in accuracy and, therefore, has limited use.