Rapid Light Field Depth Estimation with Semi-Global Matching

TL;DR

This paper introduces a fast and accurate light field depth estimation method using Semi-Global Matching, significantly reducing computation time while maintaining precision across various light field setups.

Contribution

The paper presents a novel semi-global matching approach tailored for light field images, improving speed without sacrificing accuracy compared to existing methods.

Findings

Achieves faster depth estimation than traditional algorithms.

Maintains high accuracy across different light field configurations.

Demonstrates suitability for real-time applications.

Abstract

Running time of the light field depth estimation algorithms is typically high. This assessment is based on the computational complexity of existing methods and the large amounts of data involved. The aim of our work is to develop a simple and fast algorithm for accurate depth computation. In this context, we propose an approach, which involves Semi-Global Matching for the processing of light field images. It forms on comparison of pixels' correspondences with different metrics in the substantially bounded light field space. We show that our method is suitable for the fast production of a proper result in a variety of light field configurations

Tables

Table 1. TABLE I: Evaluation of different algorithms with general metrics on 4D Light Field Benchmark [ 8 , 9 ]

	$BadPix$			$MSE$			$Runtime$, ${\log }_{10}$			$M$, %/s
	Median	Average		Median	Average		Median	Average		Median	Average
BSL [11]	13.41	12.74		5.43	7.28		0.71	0.78		18.39	22.25
EPI1 [16]	22.89	24.32		3.93	5.98		1.93	1.95		0.91	0.87
EPI2 [13]	22.94	22.65		5.72	8.24		0.94	0.92		9.05	9.31
EPINET [27]	3.38	4.93		1.21	2.48		0.29	0.30		48.91	48.12
LF [20]	16.15	16.19		7.96	9.13		3.00	3.00		0.08	0.08
LF_OCC [15]	17.82	15.07		2.70	6.76		2.69	2.72		0.17	0.17
OFSY [38]	11.33	12.04		5.43	7.03		2.30	2.30		0.46	0.47
RM3DE [18]	7.99	10.22		1.46	3.92		1.65	1.68		1.96	1.95
RPRF [22]	9.89	10.02		3.76	5.68		1.55	1.54		2.53	2.64
FSL (ours)	11.92	12.95		3.97	6.64		0.25	0.23		48.33	56.09

Equations

$$\hat{p}(u,v,s,t,d)=L(u+(\hat{s}-s)d,v+(\hat{t}-t)d,s,t).$$

$$I_c(u,v)=\underset{[i,j]\in D}{⨂}\xi (I(u,v),I(u+i,v+j)),$$

$$\xi (p_1,p_2)=\{\begin{array}{ll}0,& p_1⩽p_2\\ 1,& p_1>p_2\end{array}.$$

$$C_c(u,v,d)=HD(L_c(u,v,\hat{s},\hat{t}),{\hat{p}}_c(u,v,s,t,d)),$$

$$HD(x_i,x_j)=\sum _{k=1}^n{x}_{ik}\oplus x_{jk}.$$

$$C_{\ell 2}(u,v,d)=\Vert L(u,v,\hat{s},\hat{t})-\hat{p}(u,v,s,t,d){\Vert }_2.$$

$$C_{c_i}(u,v,d)=HD(L_c(u,v,\hat{s},\hat{t}),\widehat{p_c}(u,v,V_i,d)),$$

$$\begin{array}{rl}& L_r(p,d)=C(p,d)+\\ & \min (L_r(p-r,d),\\ & L_r(p-r,d-1)+P1,\\ & L_r(p-r,d+1)+P1,\\ & \underset{t}{\min }{L}_r(p-r,t)+P2),\end{array}$$

$$C_s(p,d)=\sum _r{L}_r(p,d).$$

$$D_s(p)=\underset{d}{\mathrm{argmin}}{C}_s(p,d).$$

$$D_H(u,v)=D_{init}(u,v)+\lambda ;D_L(u,v)=D_{init}(u,v)-\lambda .$$

$$\begin{array}{r}S(u,v,d)=\sum _{s=1}^n\sum _{t=1}^m\Vert L(u,v,\hat{s},\hat{t})-\hat{p}(u,v,s,t,d){\Vert }_2,\end{array}$$

$$\begin{array}{rl}& D_n(p)=D_f(p)+\\ & \frac{C_s(p,d-1)-C_s(p,d+1)}{2(2C_s(p,d)-C_s(p,d-1)-C_s(p,d+1))}\end{array}$$

$$\displaystyle M=\frac{100\%-BadPix}{Runtime}\Big{(}\frac{\%}{sec.}\Big{)}.$$

$$\begin{array}{r}S(u,v,d)=\sum _{s=1}^n\sum _{t=1}^{m}HD(L_c(u,v,\hat{s},\hat{t}),{\hat{p}}_c(u,v,s,t,d)).\end{array}$$

Full text

I Introduction

In terms of computer vision a light field, originally described by Gershun [1], can be interpreted as a set of 2-dimensional images, projected from a scene with an equal physical distance (baseline) between the adjacent viewpoints in the horizontal or vertical direction.

Real-world capturing of such a set can be done in different ways. The simplest one involves an ordinary camera on the moving stage, which is shifted on constant length for every viewpoint, producing a 3-dimensional light field. Light fields can be captured by so-called plenoptic camera [2], which has a micro-lens array placed in front of the sensor image plane, providing a 4-dimensional light field. Such cameras were presented by Ng *et al. *[3] and Perwass *et al. *[4]. Multi-camera arrays with individual lenses can be also used for light field capturing. A large-scale version of this camera type was proposed by Wiburn *et al. *[5], whereas small-scale versions were presented by Venkataraman *et al. *[6] and Anisimov *et al. *[7]

Light field cameras are attracting considerable interest due to the possibility of their utilization in different industrial (optical inspection), biological (three-dimensional microscopy) and cinematic applications. This demand can be explained by the features of light field images, *e.g. *digital refocusing, which is an ability to change the focus on already acquired images [3]. Another useful feature of light field images is a possibility of accurate depth estimation. In contrast to classical multi-view systems, the matching correspondence search can be simplified by preserving the constant baseline between views in light field images.

An overview of the actual light field depth estimation algorithms is provided in Section II-A. We can state a major challenge in this area as a trade-off between runtime and the depth quality. Existing approaches are computationally demanding and involve large amounts of data for processing. It limits rapid depth map calculation. Most studies have tended to focus on depth map accuracy rather than execution time. We mainly address the runtime issue and aim towards real-time processing.

The proposed algorithm is based on pixel matching in light field space with different similarity measurements for estimation of a dense depth map. We choose Census and $\ell_{2}$-norm for generation of matching cost, which is explained in sections III-B and III-C. Although this principle gives good results in terms of depth map quality, computational demand and consequential running time of this method do not allow its direct use for fast or even real-time estimation. In order to reduce the number of calculations for this step, we generate the initial disparity map from some of the views in light field image and use this information as ”boundaries” for high-intensive correspondence search among all views, which is outlined in Section III-D. For disparity quality improvement a semi-global matching (SGM) method [10] is applied for previously generated costs. This method recommended itself as one of the most developed and optimized for providing accurate real-time depth results, which is fully justified by works reviewed in Section II-B.

The presented approach follows the core idea of Anisimov *et al. *[11, 7], but introduces the following features. We consider our work to be the first attempt to apply the SGM method directly to matching costs from light field images. For initial disparity map calculation we use a fusion of disparity maps for different views w.r.t. reference view and do not apply refinement to it, unlike in [11]. Together with that, we propose the utilization of Census transform for RGB images, in contrast to classical grayscaled images. As a result of all these contributions, we overcome limitations of previous algorithm [11] such as objects’ boundaries sharpness and noise in discontinuity areas. The workflow of our method is presented in Section III.

This approach achieves almost the best running time among other methods together with acceptable depth quality level. We provide a verification of our results by 4-dimensional Light Field Benchmark [8, 9] in Section IV. Together with that, we present real-world qualitative results. On top of the benchmark estimators, we use a M-metric, proposed in [11], to evaluate algorithms in terms of efficiently estimated pixels per unit of time. Also, we show the usage of different image similarity measurements methods for matching cost estimation dependently of various light field configuration properties.

II Related work

II-A Light field processing

Several light field depth estimation approaches utilize Epipolar Plane Image (EPI) structure, proposed by Bolles *et al. *[12] and defined as a ”slice” of the light field, in which the slope of the line with reference to a certain point in an image is proportional to the depth value. Wanner and Goldluecke present a reformulation of stereo matching to a constrained labeling problem on EPIs with further variational regularization [13]. Kim *et al. *[14] present an approach for depth reconstruction from high-resolution images using a slope analysis for the lines in EPIs. Wang *et al. *[15] extend this approach for the occlusions-handling case. Johannsen *et al. *[16] present a method based on a sparse decomposition of a light field with further depth-orientation dependency retrieving. Sheng *et al. *[17] extract multi-orientation EPIs and aggregate local depth maps from them with the preservation of occlusions. Several methods do not consider EPI for depth estimation. Neri *et al. *[18] adaptively combine data term and multi-view stereo with a multi-resolution approach for reducing the complexity of the algorithm. Sabater *et al. *[19] propose a method for real-time depth estimation, using a zero-normalized cross-correlation as an image similarity measurement together with pyramid strategy for coarse-to-fine reconstruction. An approach from Jeon *et al. *[20] utilizes the cost volume from shifted sub-aperture images with different similarity measurements and further result refinement via Graph Cuts (GC) [21]. Huang [22] presents a novel framework derived from Markov random fields [23]. Based on this framework, an empirical Bayesian algorithm for depth estimation is developed. Anisimov and Stricker [11] propose an efficient approach for depth estimation by initializing the line fitting hypothesis search with a result of SGM. In this work we follow this core idea, but introduce some unique features as mentioned in Section I.

In recent years interest in the usage of neural networks for the light field processing has been growing. These methods can produce a relatively fast depth result on high-performance graphics processing units (GPU). Heber and Pock [24] utilize a Convolutional Neural Network (CNN) for predicting the orientation of a 2-dimensional hyperplane, which represent the depth information, in the 4-dimensional light field space. Sun *et al. *[25] augment the EPI with Hough and Radon transform, providing the modified result to CNN. Jeon *et al. *[26] present an extension of the algorithm [20] with learning-based matching costs. A paper by Shin *et al. *[27] explains an architecture of the multi-stream network, which currently achieves the top result in 4D Light Field Benchmark [8, 9].

II-B Semi-global matching

Original SGM description was proposed by Hirschmuller [10]. Because of the high-quality output and relatively small runtime, this algorithm found its application in stereo reconstruction-related fields. Our method utilizes the SGM routine described by Haller *et al. *[28] with the cost aggregation principles from [10]. Recent work of Hernandez-Juarez *et al. *[29] shows outstanding real-time results of SGM on embedded GPU. They present a parallel version of this approach with Center-Symmetric Census transform as a cost generation method. One approach with the SGM extension for an arbitrary number of images is presented by Bethmann and Luhmann [30]. Matching cost values in their method are computed as voxels in the object space, in which the minimization process is performed.

III Proposed approach

This section provides an overview of the steps of the proposed algorithm. We describe light field parametrization in Section III-A and provide a comparison of image similarity metrics in Section III-B. Estimation of matching cost among the views in light field images is described in Section III-C. Forming of initial disparity map is presented in Section III-D and the final result generation is outlined in Section III-E. Result post-processing is described in Section III-F.

III-A Light field parametrization

Levoy and Hanrahan [31] describe a light field in the form of two-plane parametrization: a plane of spatial coordinates $(u,v)$ for a 2-dimensional view in the light field image, and angular plane $(s,t)$ for the viewpoint representation. The whole light field space can be denoted as $L(u,v,s,t)$. The way of finding the matching pixel for a specified disparity hypothesis in light field views can be formulated using this definition. For a given reference light field view $(\hat{s},\hat{t})$ and a disparity hypothesis $d$, matching pixel position $(u,v)$ in the view $(s,t)$ can be determined as [14]:

[TABLE]

III-B Image similarity measurement

Generation of a matching cost, based on the comparison of image elements such as pixels, patches or windows, is an important step for disparity estimation algorithms. Commonly used pixel-wise functions are ”city block” and Euclidean distance [32] ($\ell_{1}$- and $\ell_{2}$-norm respectively). The result of these functions can be used directly for the cost forming or can be further improved in a form of Earth Mover Distance [33] or Kernel Density Estimation (KDE) [34]. Algorithms from [14] and [11] are using KDE in a form of Epanechnikov kernel [35].

In window-based methods, widely used measures are the sum of absolute differences, the sum of squared differences and normalized cross-correlation [36]. These estimators can provide more accurate results in contrast to pixel-based methods, but the computation time increases since for each pixel in an image more pixels around are involved, which can limit usage on window-based approaches in rapid estimation algorithms.

One of the efficiently used method for the matching cost generation is Census transform as detailed by Zabih *et al. *[37]. Radiance value of a pixel in an image $I$ is compared to pixels nearby within a set of pixels coordinates $D$, lying in a window. It results in a bit string for a pixel in Census-transformed image $I_{c}$:

[TABLE]

where $\otimes$ stands for bit-wise concatenation. Pixel relations are defined as:

[TABLE]

Although this method is based on window around a pixel, the number of calculations can be reduced by using a sparse window for census transform.

III-C Matching cost generation

Two image similarity measurements are used in this work for the generation of matching cost. A Census-based matching cost function can be defined through a Hamming distance between corresponding pixels from Census-transformed images. For two images in Census-transformed light field $L_{c}$ with coordinates $(\hat{s},\hat{t})$ and $(s,t)$:

[TABLE]

where $\hat{p}_{c}$ stands for matching pixel position in $L_{c}$ (Eq. 1). $HD$ is the Hamming distance function. For two vectors $x_{i}$ and $x_{j}$ ($|x_{i}|=|x_{j}|=n$, here and further $|\ldots|$ denotes cardinality) it can be determined as a number of elements with different values.

[TABLE]

In our approach Census transformation is extended to be applied for RGB images. It is performed for each view channel separately, and the result is composed by a sum of Hamming distances of pixels in every channel. Cost, generated by this method, is used in calculations of initial disparity map, explained in Section III-D.

Radiance comparison for correspondence matching in light field space is performed by $\ell 2$-norm. For two light field views with coordinates $(\hat{s},\hat{t})$ and $(s,t)$ is determined as:

[TABLE]

Cost from this method is used during the final disparity map estimation, described in Section III-E.

III-D Initial disparity map

In order to create boundary values for correspondence search in whole light field space by more computationally-intensive algorithm the initial disparity map is calculated by using lower computationally-intensive algorithm. According to this concept, we first estimate the disparity maps for the set of four cross-lying views in the light field image $V=\{(\hat{s},0),(\hat{s},t_{max}),(0,\hat{t}),(s_{max},\hat{t})\}$, where $s_{max}$ and $t_{max}$ correspond to horizontal and vertical angular dimensions of light field image. Disparity maps are estimated relative to reference view $(\hat{s},\hat{t})$. Calculations in this step are simplified compared to whole light field space correspondence matching by reducing the number of processed views and preserving changes only in one angular direction. Corresponding Census-transformed views from a light field image are used for this estimation. For every view in a set $V$ the cost is achieved as

[TABLE]

where $i=[1,|V|]$, and disparity hypothesis $d$ lies in predefined range $d\in T=[d_{min},d_{max}]$, which covers all possible shifts of the pixels within two opposing views on one angular axis *e.g. *$(\hat{s},0)$ and $(\hat{s},t_{max})$.

Results of the cost matching are then individually aggregated with original SGM method. For each pixel $p=(u,v)$ and $d\in T$, after traversing in direction $r$, formulated as a 2-dimensional vector $r$ = {$\Delta u$, $\Delta v$}, aggregated cost $L_{r}$ is

[TABLE]

where $P\mathit{1}$ and $P\mathit{2}$ are penalty parameters for neighbourhood disparities, $P\mathit{2}\geqslant P\mathit{1}$ and $C(p,d)=C_{c}(u,v,d)$ for the case described in this section. Costs are then summarized among all directions:

[TABLE]

We compute disparity map separately using the winner-takes-all (WTA) strategy on the summarized cost:

[TABLE]

As a result we obtain four intermediate disparity maps $D_{i},i=1...|V|$, which already correspond to the reference view of light field image, unlike in the algorithm of Anisimov and Stricker [11], where disparity maps had to be projected on the coordinates of the reference view. For obtaining the initial disparity map $D_{init}$ the intermediate maps are fused using a confidence threshold $\varphi$. As an initialization step $D_{init}=D_{1}$, for every pixel $(u,v)$ we verify if inequality $|D_{init}(u,v)-D{i}(u,v)|<\varphi$ for the rest of intermediate maps is true. If it is so – new value in initial disparity map is defined as an average between $D_{init}(u,v)$ and $D_{i}(u,v)$, if not – the pixel is discarded as uncertain. To partially cover ”holes” without a valid disparity value, which appear after the described fusion, we apply a one- or two-pass median-based filling of particularly this holes with nearby values within a window. An example of initial disparity map can be found in Fig. 1 (c).

$D_{init}$ is used for generation of boundaries for the further estimation. These boundaries will limit matching cost generation in the whole light field space. Two structures named high and low borders ($D_{H}$ and $D_{L}$ respectively) are generated by using the border threshold $\lambda$ in such a manner:

[TABLE]

The values, which lies outside on predefined disparity range ($D_{H}>d_{max}$, $D_{L}<d_{min}$) are saturated accordingly. Invalid values from $D_{init}$ are marked in the corresponding borders for re-computation on the whole disparity range $T$. Also, we exclude edges from the borders, so the objects boundaries are reconstructed better by involving all information from light field space. For that, the technique with Sobel operator [39] for gradient extraction from reference view is applied.

III-E Final disparity map

Within the border for disparity values, we perform a correspondence search across all views in light field image for computing matching cost. Matching cost $S$ for a pixel $p=(u,v)$ with respect to the reference view $(\hat{s},\hat{t})$ for each possible hypothesis $d\in[D_{L}(p),D_{H}(p)]$ can be computed using the $\ell_{2}$-norm as

[TABLE]

We do not use generated cost values directly for disparity estimation. Instead, for the result improvement, SGM method is used to aggregate the generated matching cost. Eq. 8 is applied to the $S(u,v,d)$ instead of $C_{s}(p,d)$, result for every pixel traversing direction is provided to $C_{s_{\ell}2}$. SGM in this step performed only for the disparity values, which are in the predefined bounded range $d\in[D_{L}(p),D_{H}(p)]$, so values outside the boundaries do not affect the aggregation process. We determine the final disparity map $D_{f}$ according to the lowest value of the aggregated costs $C_{s_{\ell}2}$ for each pixel by applying the WTA strategy for Eq. 10.

III-F Post-processing

Usage of the Census transformation or $\ell_{2}$-norm gives us an opportunity for sub-pixel disparity value estimation. A popular technique for it is based on parabolic interpolation of cost values. For each pixel $p$ in interpolated disparity map $D_{n}$ procedure for calculation of the interpolated value can be expressed as follows:

[TABLE]

Interpolation can only be performed on pixels, in which disparity value $D_{f}(p)\in[D_{L}(p)+1,D_{H}(p)-1]$ and $|[D_{L}(p)+1,D_{H}(p)-1]|\geqslant 3$. If the disparity value does not satisfy these conditions, then $D_{n}(p)=D_{f}(p)$ After this step we apply a median filter to $D_{n}$ in order to remove the impulse noise.

IV Experiments

Our method is evaluated with the 4-dimensional Light Field Benchmark [8, 9]. We provide a comparison of the proposed algorithm with the state-of-the-art methods presented in Section II-A: BSL [11], EPI1 [16], EPI2 [13], EPINET [27], LF [20], LF_OCC [15], OFSY [38], RM3DE [18], RPRF [22]. Together with that, qualitative results for real-world EPFL [40] and Middlebury datasets [41, 42] are presented.

IV-A Synthetic dataset

A dataset with synthetic scenes is provided by Honauer *et al. *[9] via 4D Light Field Benchmark (4DLFB) [8]. Twelve synthetic scenes are used for the comparison; each of them is represented by the 9x9 light field, collected from 8-bit RGB images with 512x512 pixel resolution. Camera settings and disparity ranges are provided for every scene; high-resolution disparity and depth maps are provided only for categories for training.

IV-B Evaluation measures

These are several general metrics given by a benchmark. Fundamental criteria for evaluation of our approach are the estimation of the percentage of pixels, in which absolute difference of the result and ground truth larger than the specified threshold, which is set to 0.07 in our comparison, formulated as the $BadPix$ metric in the mentioned benchmark, together with the runtime of the algorithm. Algorithms are also compared by the Mean Squared Error ($MSE$) over image pixels. Corresponding formulas and descriptions are presented by Honauer *et al. *[9], the result for different photo-consistency metrics, which are not covered in this paper, can be found online in the 4D Light Field Benchmark [8].

Also, we compare algorithms with $M$-metric [11], which is based on the runtime and $BadPix$ metric and formulated as a percentage of correctly computed pixels per second:

[TABLE]

IV-C Algorithm parameters

Configuration of our algorithm is adjusted for an optimal result for $BadPix$ metric. Ranges for depth hypotheses are set accordingly to configuration files of each scene, all other parameters remain same for all scenes. For the SGM from Section III-D penalty parameters $P\mathit{1}$ and $P\mathit{2}$ are empirically set to 21 and 45 respectively, whereas the penalties for the extended SGM from Section III-E are equal to 17 and 35. 16 traversing directions for SGM are used. We use a sparse 7x7 pattern for Census transformation in a configuration from [11]. Confidence threshold $\varphi$ is set to 3, and the border penalty $\lambda$ – to 2. Window size for median-based filters is equal to 3.

IV-D Results

Results of the comparison with metrics from Section IV-B are presented in Table I. Visualization of disparity maps for a scene ”dino” is presented in Fig. 2; per-scene evaluation together with disparity map results for other scenes can be found online in the 4D Light Field Benchmark [8] under the FSL acronym. Comments for the result are provided in Section IV-F.

IV-E Real-world scenes

Real-world tests were performed with two image similarity measurements for final disparity map estimation. We used an approach, described in Section III-E with $\ell 2$-norm matching cost, and we also modified in to use with Census cost by modifying Eq. 12 to:

[TABLE]

We provide qualitative results of our algorithm for light field images from EPFL dataset [40], edited and uploaded by C.-T. Huang for the publication [22]. Light fields consist of 3x3 RGB image with resolution 541x376. A visualization of the result is presented in Fig. 3. On the testing machine in average it took 21 s. for RPRF [22] to generate a result when our approach provides the output in 1.5 s.

Also, for additional tests we use 3-dimensional light fields provided by Middlebury 2006 dataset [41, 42]. Each scene is represented by 7 images in a row with a large baseline between them. Original resolution is 1240-1396x1110 pixels, we used half-sized images for our experiments. For these images correspondence search is performed in boundary-less manner. Qualitative result for some scenes with different image similarity measurements is visualized in Fig. 4. We do not provide ground truth images for this comparison, because they are available only for two bordering views on the light fields, and we compute our disparity map with respect to the central light field image. Processing of these scenes took 8 s. on average. For both datasets, penalty parameters for SGM are set to 30 and 120, other algorithm parameters remain same and described in IV-C.

IV-F Discussion

The results of our algorithm are expectedly consistent with results from BSL [11]. Quantitatively, the average values of $BadPix$ and MSE are improved, which can be explained as an effect of applying SGM to the generated costs. In general, our algorithm produces average quality results within other algorithms. Qualitatively we can see an improvement of the subjective sharpness level compared to BSL. Comparison based on photo-realistic metrics proposed by Honauer *et al. *[9] also shows a slight improvement of the result. However, a visual issue with step effect on the disparity map is recognized. Further experiments are required to determine exactly how this problem can be eliminated. We believe that this effect can be partially compensated by proper adjustment of penalty parameters for the extended SGM or with more sophisticated post-processing filtration.

Currently, we achieve the best result for runtime and the second best for M-metric (14). The approach EPINET [27] can be considered as top-of-the-line, providing good results in terms of depth quality together with the satisfying runtime. However, their algorithm is performed on the high-end GPU. Such heavy computational resources are not required by our approach, which utilizes a central processing unit (CPU) without specifically employed thread parallelism. The exact configuration is explained in Section IV-G. There is a field of improvement for this algorithm with SIMD-instructions and exploitation of parallelism *e.g. *for independent of each other traversing directions.

Borders from the initial depth map help to reduce the number of sampled hypotheses by further processing in a range from 50% (real-world scenes) up to 97% (synthetic scenes). Runtime of the correspondence search in the light field space is affected proportionally.

A possible gain of the number of bordered pixels can be achieved by the improvement of the matching algorithm for initial disparity map estimation. For instance, it can be done with different configurations of Census window *e.g. *by using adaptive Census window based on gradients. Real-world tests show that utilization of $\ell_{2}$-norm for global correspondence search cannot be considered as effective in some cases. $\ell_{2}$-norm works better for the case of synthetic images and real-world scenes with narrow baseline in light field images, whereas Census-based estimation provides a better result for other real-world cases. Configuration with Census-based matching cost tested with Middlebury dataset images (Fig. 4) revealed a fact that computation of the initial disparity map and utilization of it for correspondence search with the mentioned similarity measurement shows worse runtime compare to the configuration with initialization. In our opinion, it happens mainly because of a large number of depth hypotheses in this dataset. The initial map was computed for EPFL dataset for both similarity configurations, and the time difference was insignificant.

We assume that decision for the selection of proper matching cost and the boundaries configuration should depend on the image size, the maximum possible displacement between two boundary light field views and quality of the image by itself (*e.g. *it should not be noisy). Without boundaries, Census-based configuration has somewhat similar to the method of Tomioka *et al. *[43] in terms of aggregation principles.

During the tests with real-world images, we came up with an idea of adjustment for border threshold $\lambda$ dependent on the initial depth value, so that for small disparities this threshold is higher rather than for higher values. Such a strategy can help to determine the more accurate values for the farther objects, where the pixel discontinuity can be a crucial factor for the right depth estimation.

Additional limitations have been observed during these tests. On Fig. 3 the visual problem with grids in the middle scene can be noticed. Also, we were not able to generate proper interpolation for a bottom scene in Fig. 3, it could be a problem related to the use of a small number of images for reconstruction. Although bordering of depth values with the initial map helps to reduce depth mismatching noise, some of the wrongly calculated pixels still can ”survive” this filtering, which is visible in images on Fig. 4. These mistakes appear either in the areas marked previously as non-consistent or on the object edges. Our algorithm fails with depth estimation on image boundaries for scenes with a relatively large distance between images. The explanation of this problem is related to our selection of the central light field image as a reference view. In this case search for a matching pixel from image boundary fails since there is no match in most of the images and therefore our algorithm can not aggregate enough depth score for the correct value. A solution for this problem was proposed by Kim *et al. *[14], where the position of reference images changes over time and cost aggregation is performed from the new position. However, for the presented method such an improvement can greatly increase the running time, which is in contradiction with our main objective.

IV-G Environment

Hardware configuration for depth processing includes CPU Intel Xeon E3-1245 V2 @ 3.40 GHz, forced to work in single-thread mode. Our algorithm is implemented in C and compiled using GCC v.7.3.1 with /O3 option.

V Conclusion

In this paper, we proposed a fast depth estimation method from light fields by extending an efficient stereo matching algorithm with a methodology of enlargement to multi-view sampling by the correspondence search in light field space. The evaluation against state-of-the-art methods showed that our algorithm produces comparable depth map results, which have been proven by different quantitative metrics. In contrast to many state-of-the-art approaches, our proposed method produces depth maps in a relatively small amount of time. As a result, our method provides almost the best result in terms of computed pixels per unit of time. In addition, our approach works for different configurations of 3-dimensional and 4-dimensional synthetic and real-world light field images. Further work will investigate additional real-time improvements, *e.g. *by utilizing a pyramidal scheme with downscaled images together with hardware-specified optimizations, such as parallelism on multi-core CPU or GPU.

Acknowledgments

This work was partially funded by the Federal Ministry of Education and Research (Germany) in the context of the project DAKARA (13N14318). The authors are grateful to Kiran Varanasi and Jonathan Wray for the provided support.