Moving Object Detection Based on a Combination of Kalman Filter and Median Filtering

Abstract

The task of determining the distance from one object to another is one of the important tasks solved in robotics systems. Conventional algorithms rely on an iterative process of predicting distance estimates, which results in an increased computational burden. Algorithms used in robotic systems should require minimal time costs, as well as be resistant to the presence of noise. To solve these problems, the paper proposes an algorithm for Kalman combination filtering with a Goldschmidt divisor and a median filter. Software simulation showed an increase in the accuracy of predicting the estimate of the developed algorithm in comparison with the traditional filtering algorithm, as well as an increase in the speed of the algorithm. The results obtained can be effectively applied in various computer vision systems.

1. Introduction

At present, the solution of problems related to the determination of a moving object and the distance to it is practically significant in various robotic systems, including computer vision systems [1]. The distance to the object is determined in video monitoring systems for security [2], navigation [3], surveillance [4], control [5], etc. In turn, systems that solve the problem of detecting a moving object and determining the distance to it put forward increased technical and hardware requirements. Since, first of all, the process of detecting a moving object is complicated by the presence of projective, affine distortions, as well as distortions from receivers, the computational algorithms on which the systems are built should not only process the video sequence of data at real speed in real time, but also qualitatively process the data received from various types of distortions and artifacts. For this reason, there is a search, development of high-quality and new computational methods and algorithms used to solve the designated range of problems including in terms of quality while reducing the variability of the technological process [6].

Currently, solving problems related to determining the distance to an object is practically significant in various robotic systems, including computer vision systems [7]. Modern computer vision systems obtain real information about the distance to objects using various sets of sensors, such as radar [8], ultrasonic sensors [9], lidars [10], stereo mate [11], etc.

At the same time, in various applications (unmanned vehicles, mobile applications), the approach of merging lidar and camera sensors is becoming more widespread [12]. In [13], the authors propose an approach to merge several lidar sensors and a color camera in real time to recognize multi-scale objects at the semantic level, which makes it possible to adapt the developed module to complex scenes.

The procedure for the simultaneous use of such sensors is that the common sensor receives a combination of data coming from the camera in the form of an image, and from the lidar in the form of a cloud of points. After that, the resulting point cloud is projected onto the image. The position of the point cloud in the image is the determined distance to the moving object. In [14], the authors propose to determine the distance to objects of known sizes and geometry in order to improve the estimation of the position of the object before quantization and to obtain systematic errors inherent in lidar. The authors also propose in their work to apply the fitting method to convert the lidar into a monocular camera, which avoids the task of extracting the target edge from the point cloud. For successful sensor fusion, [15] used sparse and accurate point clouds as a guideline for determining the correspondence of stereo images in a single three-dimensional volume space. In [16], a lidar-camera fusion approach was developed to correct oscillating lidar distortions with full velocity estimation. A new mechanism for quantifying and analyzing 3D motion correlation for estimating real-time temporal displacement of fusion of dissimilar sensors is described by the authors of [17]. A multi-sensor platform for combining camera and lidar data for object detection, including small obstacles and moving objects, is proposed in [18]. A new merge pipeline based on the method of early fusion of image range and RGB image to improve the detection of 3D objects is proposed in [19]. A new approach to the use of a convolutional neural network that detects and identifies an object based on data obtained from a 3D lidar is described in [20]. Paper [21] presents a new method for estimating the transformation between the manipulator camera and the 2D lidar coordinate system, based on the use of point, line, and plane geometry constraints between the segmented 2D lidar scan and the reconstructed trihedron elements. The proposed spatiotemporal sampling algorithm activates the lidar only in areas of interest identified by analyzing visual input and reduces the base lidar frame rate according to the kinematic state of the system in [22]. In [23], the authors, before calibrating the lidar camera, use a new method in which they align 3D visual points on laser scans based on the tight coupling graph optimization method to calculate the external parameter between the lidar and the camera. The approach in [24] uses the geometric information provided by the point cloud as prior knowledge and clusters the point cloud data using an improved density clustering algorithm to further combine data from lidar and camera sensors. The authors of [25] at the theoretical level analyzed the limitations imposed by boundary objects and the sensitivity of the calibration accuracy to the distribution of boundaries in the scene, and at the implementation level, they proposed a method for detecting lidar boundaries based on cutting voxels from a point cloud and fitting the plane. Three different approaches for combining image characteristics with point cloud data in which lidar reflection data can be replaced with low-level image characteristics without degrading detector performance have been developed by researchers [26]. To solve the problem of combining data from different types of lidar and camera sensors, the authors of [20] developed a multimodal system for detecting and tracking 3D objects (EZFusion). The classification of 3D LiDAR point clouds using a visual object detector and an object tracker that jointly performs detection and tracking of 3D objects before data calibration is used in [27]. The authors of the study [28] solve the problem of segmentation of moving objects. The authors combine the steps of segmentation, background initialization, feature extraction, plotting, graph signal selection, and semi-supervised learning algorithm and explain the theoretical background, and propose two architectures for semi-supervised learning segmentation and a new evaluation procedure for GPS-based segmentation algorithms. One paper [29] proposed a processing method for practical applications under conditions of strong input uncertainty.

However, in all the listed works, the sensor data are calibrated without their preliminary processing. Since there may be impulsive noise among the data during projection, then in this case, in order to improve the accuracy of distance estimation, the received data require primary processing with a digital filter. From this point of view, a suitable tool is the median filter [30], which allows cleaning data from impulse noise. On the other hand, the process of combining several sensors at the same time requires the use of a suitable algorithm that allows you to work with multiple input signals. The Kalman filter [31] is a recursive filter capable of predicting the future state of a system based on previous data.

However, in real-time computer vision systems, the process of estimating the distance to a moving object should be as fast as possible. The presence of the division operation in the traditional Kalman filter algorithm increases the computational cost [32]. There are various approaches that allow to increase the speed of a computing system built on the basis of the Kalman filter, among which are [32,33,34] and others.

However, the existing real Kalman filtering methods for solving the problem of detecting a moving object use the traditional structure of the algorithm. Such a structure includes the execution of a division operation. This is a problematic application of this approach in terms of the computational delay of the algorithm and the quality of data processing in real time. In this paper, we propose an algorithm that includes combinational filtering of data based on a median filter used to filter a point cloud and a modified Kalman filter with a Goldschmidt divider used to predict estimates of distances to a moving object. The modified Kalman filter algorithm, including the Goldschmidt divider, replaces the division operation by reducing it to iterative multiplication, which allows to speed up data processing, thereby reducing computational costs. The median filter is used to preprocess data from impulse noise. The modified algorithm proposed by us, built on the basis of the integration of these solutions, made it possible to obtain advantages in the form of a reduction in the time delay and the error in calculating the distance to a moving object. Software simulation confirms the obtained results.

The article includes: Section 1 containing preliminary information and problem statement; Section 2, which introduces the developed filter algorithm; Section 3, which describes software and experimental simulations of filter accuracy and time performance estimates.

2. Materials and Methods

The Kalman filter is a recursive probabilistic filter. Based on the filter, the past state, present state and future state of the dynamic system are determined [35]. The entire filtering procedure is divided into two processes: performing prediction and updating the state. The predicted state is a mathematical model (1) and (2). They use previous and input data received from a series of sensors:

$${\overline{x}}_k=A{x}_{k-1}+B{u}_{k-1}$$

(1)

where ${\overline{x}}_k$—state variable vector, $A$—transition matrix between system states, $B$—control matrix and $u_{k-1}$—system control action at the previous moment of time.

$${\overline{P}}_k=A{P}_{k-1}{A}^T+Q$$

(2)

where ${\overline{P}}_k$—error covariance matrix and $Q$—technological noise covariance matrix.

The updated state uses the predicted state value to perform the next prediction step. The updated state is calculated using Equations (4) and (5):

$$K_k=\frac{{\overline{P}}_{k-1}}{H{\overline{P}}_{k-1}{H}^T+R}$$

(3)

$${\widehat{x}}_k={\overline{x}}_{k-1}+K_k\left(y_k-H{\overline{x}}_{k-1}\right)$$

(4)

$${\widehat{P}}_k=\left(I-K_{k}H\right){\overline{P}}_{k-1}$$

(5)

where $K_k$—Kalman gain, $H$—measurement matrix showing the relationship between measurements and the state of the system, $R$—measurement noise matrix, $y_k$—measurement of the system state at the current time and $I$—identity matrix.

However, the step of updating the states of a dynamical system requires a preliminary determination of the value of the Kalman gain (3) [36]. Since Kalman gain involves performing a division operation, it can be concluded that gain calculation is the most computationally expensive operation.

There are many methods for designing fission equipment. Among which we can single out the quadratically convergent Goldschmidt algorithm [37]. A feature of this algorithm is the ability to obtain the result of division without a remainder. Then, this algorithm is defined by Equation (6):

$$N=\frac{a\ast F_i}{b\ast F_i}$$

(6)

where coefficient $F_i=2-b$. In Section 2, we will show the application of the Goldschmidt algorithm in the Kalman filter when calculating the gain $K_k$, and we will also use the median filter to filter the point cloud projected onto the input image.

The median filter is a non-linear digital filter [38]. Such a filter is used in image and signal processing to remove impulse noise and smooth the signal. In systems that receive information using sensors, the signals always have noise from the environment and noise from the loss of sensors.

The process of median filtering is to obtain the signal values in the form of a variational series built in ascending or descending order. Signal values are taken in the vicinity of some point (filter window). To solve the task of determining the distance to a moving object, the median filter will select a cloud of points from the input images using nearby data. Thus, if we designate the filtered selection of array elements as $D=\left\{d_1, d_2, \dots , d_n\right\}$, so that the number of selection elements coincides with the size of the filter window, then the application of median filtering, which selects the central values of the ordered selection, can be written as:

$$x^{\ast }=med\left(d_1, d_2, \dots , d_n\right)$$

(7)

3. Results

This section presents a filtering algorithm that uses the median filtering method, as well as a modified Kalman filter based on the Goldschmidt divisor.

3.1. Proposed Algorithm

The proposed model of the process of determining the distance to a moving object based on the fusion of camera and lidar sensors is shown in Figure 1. The presented model uses a cloud of points obtained by lidar and an RGB image obtained from a video camera as input and predicts oriented 3D frames for moving objects (cars, pedestrians, cyclists).

This model includes four main modules: Point Merge Module, which extracts point features from an RGB image and combines the extracted features with the corresponding point cloud features, Value Calibration Module, Merged Values Processing Module and Object Distance Module. Below is a filtering algorithm that uses the median filtering method, as well as a modified Kalman filter, built on the basis of the Goldschmidt divider, used in the modules for processing and determining the distance.

The processing of lidar data can be represented in several stages. At the first stage, lidar points are captured, after which all points in a single system are complexed and reduced to a single coordinate system or a uniform grid. The grid is created by transforming between irregular raw lidar measurements and a grid at regular intervals. The m×n grid dimensions are defined as follows:

$$m=\left(\frac{y_{max}-y_{min}}{G_s}\right)+1$$

(8)

$$n=\left(\frac{x_{max}-x_{min}}{G_s}\right)+1$$

(9)

where $m$ is the number of grid rows, $n$ is the number of columns in the grid and $G_s$ is the grid cell size depending on the lidar data density. The denser the raw data, the smaller the cell size and vice versa. Thus, after appropriate transformations, all coordinates of the lidar measurement are assigned to each grid cell.

All data have a certain amount of noise, so the next step is to filter these data. Since an isolated outlier is a noise point that is isolated from the main point cloud, it remains to determine how far it is from the point cloud. At this stage, the algorithm proposed in the paper applies median data filtering. To do this, point clouds are divided into voxels of a given size and a minimum number of voxel points.

Voxels that do not pass the test are discarded, leaving only useful points that carry information about objects. This approach is effective for lidars with a large number of points and allows you to analyze the entire three-dimensional matrix of voxels, based on the occupancy of neighboring cells, passing through the filter through all points sequentially.

Let some point $m={\left[u, v\right]}^T$ on the image plane be given. Moreover, it is a projection of some point $M={\left[X,Y,Z\right]}^T$ in the space of the point cloud. Then the relationship between these points can be written as:

$$S\ast m=W\ast \left[ R^{\ast }t\right]\ast M$$

(10)

where $S$—some scalar, $R^{\ast }$ and $t$—external parameters of the camera and $W$—matrix of internal parameters of the camera (10):

$$W=\left[\begin{array}{ccc}\alpha & \gamma & x_o\\ 0& \beta & y_o\\ 0& 0& 1\end{array}\right]$$

(11)

where $\left(x_0,y_0\right)$—coordinates of the point, $\alpha$ and $\beta$—compression ratios along the Ox and Oy axes and $\gamma$—coefficient of asymmetry between the image axes. We take $Z=0$ and denote by $r_{ij}$ the i-th element of the rotation matrix $R^{\ast }$. Then the projective matrix $M_p$ (10), which projects the point cloud onto the image obtained by calibrating the lidar and camera sensors, will take the form:

$$M_p=\left[\begin{array}{ccc}{r}_{11}& r_{12}& x_0\\ r_{21}& r_{22}& y_0\\ 0& 0& 1\end{array}\right]$$

(12)

Then, we rewrite (10) for a point on the object $M^{\ast }={\left[X,Y,1\right]}^T$ and the corresponding point on the image $m^{\ast }$ in the form:

$$S\ast m^{\ast }=L\ast M^{\ast }$$

(13)

where $L$—image homography matrix, defined as:

$$L=W\left[\begin{array}{ccc}{r}_1& r_2& t\end{array}\right]$$

(14)

Let us find the homography matrix; for this, we introduce the covariance matrix ${\Phi }_{m_i}$:

$${\sum }_i{\left(m_i-m_i^{\ast }\right)}^T{\Phi }_{m_i}^{-1}\left(m_i-m_i^{\ast }\right)$$

(15)

where $m_i^{\ast }$ is determined from Equation (15):

$$m_i^{\ast }=\frac{1}{{\overline{l}}_3^T{M}_i}\left[\begin{array}{c}{\overline{l}}_1^T{M}_i\\ {\overline{l}}_2^T{M}_i\end{array}\right]$$

(16)

where ${\overline{l}}_{\mathrm{i}}$—i-th row of the matrix $L$.

Let $L=\left[\begin{array}{ccc}{l}_1& l_2& l_3\end{array}\right]$, then from (12) we obtain:

$$\left[\begin{array}{ccc}{l}_1& l_2& l_3\end{array}\right]=\lambda W\left[\begin{array}{ccc}{r}_1& r_2& t\end{array}\right]$$

where $\lambda$—some scalar. Knowing that $r_1$ and $r_2$ are orthogonal, then we write:

$$l_1^T{W}^{-T}{W}^{-1}{l}_2=0$$

(17)

$$l_1^T{W}^{-T}{W}^{-1}{l}_1=l_2^T{W}^{-T}{W}^{-1}{l}_2$$

(18)

For $v_{ij}$, we obtain:

$$v_{ij}={\left[l_{i1}{l}_{j1},l_{i1}{l}_{j2}+l_{i2}{l}_{j1},l_{i2}{l}_{j2}+l_{i3}{l}_{j1}+l_{i1}{l}_{j3},l_{i3}{l}_{j2}+l_{i2}{l}_{j3},l_{i3}{l}_{j3}\right]}^T$$

Then, we rewrite (18) and (19) as:

$$\left[\begin{array}{c}{v}_{12}^T\\ {\left(v_{11}-v_{22}\right)}^T\end{array}\right]e=0$$

(19)

where the vector $e$:

$$e=\left[E_{11}, E_{12}, E_{22}, E_{13}, E_{23}, E_{33} \right]$$

$E_{ij}$ matrix elements $E=W^{-T}{W}^{-1}$. Then, to determine the matrix $W$ of the internal parameters of the camera, it suffices to use n images and Equation (19):

$$v_0=\left(E_{12}{E}_{13}-E_{11}{E}_{23}\right)/\left(E_{11}{E}_{22}-E_{12}^2\right)$$

$$\lambda =E_{33}-\left[E_{13}^2+v_0\left(E_{12}{E}_{13}-E_{11}{E}_{23}\right)\right]/E_{11}$$

$$\alpha =\sqrt{\lambda /E_{11}}$$

$$\beta =\sqrt{\lambda E_{11}/\left(E_{11}{E}_{22}-E_{12}^2\right)}$$

$$\gamma =-\frac{E_{12}{\alpha }^2\beta }{\lambda }$$

$$u_0=\frac{c{v}_0}{\alpha }-\frac{E_{13}{\alpha }^2}{\lambda }$$

After determining the matrix $W$, it is possible to determine the homography matrix, and using expression (11) to carry out a complete projection of the point cloud into the image space. Denote $d_{ij}=L\ast M^{\ast }$. Then, after projecting the points, we obtain some matrix of values:

$$D=\left[\begin{array}{ccc}{d}_{11}& \cdots & d_{1j}\\ ⋮& \ddots & ⋮\\ d_{i1}& \cdots & d_{ij}\end{array}\right]$$

(20)

We will apply a median filter with a weighted weight vector $V$ of size $N$ to the resulting array of values for pre-processing and removal of impulse noise. Data processing is as follows. We have an input sequence such as $D=\left\{d_1, d_2, \dots , d_n\right\}$. Then, after some algebraic transformations using replication over each value of the vector V, the median filtering output is calculated as:

$$x^{\ast }\left(n\right)=median\left(V_1\diamond d_1,V_2\diamond d_2, \dots ,V_n\diamond d_n\right)$$

(21)

where $V_n$ are the values of the weight vector and $\diamond$ is the replication operator. In what follows, we will use a median filtering window of size $N=5$. In this case, we obtain a symmetric weight vector $V=\left[V_1,V_2,V_3,V_2,V_1\right]$ and an observation $D=\left[d_1,d_2,d_3,d_4,d_5\right]$. Then, from (21), the filter output will be as follows:

$$\begin{gathered} x^{\ast }\left(n\right)=median\left[V_1\diamond d_1,V_2\diamond d_2,V_3\diamond d_3,V_4\diamond d_4,V_5\diamond d_5\right]= \\ median\left[d_1,d_2,d_2,d_3,d_3,d_3,d_4,d_4,d_5\right]=median\left[d_4,d_4,d_3,d_3,d_3,d_2,d_2,d_5,d_1\right]=d_3 \end{gathered}$$

The approach associated with the use of median filtering will improve the accuracy of the position of the point cloud to further determine the distance to the object. After receiving the processed data, a digital Kalman filter is applied to them. The Kalman filter can predict future status based on previous data. We propose a modified Kalman filter algorithm based on the use of the Goldschmidt divider to calculate the Kalman gain value.

Thus, based on the conditions described, the paper proposes an algorithm for implementing data filtering to detect the distance to an object in a video data stream (Algorithm 1).

Algorithm 1: Data filtering using median filter and Kalman filter built using the Goldschmidt algorithm to calculate the Kalman gain

Input data: 1:       $\left\{m, M,S, R^{\ast }, L,E,r_1,r_2,t, x_{0,i},P_{o,i},A, B, C,D, H,Q,R\right\}$ Calibration of sensor values: Determination of the internal parameters of the camera matrix $W$: 2.        $v_0=\left(E_{12}{E}_{13}-E_{11}{E}_{23}\right)/\left(E_{11}{E}_{22}-E_{12}^2\right)$ 3.          $\lambda =E_{33}-\left[E_{13}^2+v_0\left(E_{12}{E}_{13}-E_{11}{E}_{23}\right)\right]/E_{11}$ 4.              $\alpha =\sqrt{\lambda /E_{11}}$ 5.           $\beta =\sqrt{\lambda E_{11}/\left(E_{11}{E}_{22}-E_{12}^2\right)}$ 6.             $\gamma =-\frac{E_{12}{\alpha }^2\beta }{\lambda }$ 7.           $u_0=\frac{c{v}_0}{\alpha }-\frac{E_{13}{\alpha }^2}{\lambda }$ Definition of homography matrix: 8.           $L=W\left[\begin{array}{ccc}{r}_1& r_2& t\end{array}\right]$ Projection matrix calculation $D$: 9.             $d_{ij}=L\ast M^{\ast }$ Calculation of median filtering values: 10.             $x^{\ast }=median\left(d_1,d_2,\dots ,d_n\right)$

gKalman filtering: Prediction Calculation: 11:           ${\overline{x}}_k=A{x}_{k-1}+B{u}_{k-1}$

12:                ${\overline{P}}_k=A{P}_{k-1}{A}^T+Q$ Kalman gain calculation: 13:               $b_0=H{\overline{P}}_k{H}^T+R$ 14:                $F_k=2-b_k$ 15.                $N_k=N_{k-1}{F}_k$ 16:                $b_k=b_{k-1}{F}_k$ If $b_k=1$, then 17:               $K_k={\overline{P}}_k{H}^T{b}_k$ other $F_{k+1}=2-b_k$, Update Calculation: 18:            ${\widehat{x}}_k={\overline{x}}_{k-1}+K_k\left(y_k-H{\overline{x}}_{k-1}\right)$ 19:               ${\widehat{P}}_k=\left(I-K_{k}H\right){\overline{P}}_{k-1}$

The developed algorithm makes it possible to obtain such a filter design that is capable of processing data obtained after calibrating the values coming from different types of sensors. At the same time, the use of median filtering preliminarily clears the projected data from different planes from impulse noise. In turn, the modified Kalman filter, due to the use of the Goldschmidt algorithm in calculating the Kalman gain, makes it possible to avoid the division operation in the filter design, which will reduce computational costs during filtering.

Let us consider the numerical implementation of the algorithm described above, which proves the effectiveness of the proposed algorithm and theoretical results in comparison with the known algorithm.

3.2. Numerical and Software Implementation

Let the system under consideration consist of two sensors: a lidar sensor and a camera from which images are received. The system matrices and input data are proposed to be equal: $m={\left[4, 3\right]}^T$, $M={\left[2,1,0\right]}^T$, $Wi=10\times 10;$ $\alpha =\beta =1$, $\gamma =0$, $R^{\ast }=1$, $t=1$, $\Delta T=0.05$—sampling time for each frame, $B=0$, $\tau =0.05$—measurement noise variance.

$$A=\left[\begin{array}{cccc}1& 0& \Delta T& 0\\ 0& 1& 0& \Delta T\\ 0& 0& 1& 0\\ 0& 0& 0& 1\end{array}\right]$$

$$Q=[\begin{array}{cccc}\Delta T^4/4& 0& \Delta T^3/2& 0\\ 0& \Delta T^4/4& 0& \Delta T^3/2\\ \Delta T^3/2& 0& \Delta T^2& 0\\ 0& \Delta T^3/2& 0& \Delta T^2\end{array}]\ast {\tau }^2$$

$$R=\left[\begin{array}{cccc}{\tau }_1& 0& 0& 0\\ 0& {\tau }_1& 0& 0\\ 0& 0& {\tau }_1& 0\\ 0& 0& 0& {\tau }_1\end{array}\right]$$

$$H=\left[\begin{array}{cccc}1& 0& 0& 0\\ 0& 1& 0& 0\\ 1& 0& 0& 0\\ 0& 1& 0& 0\end{array}\right]$$

A comparison of the simulation results for the well-known Kalman filtering algorithm and the developed algorithm is presented in

Table 1. Results in the measurement error and the time of determining the distance to the object in the known and proposed algorithm.

No	Known Algorithm		Algorithm 1
	Error	Temporary Delay	Error	Temporary Delay
1	0.89	0.17	0.48	0.12
2	0.65	0.17	0.57	0.14
3	0.87	0.16	0.32	0.14
4	0.35	0.18	0.13	0.16
5	0.78	0.19	0.07	0.15
6	0.26	0.23	0.18	0.19
7	0.37	0.22	0.33	0.19
8	0.58	0.27	0.31	0.22
9	0.82	0.25	0.55	0.25
10	0.82	0.25	0.39	0.22

. The error in determining the distance was found as the difference between the true value of the distance and the determined one. Each scenario number has a different distance. Simulation was carried out on 10 scenarios with different true distance values, respectively, from 1 to 10 m.

To assess the influence of key parameters affecting performance in the known algorithms [31, 35] and the proposed algorithm, we will carry out their numerical simulation to solve the problem of determining the state of a dynamic system at the next time point for 100 consecutive measurements. As input data, we will use the following system matrices and input data that will describe the position of the object and update this estimate:

$$A_k=\left(\begin{array}{cc}0.3\times \left(1+0.01t_k\right)& 0.01\\ 0.1& 0.96\end{array}\right),B_k=I, Q_k=0.1\times I,$$

$$R=\left(\begin{array}{cc}0.02& 0.06\\ 0.07& 0.07\end{array}\right), H=\left(\begin{array}{cc}1& 0\end{array}\right)$$

The time sequence $\left\{t_k\right\}$ lies in the interval [0, 10] with a uniform sampling step of 0.1; therefore, $k=0,1,\dots ,100$. Initial filter setting: ${\widehat{x}}_{1,0}=1$ and $P_{1,0}=100\times I$. The performance check and accuracy of all three algorithms will be evaluated using different input values of the matrix $P_0$. This matrix is the state covariance matrix and affects the confidence of the filter in estimating the state variables. We will evaluate the accuracy of the algorithm by calculating the root mean square error (RMSE) for each specific state of the system:

$$RMSE=\sqrt{\frac{{\sum }_{i=1}^n{\left(Erro{r}_i\right)}^2}{n-1}}$$

The simulation results are presented in

Table 2. Time delays and measurement errors of known Kalman filtering algorithms and the developed algorithm based on the Goldschmidt divider.

Indicator	Algorithm
	[35]		[31]		Algorithm 1
	Delay	RMSE	Delay	RMSE	Delay	RMSE
$P_0$	1.0833	0.9871	0.9061	0.8722	0.3734	0.2135
$100P_0$	1.0879	1.1109	0.9070	0.9969	0.3839	0.3368
$500P_0$	1.0878	1.1770	0.9064	1.0622	0.3841	0.4021

. The obtained results show that the calculation error, which depends on the measurement noise in the developed method, decreases by 0.7 and 0.6 in comparison with the [35, 31] algorithms. The application of the Goldschmidt algorithm in the structure of the developed filter makes it possible to reduce the computational delay by 2.9 and 2.4 times, respectively. At the same time, the variation of the parameter of the covariance matrix shows that they practically do not affect the time delay of the filter; however, an increase in the values of the matrix leads to an increase in the mean square error of the filter for all three algorithms.

Figure 2 shows the results of software simulation. To carry out software simulation, archival data were used in the form of a video file with a frame size of 720 × 1280 and an input rate of up to 30 frames per second. The simulation was carried out using the Matlab R2021a software package. The purpose of the simulation is to measure the distance from the sensor to the object. A moving object is determined by analyzing a sequence of points for four situations. This takes into account that the sequence of points is interrupted only when no re-reflection has occurred. If this did not happen, then we are dealing with an object that strongly refracts waves. Thus, the sequence of points can be refracted with a shift closer to the vehicle. Thus, we are dealing with a convex obstacle; in this case, by a convex obstacle, we mean cars, people, etc. By the magnitude of the shift, we can judge the size of the obstacle. If the sequence of points is not interrupted, we obtain a solid line, and there are no obstacles. When a sequence of points is refracted with a shift from the vehicle, then we are dealing with a concave obstacle (puddle, pit, etc.). Having determined all the obstacles, the algorithm determines the contours of the moving object from all sides.

Thus, the object of interest is within the bounding box, where the box is created by detecting the object. The determined distance corresponds to the measured distance from the point cloud. The data are unstable due to the large number of point clouds from the environment and objects in the bounding box. There was a difficulty in choosing an objective point cloud. The median filter helps select a bounding box point cloud using nearby data. The domain code is in the public domain [39].

4. Discussion

The obtained results show that the developed algorithm gives a gain in the measurement error due to the use of the median filter and the detection time of the distance to the object in the video data stream. Moreover, the greater the distance to the object, the higher the error and the time of determining the distance.

As a result of the program, the distance to moving objects is determined. During the entire video sequence, moving objects can be covered by other objects, and projective transformations associated with camera tilt do not occur. However, there are affine transformations associated with scalability and rotation of moving objects. The results obtained make it possible to determine the distance to moving objects when this object is overlapped in computer vision systems.

5. Conclusions

In this paper, we studied the solution of the problem of determining the distance to an object using the well-known Kalman filtering algorithm and the developed filtering algorithm, which uses the Goldschmidt divider design to improve the performance of the computing system. Additionally, the developed algorithm includes a block of median data filtering to improve the accuracy of determining the distance to the object. The results of software simulation showed a faster determination of the distance to an object in the video data stream, as well as a smaller error in such determination. The results obtained showed that the developed algorithm can be applied in computer vision systems to combine data obtained from different types of sensors. In addition, the proposed algorithm should be applied in computer vision systems, where a critical indicator is to increase the performance of the system, i.e., indicator of the time delay of the system.

Further research will be aimed at developing the hardware implementation of the developed algorithm, the architectural implementation of the median filtering units, and the modified algorithm divider, as well as comparing the work of the developed architectures in positional and non-positional number systems.