SceneFlowFields++: Multi-frame Matching, Visibility Prediction, and Robust Interpolation for Scene Flow Estimation
René Schuster Oliver Wasenmüller Christian Unger Georg Kuschk Didier Stricker





SceneFlowFields++        





R. Schuster O. Wasenmüller D. Stricker DFKI - German Research Center for Artificial Intelligence

              Kaiserslautern, Germany

              firstname.lastname@dfki.de           

           C. Unger G. Kuschk BMW Group

              Munich, Germany

              christian.unger@bmw.de

              g.kuschk@gmx.de






SceneFlowFields++:
Multi-frame Matching, Visibility Prediction, and Robust Interpolation for Scene Flow Estimation



    René Schuster         Oliver Wasenmüller Christian Unger Georg Kuschk Didier Stricker 

    Received: date / Accepted: date
=====================================================================================================================




State-of-the-art scene flow algorithms pursue the conflicting targets of accuracy, run time, and robustness. With the successful concept of pixel-wise matching and sparse-to-dense interpolation, we shift the operating point in this field of conflicts towards universality and speed. Avoiding strong assumptions on the domain or the problem yields a more robust algorithm. This algorithm is fast because we avoid explicit regularization during matching, which allows an efficient computation. Using image information from multiple time steps and explicit visibility prediction based on previous results, we achieve competitive performances on different data sets. Our contributions and results are evaluated in comparative experiments. Overall, we present an accurate scene flow algorithm that is faster and more generic than any individual benchmark leader.








§ INTRODUCTION
 
Scene flow is the problem of estimating the perceived dense 3D motion field along with the 3D geometry of the scene. Typically, a set of stereo image pairs is used to estimate scene flow.
Motion estimation is a crucial part for autonomous systems like self-driving vehicles and in many applications such as collision detection and path planning in driver assistance systems and robot navigation, object tracking, moving object detection, frame interpolation (temporal super resolution), and many others. 

Traditionally, motion is described by optical flow in 2D. Recently, with more computational resources and stereo cameras in mobile systems and vehicles available, the more complex, yet more realistic representation of motion in 3D is gaining increasing interest from research and industry. Despite growing efforts, either problem under unconstrained settings is far from being solved. However, with certain assumptions and restrictions to special domains, there exist methods that achieve impressive results on popular benchmarks.
Yet, any assumption – even if it's reasonable for a certain domain – will limit the applicability to other domains. The variance of performance of an algorithm on different data sets is one indicator for the robustness of that algorithm. Especially when applying deep neural networks, the generalization to different domains suffers heavily, unless the specific network is retrained or fine-tuned for the new domain. On the other hand, robustness alone should not be the only goal. A reasonable level of accuracy is required for any application that uses scene flow. Often, high accuracy comes at the price of run time. Top performing methods on the KITTI benchmark <cit.> have run times of more than 5 minutes. Existing algorithms are focused on one or at most two of these targets, either speed, accuracy, or robustness. Upcoming deep learning approaches are potentially fast and accurate, but lack generalization. The state-of-the-art can be very accurate – sometimes even across different domains – but has high run times often.

With our novel concept of *sff <cit.>, we want to push the limits of scene flow estimation towards a robust, comparatively fast, and accurate algorithm. Towards this end, we restrict ourselves to very few reasonable assumptions with minor impact on the versatility. Further, we avoid explicit regularization in our scene flow problem formulation which enables a fast computation of the solution. Regularization is imposed by outlier filtering and interpolation as it is often done in state-of-the-art optical flow algorithms <cit.>. This approach is fast and domain invariant. However, the basis is accurate matching based on visual similarity in images. Therefore, we have to deal with the typical problems of matching tasks: Changes in lighting, image noise, perspective deformations, occlusions, etc. 
To further improve the accuracy and robustness of this sparse-to-dense pipeline, we extend the concept to a multi-frame setup with explicit visibility reasoning. We also use novel concepts for interpolation to increase the robustness.

Working in the context of classical, image-based scene flow estimation, we assume to have consecutive frame pairs of a stereo image sequence (at least 4 images, cf. <ref>) as input. We represent scene flow as a 4D vector s =(u,v,d_0,d_1)^T consisting of two optical flow components u, v and the disparity values d_0, d_1 for both time steps. This way, we can express pixel correspondences in the four relevant images. Having rectified stereo image pairs and calibrated cameras, the 4D representation in image space is equivalent to the full scene flow representation of 3D geometry and 3D motion in world space. 

This paper re-presents our work of *sff <cit.> and extends it considerably. In detail, the contributions of the original conference paper are:


  * The first method of sparse-to-dense interpolation for scene flow.

  * A novel method to find scene flow matches.

  * A new interpolation method for scene flow that preserves boundaries of geometry and motion.

  * An improved edge detector to approximate scene flow boundaries for the KITTI data set.

  * An optional approach for straightforward integration of ego-motion.

We substantially extend *sff in this paper by the following contributions:


  * Novel matching and filtering for scene flow in a multi-frame instead of dual-frame setup.

  * Explicit one-shot visibility reasoning for scene flow matching on pixel-level.

  * More robust two-stage interpolation of scene flow correspondences.

  * A unified boundary detector for different data sets.

  * Thorough evaluation of our conference approach and our novel extension with comparison to state-of-the-art on KITTI and MPI Sintel.

Since the extensions are based on the original *sff, we term our novel approach *sffpp.

The rest of the paper is structured as follows: We give an overview of related work in <ref>. <Ref> presents details about *sff, followed by an incremental description of *sffpp in <ref>. Experimental comparisons between sff and *sffpp and to state-of-the-art are described in <ref>. We summarize our findings in <ref>.




§ RELATED WORK
 


  
Data Sets.
Since it is hard to capture ground truth scene flow information, there exist only very few data sets to evaluate scene flow algorithms on. Most of them use virtually rendered scenes to obtain the ground truth data <cit.>. To the best of our knowledge the only realistic data set that provides a benchmark for scene flow is the KITTI Vision Benchmark <cit.> that combines various tasks for automotive vision. Its introduction has played an important role in the development of stereo and optical flow algorithms, and the extension by <cit.> has also driven the progress in scene flow estimation.



  
Variational Scene Flow Estimation.
 were among the first to compute 3D scene flow. Afterwards, many variational approaches for scene flow estimation followed. First using pure color images as input <cit.> and later using RGB-D images <cit.>. While a variational formulation is typically complex, <cit.> achieved real-time performance with a primal-dual framework. Yet, all these approaches are sensitive to initialization and can not cope with large displacements, which is why they use a coarse-to-fine scheme. That in turn tends to miss finer details. Furthermore, the RGB-D approaches rely on depth sensors that either perform poorly in outdoor scenarios or are accordingly very expensive <cit.>. Nowadays, variational methods are outperformed in terms of speed and accuracy by other approaches and are only used as a refinement step.



  
Combination Approach.
Because the scene flow problem is highly related to the auxiliary tasks of optical flow and stereo disparity estimation, people have tried to estimate scene flow by combining separate results for optical flow and stereo disparity <cit.>. Though the separation brings advantages for the complexity of the problem and thus the run time, it is believed that a single formulation of the problem yields more consistent scene flow results, which are more accurate and realistic.



  
Assumption of Planarity and Rigidity.
Due to the advent of a piece-wise rigid plane model <cit.>, scene flow has recently achieved a boost in performance. The majority of top performing methods at the KITTI Vision Benchmark employ this model to enforce strong regularization <cit.>. 
 encode this model by alternating assignment of each pixel to a plane segment and each segment to a rigid motion, based on a discrete set of planes and motions in view-consistent manner over multiple frames.  further lower the complexity of the model by the assumption that a scene consists of very few independently moving rigid objects. Thus each plane segment only needs to be assigned to one object. All segments assigned to the same object share the same motion. By propagation of objects over multiple frames, <cit.> achieve temporal consistency for the model of <cit.>.  use deep learning to obtain semantic object information a-priori.  solve the pixel-to-plane assignment and the plane-to-motion assignment in a continuous domain.
Despite the remarkable accuracy on KITTI, many of these methods are not applicable to domains with different characteristics. The rigid motion assumption is strongly violated by articulated gestures and other non-rigid motions that often occur in the Sintel data set <cit.>. The assumption made by <cit.> that there are only a few independent dynamic objects in a scene is inappropriate for highly dynamic scenarios. Further, methods falling into this category typically have very long run times of several minutes up to almost one hour per frame.



  
Guided by Semantics.
Other scene flow algorithms use deep learning to incorporate semantic information into the motion estimation problem <cit.>. Yet, in terms of robustness, deep learning approaches <cit.> typically lag behind because they generalize badly to unseen data and even worse to data from different domains <cit.>. This is especially true for semantic segmentation, where the domain gap is amplified by the mismatch of semantic classes between domains <cit.>.
Our algorithm is especially designed to achieve good results across different data sets without any dedicated parameter tuning.



  
Static-Dynamic Decomposition.
Yet another promising strategy builds on the decomposition of a scene into static and moving parts <cit.>. While the motion of dynamic objects is estimated by solving a discrete labeling problem (as by <cit.>) using the *sgm <cit.> algorithm, the perceived motion of all static parts is directly obtained from the 3D geometry of the scene and the ego-motion of the camera. This approach is especially convenient for scenes, where only a small proportion consists of moving objects, like it is usually the case in traffic scenarios.
However, any a-priori assumption limits the versatility of a method. A rigid plane model performs poorly when applied to deformable objects, and ego-motion estimation for highly dynamic scenes is hard.





  
From Dual to Multiple Frames.
When speaking about the related work, one has to differentiate between dual-frame <cit.> and multi-frame <cit.> approaches. Especially in the context of traffic scenarios, we have several characteristics that make matching between two frame pairs much more challenging than in a multi-view setting. These characteristics are: 1.) Considerably large stereo and flow displacements. 2.) Difficult lighting conditions and many reflective and (semi-)transparent surfaces of cars. 3.) Fast ego-motions sometimes combined with low frame rates, which causes large regions to move out of image bounds. 
This explains why there exist pairs of dual-frame and multi-frame methods. The transitions from OSF <cit.> to OSF+TC <cit.> and from PRSF <cit.> to *prsm <cit.> brought essential improvements by using the additional information of multiple image frames.
However, this additional information comes at a cost. The relationship between multiple temporal steps needs to be modeled to make use of the additional images. A typical model is to assume smooth, constant motion between neighboring time steps <cit.>.
In this extension of *sff <cit.>, we also follow this trend and use more than two image pairs, assuming constant motion.





  
Discrimination from State-of-the-Art.
We can cluster related work into certain categories (cf. <ref>).
Because our scene flow method follows the newly introduced sparse-to-dense approach, it differs from any of the related approaches. We find sparse scene flow matches that are interpolated to a dense scene flow field, recovering the geometry of the scene and the 3D motion. 
Our method has to be distinguished from purely variational approaches. Although we use variational optimization, it can be considered as a post-processing step for refinement.
Similar, the cameras ego-motion is only used to refine the results for static image regions.
During interpolation, we assume that the geometry of a scene can be modeled by very small planar segments, but we do not initially presume any coarse segmentation. In fact, the very small size of our plane segments leads to smoothly curved shapes and sharp boundaries. The same holds for our piece-wise motion model that is used to interpolate the 3D motion.
Methods which are guided by semantic segmentation from deep neural networks will generalize badly to other domains, unless they are fine-tuned for the new task. Same is assumed for upcoming purely learning based approaches <cit.> which are potentially even faster than our approach.  *sffpp focuses especially on robustness across domains and applications.

We contrast the different categories and compare their properties in <ref>.
The piece-wise rigid planes models is particularly accurate due to its strong regularization (as long as the assumptions are not violated), but is also complex and computationally expensive.
The decomposition (separation) approach that splits the scene flow problem into less difficult sub-problems is especially fast and benefits from advances in the auxiliary tasks. Yet, separate computation leads to overall less consistent scene flow.
Deep learning is potentially fast due to the inherent parallelization on GPUs, but sensitive to the distribution of available training data and not interpretable in case of failure.
The novel scene flow concept of sparse-to-dense interpolation allows to separate matching from regularization. With the use of appropriate interpolation models and interpolation regions, the negative impact of violated assumptions can be diminished.
However, the separation of matching and regularization makes our approach sensitive to the quality of the sparse matching results. To overcome this issue, we propose to use multiple frames within this work.




§ SCENEFLOWFIELDS
 
For our dual-frame scene flow estimation we assume to have the typical stereo image information provided, two rectified stereo image pairs (I_0^l, I_1^l, I_0^r, I_1^r) at times t and t+1 along with the camera intrinsics. We further assume that the baseline B is known. For rectified images, the baseline describes the relative pose between the left and right cameras as translation parallel to the image plane. 
During matching, we jointly optimize all four components to obtain coherent scene flow. Our matching algorithm follows the ideas of non-regularized, coarse-to-fine matching with propagation and random search <cit.> which was shown to work the best for sparse-to-dense optical flow pipelines <cit.>.
Given the mentioned information, we estimate a dense scene flow field as follows: 
For k sub-scales we initialize the coarsest scale. For all k+1 scales (the k=3 sub-scales plus full resolution), we iteratively propagate scene flow vectors and adjust them by random search. Afterwards, the dense scene flow map on full resolution is filtered using a two-stage consistency check. The filtered scene flow map is further thinned out in a sparsification step. Scene flow boundaries are detected using a structured random forest. Geometry and 3D motion are separately interpolated with respect to object boundaries of the scene. Finally, we refine the 3D motion by variational optimization. An overview of the dual-frame method *sff is outlined in <ref>. 



 §.§ Sparse Correspondences
 


  
Matching Cost.
The matching cost in our algorithm solely depends on a data term. No additional smoothness assumptions are made like by <cit.>. Given a scene flow vector, we define its matching cost by the sum of Euclidean distances between SIFTFlow features <cit.> over small image patches.
Our matching error for two corresponding pixels 𝐩 and 𝐩' in images I and I' is defined by the following cost

    C(I,𝐩,I',𝐩') = 
    ∑_𝐩̃∈ W(𝐩)‖ϕ(I,𝐩̃) - ϕ(I',𝐩'+𝐩̃-𝐩) ‖,

where W(𝐩) is a 7 × 7 patch window centered at pixel 𝐩 and ϕ(I,𝐩) is a function that returns the first three principal components of a SIFT feature vector (SIFTFlow) for pixel 𝐩 in image I.
We evaluate the cost for three image correspondences. The stereo image pair at time t, the temporal image pair for the left view point (standard optical flow correspondence) and a cross correspondence between the reference frame and the right frame at the next time step (cf. <ref>). This leads to the following overall cost C for a scene flow vector 𝐬 = (u,v,d_0,d_1)^T at pixel 𝐩:

    C(𝐩,𝐬)    = C(I_0^l,𝐩,I_1^l,𝐩 +(u,v)^T)
        + C(I_0^l,𝐩,I_0^r,𝐩+(-d_0,0)^T)
        + C(I_0^l,𝐩,I_1^r,𝐩+(u-d_1,v)^T).

With that we can obtain a dense scene flow field 𝒮 by optimizing the following energy minimization problem

    E(𝐈, 𝒮) = ∫_Ω C(𝐩,𝒮(𝐩))d𝐩.


    𝒮̂ = _𝒮 E(𝐈,𝒮).


Though this optimization includes a lot of variables, we can exploit the fact that we can optimize 𝐬 = (u,v,d_0,d_1)^T for each pixel individually since our formulation includes no inter-pixel dependencies, e.g. no explicit regularization.
Therefore, we use an efficient, greedy, stochastic optimization approach of propagation and random search.



  
Initialization. 
Initialization is based on kD-trees similar to the work of <cit.>, but with three trees, using *wht features as done by  <cit.>. For each frame other than the reference frame (I_0^l), we compute a *wht feature vector per pixel and store them in a kD-tree. To initialize a pixel of the reference image, we query the feature vector of the pixel to the pre-computed kD-trees. Scene flow matches are then obtained by comparing all combinations of the leafs for each queried node according to the matching data term introduced before (<ref>). Since our stereo image pairs are rectified, for the images observed from the right camera view, we create kD-trees which regard the epipolar constraint, queries for such a tree will only return elements, which lie on the same image row as the query pixel. This way, we can efficiently lower the number of leaves per node for the epipolar trees, which speeds up the initialization process without loss of accuracy. For further acceleration, we use this initialization on the coarsest resolution only, and let the propagation fill the gaps when evolving to the next higher scale.

Though the result of the initialization looks very noisy and unreliable (cf. <ref>), it is much better than random initialization. In fact, we could not reproduce similar results of our full approach with random initialization or any other more simple initialization method. This is because although the *wht features are not very expressive, they are sufficient to find at least a few close-to-correct initial scene flow values, which later are spread and refined.



  
Multi-Scale Propagation. 
The initial matches are spread by propagation and steadily refined by random search. This is done over multiple scales which helps to distribute rare correct initial matches over the whole image. For each scale, we run several iterations of propagation in one out of the four image quadrants, so that each direction is used equally often. During propagation, a scene flow vector will be replaced if the propagated vector has a smaller matching cost (see <ref>). If this is not the case, the propagation along this path will continue with the previously existing scene flow vector. After each iteration we perform a random search. This means that for all pixels we add a uniformly distributed random offset in the interval ]-1,1[ in pixel units of the current scale to each of the four scene flow components and check whether the matching cost decreases. Both propagation and random search help to obtain a smoothly varying vector field and to find correct matches even if the initialization is flawed. For the different scale spaces, we simulate the scaling by smoothing the images and taking only every n-th pixel for a subsampling factor of n = 2^k, so that the patches consist of the same number of pixels for all scales. This way, we prevent (up)sampling errors because all operations are performed on exact pixel locations on the full image resolution. Smoothing is done by area-based downsampling followed by upsampling using Lanczos interpolation. Note that a similar matching strategy has already been used by <cit.>, but while they use it for optical flow, we apply it to twice as many dimensions in search space.
This matching method was shown to work very well for motion fields. Even unique initial values are spread across the whole image yielding smooth motion fields with sharp boundaries.



  
Consistency Check.
The matching procedure yields a dense map of scene flow correspondences across all images. However, many of the correspondences are wrong because of occlusions, out-of-bounds motion or simply because of mismatching due to challenging image conditions. To remove these outliers, we perform a two-step consistency check. First, we compute an inverse scene flow field for which the reference image is the right image at time t+1. Temporal order as well as points of view are swapped. Everything else remains as explained above.

During consistency check, optical flow and both disparity maps for each pixel are compared to the corresponding values of the inverse scene flow field. If either difference exceeds a consistency threshold τ_c=1 in image space (pixels), the complete scene flow vector will be removed. In a second stage, we form small regions of the remaining pixels as proposed by <cit.>, where a pixel is added to a region if it has approximately the same scene flow vector. Afterwards, we check whether it is possible to add one of the already removed outliers in the neighborhood following the same rule. If this is possible and the region is smaller than s_c=100 pixels, we will remove the whole region. This way we obtain the filtered final scene flow correspondences of high accuracy and very few outliers (cf. <ref>). 

Since we use a single scene flow formulation during consistency check also, the filtered results are very coherent. However, the joint filtering of all four scene flow components removes entire matches which might be only partly inconsistent. This applies especially to the reference disparity d_0. Since our interpolation model (see <ref>) is split into separate steps for geometry and motion, we counter this problem, and fill up some gaps of the filtered disparity with additional values. These values are the result of a second independent consistency check for the disparity matches only. For the separate check we compute a second disparity map with *sgm <cit.> and use the same threshold τ_c as before. The additional disparity values that are retrieved this way are as accurate as the one from our standard consistency check, but much denser, which is shown in <ref>. We merge the result of the second consistency check for disparity only with the result of the first full consistency check.





 §.§ Dense Interpolation
 


  
Sparsification.
Before interpolating the filtered scene flow field to recover full density, an additional sparsification step is performed. This helps to extend the spatial support of the neighborhood during interpolation and speeds up the whole process <cit.>. It also serves as a final filtering step, because for each non-overlapping 3 × 3 block, we select the match with the lowest consistency error during filtering only. The remaining matches are called seeds with respect to the interpolation.



  
Interpolation Boundaries.
A crucial part of the interpolation is the estimation of scene flow boundaries. While <cit.> approximate motion boundaries for optical flow with a texture-agnostic edge detector <cit.>, our edge detector is trained on semantic boundaries. We find that this models geometric boundaries, as well as motion boundaries, much better than image edges and is much more robust to lighting, shadows, and coarse textures. To do so, we have gathered 424 images of the KITTI data set from <cit.> that have been densely labeled with semantic class information. Within these images we have merged semantic classes that in general neither align with geometric nor motion discontinuities, lane markings and road, or pole and panel.
The boundaries between the remaining semantic labels are used as binary edge maps to train our edge detector. To this end, we utilize the framework of *sed <cit.> and train a random forest with the same parameters as in their paper, except for the number of training patches. We sample twice as many positive and negative patches during training because we use a bigger data set with images of higher resolution. The impact of the novel boundary detector will be evaluated in our ablation study in <ref> and is visualized in <ref>.



  
Interpolation Models.
We interpolate geometry and 3D motion separately. This allows us to incorporate domain knowledge into the interpolation process by having dedicated models for both types of interpolation. Also, due to the separate consistency check for disparity only and full scene flow, we have different amounts of matches for geometry and motion, which favors the separation.
Apart from the models and number of seeds, the general concept of interpolation is the same. Suppose a local, boundary-aware neighborhood of 160 and 80 seeds is given for each unknown scene flow vector ŝ at pixel p̂ for geometric and motion seeds respectively, 𝒩_geo and 𝒩_motion. The depth of pixel p̂ is reconstructed by fitting a plane E(p̂): a_1 x + a_2 y + a_3 = d_0 through all seeds of the neighborhood 𝒩_geo. This is done by solving a linear system of equations for all neighboring seed points p_g for which the disparity values are known, using weighted least squares. The weights for each seed are obtained from a Gaussian kernel g(D)= exp(-α D) on the distance D(p̂,p_g) between target pixel and seed with coefficient α = 2.2. The missing disparity value of p̂ is obtained by plugging the coordinates of p̂ into the estimated plane equation. In a similar fashion, but using a neighborhood of motion seeds 𝒩_motion, the missing 3D motion is obtained by fitting an affine 3D transformation 𝐱_1 = 𝐀𝐱_0 + 𝐭 using weighted least squares on all neighboring motion seeds p_m. Where 𝐱_𝐭 = (x_t,y_t,z_t)^T are the 3D world coordinates of motion seed p_m at time t and t+1, and [𝐀|𝐭] ∈ℝ^3 × 4 is the affine 3D transformation of twelve unknowns. The weights are computed by the same Gaussian kernel as for geometric interpolation, but using the distances D(p̂,p_m) between the target pixel and the motion seeds. To summarize, for the full reconstruction of scene flow ŝ=(u,v,d_0,d_1)^T at pixel p̂, we compute d_0 using the plane model E(p̂), reproject the point into 3D world space, transform it according to its associated affine transformation [𝐀|𝐭], and project it back to image space to obtain u, v and d_1.





  
Edge-Aware Neighborhood.
To find the local neighborhoods, we follow the idea of <cit.> using both of their approximations. That is first, the n closest seeds to a pixel p̂ are the n-1 closest seeds to the closest seed of p̂, thus all pixels with the same closest seed share the same local neighborhood. And secondly, the distance between p̂ and its closest seed is a constant offset for all neighboring seeds, which can be neglected. It is therefore sufficient to find a labeling that assigns each pixel to its closest seed and to find the local neighborhood for each seed. We use the graph-based method of <cit.> for this. The graph is constructed using the geodesic distances  between seeds, that are directly based on the edge maps from our boundary detector. A strong boundary, a high value in the edge map, indicates a high cost for crossing that pixel, which leads to a high geodesic distance. The algorithm finds the shortest path between seeds and sums up the edge values along this path to obtain the geodesic distances between seeds.



 §.§ Variational Optimization
 
To further refine the 3D motion after interpolation, we use variational energy minimization to optimize the objective

    E(u,v,d') = E_data^flow + E_data^cross + φ· E_smooth.

Motion is represented in image space by optical flow and the change in disparity d'. The energy consists of three parts. Two data terms, one temporal correspondence and one cross correspondence, and an adaptively weighted smoothness term for regularization. The data terms use the gradient constancy assumption. Our experiments have shown, that a term for the color constancy assumption can be neglected.

    E_data^∗(I,I',𝐱,𝐰) = 
    ∫_Ωβ(𝐱,𝐰) ·Ψ( γ·|∇ I'(𝐱+𝐰)-∇ I(𝐱)|^2)dx

with 𝐰 being a placeholder for either the optical flow displacement in <ref> or the cross image displacement in <ref>.

    E_data^flow = E_data^∗(I_0^l,I_1^l,𝐱,(u,v)^T)


    E_data^cross = E_data^∗(I_0^l,I_1^r,𝐱,(u-d_0-d',v)^T)

The data terms do not contribute to the energy if the function

    β(𝐱,𝐰) = 
    1,    if(𝐱+𝐰)^T ∈Ω
    
    0,    otherwise

indicates that the scene flow is leaving the image domain (out-of-bounds motion). The smoothness term 

    E_smooth = ∫_ΩΨ(|∇ u|^2 + |∇ v|^2 + λ·|∇ d'|^2)dx

penalizes changes in the motion field where |∇ u|^2 is the magnitude of the spatial derivatives of one scene flow component. It is weighted by 

    φ(𝐱) = e^-κ B(𝐱),

where B(𝐱) is the edge value of our boundary detector at pixel 𝐱 (cf. <ref>) and κ=5 is a kernel coefficient. All parts use the Charbonnier penalty Ψ(x^2) = √(x^2+ε^2) with ε^2=0.0001 to achieve robustness. Since the smoothness term rather enforces constancy instead of smoothness if β for both data terms is zero, we do not optimize the scene flow at pixels where the interpolated scene flow field leaves Ω. Our energy formulation is inspired by <cit.>.
We use linear approximations of the Euler-Lagrange equations for the objective in <ref> and apply the framework of <cit.> without the coarse-to-fine steps to find a solution by *sor. Again, we will compare the results with and without the variational refinement in our ablation study in <ref>.







 §.§ Optional Ego-Motion Model
 
In <ref> we will show that our approach as described so far achieves competitive results. For the special challenges of the KITTI data set, we make an additional, optional assumption to further improve the performance of *sff. Following <cit.>, we argue that most parts of a scene are static and thus that the 3D motion for these areas is fully determined by the ego-motion of the observer. Given the ego-motion and a motion segmentation into static and dynamic areas, we apply the inverse ego-motion to all static points in the scene. 
Using our matching and interpolation scheme, both can be estimated easily with almost no additional effort.
However, our improvements in <ref> will make the refinement step by the ego-motion model obsolete. Our experiments will show, that the impact of the ego-motion optimization diminishes when using our more robust interpolation.



  
Ego-Motion Estimation.
The filtered scene flow field before interpolation provides very accurate matches across all images. We compute 3D-2D correspondences between the reference frame and the temporally subsequent frame by triangulation with the stereo matches. We limit the depth of these correspondences to 35 meters because disparity resolution for farther distances becomes too inaccurate. This way, we obtain a Perspective-n-Point (PnP) problem, which we solve iteratively using Levenberg-Marquardt and RANSAC to find the relative pose between the left camera at time t and t+1 by minimizing the re-projection error of all correspondences. For RANSAC, we consider a correspondence to be an outlier if the re-projection error is above 1 pixel. After a first estimation, we recompute the set of inliers with a relaxed threshold of 3 pixels and re-estimate the pose P=[R|t] ∈ℝ^3 × 4. The two-stage process helps to avoid local optima and to find a trade-off between diverse and robust correspondences.



  
Motion Segmentation.
An initial sparse motion segmentation can directly be obtained as a side product of the ego-motion estimation. Outliers in RANSAC are considered in motion, while points in conformity with the estimated ego-motion are marked as static. We use our boundary-aware interpolation to compute a dense segmentation (cf. <ref>). Pixels labeled as moving are spread up to the object boundaries within which they are detected. Because the segmentation is only a binary labeling, no complex interpolation model is needed. An unknown pixel gets assigned with the weighted mean of its local neighborhood. The weights are again based on the geodesic distances between matches. This interpolation method is similar to the Nadaraya-Watson estimator described by <cit.>. The interpolated motion field is then thresholded to obtain a dense, binary motion segmentation.
Finally, the inverse estimated ego-motion is applied to all points that are labeled as static.
The impact of the ego-motion model is huge for our dual-frame conference approach, as will be shown in <ref>.




§ ROBUST MULTI-FRAME EXTENSION
 
Our experiments will show that *sff, presented in the previous section, yields competitive scene flow results, especially when the ego-motion model is applied. However, there are two main problems with the presented pipeline: 1.) Pixel-wise matching without regularization is error prone under some circumstances (saturation, lighting variations, homogeneous or repetitive textures, etc.) and even impossible in occluded and other invisible image regions (out-of-bounds motions, cf. <ref>). 2.) The accuracy of the interpolation suffers from increasing gap sizes in the filtered scene flow field and from remaining outliers after consistency check. The ego-motion model can compensate inaccurate interpolation to some extend, but not sufficiently.
In this paper, we address both major issues with our novel robust extension to multiple frame pairs.



There are different techniques to handle the unmatchable parts of a scene, cases where it is difficult or even impossible to find correspondences in the relevant images. Typically, some kind of regularization is applied, like in form of a smoothness assumption which encodes that neighboring pixels should represent a similar motion so that local visual evidence can support the motion estimation in the difficult areas. In methods that employ the piece-wise rigid plane model <cit.> this kind of regularization is for two reasons considerably strong. Firstly, each local patch describing a slanted plane undergoes the same transformation by design. Secondly, inter-plane smoothness is further enforced by dedicated terms in the energy formulation. However, regularization terms increase the computational effort significantly (cf. <ref>), and would prohibit the use of our efficient optimization strategy of <ref>.
An alternate concept to handle unmatchable regions is sparse-to-dense interpolation. This idea is rather young and was first successfully realized by EPICFlow <cit.> for the optical flow problem. The idea is to remove regions of low confidence (regions where regularization would be required to match them accurately) and to use interpolation to fill the gaps based on reliable matches.
*sff is to the best of our knowledge the first method of sparse-to-dense interpolation for scene flow correspondences and our extension is transferring this concept to a multi-frame setup for the first time.
Even though the consistency check removes outliers reliably, the gaps can not be refilled by the interpolation correctly in some scenarios. Therefore, we tackle the problem before it occurs by using image information from multiple frames to avoid mismatches and resolve ambiguity in unmatchable regions. This will result in more accurate and better distributed matches of higher density as will be shown in <ref>. Further, we transfer the concepts for interpolation from RICFlow <cit.> to the scene flow domain to improve robustness during interpolation.

All our extensions using more than two stereo image pairs build on the assumption of constant motion. That means, we assume the observed motion at both time steps (from t-1 to t and from t to t+1) to be the same. The error made by this assumption converges towards zero for continuous motions with increasing frame rates.
Our multi-frame approach is additionally designed to process video streams in an online manner. That means that the first two frame pairs of a sequence are processed with the dual-frame approach from <ref>. All subsequent frames are than added in an incremental way and processed within a sliding temporal window of three frame pairs.
We exploit the additional information of the extra images during matching in three ways. First, the previous results are used during initialization. Secondly, we use the previous scene flow to predict visibility of the scene. Lastly, we use our assumption together with the visibility prediction to match scene flow across all six relevant images.

The overall structure of our multi-frame approach remains the same as in the dual-frame method but with two more images. Using a set of six input images 𝐈 = {I_0^l, I_0^r, I_1^l, I_1^r, I_-1^l, I_-1^r}, we find accurate matches, remove possible outliers, and interpolate back to a dense scene flow field. The overview of the multi-frame pipeline is shown in <ref>. A comparison between *sff and  *sffpp is given in <ref>.




 §.§ Multi-frame Matching
 



  
Initialization.
Improved initialization is the first extension in our multi-frame approach. We use the previous scene flow result and apply our assumption of constant motion. We propagate each 3D point according to its 3D motion to get an initial prediction of the scene flow at the current time step. We use the temporally propagated scene flow prediction as additional candidate during the initialization process earlier described in <ref>. The process is visualized in <ref>. By not relying on the previous result alone, we successfully avoid error propagation (cf. <ref>).





  
Matching Cost.
As before, our matching process is based on the visual similarity of corresponding pixels (cf. <ref>). We add the additional image correspondences to our scene flow matching cost from <ref> and obtain

    C_multi(𝐩,𝐮) = C(I_0^l,𝐩,I_1^l,𝐩 +(u,v)^T)
        + C(I_0^l,𝐩,I_0^r,𝐩+(-d_0,0)^T)
        + C(I_0^l,𝐩,I_1^r,𝐩+(u-d_1,v)^T)
        + C(I_0^l,𝐩,I_-1^l,𝐩+(u_-1,v_-1)^T)
        + C(I_0^l,𝐩,I_-1^r,𝐩+(u_-1-d_-1,v_-1)^T).

We match all pixels of the image domain Ω to all five other images and derive corresponding pixel locations from our scene flow representation in 2D (cf. <ref>). For matching with the previous frame pair, we compute the inverse scene flow (in image space) u_-1, v_-1, d_-1 by projecting the flow to 3D, inverting it, and projecting back to 2D, according to our constant motion assumption. 
Note that u_-1 = -u if and only if d_0 = d_1. We do not simply invert the 2D optical flow directly. The (pixel-wise) constant motion assumption allows us to match across multiple time steps without increasing the search space or complexity of the scene flow domain.





  
Visibility Prediction.
One additional major extension is our explicit visibility reasoning. Since the energy is based on visual data only, it is impossible to match regions, that are not visible in one of the images. Depending on the magnitude of camera movement, the baseline, and other circumstances, those unmatchable areas can become considerably large. <ref> shows an invisibility mask for pixels whose imaged 3D point is not visible in at least one of the views of I_0^r, I_1^l, or I_1^r. This gives an impression of the limitations of dual-frame matching methods. 
However, <ref> also visualizes the remaining invisibility when considering one additional time step.
More than two frame pairs can compensate for missing visual evidence when a pixel correspondence that is invisible in one image can be observed in another. Assuming to know which pixels are occluded or out-of-bounds of the image domain in each view, we can replace the matching cost for a single image correspondence (<ref>) in <ref> by

    C_vis(I,𝐩,I',𝐩', occ', oob') = 
    θ_occ,    if  occ'(𝐩) 
    θ_oob,    if  oob'(𝐩) 𝐩'∉Ω
    θ_penalty,    if  oob'(𝐩) ≠𝐩'∈Ω
    
    	C(I,𝐩,I',𝐩'),    else,

with occ' and oob' being binary occlusion and out-of-bounds masks that indicate for each pixel 𝐩 whether the corresponding point in view I' is visible. For our full multi-frame matching cost in <ref>, we need two invisibility masks for all 5 corresponding images. The adjusted cost uses a constant invisibility cost θ_occ in case of occlusions to avoid trivial solutions where all points would be occluded. Same holds for out-of-bounds motions, with the additional option to assign a very large penalty cost θ_penalty if motion under test is inconsistent with the out-of-bounds mask oob'. Otherwise, the normal matching cost of <ref> will be used. In practice, we choose θ_occ = θ_oob = 10 000 based on empirical studies of the matching cost of ground truth scene flow vectors and make θ_penalty=10^6 large enough so that out-of-bounds motion is forced to be consistent with the prediction.

Because the algorithm is designed to process sequences sequentially, we can use the estimated scene flow of the previous time step to predict the visibility for all six images. To this end, we use the temporally propagated scene flow prediction as for the initialization. This propagation can be used to check which parts of the scene leave the image domain Ω for a specific view. These areas are marked as invisible in the associated out-of-bounds mask. It also allows to reason about occlusions by z-buffering, since we have full 3D information including depth. If multiple motions have the same target pixel in the target view, all but the closest are occluded. Examples of the visibility prediction are given in <ref>. For each of the five relevant frames, we show which pixel position of the reference frame can not be observed from the respective view. All pixels of the reference frame are visible by definition.

The impact of our multi-frame strategy combined with the explicit visibility reasoning will be shown in <ref> by comparing to the basic dual-frame *sff from <ref> <cit.>.



  
Consistency Check.
The next step of the pipeline is the consistency check to remove possible outliers. As before, we do so by computing a consistency scene flow field and compare corresponding scene flow vectors. 
Due to the changed setup to multiple frames from a stereo sequence, the way the consistency field is computed needs to be changed. We do not invert the temporal order of the images (cf. <ref>), but only change the view point. This leaves us with a left-right consistency check. Although a left-right check alone is less reliable than our previous consistency check, this has an important advantage. With inverted temporal order, scene flow correspondences according to the optical flow can not be established where the motion leaves the image boundaries. Thus, out-of-bounds regions are always filtered. This was no issue in the dual-frame approach, but using multi-frames we are able to match scene flow in these regions. With the left-right consistency check, we have the ability to maintain the correct correspondences in out-of-bounds regions. 
Matching for the consistency scene flow field is done exactly as before, using multiple scales, visibility reasoning, etc. Afterwards, each scene flow estimate of the reference frame is compared to its corresponding vector of the consistency field component-wise. If any error exceeds τ_c=1 pixel, the whole scene flow vector is removed. 
*sff did benefit from an additional consistency check for the disparity only to obtain more matches for geometry interpolation. We follow that idea and compare our dense multi-frame matches to a second independent disparity map computed with the algorithm from <cit.>. Afterwards, we take the union of the additional matches and the results of the previous consistency check. 
We did change the stereo algorithm from *sgm <cit.> to SPS <cit.> because it is faster, more accurate, and also able to match occluded and other invisible regions as our matching approach.
The remaining merged correspondences are very accurate and serve as input for the robust interpolation (cf. <ref>).




 §.§ Robust Interpolation
 
We apply the same sparsification as in *sff because sparse-to-dense interpolation works best if input matches are not too dense already  <cit.>. The sparsification works as an additional outlier filter and increases the spatial support for the same number of neighbors during interpolation.



The interpolation in our extension is robust against possible remaining outliers and edge-preserving to create sharp motion boundaries at object edges. As in the less robust approach, we split interpolation into interpolation of the 3D geometry, followed by interpolation of the 3D motion. Because of this separation, we can use different sets of input seeds for each. Other than SFF in <ref> <cit.> where the interpolation algorithm of <cit.> was transferred to the higher dimensional scene flow problem, we adopt the robust concepts of <cit.> for our scene flow problem. 

In short, we dissect the reference frame into superpixels of size 25. Each superpixel is associated with a local neighborhood of the 200 closest input matches as shown in <ref>. The distance is computed as a geodesic distance based on an edge map. Additionally, each superpixel is initialized with two scene flow models, one for the 3D geometry and one for the 3D motion. Afterwards, the models for each superpixel is adjusted by propagation and random search. Based on the final models, dense scene flow can be computed for each pixel.



  
Interpolation Models.
The geometric model is a slanted plane for each superpixel. It is initialized with a constant depth, parallel to the image plane. 
The motion model is a rigid transformation of 3D rotation and 3D translation for each superpixel. This rigid model is less universal, but more robust compared to our affine model in <ref>. We do not assume rigid motions, though. Our approach is not limited to rigid motions. Due to the small size of the superpixel segmentation, we can approximate non-rigid motions closely. Same holds for the planarity. Arbitrarily curved surfaces will be approximated by very small plane segments. The superpixel motion is initialized with translation only.
For initialization, three different strategies have been tried: 1.) The basic approach of <cit.> where the initial values are obtained from the the closest input seed. 2.) One where the local weighted medoid is used. 3.) One estimating the weighted geometric median. Though the multivariate estimators are much more accurate than the nearest neighbor method, the robust propagation with random search can compensate for less accurate initialization. Independent of the superpixel initialization, the final interpolation result was almost the same in all cases. We decided to use the robust geometric median in practice, since it provides a reasonable tradeoff between accuracy and run time.



  
Robust Model Estimation.
To optimize the models for interpolation (plane + rigid transformation), we apply a robust, stochastic approach in a RANSAC-like fashion.
For each superpixel, we randomly sample seeds from a local edge-aware neighborhood and use those to predict the models. Apart from random sampling, we use propagation to test estimated models at neighboring superpixels.
To determine the fitness of a model, a truncated error for all supporting input seeds 𝐬 of the local neighborhood 𝒩 gets summed

    C(M) = ∑_𝐬∈𝒩min(τ, exp(-1/α· D(𝐬) )·ϵ(𝐬) ).

In this formula, M is the respective model under test, τ is the truncation error threshold of 4 pixels, and ϵ(𝐬) is the re-projection error when applying model M to input seed 𝐬 which is weighted by a geodesic distance D between the seed 𝐬 and the position of the respective superpixel with weight coefficient α=0.6. By minimizing the cost of all models for all superpixels using propagation and random model generation, we obtain robust interpolation models for geometry and motion.
As before with multi-frame matching, our novel robust interpolation is compared directly to the previous interpolation method for scene flow matches of <ref> <cit.> in <ref>.





  
Universal Boundary Detector.
We will show that the boundary detector from <ref>, trained on semantic boundaries of KITTI, performs much better than the original detector <cit.> on that particular domain. However, improved robustness requires reliability across multiple domains. Thus, we train a third variant with the goal to perform equally well on several different data sets.
Towards this end, we use a joint set of training images from the 200 images of the original BSDS data set <cit.> and add semantic boundaries for 424 images of KITTI and for 100 images of Sintel. The semantics for KITTI are the same as before. For Sintel, we use the sequences cave_2 and sleeping_1 of the clean rendering pass that are excluded during evaluation. We create semantics by merging the provided mesh and material segmentation, e.g. all segments belonging to the dragon are labeled with the same ID. Examples of ground truth boundaries for each of the data sets are given in <ref>. By combining these three sets, we obtain a total of 724 images for training. The combined edge model is much more versatile and applicable to different data sets.
Examples of the detected edges are visualized in <ref>. Textures and shadows are suppressed, while at the same time, object boundaries are detected accurately.

For optional refinement of the dense 3D motion field, we use variational optimization of <ref> and the ego-motion model of <ref>. However, our improvements in matching and interpolation make both refinement steps obsolete as we will show in <ref>.




§ EXPERIMENTS AND RESULTS
 
A series of experiments was conducted to evaluate our scene flow algorithm. We start with an ablation study to show the impact of each individual step of our sparse-to-dense pipeline and the incremental improvements presented within this paper. It follows a more detailed comparison between the dual-frame approach (<ref>) and the robust multi-frame extension (<ref>). Afterwards, we will present results on the public KITTI scene flow benchmark and on the MPI Sintel dataset for comparison to state-of-the art.
Finally, we disclose the limitations of our approach.

For all our experiments, we keep the parameters of *sffpp fixed at the given values in the previous sections. For *sff, we use the parameters of the original approach <cit.> which are not identical for KITTI and Sintel. The other approaches in our comparison also use adjusted parameters for the Sintel data set.













 §.§ Ablation Study
 
The modularity of our method allows us to replace or leave out various parts of the pipeline. This way, it is easy to evaluate the effect of each component separately. We do so in <ref> by evaluating the results of all 200 training images of the KITTI data set <cit.> for several variants of our method. In particular, we vary the number of frames for the matching between dual and multi. We also alter the interpolation mechanism from the original one presented by <cit.> (epic3d) to the robust version presented within this work in <ref> (ric3d). Further, we evaluate the impact of the training data for the boundary detector. The original version was trained on BSDS <cit.> (bsds). <cit.> presented a specialized version optimized for the KITTI data set (kitti). Lastly, we present results for our universal boundary detector (cf. <ref>) trained on a mix of data from BSDS, KITTI, and Sintel <cit.> (mixed). Finally, we successively add the variational refinement (var) and the ego-motion optimization (ego) for different combinations of the components.

In conformity with previous experiments <cit.>, the dedicated KITTI boundary detector outperforms the original version that was trained on BSDS only. The universal boundary detector that was trained on mixed data performs almost equally well on KITTI and much better on other data sets like Sintel. Further, the novel more robust interpolation improves the accuracy of the scene flow result greatly, making the ego-motion model and even the variational refinement in almost all cases obsolete. Multi-frame matching improves the results even more. The impact of the multi-frame setup will be analyzed in <ref> in more detail.





 §.§ Evaluation of the Extensions
 
For visual comparison of our robust multi-frame approach *sffpp to *sff <cit.>, we show optical flow and disparity at the next time step along with a scene flow error map for full matching, filtered matches, and dense interpolation in <ref>. The error maps give correct estimates in green and outliers in blue to red according to the KITTI metric. Our novel multi-frame approach with explicit visibility reasoning is able to match occluded areas (e.g. next to the tree and traffic signs) and out-of-bounds regions (e.g. the front of the car) that are both not visible in some of the relevant frames (cf. <ref>). In addition, our robust interpolation can handle regions with almost no input seeds (e.g the lower left part of the image).
<ref> compares the same in terms of average end-point-error and average outliers on all KITTI training sequences for all ground truth pixels (KITTI occ data) and occluded regions only (occ without noc). 
Our novel method is already very accurate during matching with a much smaller average end-point-error compared to *sff. Unlike SFF, our multi-frame approach is able to match almost 40 % of the invisible areas. Though overall filtered results after the consistency check appear to be worse, our novel approach is able to retain 9.8 % of the matches in occluded areas where SFF filters almost everything. That makes the spatial distribution of our matches preferable to that of the dual-frame approach (cf. <ref>). Because of this and due to our robust interpolation, final results are much better with only about one third of scene flow outliers in occluded areas and less than half the percentage of overall outliers.

The direct comparison in these experiments shows that our novel multi-frame matching strategy with explicit visibility reasoning and robust interpolation is superior to the original *sff <cit.>. Even with the significant boost of the optional ego-motion model of <cit.>, our novel method without this model outperforms the dual-frame version on both evaluated data sets (see <ref>).



 §.§ KITTI Benchmark
 
We use the famous KITTI data set <cit.> for the first part of our comparison to state-of-the-art. Please note that this benchmark does not provide reference motions for vulnerable road users like pedestrians or cyclists. The only dynamic objects are rigidly moving vehicles.
Complete results for this benchmark are publicly available on the respective homepage. In <ref> we give the top methods of the leader board, where the average amount of outliers are compared for disparity at both time steps (D1, D2), optical flow (Fl), and scene flow (SF). Each category is further divided into regions of background (bg, static areas), foreground (fg, moving objects), and both (all, all available ground truth).
As assumed, our novel approach scores better than the dual-frame conference version <cit.>. Especially for the important foreground regions, our results are even comparable to the deep learning approach of <cit.> that uses semantic segmentation and to that of <cit.> that explicitly estimates a single rigid motion for complete independent objects. In addition, our method is at least three times faster than any better performing algorithm.

While investigating the discrepancy between our results on the validation data (<ref>) and on the test data (<ref>), we discovered that our multi-frame approach has difficulties in case the constant motion assumption is harshly violated (cf. <ref>). This can happen in KITTI due to the low frame rate of 10 frames per second and because of strong sudden pitch or roll rotations on bumpy streets, the last example in <ref>.
However, in most cases the assumption holds and produces robust and accurate results.

We compare the error maps for different frames of the KITTI test data for *prsm, OSF+TC, FSF+MS, SFF, and our novel method SFF++ in <ref>. Even for the partly occluded, badly illuminated vehicle in the second example, scene flow is estimated reliably. In this example also, scene flow at the occluded areas around the left traffic light is predicted correctly with sharp boundaries around the traffic sign. Within the third example, larger parts of the background exceed the error threshold slightly due to the violated constant motion assumption. However, dynamic objects are still detected more reliably than in most other approaches.





 §.§ MPI Sintel
 
The impact of our contributions has already been shown on a public benchmark in the previous section.
To additionally demonstrate the robustness and versatility, we evaluate *sff and our more robust multi-frame extension *sffpp on a second data set – MPI Sintel <cit.>. For our novel *sffpp, we use exactly the same set of parameters. We explicitly highlight this, since many methods rely on parameter tuning. Especially deep learning models often require fine tuning.
Sintel has a lot of contrary properties to KITTI. Most prominently, MPI Sintel consists of non-realistic, synthetically rendered images. Further, images are captured from a totally different domain and have therefore different characteristics. Sintel contains small as well as very large motion displacements of deformable, articulated characters. Thus, many of the included motions are non-rigid and the geometries are less often planar, compared to KITTI. This is also reflected in the results of this data set that are given in <ref>. OSF <cit.>, that is strongly relying on the piece-wise rigid plane model, performs considerably worse than on KITTI. Same is assumed for methods that rely on specialized deep neural networks, e.g. <cit.>.

For evaluation, we have used the final rendering pass of all training sequences except cave_2 and sleeping_1 as <cit.>. Since no full scene flow ground truth is available, we compute the average percentage of outliers for disparity and optical flow, similar to D1-all and Fl-all on KITTI.
*sffpp outperforms the less robust dual-frame version *sff <cit.>, again highlighting the improvements of our contribution. We even achieve the best accuracy for disparity with quite some margin to the next best method FSF <cit.> and the best performing method on KITTI, *prsm <cit.>. 
With that, our method joins the few methods with top performance on both data sets next to *prsm <cit.>, FSF+MS <cit.>, and SFF <cit.>.

<ref> shows exemplary results of our approach for one frame of the sequences alley_2 and ambush_5. The latter can be considered particularly challenging (cf. <ref>), though it is handled quite well by our approach. <ref> also demonstrates that a bit of accuracy is traded in for increased robustness. Small details, the arm of the girl, are lost during interpolation.




 §.§ Limitations
 
Despite all efforts, it is not possible to avoid any assumption to estimate scene flow due to the ill-posedness of the problem. However, we tried to keep the method as unrestricted as possible.
Our initial matching is purely data-based and requires no assumptions at all.
The later imposed regularization during interpolation makes use of the piece-wise rigid plane model but applies it to an extreme over-segmentation of the scene into tiny superpixels of 25 pixels to reduce the negative effects greatly.
Further, to make use of additional image information from multiple time steps, sffpp assumes a constant motion within a temporal window of three stereo frames.
With that, sffpp is subject to a set of (mostly theoretical) limitations that will be described here.

As discussed several times, sffpp keeps unaffected by the drawbacks of a piece-wise rigid, planar motion assumption even though this model is used during interpolation. The reason is the size of the superpixel segments. An impression of the size of the superpixels is give in <ref>. During all our experiments, we could not observe that our superpixels are the limiting factor in the estimation of non-planar surfaces or non-rigid motions. However in theory, not all kinds of objects and motions can be approximated by small superpixels.

Another hypothetical failure case arises from the complete separation of matching and regularization. If unregularized matching leads to the removal of entire image regions during the consistency check, the later imposed regularization of the interpolation can not recover the content of these regions. This phenomenon was regularly observed for the dual-frame approach when highly dynamic objects where leaving the image domain. At the same time, this case was one of the motivations for the shift to multiple frames. In the multi-frame scenario, it is much less likely that matching fails consistently for entire regions. This is also supported by the study of visible areas in <ref>.

Lastly, the constant motion assumption is the only assumption-based limitation that causes practical impact on the performance of sffpp.
For the KITTI data, we could notice degradation of the estimated scene flow due to the violation of this assumption. One of these examples is shown in the right column of <ref>. Anyway, this problem was encountered rarely, mostly in the presence of potholes or crossing rails that lead to an extreme sudden discontinuity of the motion.




§ CONCLUSION
 
*sff is the first approach that uses sparse-to-dense interpolation for scene flow estimation. The extension to multi-frame matching with visibility prediction of *sffpp produces accurate correspondences even for occluded parts of the scene. A consistency check removes outliers. Robustly estimated models for 3D geometry and motion on small superpixels are used as novel interpolation method to reconstruct a dense scene flow field.
Results on two diverse data sets that were computed with the exact same parameters have demonstrated the robustness for both, *sff and *sffpp. Our robust multi-frame approach achieves the seventh best position in the overall ranking on KITTI and is among the top performing methods on MPI Sintel, with the lowest amount of outliers for disparity estimation. In a joint score on both data sets, we claim to achieve the second best performance after *prsm <cit.>. Separate fine tuning on each data set is assumed to further increase the accuracy of our method. However, the focus in this work was on robustness across different domains.
To make our approach even more robust in the future, we suggest to use more than three frame pairs and most importantly evolve from our constant motion assumption to a higher order motion model.









spbasic      


   
















