Velocity Filtering Using Quantum 3D FFT

Abstract

In this work, the quantum version of 3D FFT is proposed for constructing velocity filters. Velocity filters are desirable when we need to separate moving objects with a specific velocity range in amplitude and direction in a rapidly changing background. These filters are useful in many application fields, such as for monitoring regions for security reasons or inspecting processes in experimental physics. A faster and more attractive way to implement this filtering procedure is through 3D FFT instead of using 3D FIR filters. Additionally, 3D FFT provides the capability to create banks of ready-made filters with various characteristics. Thus, 3D filtering is carried out in the frequency domain by rejecting appropriate frequency bands according to the spectral content of the trajectory of the object to be isolated. The 3D FFT procedure and the corresponding inverse one are required in the beginning and end of the filtering process. Although 3D FFT is computationally effective, it becomes time-consuming when we need to process large data cubes. The implementation of velocity filters by means of the quantum version of 3D FFT is investigated in this work. All necessary quantum circuits and quantum procedures needed are presented in detail. This proposed quantum structure results in velocity filtering with a short execution time. For this purpose, a review of the necessary quantum computational units is presented for the implementation of quantum 3D FFT and representative examples of applications of velocity filtering are provided.

1. Introduction

Fast Fourier transform (FFT) provides a means for frequency analysis and filtering, avoiding the operation of convolution. The quantum version of Fourier transform (QFT) provides an opportunity to quickly obtain the results derived by FFT. The use of QFT has been investigated for various applications. Accordingly, in [1], it is proved that a quantum version of the filtering operation can be achieved, even though the quantum convolution of two sequences is physically impossible. There are important differences between classical and quantum implementations for image filtering. These differences are analyzed in [1], and it is shown that the major advantage of the quantum approach lies in the exploitation of the efficient implementation of QFT. A common approach to image filtering is to convolve the image with a filter function, which in the frequency domain translates into a multiplication operation. However, there are classical processing operations that cannot be directly applied to quantum images, such as convolution and correlation [2]. In [3], a survey is provided with some topics on the properties of quantum gates and their assembly into interesting quantum circuits. The role of reversibility in the theory of computation and an early discussion of gate and circuit constructions in reversible computation are also provided.

The application of QFT within the field of quantum computation has been extensively presented in [4]. Shor’s algorithm, phase estimation, and computing discrete logarithms are some classic examples of its use. These special properties of quantum algorithms have resulted in novel solutions to problems difficult to be solved on a classical computer. QFT has been used in several applications [5,6,7]. Since QFT is the core to a lot of quantum algorithms, current research mainly focuses on its effective realization [7,8,9,10,11,12,13]. These studies discuss quantum information issues [7], approximate QFT and decoherence [8], Shor’s algorithm [9,10], QFT for phase estimation [11], and quantum circuitry [12,13]. Quantum edge detection is carried out in [14] based on double-chain quantum genetic algorithms. Hybrid quantum-classical networks for image generation are proposed in [15].

A review of quantum image processing is presented in [16], revealing the possibilities for intensive image-processing procedures due to the powerful parallel computing capabilities of quantum computers. In [17], a quantum implementation of the FFT algorithm composed of a combination of quantum gates is proposed. QFT is implemented in [18] on a 3-qubit nuclear magnetic resonance (NMR) quantum computer to extract the periodicity of an input state. A fast quantum image component-labeling algorithm is proposed in [19], which is the quantum counterpart of the classical local operator technique. A quantum color image encryption algorithm is designed in [20] based on geometric transformation and intensity channel diffusion. A framework of quantum image filtering in the spatial domain is proposed in [21]. A quantum image median filtering approach is proposed and its corresponding quantum circuit is designed in [22]. The main idea of the approach is that first, the classical image is converted into a quantum version based on the novel enhanced quantum representation (NEQR) of digital images, and then, a unique quantum module is designed to realize the median calculation of neighborhood pixels for each pixel point in the image. In [23], the authors consider QFT-based color-image-filtering operations and their applications in image smoothing, sharpening, and selective filtering using quantum frequency domain filters. The proposed quantum filters use the principle of quantum oracles to implement the filter function.

The 3D FFT technique is useful in numerous physical problems. Four of these problems are listed next in order to provide the reader with a sense of the potential applicability of QFT. First-principles methods based on density functional theory (DFT) where the wave functions are expanded in plane waves (Fourier components) are the most widely used approaches for electronic structure calculations in materials science [24]. The scaling of this method depends critically on having an efficient parallel 3D FFT that minimizes communications and calculations. First-principles methods based on DFT in the Kohn–Sham (KS) [25] formalism are the most widely used approaches for electronic structure calculations in materials science. The most common implementation of this approach involves the expansion of the wave functions in plane waves (Fourier components) and the use of pseudopotentials to replace the nucleus and core electrons. In this implementation, parallel 3D FFT is required to transform the electronic wave functions from Fourier space to real space in order to construct the charge density. The 3D Fourier forward modeling of 3D density sources is capable of providing 3D gravity anomalies coinciding with the meshed density distribution within the whole source region [26]. Forward modeling of potential fields’ anomalies is essential for geophysical interpretation and inversion. An implicit split-operator FFT algorithm for the numerical solution of the time-dependent Schrodinger equation is implemented for the electronic structure of $H_2^{+}$ and $H_2$ in [27]. In this article, an algorithm appropriate for 3D applications is implemented that is implicit and thus overcomes the difficulty of the non-conservation of energy.

The tracking and isolation of moving objects with a specific range of speed are a challenging research topic in the field of automotive application [28,29,30,31]. To cope with this issue, velocity filters have been used in the past for localizing and monitoring moving objects in image sequences or otherwise 3D imagery [32,33,34]. Filter banks are used for fast implementation of the localization and monitoring of moving vehicles. These banks are built using 3D FFT to perform directional filtering [28,29,30,31,32,33,34,35].

In this work, the way that basic quantum circuits are combined to build up the QFT structure is extensively presented. This structure is applied in the well-known separable procedure in order to implement 3D QFT. This way, the 3D spectral content of the data cube is evaluated. A quantum oracle is used for isolating the necessary frequency components in the 3D spectral cube that correspond to the required trajectory. In fact, a variety of quantum oracles are represented by the quantum filter used in order to realize the necessary filter bank. Inverse QFT (IQFT) is applied at the output of the quantum oracle to obtain the final result with the isolated moving object (trajectory). The implementation of velocity filters by means of the quantum version of 3D FFT results in fast filtering procedures, which are necessary for discriminating objects’ velocities. QFT can calculate the Fourier transform of a vector of size N with time complexity $\mathcal{O}({log}_2^{2}N)$ compared to the classical complexity of $\mathcal{O}\left(N{log}_{2}N\right)$ [36]. However, if one wants to measure the full output state, then the QFT complexity becomes $\mathcal{O}(N{log}_2^{2}N)$, thus losing its apparent advantage, indicating that the advantage is fully exploited for algorithms when only a limited number of samples is required from the output vector, as is the case in many quantum algorithms. Accordingly, for a signal of 1024 samples, QFT requires operations of the order of 100, while classical FFT requires operations of the order of 10,000.

The paper is organized in the following way. In Section 2, the quantum theory for supporting QFT is presented. The velocity filtering approach is provided in Section 3. In Section 4, the use of QFT for implementing velocity filters is analyzed. Experimental results are presented in Section 5. Finally, conclusions are drawn in Section 6.

2. Quantum Theory

2.1. Quantum Fourier Transform Theory

Fourier transform occurs in many different versions in all areas from signal processing to complexity theory to data compression [37,38,39]. QFT is the classical discrete Fourier transform applied to a vector of amplitudes of a quantum state, where we usually consider vectors of length $N$.

Discrete Fourier transform acts on a vector $\left(x_0, x_1, \dots , x_{N-1}\right)\in C^N$ and maps it to a vector $\left(y_0, y_1, \dots , y_{N-1}\right)\in C^N$ according to the formula

$$y_k=\frac{1}{\sqrt{N}}{\sum }_{j=0}^{N-1}{x}_j{\omega }_N^{jk},k=0,1,2,3,\cdots ,N-1$$

(1)

where ${\omega }_N^{jk}=e^{\frac{2\pi i}{N}jk}$ and ${\omega }_N^j$ is the j-th root of unity.

Similarly, QFT acts on a quantum state $|x\rangle ={\sum }_{j=0}^{N-1}{x}_j|j\rangle$ and maps it to a quantum state $|y\rangle ={\sum }_{k=0}^{N-1}{y}_k|k\rangle$ according to the formula

$$y_k=\frac{1}{\sqrt{N}}{\sum }_{j=0}^{N-1}{x}_j{\omega }_N^{jk},k=0,1,2,3,\cdots ,N-1$$

(2)

Since ${\omega }_N^{jk}$ is a rotation, IQFT acts similarly:

$$x_j=\frac{1}{\sqrt{N}}{\sum }_{k=0}^{N-1}{y}_k{\omega }_N^{-jk},j=0,1,2,3,\cdots ,N-1$$

(3)

In case $|j\rangle$ is a basis state, QFT can also be expressed as the map

$$|j\rangle \to \frac{1}{\sqrt{N}}{\sum }_{k=0}^{N-1}{\omega }_N^{jk}|k\rangle$$

(4)

Equivalently, QFT can be viewed as a unitary matrix (or quantum gate) acting on quantum-state vectors, where the unitary matrix $F_N$ is given by

$$F_N=\frac{1}{\sqrt{N}}\left[\begin{array}{cccccc}\begin{array}{c}1\\ 1\\ 1\\ 1\\ ⋮\\ 1\end{array}& \begin{array}{c}1\\ \omega \\ {\omega }^2\\ {\omega }^3\\ ⋮\\ {\omega }^{{\rm N}-1}\end{array}& \begin{array}{c}1\\ {\omega }^2\\ {\omega }^4\\ {\omega }^6\\ ⋮\\ {\omega }^{2\left({\rm N}-1\right)}\end{array}& \begin{array}{c}1\\ {\omega }^3\\ {\omega }^6\\ {\omega }^9\\ ⋮\\ {\omega }^{3\left({\rm N}-1\right)}\end{array}& \cdots & \begin{array}{c}1\\ {\omega }^{{\rm N}-1}\\ {\omega }^{2\left({\rm N}-1\right)}\\ {\omega }^{3\left({\rm N}-1\right)}\\ ⋮\\ {\omega }^{\left({\rm N}-1\right)\left({\rm N}-1\right)}\end{array}\end{array}\right]$$

(5)

where $\omega ={\omega }_N$.

Most of the properties of QFT follow from the fact that it is a unitary transformation. This can be checked by performing matrix multiplication and ensuring that the relation $F{F}^{+}=F^{+}F=I$ holds, where $F^{+}$ is the Hermitian adjoint of $F$. Alternately, one can check that orthogonal vectors of norm 1 get mapped to orthogonal vectors of norm 1.

From the unitary property, it follows that the inverse of quantum Fourier transform is the Hermitian adjoint of the Fourier matrix, so $F^{-1}=F^{+}$. Since there is an efficient quantum circuit implementing QFT, the circuit can be run in reverse to perform IQFT. Thus, both transforms can be efficiently performed on a quantum computer.

QFT transforms between two bases, the Fourier basis and the computational basis (Z). The H gate is single-qubit QFT, and it transforms between the Z-basis states $|0\rangle$ and $|1\rangle$ to the X-basis states $|+\rangle$ and $|-\rangle$. In the same way, all multi-qubit states in the computational basis have corresponding states in the Fourier basis. QFT is simply the transform that transforms between these bases.

2.2. The Circuit Implementation of QFT

The circuit implementation of QFT makes use of two gates. One of them is the single-qubit Hadamard gate $H=\frac{1}{\sqrt{2}}\left(\begin{array}{cc}1& 1\\ 1& -1\end{array}\right),$ and the other is the phase gate $R_m=\left(\begin{array}{cc}1& 0\\ 0& e^{2\pi i/2^m}\end{array}\right)$.

Consider how QFT operates on a single-qubit state (1-qubit QFT) $|\psi \rangle =a|0\rangle +b|1\rangle ,$ where $x_0=a$, $x_1=b$ and $N=2$.

$$y_0=\frac{1}{\sqrt{2}}\hspace{1em}\left(a·e^{\frac{2\pi i}{2}0\times 0}+b·e^{\frac{2\pi i}{2}1\times 0}\right)=\frac{1}{\sqrt{2}}\left(a+b\right)$$

(6)

and

$$y_1=\frac{1}{\sqrt{2}}\hspace{1em}\left(a·e^{\frac{2\pi i}{2}0\times 1}+b·e^{\frac{2\pi i}{2}1\times 1}\right)=\frac{1}{\sqrt{2}}\left(a-b\right)$$

(7)

so the final result is the state

$$U_{QFT}|\psi \rangle =\frac{1}{\sqrt{2}}\left(a+b\right)|0\rangle +\frac{1}{\sqrt{2}}\left(a-b\right)|1\rangle$$

(8)

This operation is exactly the result of applying the Hadamard gate to the qubit. If we apply the Hadamard gate to the state $|\psi \rangle =0+b|1\rangle$, we obtain a new state:

$$\frac{1}{\sqrt{2}}\left(a+b\right)|0\rangle +\frac{1}{\sqrt{2}}\left(a-b\right)|1\rangle \equiv \overline{a}|0\rangle +\overline{b}|1\rangle$$

(9)

The Hadamard gate H for n qubits is given as

$$H_{2^n}=H_2\otimes H_{2^{n-1}},2\le n\in N$$

(10)

where $\otimes$ is the Kronecker product, i.e., for $n=2$, we have the Hadamard gate $H_4$

$$H_{2^2}=H_4=H_2\otimes H_{2^{2-1}}=H_2\otimes H_2=\frac{1}{\sqrt{2}}\left(\begin{array}{cc}1& 1\\ 1& -1\end{array}\right)\otimes \frac{1}{\sqrt{2}}\left(\begin{array}{cc}1& 1\\ 1& -1\end{array}\right)=\frac{1}{2}\left(\begin{array}{llll}1& +1& 1& 1\\ 1& -1& 1& -1\\ 1& 1& -1& -1\\ 1& -1& -1& 1\end{array}\right)$$

(11)

Given these two gates, a circuit implementation of n-qubit QFT is shown in Figure 1 [34,35,37].

The basis states that enumerate all possible states of the n qubits are

$$|x\rangle =|x_1\rangle \otimes \left|x_2\right.〉\otimes |x_3\rangle \otimes \cdots \otimes \left|x_{n-1}\right.〉\otimes |x_n\rangle$$

(12)

where $|x_k\rangle$ indicates that qubit $k$ is the state $x_k,$ with $x_k$ being either 1 or 0. The basis state index $x$ is the binary number encoded by $x_k$, with $x_1$ being the most significant bit. So, we can write the QFT as

$$QFT(|x\rangle )=\frac{1}{\sqrt{N}}{\otimes }_{k=1}^n(\left|0\right.〉+e^{2\pi ix/2^k}|1\rangle$$

(13)

After rearranging the sum and the products and expanding ${\sum }_{y=0}^{N-1}={\sum }_{y_1=0}^1{\sum }_{y_2=0}^1\cdots {\sum }_{y_n=0}^1$, the action of the QFT can be expressed by

$$\begin{array}{c}QFT\left(|x_1{x}_2{x}_3\cdots x_{n-1}{x}_n\rangle \right)=\frac{1}{\sqrt{N}}\left(|0\rangle +e^{\frac{2\pi i{x}_n}{2}}|1\rangle \right)\otimes \left(|0\rangle +e^{\frac{2\pi i{x}_{n-1}}{2}+\frac{2\pi i{x}_n}{2^2}}|1\rangle \right)\otimes \cdots \otimes (|0\rangle +\\ e^{\frac{2\pi i{x}_1}{2}+\frac{2\pi i{x}_2}{2^2}+\frac{2\pi i{x}_3}{2^3}+\cdots +\frac{2\pi i{x}_{n-1}}{2^{n-1}}+\frac{2\pi i{x}_n}{2^n}}|1\rangle )\end{array}$$

(14)

i.e., for 3-qubit QFT

$$|y\rangle =\frac{1}{\sqrt{2^3}}[(|0\rangle +e^{\frac{2\pi i{x}_3}{2}}|1\rangle )\otimes (|0\rangle +e^{\frac{2\pi i{x}_2}{2}+\frac{2\pi i{x}_3}{2^2}}|1\rangle )\otimes (|0\rangle +e^{\frac{2\pi i{x}_1}{2}+\frac{2\pi i{x}_2}{2^2}+\frac{2\pi i{x}_3}{2^3}}|1\rangle )]$$

(15)

In a similar way, one can extend to N-qubit QFT if a larger amount of information is to be processed.

3. Theory of Velocity Filtering

Studies [28,29] have carried out velocity filtering using filter banks created using conventional FFT, and simultaneously, they are selected by means of the specific spectral content required. In this work, all necessary spectral quantities are evaluated using QFT for radically accelerating the mathematical calculations. A bank of velocity filters [28] is necessary for separating multiple objects with different velocities in a sequence of frames. In [28], the 3D FFT transformation of a large number of objects with a variety of different velocities is applied. The proposed approach is based on experimentation and avoids using theoretical concepts. Accordingly, in this study, an object moving each time with a different velocity and in various directions was used in order to construct a filter bank. Multiple moving objects can be isolated from other objects with different velocities or from objects with the same amplitude of velocity but having different directions. The simulated datasets that were used in order to create the spectral signatures of different moving objects consisted of 256 frames of 256 × 256 pixels each. Accordingly, a data cube (shown in Figure 2) was formed of 256³ pixels. The number 256 = 2⁸ was selected to fit the FFT requirements for fast evaluation of the 3D spectrum.

The time parameter is considered the distance from frame to frame. Based on this, the amplitude of the radial velocity of each object is referred to as the number of pixels it comes across from one frame to the next. A simple example of one object of size 10 × 10 pixels that is moving with a radial velocity of 1/3 pixels per frame is shown in Figure 3. The object is moving in the direction of 340 degrees with respect to the horizontal left-to-right direction. Four different frames are given, i.e., the 1st, 64th, 128th, and 256th.

The datasets used for experimentation covered a wide range of velocities with regard to the amplitude and direction. Specifically, six different radial velocities (amplitudes) were selected, i.e., 1/2 (fast), 1/3, 1/4, 1/8, 1/16, and 1/32 (slow) pixels per frame. For all these velocities, 24 different directions were chosen, with the first one at 0 degrees (horizontal direction from left to right) and counterclockwise every 15 degrees, as shown in Figure 4. Accordingly, a total of 6 × 24 = 144 different data cubes (velocities) were implemented.

Since the spectrum is a complex quantity, its amplitude and phase were evaluated separately. Parallel trajectories in the data cube that correspond to objects having the same velocity possess the same spectral amplitude information and differ in the phase information. Accordingly, regardless of the initial position of an object, its velocity corresponds to a specific amplitude of the spectral content. Thus, only the amplitude information is of interest and was recorded.

Studying the amplitude of the spectral content of a data cube, one can easily observe that from the total of 256³–2²⁴–16 million harmonics, only a small percentage has significant value. Thus, for each direction of the moving object with a specific velocity, a file that contained the positions of the most important harmonics (about 4000) was created, as those spectral components that are larger than the 12% (pixel value 30 with maximum 255) of the biggest spectral component are considered important harmonics.

However, later, when it is necessary to process complicated signals, the 20 largest harmonics among the 4000 will be recalled and their use in the final filter will be examined again. This is needed when in the signal to be processed, the vehicle to be recorded is not among the strongest objects.

To isolate an object moving with a specific velocity (velocity filtering) among other objects in a data cube, we need to perform the following steps:

1. Find the spectral content of the specific cube 3D FFT.

2. Eliminate from the spectral amplitude all harmonics except those corresponding to the specific velocity.

3. Evaluate the inverse 3D FFT to recover the data cube containing only the object with the specific velocity.

4. Implementation of Velocity Filtering Using QFT

4.1. Three-Dimensional Discreet Fourier Transform

The 3D discreet Fourier transform technique is a separable procedure. This comes from the fact that its expression

$$p\left(k_1,k_2,k_3\right)={\sum }_{n_1=0}^{N-1}{\sum }_{n_2=0}^{N-1}{\sum }_{n_3=0}^{N-1}q\left(n_1,n_2,n_3\right)W_N^{k_1{n}_1}{W}_N^{k_2{n}_2}{W}_N^{k_3{n}_3}0\le k_1,k_2,k_3\le N-1$$

(16)

can be written as follows:

$$p\left(k_1,k_2,k_3\right)={\sum }_{n_1=0}^{N-1}{W}_N^{k_1{n}_1}{\sum }_{n_2=0}^{N-1}{W}_N^{k_2{n}_2}{\sum }_{n_3=0}^{N-1}q\left(n_1,n_2,n_3\right)W_N^{k_3{n}_3}0\le k_1,k_2,k_3\le N-1$$

(17)

The first summation on the right of this equation means that we must perform N² N-point discreet Fourier transforms along the n₃ direction. Since each N-point FFT (for N being a power of 2) requires N log₂ N operations, for the implementation of the first summation of Equation (17), N³ log₂ N operations are needed. The derived intermediate result is an N³ complex cube to be again processed along the n₂ direction. Thus, another set of N³ log₂ N complex operations is required. The second derived intermediate result is again an N³ complex cube to be finally processed along the n₁ direction. Thus, a total of 3N³ log₂ N of complex operations are required. Following another way, we must perform N-point FFT along all horizontal lines, all horizontal columns, and all vertical columns regardless of the order in which they will be performed.

An example of 3D FFT is shown in Figure 5 for N = 4. From this figure and Equation (17), it is evident that the order of implementation of the 1D transforms, i.e., the order of the summations in Equation (17), does not matter. In image cubes (frame sequences), one of the dimensions is usually time.

4.2. Quantum 3D Fast Fourier Transform

A quantum cube can be represented using a quantum register Q constructed so that it encodes all required information, i.e., the position of a pixel in the frame (x, y), the serial number of the frame (time t), and the intensity or color (c) of the pixel [24]. We assumed that we have 2^k frames with 2ⁿ × 2ⁿ pixels each and that the color of each pixel requires m bits for its color representation. In this case, a register |P > having 2ⁿ qubits is adequate for holding all position information, another register |T> having k qubits will represent the time information, and a register |C > with m qubits will represent 2^m different colors or grayscale levels. The register |P > is separated into two sub-registers of n qubits each containing the row and column information in the form |y > |x >. The quantum register Q containing all the information about the quantum frame cube can be expressed as

$$Q=\left|C{>}_m\otimes \right|P{>}_{2n}\otimes \left|T{>}_k\right|={\sum }_{t=0}^{2^k-1}{\sum }_{i=0}^{2^{2n}-1}{\sum }_{j=0}^{2^m-1}{a}_{ijt}\left|j\right.>\left|i\right.>\left|t\right.>$$

(18)

In Equation (18), the coefficients a_ijt for a specific t (frame of the cube) sum up to 1:

$${\sum }_{j=0}^{2^m-1}{\left|a_{ijt}\right|}^2=1\mathrm{for}\mathrm{all}\mathrm{i}\mathrm{with}0\le i<2^{2n}\mathrm{and}\mathrm{all}\mathrm{t}\mathrm{with}0\le t<2^k$$

and are used to express the color of a pixel with position i by means of a superposition of all possible colors. For a given pixel i, the coefficients a_ij take the value of 1 if the color of the pixel is j and 0 otherwise. This is illustrated in Figure 6 with a simple example of a 2 × 2 × 2 frame cube with eight colors (0–7). The corresponding coefficients a_ijt for the specific examples in Figure 6 are as follows:

$$\begin{array}{l}\hspace{1em}\hspace{1em}\begin{array}{llllllll} pct& pct& pct& pct& pct& pct& pct& pct\\ a_{000}=1,& a_{010}=0,& a_{020}=0,& a_{030}=0,& a_{040}=0,& a_{050}=0,& a_{060}=0,& a_{070}=0\\ a_{100}=0,& a_{110}=0,& a_{120}=1,& a_{130}=0,& a_{140}=0,& a_{150}=0,& a_{160}=0,& a_{170}=0\\ a_{200}=0,& a_{210}=0,& a_{220}=0,& a_{230}=0,& a_{240}=1,& a_{250}=0,& a_{260}=0,& a_{270}=0\\ a_{300}=0,& a_{310}=0,& a_{320}=0,& a_{330}=0,& a_{340}=0,& a_{350}=0,& a_{360}=1,& a_{370}=0\\ a_{001}=0,& a_{011}=0,& a_{021}=0,& a_{031}=0,& a_{041}=0,& a_{051}=0,& a_{061}=0,& a_{071}=1\\ a_{101}=0,& a_{111}=0,& a_{121}=0,& a_{131}=0,& a_{141}=1,& a_{151}=0,& a_{161}=0,& a_{171}=0\\ a_{201}=0,& a_{211}=0,& a_{221}=0,& a_{231}=0,& a_{241}=0,& a_{251}=1,& a_{261}=0,& a_{271}=0\\ a_{301}=0,& a_{311}=0,& a_{321}=0,& a_{331}=0,& a_{341}=0,& a_{351}=0,& a_{361}=1,& a_{371}=0\end{array}\\ P=Position\hspace{1em}c=Color\hspace{1em}t=Time\end{array}$$

In case we assume the time register |T> as being the third dimension in our pixel cube representation without distinction between time and space (such data are available in various cases, such as computed tomography), and furthermore, k equals n, then Equation (18) becomes

$$Q=\left|C{>}_m\otimes \right|P{>}_{3n}={\sum }_{i=0}^{2^{3n}-1}{\sum }_{j=0}^{2^m-1}{a}_{ij}\left|j\right.>\left|i\right.>$$

(19)

In Equation (19), the coefficients a_ij sum up to 1:

$${\sum }_{j=0}^{2^m-1}{\left|a_{ij}\right|}^2=1\forall iwith0\le i<2^{3n}$$

(20)

and are used to express the color of a pixel with position i by means of a superposition of all possible colors. For a given pixel i, the coefficients a_ij take the value of 1 if the color of the pixel is j and 0 otherwise:

$$\begin{array}{c}{a}_{00}=1, a_{01}=0, a_{02}=0, a_{03}=0, a_{04}=0, a_{05}=0, a_{06}=0, a_{07}=0\\ a_{10}=0, a_{11}=0, a_{12}=1, a_{13}=0, a_{14}=0, a_{15}=0, a_{16}=0, a_{17}=0\\ a_{20}=0, a_{21}=0, a_{22}=1, a_{23}=0, a_{24}=1, a_{25}=0, a_{26}=0, a_{27}=0\\ a_{30}=0, a_{31}=0, a_{32}=0, a_{33}=0, a_{34}=0, a_{35}=0, a_{36}=1, a_{37}=0\\ a_{40}=0, a_{41}=0, a_{42}=0, a_{43}=0, a_{44}=0, a_{45}=0, a_{46}=0, a_{47}=1\\ a_{50}=0, a_{51}=0, a_{52}=0, a_{53}=0, a_{54}=1, a_{55}=0, a_{56}=0, a_{57}=0\\ a_{60}=0, a_{61}=0, a_{62}=0, a_{63}=0, a_{64}=0, a_{65}=1, a_{66}=0, a_{67}=0\\ a_{70}=0, a_{71}=0, a_{72}=0, a_{73}=0, a_{74}=0, a_{75}=0, a_{76}=1, a_{77}=0\end{array}$$

This is illustrated in Figure 7 with a simple example of a 2 × 2 × 2 frame cube with eight colors (0–7).

The quantum register Q, expressed using Equation (18), was experimentally implemented by the circuit in Figure 8. It is in fact the quantum circuit that implements 3D velocity filtering.

As shown in Figure 8, at the output of the proposed quantum velocity filtering circuit, we find the input image cube. Additionally, exploiting the quantum interference phenomenon, we can use an additional qubit initially in state |0> to reinterpret the quantum image cube as a superposition of two image cubes. For example, for a high-pass or a low-pass 3D filter, the output image is the sum of the image cube containing high frequencies and the image cube containing the corresponding low frequencies. The additional qubit can be used to make the distinction between the two image cubes.

Next, we analyzed this process and described the state of the quantum velocity filtering circuit at each step of the computation, as marked in Figure 8. With respect to Equation (18), the register |P> having 2n qubits and holding all position information is represented in the following Equation (21), with two registers of n qubits each corresponding to x and y positions, respectively. The input state $\left|I_0\right.>$ is represented by the input image cube and an additional qubit in state $\left|0\right.>$:

$$\left|I_0\right.>=\left|Q\right.>\otimes \left|0\right.>=\frac{1}{2^n}{\sum }_{t=0}^{2^n-1}{\sum }_{y=0}^{2^n-1}{\sum }_{x=0}^{2^n-1}{\sum }_{j=0}^{2^m-1}{a}_{tyxj}\left|j\right.>\left|t\right.>\left|y\right.>\left|x\right.>\left|0\right.>$$

(21)

where $\left|Q\right.>$ holds the quantum image cube using the representation described previously. Applying 3D QFT on the image cube produces state $\left|I_1\right.>$:

$$\left|I_1\right.>=(I_m\otimes {QFT}_{2^{3n}})\left|Q\right.>\otimes I\left|0\right.>$$

$$=\frac{1}{2^n}{\displaystyle \sum }_{t=0}^{2^n-1}{\displaystyle \sum }_{y=0}^{2^n-1}{\displaystyle \sum }_{x=0}^{2^n-1}{\displaystyle \sum }_{j=0}^{2^m-1}{a}_{tyxj}\left|j\right.>QF{T}_{2^{3n}}(\left|t\right.>\left|y\right.>\left|x\right.>)\left|0\right.>$$

$$=\frac{1}{2^n}{\displaystyle \sum }_{t=0}^{2^n-1}{\displaystyle \sum }_{y=0}^{2^n-1}{\displaystyle \sum }_{x=0}^{2^n-1}{\displaystyle \sum }_{j=0}^{2^m-1}{a}_{tyxj}\left|j\right.>(QF{T}_{2^n}\left|t\right.>)(QF{T}_{2^n}\left|y\right.>)(QF{T}_{2^n}\left|x\right.>)\left|0\right.>$$

$$\begin{array}{c}=\frac{1}{2^n}{\displaystyle \sum _{t=0}^{2^n-1}}{\displaystyle \sum _{y=0}^{2^n-1}}{\displaystyle \sum _{x=0}^{2^n-1}}{\displaystyle \sum _{j=0}^{2^m-1}}{a}_{tyxj}\left|j\right.>{\displaystyle \sum _{l=0}^{2^n-1}}{e}^{\frac{2\pi itl}{2^n}}\left|l\right.>{\displaystyle \sum _{k=0}^{2^n-1}}{e}^{\frac{2\pi iyk}{2^n}}|k\\ >{\displaystyle \sum _{p=0}^{2^n-1}}{e}^{\frac{2\pi ixp}{2^n}}\left|p\right.>\left|0\right.>\end{array}$$

$$=\frac{1}{2^n}{\displaystyle \sum }_{t=0}^{2^n-1}{\displaystyle \sum }_{y=0}^{2^n-1}{\displaystyle \sum }_{x=0}^{2^n-1}{\displaystyle \sum }_{j=0}^{2^m-1}{\displaystyle \sum }_{l,k,p=0}^{2^n-1}{a}_{tyxj}{e}^{\frac{2\pi itl}{2^n}}{e}^{\frac{2\pi iyk}{2^n}}{e}^{\frac{2\pi ixp}{2^n}}\left|j\right.>\left|l\right.>\left|k\right.>\left|p\right.>\left|0\right.>$$

(22)

where I and I_m denote the identity operator on 1 and m qubits, respectively.

The next step performed by the quantum circuit is the equivalent of the classical filtering step. The state of the register holding the image cube does not in fact change to a state representing the filtered image cube, but rather, it undergoes an interference process with the additional qubit initially in state $\left|0\right.>$. This is achieved using a quantum oracle built using the filter function H(l, k, p).

The quantum state $\left|I_1\right.>$ is a superposition of two states, a state representing the 3D frequencies that remain in the image cube and a state representing the 3D frequencies removed. Applying the oracle operator U_H to this superposition, one can use the additional qubit to make the distinction between the two states. The oracle U_H acts only on the position qubits and leaves the color qubits unaffected. Different choices of the filter H(l, k, p) result in different selections of 3D velocity filters. So, the resulting $\left|I_2\right.>$ can be the input to IQFT.

The last computational step in the quantum circuit in Figure 8 represents the IQFT that reverts from the frequency to the spatial representation of the image cube. The final state of the circuit contains the superposition of two quantum image cubes: the image cube containing the frequencies passed by the 3D filter and the image cube containing the frequencies suppressed by the 3D filter. The distinction between these two image cubes can be made using the additional qubit $\left|I_3\right.>$. In fact, it can be interpreted as [1]

$$\left|I_3>=\right|Q_{unusedvelocities}>\left|0\right.>+\left|Q_{usedvelocities}\right.>\left|1\right.>$$

(23)

For extracting necessary information from the quantum-transformed image, a further processing step must be performed [1].

4.3. QFT Performance Versus FFT Performance

The computational performance of QFT is discussed in this subsection with regard to its superiority when compared to the computational performance of FFT. The required number of quantum gates is calculated, and a simple demonstration of their simplicity is presented with regard to the first simple necessary quantum gates. Note that the matrix in Equation (5) also implements classical FFT and performs the multiplication of the QFT matrix by the N × 1 column vector that contains the classical dataset. This multiplication would require N² operations. Therefore, we would expect classical discreet Fourier transform to require O(N²) = O(2²ⁿ) operations, which is exponential in n. The classical FFT algorithm can compute discreet Fourier transform in O(N log N) or O(n2ⁿ) operations, which is faster but still exponential in n.

However, QFT uses operation gates for its implementation. According to Figure 1, the number of operation gates used can be evaluated as follows:

1st row: 1 H gate + (n − 1)R gates = n gates

2nd row: 1 H gate + (n − 2)R gates = n − 1 gates

.

.

.

(n − 1)th row: 1 H gate + 1 R gate = 2 gates

n-th row: 1 H gate = 1 gate

Adding the gate count from each row gives n + (n − 1) + (n − 2) +··· + 1, or O(n²), gates, which is polynomial in n. Therefore, QFT is exponentially faster than discreet Fourier transform or FFT.

Furthermore, classical FFT (corresponding to 2 qubits, N = 4) in matrix form is

$$\overrightarrow{y}=U\overrightarrow{x}$$

(24)

where $U$ is

$$U=\frac{1}{2}\left(\begin{array}{llll}1& 1& 1& 1\\ 1& i& i^2& i^3\\ 1& i^2& 1& i^2\\ 1& i^3& i^2& i\end{array}\right)$$

(25)

and we replace $exp\left(2\pi i/4\right)=i$. Equation (25) can be written as the product of two sparse matrices $U=U_1{U}_2,$ where

$$U_1=\frac{1}{\sqrt{2}}\left(\begin{array}{llll}1& 0& 1& 0\\ 0& 1& 0& 1\\ 1& 0& i^2& 0\\ 0& 1& 0& i^2\end{array}\right)$$

(26)

and

$$U_2=\frac{1}{\sqrt{2}}\left(\begin{array}{llll}1& 1& 0& 0\\ 0& 0& 1& i\\ 1& i^2& 0& 0\\ 0& 0& 1& i^3\end{array}\right)$$

(27)

QFT is generated by matrix U and can be written as the product of four sparse matrices (the swap gate, the Hadamard gates (2 gates), and the controlled phase gate) as follows:

Swap gate

$$S=\left(\begin{array}{llll}1& 0& 0& 0\\ 0& 0& 1& 0\\ 0& 1& 0& 0\\ 0& 0& 0& 1\end{array}\right)$$

(28)

Hadamard gate for the lower qubit

$$H_0=\frac{1}{\sqrt{2}}\left(\begin{array}{llll}1& 1& 0& 0\\ 1& -1& 0& 1\\ 0& 0& 1& 1\\ 0& 0& 1& -1\end{array}\right)$$

(29)

Hadamard gate for the upper qubit

$$H_1=\frac{1}{\sqrt{2}}\left(\begin{array}{llll}1& 0& 1& 0\\ 0& 1& 0& 1\\ 1& 0& -1& 0\\ 0& 1& 0& -1\end{array}\right)$$

(30)

Controlled phase gate

$$R_1=\frac{1}{\sqrt{2}}\left(\begin{array}{llll}1& 0& 0& 0\\ 0& 1& 0& 0\\ 1& 0& 1& 0\\ 0& 1& 0& i\end{array}\right)$$

(31)

As shown, the sparse matrices of QFT are simpler than the classical matrices of FFT without dynamics. So, the calculations in QFT are simpler and faster. Similarly, in classical FFT (3 qubits, n = 8), we have three sparse matrices, and in QFT, we have seven simpler sparse matrices, so the calculations are also faster.

Accordingly, for the N-qubit registers in QFT, a significant reduction is achieved in the required operations since all matrices involved in its evaluation are sparse. In the implementation of the example of Section 5.2, the execution time of conventional FFT was 200.63 s, while QFT implementation was carried out in 16.2 s.

5. Experimental Results

5.1. Moving Objects

In this subsection, the movement of some simple objects in a 3D scene is presented and their 3D spectrum is evaluated using the 3D QFT described by Equation (22). The data cube is considered to consist of 256 × 256 pixels and a total of 256 frames.

In Figure 9a, a small squared object in 3D space is shown. This thin (in the time axis—5 frames are occupied) object gives a horizontal spectrum with harmonics in a broad region as it is shown from various aspects of the spectrum (Figure 9b–d). Such an object, which would appear suddenly in the image cube for a small number of frames and then disappear, does not in fact exist. This means that the blue still object in Figure 9a is just a simulation to demonstrate its simple spectral content, and it exists only for five frames. Each direction in the spectral cube corresponds (inverse dimensions) to one of the three dimensions of the data cube, with a large extent of the one in Figure 9c, which is toward the vertical axis of the data cube (time). The three objects in Figure 9b–d in fact present the spectral content of the data cube in Figure 9a from different aspects.

The object shown in Figure 10 cannot also exist in practice, since while unmovable, it appears in some of the frames and then disappears. However, its spectrum given in red becomes thinner compared to the previous one in Figure 9 and contains a smaller amount of spectral energy out of the horizontal spectral plane 129. In practice, a still object in space should exist from 0 to 255 in the vertical axis. In this case, the spectrum is flat-lying only in the horizontal spectral plane 129 and corresponds only to frequencies irrelevant to the movement. So, the absence of movement corresponds to the spectral energy distributed in the horizontal plane 129 of 3D FFT.

In Figure 11, a moving object appears in the data cube in blue. The corresponding spectrum, in red, is flat and lies in a linear plane being vertical to the blue trajectory line. In this spectrum, some of the DC components exist in the horizontal spectral plane 129. This is a problem when we try to get rid of the (still) background. In Figure 12, a similar case is examined, where the object is moving in a different direction and its spectrum (red) is again oriented perpendicular to the blue trajectory.

Finally, in Figure 13, both moving objects exist in the data cube, and their (red) spectrum consists of the combination of the spectra in Figure 11 and Figure 12. Evidently, when one of the two objects must be rejected (filtered), the common frequency components need special care.

According to the described capabilities of the network in Figure 8, we need to evaluate the 3D spectrum of a specific trajectory and then devise the circuit $U_H\left(l,k,p\right)$ so that only specific frequencies are selected according to the 3D filter bank with various versions of $U_H\left(l,k,p\right)$ that have been built. This is in fact the procedure described in Section 3.

The selection of the filter $U_H\left(l,k,p\right)$ is initially made for a specific filtering transfer function according to the trajectory that is necessary to be isolated. The block diagram in Figure 8 contains a unique filtering capability and, of course, its complement. To isolate a different trajectory, another block diagram should be activated.

5.2. QFT Velocity Filtering Example

A bank of filters $U_H\left(l,k,p\right)$ was devised in an analogous manner to that in [28]. This filter bank was used to isolate cars moving with a specific velocity on a bridge. In Figure 14, two frames of a video from the bridge are shown, the 360th and the 380th. The white car moving from left to right at the bottom of the scene was isolated. All the frames were converted from color to grayscale using the MATLAB rgb2gray utility. Simultaneously, the length of the scenes was restricted to 512 pixels, and 512 frames were used so that a data cube of 512 × 512 × 512 was processed. Frames 360 and 380 in grayscale and restricted in length to 512 pixels are shown in Figure 15. After the appropriate selection of the filter $U_H\left(l,k,p\right)$, inverse 3D QFT was applied, and the obtained result is shown in Figure 16. The obtained 360th and 380th frames contained only the white car that was moving at the bottom of the scene from left to right. This was possible since the spectrum of the trajectory of this car was recorded in one of the filters in the filter bank and was appropriately loaded in the block $U_H\left(l,k,p\right)$.

In Figure 17, the selection of the filter $U_H\left(l,k,p\right)$ used in this experiment is demonstrated, providing three frames containing the specific car isolated from Figure 16 (Figure 17a–c), along with a sketch in the 3D data cube of the trajectory of this car (Figure 17d) and its corresponding spectral content $U_H\left(l,k,p\right)$ (Figure 17e).

As stated in the Introduction section, the isolation of the trajectory of a moving object within a specific range of speeds provides the capability of exactly evaluating the spectral content of the specific trajectory. The quantum oracle used incorporates this spectral content in a special way. Specifically, the |l>, |k>, and |p> registers in Figure 8 contain the whole spectrum of the image cube, but only the spectral content of the specific trajectory is left to pass through U_H (filtering). Accordingly, the quantum oracle U_H reorganizes the contents of the |l>, |k>, and |p> registers so that only the spectrum of the trajectory of the specific moving object remains in the data cube. The output of U_H is shown in Figure 17e. Furthermore, based on the quantum interference phenomenon, we can use an additional qubit initially in state |0> to reinterpret the quantum image cube as a superposition of two image cubes, namely the spectral content of the trajectory (Figure 17e) and its complement.

Experimentally, we ran quantum simulations on a conventional computer running MATLAB. All procedures were based on the approach the authors in [36] specified. Comparisons with conventional approaches proved that the execution time for QFT is smaller in the order of 100 when a quantum circuit is used. This significant reduction is achieved since all matrices involved in its evaluation are sparse. In the implementation of the simulation experiment, the execution time of conventional FFT was 200.63 s, while QFT implementation was carried out in 16.2 s.

6. Conclusions

The quantum version of 3D FFT was presented analytically in this work, emphasizing the detailed explanation of its application to a specific example of a data cube coming from an ordinary video. The form of the development of 3D QFT has an important tutorial character. Simultaneously, it constitutes an important technical utility for isolating objects that are moving at speeds within certain limits. This utility can be used for numerous applications.

A filter bank was built having a series of quantum filter functions $U_H\left(l,k,p\right)$ that differ in their filtering capabilities with regard to the velocity of the object as well as its direction. The filter function is selected based on the properties of the object that is to be isolated.

The performance of the quantum circuit in Figure 8 is effective since the object with the specific velocity (white car at the bottom of the scene moving from left to right in Figure 14, Figure 15 and Figure 16) is totally isolated as the spectral signature of its trajectory (Figure 17e) is embodied as the operational content of the quantum oracle U_H. Simultaneously, other cars with the same velocity are also isolated and brought to the foreground in the final scene.

Specific quantum velocity filtering techniques were not found in the literature for comparisons to be carried out. However, our approach was based on [28] only with regard to the organization of the filter bank. Its superiority in performing fast calculations for isolating objects with a specific velocity is clear.