TSTTC: A Large-Scale Dataset for Time-to-Contact Estimation in Driving Scenarios

## Abstract

Abstract Time-to-Contact (TTC) estimation is a critical task for assessing collision risk and is widely used in various driver assistance and autonomous driving systems. The past few decades have witnessed development of related theories and algorithms. The prevalent learning-based methods call for a large-scale TTC dataset in real-world scenarios. In this work, we present a large-scale object oriented TTC dataset in the driving scene for promoting the TTC estimation by a monocular camera. To collect valuable samples and make data with different TTC values relatively balanced, we go through thousands of hours of driving data and select over 200K sequences with a preset data distribution. To augment the quantity of small TTC cases, we also generate clips using the latest Neural rendering methods. Additionally, we provide several simple yet effective TTC estimation baselines and evaluate them extensively on the proposed dataset to demonstrate their effectiveness. The proposed dataset is publicly available at https://open-dataset.tusen.ai/TSTTC .

## 1 Introduction

In recent years, there has been a growing trend towards equipping vehicles with Advanced Driver Assistance System (ADAS), which consists of several subsystems such as Adaptive Cruise Control (ACC), Automated Emergency Braking (AEB) and Forward Collision Warning (FCW). ADAS aims to detect potential hazards as quickly as possible and alert the driver, or take corrective action to improve driving safety. AEB and FCW are critical features of ADAS that protect drivers and passengers and prevent traffic accidents. They both rely on the estimation of Time-to-Contact (TTC) which is defined as the time for an object to collide with the observer’s plane. Although TTC can be predicted using data from various sensors, such as LiDAR, radar or camera. Vision-based methods are particularly attractive due to their low-cost and have been a popular choice among ADAS designers and manufacturers. Even in high-level (L3+) autonomous driving system, direct TTC estimation could also serve as an redundant observation when other distance measuring sensors fail.

Figure: Figure 1: Example sequences and annotations from our dataset. The $\tau$ denotes the TTC ground-truth while the subscript denotes the frame index. We could observe that, the scale of the object increases as the TTC decreases.
Refer to caption: /html/2309.01539/assets/x1.png

Prior to the widespread adoption of deep learning, numerous vision-based theories and algorithms [, , , , ] for estimating TTC had been proposed. These algorithms are not data-driven, and usually rely on hand-crafted cues.
Recently, several deep learning based TTC estimation algorithms have emerged [, ] and demonstrate promising results in driving scenarios. The emergence of deep learning has brought more powerful tools to computer vision and also brought higher demands for large-scale datasets. However, due to the lack of large-scale TTC datasets that capture real-world driving scenarios, these methods have to pre-train their model on synthetic flow datasets [, , ].

In this paper, we primarily address the challenge of TTC estimation in highway scenarios. Compared to urban scenarios, high speed driving in highway exhibits longer braking distances, thereby necessitating a broader range of perception capabilities. In order to facilitate the development of vision-based TTC estimation algorithms, we propose a large-scale monocular TTC dataset in this paper, using a class 8 heavy truck as the data collection platform.
From raw data collected in urban and highway scenarios, we identify over 200K sequences covering a depth range of 400 meters. Each sequence contains six consecutive frames captured at a rate of 10Hz, with 2D, 3D bounding box and TTC ground-truth provided for a single object in each frame. Additionally, to address the limited availability of samples in rare scenarios, such as sudden braking (e.g. small TTC cases), we utilize Neural Radiance Fields (NeRF) [] to generate additional data. These artificially generated data can be seamlessly integrated into our dataset, thereby increasing the quantity and diversity of data available for training. Fig.[1](#S1.F1) illustrates two typical examples from our dataset: vehicles are gradually approaching in real scenes and NeRF scenes, respectively.
Besides the proposed dataset, we focus on object level TTC estimation rather than pixel level TTC estimation in []. Specifically, we provide a sequence of images for a certain object and ask for estimating the TTC value of it in the last frame. 2D Bounding boxes are available as optional inputs. Then we provide simple yet effective baselines based on the relationship between the scale ratio of objects in adjacent frames and TTC.
We reformulate the problem as choosing the scale with the highest similarity in adjacent frames.
Inspired by recent studies [, ], we further transform scale estimation from a regression problem into a set of binary classification tasks.
A series of quantitative experiments are conducted to demonstrate the effectiveness and feasibility of our proposed techniques.

Our main contribution can be summarized as follows:

- •
We propose a large-scale monocular TTC dataset for driving scenarios and will make it publicly available along with relevant toolkits to facilitate the development of TTC estimation algorithms for driving scenes.
- •
We propose two simple yet effective TTC estimation algorithms and extensively test them on the dataset to validate their effectiveness, which could serve as baseline methods for future study.

## 2 Related work

In this section, we will first introduce the concept of TTC briefly, and then review the related methods and datasets of the vision-based TTC estimation task.

#### Task and Methods.

In the scheme of monocular TTC estimation, TTC describes the time that an object will cross the camera plane under concurrent relative velocity. Denote the depth of an object in the camera coordinate as $y$, the time for the object under the current velocity to cross the camera plane could be calculated by:

$$ $\begin{array}[]{c}\tau=-y/\frac{dy}{dt}=-y/\dot{y},\end{array}$ (1) $$

where $\dot{y}$ is the relative velocity between the object and the camera. Though estimating either velocity or depth is an ill-posed problem, TTC can be estimated from images directly because it only depends on the ratio of them. And researchers have proposed various approaches to accomplish TTC estimation.

A viable approach is to utilize hand-crafted features such as closed contours, optical flow, brightness, or intensity from images [, , , , , , ]. Mobileye [] adopted geometric information of the vehicles in image to estimate TTC by establishing the relationship between TTC and the width of vehicle. In addition to geometric-based methods, several studies have been proposed to address the task of TTC estimation using photometric-based features, without relying on geometric features or high-level processing. For instance,  [] adopted accumulated sums of suitable products of image brightness derivatives from time varying images to determine the TTC value. Furthermore,  [] elucidates the relationship between TTC and the changes in intensity in images. However, these hand-crafted features need carefully tuned parameters or strong priors, such as constant brightness [] or static scene [], which restricts their practical applicability.

Besides to these hand-crafted methods, deep-learning approaches can also be employed for TTC estimation. One alternative approach is to use scene flow estimation methods [, , , , ] that predict both depth and velocity simultaneously, enabling the generation of pixel-level TTC estimation maps. However, these methods depend on accurate optical flow information, which can result in significant computational overhead. Recently, [] proposed Binary TTC that bypasses optical flow computation and directly computes TTC via estimating scale ratio between consecutive images. While these learning-based methods may produce more promising results, they require a larger amount of data with annotated scene flow ground-truth. Due to the expensive labeling cost, scene flow datasets are mostly obtained through synthesis, leading to a domain gap for real-world applications.

In addition to the aforementioned literature, single object tracking (SOT)  [, , , , ] can also infer the scale ratio between the template and the tracked object, serving as an alternative approach to estimating TTC. However, these methods often rely on large downsampling rates, which may lead to the bounding box estimation not accurate enough to meet the requirements of TTC estimation. The baseline method which utilized SOT models in our experiment validates the similar effect.

Contrary to previous TTC estimation studies, our proposed dataset facilitates the expansion of hand-craft features from solely relying on RGB images to utilizing the features extracted by neural networks. Moreover, we propose a method to address the problem of estimating the TTC by classifying the scale ratio. And we extend the implementation on RGB images to feature maps extracted using deep learning models, thereby significantly enhancing the accuracy of TTC estimation.

#### Datasets.

**Table 1: Comparison with several autonomous vehicle (AV) datasets. "2D-to-3D" indicates the presence of tightly bounded 2D box annotations with corresponding 3D bounding boxes, which is crucial for TTC estimation. And we report the average velocity of the recording platform in the training set for comparison.**
|  | KITTI | NuScenes | Waymo | Ours |
| --- | --- | --- | --- | --- |
| Scenes | Urban | Urban | Urban | Urban+Highway |
| Frequency ($hz$) | 10 | 2 | 10 | 10 |
| Range ($m$) | [0,125] | [-80,80] | [-75,75] | [-160,400] |
| 2D-to-3D | ✔ | ✖ | ✖ | ✔ |
| Avg Speed ($m/s$) | - | 5.1 | 6.9 | 19.1 |
| Ann. Frames | 15K | 40K | 200K | 1M |
| Boxes | 200K | 1.4M | 12M | 1M |

For TTC estimation, several datasets collected in real scenes are available. For example, [] proposed a multi-person tracking dataset with stereo depth details, and  [] presented a large-scale dataset for TTC estimation in indoor scenes. However, these datasets mainly focus on low speed scenarios and are not suitable for direct application to TTC estimation in driving scenarios. In addition to datasets specifically designed for TTC estimation, some datasets have been synthesized for scene flow tasks and can provide detailed depth information, which are suitable for TTC estimation. For example, KITTI scene flow [] proposed an outdoor scene flow dataset containing 400 dynamic scenes collected from KITTI []. These scenes are annotated using 3D CAD models for vehicles in motion and manually mask non-rigid moving objects. The Driving [] dataset proposed a synthetic stereo video dataset rendering in realistic style. However, these datasets are constrained by synthetic and limited scenes, which result in domain gaps with real scenes.
Except to the scene flow datasets, some RGBD datasets [, , ], equipped with comprehensive depth annotations, can be utilized to train depth estimation models, which in turn can be used for TTC estimation. However, the majority depth annotations in these datasets are typically confined to a relatively small range (less than 50 meters) and the number of scenes available is limited. In addition to the aforementioned datasets, several large-scale datasets proposed for autonomous driving, such as [, , , ], offering comprehensive annotations like 3D LiDAR bounding boxes that can be used to generate TTC ground-truth. Nevertheless, these datasets were not specifically tailored for TTC estimation and presented issues like unbalanced TTC distribution. Furthermore, these datasets were mainly collected from urban areas, lacking data for highway scenarios where the estimation of TTC is particularly important. Please refer to Table [1](#S2.T1) for a comparison of various datasets.

Compared to the aforementioned datasets, our proposed dataset holds the distinct advantage of being large-scale and recorded in real scenarios, encompassing both urban and highway scenes.

## 3 Discussion

A common question related to TTC is that is TTC only applicable for low level assistant driving system? Why do we need TTC when we have distance and velocity measurement in advanced assistant or autonomous driving system?

We argue that there are two main reasons for the essence of TTC: First, among all the three physical properties of one object (distance, velocity and time to contact), TTC is the only direct observation from monocular image. Monocular depth estimations are mostly from fully data-driven aspect, which highly relies on the recognition of the objects and scenes, which suffers from out of domain issue seriously []. For velocity, the situation is similar to that of depth estimation. However, TTC estimation does not require the recognition of semantic of objects (can even be achieved by pixel photometric loss), thus has better generalization in corner cases. Second, for a high level autonomous driving system, redundancy design is indispensable. Even though we have distance and velocity observation, TTC can also be fused into these observations in subsequent perception fusion modules, which serves as another independent safety guarantee.

## 4 TTC Dataset

Figure: Figure 2: Preset data distribution in real scenes for different TTC ranges.
Refer to caption: /html/2309.01539/assets/x2.png

In this section, we will present the details of our TTC Dataset in the aspect of data collection, ground-truth annotation, and dataset statistics. Then, we will claim the definition of the TTC estimation task in terms of our proposed dataset.

### 4.1 Data Collection

The dataset consists of two parts, including a majority of data from real scenes and a minority of data from NeRF virtual rendering.
After obtaining raw sensor data, we consider a sequence that contains a number of consecutive frames of a vehicle as a sample.
To gather valuable data, we discard truncated objects within the camera plane and filter out 2D boxes smaller than 15 $\times$ 15 pixels.

#### Real Scenes.

For real-world scenarios, raw data was collected by our commercial trucks.

We capture image data using three frontal and two backwards cameras with same $1024\times 576$ resolution. We adopt 2D object detection and tracking algorithms on the images to obtain 2D bounding boxes and corresponding track ID for other vehicles. And the LiDAR and Radar data are adopted to generate accurate depth and velocity of them. The sampling rate is 10Hz. Detailed sensor specification can be found in the supplementary material.

After applying these rules to filter the raw data, we observe that the resulting data distribution is highly imbalanced across different TTC ranges. For example, vehicles with small TTC are extremely rare in driving scenes, especially for vehicles lie in the same lanes as ego vehicle. However these are the cases which FCW and AEB should focus on. In such conditions, data collection without rebalancing may result in lack of these valuable scenarios. To overcome this challenge, we pre-define a data distribution and sample the data accordingly. The data are divided into various conditions based on TTC range, as illustrated in Fig. [2](#S4.F2).

#### NeRF Scenes.

Despite thorough data collection efforts, we discover samples with small TTC values within the same lane are still extremely scarce, which is a crucial scenario in automated driving and ADAS. To supplement the absence of data in particular conditions, we adopt an internal undisclosed project which is developed based on Instant-NGP [] to render novel scenes.
Briefly speaking, the background models and object models are firstly extracted and trained separately. And then we can form a new scene and render them together.
Given a specific object, we pre-define some scripts in which the TTC of the object is distributed between 0 and 6.
The preset script can be found in our supplementary material. After obtaining NeRF rendered images, we organize them with the same format as real scenes data, which serves as an optional component within the training set.

### 4.2 Annotation

In each sequence, we provide the TTC ground-truth for every frame as the annotation. In the following, we will describe how we generate the TTC annotation.

Given a frame, we first run 2D detection on the image and 3D detection on LiDAR. The long range LiDAR detection algorithm which reliably covers [-160, 400] meter range. Then, we could obtain its corresponding 2D detection box by projecting the 3D box to the image plane then picking the 2D detection box which has highest IoU between the projected box. In the vehicle coordinate system, one corner of the 3D bounding box could be denoted as $x_{j},y_{j},z_{j}$ where $j\in\{1,2,...,8\}$ is the corner index. Here, we take the y-coordinate of the corner point which is the closest to ego as the depth of this object:

$$ $\begin{array}[]{c}j^{*}=\underset{j\in\{1,2,...,8\}}{\arg\min}(\sqrt{(x_{j}^{i}-0)^{2}+(y_{j}^{i}-0)^{2}+(z_{j}^{i}-0)^{2}}),y^{i}=y^{i}_{j^{*}},\end{array}$ (2) $$

where $y^{i}$ is the depth of the vehicle in $i$-th frame. Here, we assume the relative velocity between the vehicle and ego is constant in a short time interval (e.g. $q$ frames) to acquire a stable estimation of the velocity. Given the depth of the vehicle in the past $q$ frames, we fit the depth to obtain the relative velocity $v^{i}$ by RANSAC [] algorithm. We set the value of $q$ to 10 by default. It is worth noting that the velocity is acquired prior to sequence splitting, thereby $q$ may be greater than the sequence length. After obtaining the depth and relative velocity of current frame, the TTC ground-truth could be obtained by the following:

$$ $\begin{array}[]{c}\tau^{i}=y^{i}/v^{i},\end{array}$ (3) $$

Since the camera planes are almost parallel to the XZ plane in the vehicle coordinate and the origins of these coordinate systems are highly aligned, we regard the TTC value calculated in the vehicle coordinate system as the TTC ground-truth for camera planes. The annotation process is illustrated in Fig [3](#S4.F3).

One may challenge that using past $10$ frames to fit the velocity may result in latency in velocity estimation especially for sudden break. To remedy this issue, we first generate TTC ground-truth with different $q$ (e.g. 3, 5 and 10) and consider the vehicle with varied TTC values as an accelerating or decelerating object. For object with varied TTC values, we select the one closest to the TTC computed by the velocity of radar sensor as the ground truth. Note that we do not directly utilize radar sensors for all objects since they could not cover too distant objects. The data annotations in validation and test sets are manually checked by our annotation team to ensure the quality of data.

Table: Figure 3: Relative position between ego vehicle and an object in bird-eye-view. Only three frames are plotted for brevity.

### 4.3 Dataset Statistics

We construct the dataset following the pre-defined rules and annotation pipeline, resulting in 206K sequences comprising over 1M frames from real scenes, as well as 1K sequences from 6.0K NeRF rendered images. We split the sequences from the real scenes based on their recorded date to training, validation and test sets, yielding 149.1K, 28.8K, and 28.6K sequences respectively. For better understanding the data distribution, we plot the histogram of the TTC ground-truth and depth in the training set in Fig. [4](#S4.F4). The distribution in validation and test set is similar. Note that the far away samples are rare because we set a minimum 2D bounding box size.

### 4.4 Task Definition

As the tracklet of a vehicle is collected in the format of fixed length sequences, we formulate the TTC estimation task in sequence level. For a sequence of a specific vehicle, we provide six consecutive frames and their corresponding 2D bounding boxes as input. The last frame in the sequence is considered as the target frame while the rest of the frames serve as references. With all frames and boxes available in the sequence, the objective is to predict the TTC value of the object in the target frame or equivalently relative scale ratio between the target box and the referenced one.

## 5 Metrics & Method

In this section, we first review the relationship between TTC estimation and scale ratio briefly. Then, we explicate the evaluation metrics for our TTC estimation task. Subsequently, we introduce our approach, which comprises two variants: the pixel MSE approach and its deep learning counterpart.

### 5.1 Estimate TTC via Scale Ratio

As shown in Sec. [4](#S4), TTC could be obtained by depth and its rate of change. However, estimating the depth and relative velocity of an object directly with only a monocular camera is very challenging. To address this issue, researchers proposed to estimate the TTC of frontal-parallel, planar non-deformable objects according to the change of object scales. As described in [], we can obtain the image size of a frontal-parallel, non-deformable object of size $S$ at distance $y$ as:

$$ $\begin{array}[]{c}s=fS/y,\end{array}$ (4) $$

where $f$ is the focal length of the camera. For an object without rotation, TTC can be formulated as a function of object size in image space by combining Eq. ([1](#S2.E1)) and  ([4](#S5.E4)):

$$ $\displaystyle\tau=\frac{t_{1}-t_{0}}{1-\frac{s(t_{0})}{s(t_{1})}}=\frac{t_{1}-t_{0}}{1-\alpha},$ (5) $$

where $s(t_{0})$ and $s(t_{1})$ are the sizes of image of an object in frame $t_{0}$ and $t_{1}$ correspondingly. Thus, the estimation of TTC can be simplified as a scale ratio estimation problem which can be done with only observations in image space. With the development of deep learning, modern object detectors or tackers could produce relatively accurate 2D bounding boxes for vehicles. Given the detection or tracking bounding box in consecutive frames of a vehicle, one intuitive idea is that we can use the ratio of the box or mask area to accomplish the scale ratio estimation. However, are these bounding boxes accurate enough for the TTC estimation task and does there exist more accurate scale ratio estimation algorithms under such conditions? We try to answer these questions via experimental validation on the proposed dataset.

### 5.2 Evaluation Metrics

Before introducing the detailed design, we need to design the metrics for evaluation. Here, we adopt Motion-in-Depth (MiD) error and Relative TTC Error (RTE) as performance indicators, which could be denoted as:

$$ MiD $\displaystyle=||\log(\alpha)-\log(\hat{\alpha})||_{1}\times 10^{4},$ (6) RTE $\displaystyle=||\frac{\tau-\hat{\tau}}{\tau}||_{1}\times 100\%,$ $$

where $\alpha$ and $\hat{\alpha}$ mean the ground-truth and predicted scale ratios while the $\hat{\tau}$ denotes predicted TTC value. The scale ratio ground-truth $\alpha$ is obtained by Eq. ([5](#S5.E5)). MiD is utilized in previous works [, ] to describe the TTC error indirectly from the perspective of scale ratio. Due to the instability of TTC at larger values, we prioritize the MiD as the primary metric.

With the purpose of revealing more information from the evaluation metrics, we partition several TTC intervals, namely crucial(c) / small(s) / large(l) / negative(n)(^1^11Negative TTC indicates away from the observer.), which correspond to TTC values of 0$\sim$3, 3$\sim$6, 6$\sim$20, and -20$\sim$0, respectively. We mark them on the indices of the RTE and MiD. The threshold for crucial cases is determined by rounding the typical TTC threshold of 2.7 seconds used in FCW systems [, ].
This division allows a more detailed analysis of the performance for the TTC estimation algorithms in different TTC intervals, providing a better understanding of their limitations and strengths. During the prediction process, any TTC values that exceed the predefined range will be truncated to the boundary value.

### 5.3 Our Design

Figure: Figure 5: Framework of our proposed methods. After aligning the size between contents in $\mathbf{b}_{1}$ and $\mathcal{B}$, an operator $\bigotimes$ is applied to measure their similarity. For simplicity, we only illustrate three different scale rates of $\mathcal{B}$. Some operations such as center shift are omitted for brevity.
Refer to caption: /html/2309.01539/assets/x4.png

#### Formulation.

We denote the 2D bounding box as $\mathbf{b}=[x,y,w,h]$ where $x,y$ represent the center coordinate and $w,h$ denote the width and height. Given a reference frame $\mathbf{F}_{0}$ and a target frame $\mathbf{F}_{1}$, $\mathbf{b}_{0}=[x_{0},y_{0},w_{0},h_{0}]$ and $\mathbf{b}_{1}=[x_{1},y_{1},w_{1},h_{1}]$ are bounding boxes of a specific object in these two frames. The core idea of our methods is to estimate the relative scale ratio of this vehicle between the reference frame and the target frame. A straightforward approach is simply adopting the scale ratio between $\mathbf{b}_{0}$ and $\mathbf{b}_{1}$ as the result. However, this strategy is largely influenced by the precision of detection algorithms. In our methods, we estimate the scale ratio change in these two frames in pixel space or feature space, yielding two kinds of implementation: Pixel MSE and Deep Scale. For the reference frame, we enumerate $n$ different scale ratios to obtain a series of scaled boxes $\mathcal{B}=[\mathbf{b}_{0}^{\alpha_{1}},\mathbf{b}_{0}^{\alpha_{2}},...,\mathbf{b}_{0}^{\alpha_{i}},...,\mathbf{b}_{0}^{\alpha_{n}}]$ where $\mathbf{b}_{0}^{\alpha_{i}}=[x_{0},y_{0},\alpha_{i}w_{1},\alpha_{i}h_{1}]$. Then, we crop $\mathbf{F}_{0}$ via $\mathcal{B}$ and resize them to a target size of $W,H$, which could be denoted as $\mathcal{G}(\mathbf{F}_{0},\mathbf{b}_{0}^{\alpha_{i}})$ for the $i$-th scale ratio, where $\mathcal{G}(\mathbf{F},\mathbf{b})$ denotes the crop $\mathbf{b}$ on $\mathbf{F}$ and resize it. Similarly, we could get $\mathcal{G}(\mathbf{F}_{1},{\mathbf{b}_{1}})$ for the target frame. Finally, we use an operator to measure the similarity between $\mathcal{G}(\mathbf{F}_{0},{\mathbf{b}_{0}^{\alpha_{i}}})$ and $\mathcal{G}(\mathbf{F}_{1},{\mathbf{b}_{1}})$, yielding $n$ similarity scores.

With five frames free to reference, taking different frames as the reference will produce different scale ratios. To address this issue, we convert scale ratio to corresponding TTC value via Eq. ([5](#S5.E5)) and convert it to the scale ratio under the setting of 10Hz when computing MiD error. We list the relationship between different scale ratios of same $\tau$ in the supplementary materials.

#### Pixel MSE.

We can measure the similarity between $\mathcal{G}(\mathbf{F}_{0},{\mathbf{b}_{0}^{\alpha_{i}}})$ and $\mathcal{G}(\mathbf{F}_{1},{\mathbf{b}_{1}})$ in image space with Mean Squared Error (MSE). The weighted sum of the top $k$ similar scale ratios is adopted as the final estimation and the weight is normalized by the reciprocal of MSE. The top of Fig. [5](#S5.F5) illustrates the pipeline of Pixel MSE.

#### Deep Scale.

For the deep version, we first input two images into a backbone network for feature extraction. Afterwards, the grid sampling operation is used to align the features of different box sizes into one fixed size. Then, we calculate the similarity of each position in the two feature maps via cosine similarity, yielding a similarity map $\mathbf{S}_{i}$. Afterwards, the similarity score of scale $\alpha_{i}$ is obtained by adopting a Global Average Pooling (GAP) operation to $\mathbf{S}_{i}$. Then we concatenate the similarity scores of different scale ratios and use a Fully-Connected (FC) layer to obtain the final prediction. During training, binary cross-entropy (BCE) loss is used and we adopt the strategy proposed in [, ] to convert the scale ratio ground-truth to a size $n$ vector as soft label.

Similar to Pixel MSE, we apply a top $k$ weighted sum operation to get the final results and the weight is defined as the sigmoid of the FC output. For fast inference, we adopt a convolutional layer followed by a stage of modified CSPNet [] used in [] as our backbone. After obtaining backbone features, we fed them into one transposed convolutional layer and two convolutional layers before similarity measurement. To capture subtle details, all the stride in the network is set to 1 except the first and the transposed convoultional layer which are set to 2 yielding a feature map with the same size of input. The framework is illustrated at the bottom of Fig. [5](#S5.F5).

#### Center Shift.

The boxes predicted by the object detection model may be inaccurate, which will bring misalignment between the centers of reference and target boxes. To address this problem, we introduce a center shift operation. Specifically, we enumerate an offset of $[-c,c]$ along height and width direction, respectively, which yields a total of $(2c+1)\times(2c+1)$ candidates. After obtaining $(2c+1)\times(2c+1)$ similarity scores for a single scale, we adopt the highest score as the final score for both Pixel MSE and Deep Scale. Our experiments show that this operation will bring significant improvement in terms of MiD and RTE with little time cost.

## 6 Experimental Validation

In this section, we first describe the implementation details of our proposed methods and report the results on the proposed dataset. Extensive ablation experiments could be found in the supplementary material.

### 6.1 Implementation Details

#### Pixel MSE.

For Pixel MSE, we validate its performance on validation, and test set. The target size $W,H$ after interpolation is set to the size of $\mathbf{b}_{1}$.

The scale ratio is set to the range of $[0.65,1.5]$ to cover samples with different scale ratios in the training set. The number of scale bins $n$ is 125, the top $k$ for the weighted sum and the $c$ for center shift are 3. Besides, the detection boxes are manually expanded with a maximum ratio of 1.1 (if the expanded boxes do not exceed the image boundary) to reduce the influence of inaccurate detection results.

#### Deep Scale.

In terms of Deep Scale, we train it for 36 epochs on the train/train$+$val set dataset for evaluation on val/test respectively with a batch size of 16 on one GPU using SGD []. The image is resized to $1024\times 576$ for both training and test phases. We adopt random color augmentation on HSV space as data augmentation during training. The weight decay and SGD momentum parameters are set to 0.0005 and 0.9, respectively. We start from a learning rate of $10^{-4}\times$ BatchSize and adopt cosine learning rate schedule. The target size is set to $50\times 50$ for grid sample as larger size does not bring more benefits. The input channel for the backbone is set to 12, while the channel for the three followed convolutional layers is set to 24. The kernel size of the convolutional layers is 7 while the transposed one is 3. For the scale range and box expansion, we keep them the same as Pixel MSE. Besides, the number of scale bins $n$, the top $k$ for the weighted sum and the $c$ for center shift are set to 20, 4 and 1 respectively. We test the latency of all models with FP16 and batch size of 1 on a 3090 GPU.

**Table 3: Main results of different methods. The ${\dagger}$ means the result is obtained under padding NeRF data setting. The $\%$ after RTE is omitted.**
| Methods | Validation Set |  |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| MiD | MiDc | MiDs | MiDl | MiDn | RTE | RTEc | RTEs | RTEl | RTEn |  |
| Detection | 213.9 | 675.4 | 305.1 | 112.4 | 115.3 | 54.2 | 58.1 | 56.3 | 55.0 | 50.2 |
| SOT [] | 200.8 | 641.1 | 261.1 | 77.4 | 158.8 | 52.8 | 57.1 | 50.9 | 48.1 | 58.4 |
| Pixel MSE | 41.0 | 57.4 | 36.5 | 32.5 | 48.4 | 29.9 | 11.3 | 13.0 | 31.0 | 44.3 |
| Deep Scale | 14.4 | 27.1 | 16.4 | 10.9 | 13.5 | 12.1 | 6.3 | 8.7 | 13.0 | 14.8 |
| Deep Scale^† | 14.3 | 26.5 | 15.2 | 10.8 | 13.5 | 12.0 | 6.2 | 8.4 | 12.9 | 14.6 |
|  | Test Set |  |  |  |  |  |  |  |  |  |
| Detection | 214.5 | 682.0 | 305.0 | 112.1 | 114.1 | 54. 0 | 58.2 | 56.0 | 55.2 | 49.6 |
| SOT [] | 197.6 | 636.4 | 258.5 | 72.1 | 157.0 | 52.0 | 57.6 | 51.1 | 46.8 | 57.7 |
| Pixel MSE | 40.5 | 54.5 | 34.3 | 32.2 | 49.6 | 28.7 | 10.9 | 13.6 | 29.2 | 42.6 |
| Deep Scale | 14.8 | 27.6 | 15.6 | 11.5 | 13.7 | 12.3 | 6.5 | 8.8 | 13.1 | 15.0 |
| Deep Scale ^† | 14.9 | 27.7 | 15.6 | 11.5 | 13.8 | 12.4 | 6.5 | 8.7 | 13.3 | 15.3 |

Besides the aforementioned methods, we further propose two baselines termed as Detection and SOT in Table [3](#S6.T3).
For Detection, the scale ratio is obtained by simply computing the ratio between the area of the target box and the reference box. As for SOT, given a target box, we adopt a state-of-the-art (SOTA) SOT tracker [] to obtain a reference box and then estimate the scale ratio as the same as in Detection.

Although there are other methods available, such as [, ], the models released by the authors achieve poor results in our dataset due to the domain gap, and no training codes are provided.

Figure: Figure 6: Case study for our Pixel MSE and Deep Scale, best viewed in color. For the last column, box with green, red and blue color denote the scaled box obtained by GT, Pixel MSE and Deep Scale.
Refer to caption: /html/2309.01539/assets/x5.png

As shown in Table [3](#S6.T3), RTE predicted by the boxes detection or tracking method is near 50$\%$, which obviously cannot satisfy the needs of practical use. In contrast, our Pixel MSE shows a much lower MiD error which indicates a more accurate scale ratio estimation. As a consequence, the RTE is also much lower. Furthermore, the Deep Scale achieves 16.7 MiD and 13.1$\%$ RTE on the test set, outperforming other methods by a large margin.

### 6.2 Main Results

Estimating the scale ratio in feature space is much more robust than in image space. We illustrate several cases in Fig. [6](#S6.F6) for intuitive understanding. In the last column, we draw the scaled target box in the reference frame which is obtained by utilizing the center of the reference box and the scale ratio obtained from various methods and ground truth.
From the first and second cases, we can observe that the Deep Scale is more robust to the illumination changes and inaccurate detection boxes compared to Pixel MSE. In the last row, we showcase a failure case caused by a severely inaccurate detection box. As described before, our methods are sensitive to the alignment between the box center of the target and reference frame, which is also a limitation of our methods. These cases also reveal the key difference between TTC estimation and tracking task: *TTC estimation requires far more accurate estimation than tracking, while tracking usually focuses on complicated appearance change.*

## 7 Limitations

Our work is a large-scale benchmark for Time-To-Contact estimation, but there are still some limitations that need to be addressed in future works.
In regard to our dataset, the collected data primarily focuses on trucks and cars in highway and urban scenarios, lacking more diverse categories that are commonly found in autonomous driving datasets, such as cyclists and pedestrians. Besides, we have to acknowledge that due to the inherent differences in distribution between our dataset and real-world scenarios, there may be potential challenges when directly applying the model trained on our dataset to real-world contexts.

Furthermore, the baseline methods proposed in this study operate under the assumption that objects exhibit frontal-parallel characteristics and are non-deformable. However, it is essential to acknowledge that real-world conditions are considerably more intricate, and these methods may yield suboptimal performance when the underlying assumption is not met. Additionally, as we mentioned earlier, our methods are sensitive to the alignment between the box center of the target and reference frame, which poses another limitation.

## 8 Conclusion

In this work, we built a large-scale TTC dataset and provided a simple yet effective TTC estimation algorithm as baselines for the community. Our dataset is characterized by its focus on objects in driving scenes, which contains both urban and highway scenarios and covers a wider range of depth. We hope that our proposed dataset could facilitate the development of TTC estimation algorithms.

## Appendix

## Appendix A The TSTTC Dataset

The data, annotation, document, and API are publicly available. Please download the document we uploaded to openreview for detailed information. We take full responsibility for any rights violations and ensure compliance with the data license.

#### License

Our dataset is published under CC BY-NC-SA license and only non-commercial research usage is allowed.

#### Dataset Maintenance

We will release a website and maintain it for a long time. Besides, we will also check its accessibility regularly and response for following modification. We also plan to update the dataset with more challenging samples.

#### Privacy

In order to protect the privacy of the vehicles and humans appeared in our dataset, we detect license plates and human faces and then apply a Gaussian blur to detected boxes. Besides, we conducted experiments to show the impact of the plate blur operation, which could be found in Sec. [E](#A5).

Figure: Figure 7: Sensor layout and coordinate system. The coordinate system of radars and Lidars are omitted for brevity. And GNSS means the Global Navigation Satellite System.
Refer to caption: /html/2309.01539/assets/x6.png

## Appendix B Sensor Specification

In our research, we conducted a comprehensive data collection process utilizing five cameras with varying focal lengths, five radar sensors, and three Lidar sensors. The spatial arrangement of these sensors is visually depicted in Fig. [7](#A1.F7). Furthermore, we provide detailed specifications of the cameras in Tab. [4](#A2.T4).

**Table 4: Camera specification. all images captured by the cameras are subjected to downsampling and cropping, resulting in a size of 1024x576 pixels. The camera’s horizontal field of view (HFOV) refers to the angular range covered by the camera along the y-axis in the x-y plane of the camera sensor frame.**
| Camera | 1 | 3 | 4 | 8 | 9 |
| --- | --- | --- | --- | --- | --- |
| HFOV | $\pm 63.2^{\circ}$ | $\pm 40.4^{\circ}$ | $\pm 18.4^{\circ}$ | $\pm 63.2^{\circ}$ | $\pm 63.2^{\circ}$ |

## Appendix C Annotation

To ensure label accuracy, our annotation team meticulously reviews and adjusts the 3D detection boxes in the validation and test sets. For the training set, we randomly selected 1,000 sequences and annotated the corresponding 3D bounding boxes. Subsequently, we employed RANSAC to fit the manually annotated 3D bounding boxes, generating a set of TTC values. By comparing these TTC values obtained from our annotation pipeline with those from human annotation, we achieved a MiD of 6, indicating a minimal scale error of only 0.0006 between our annotation pipeline and human annotation.

## Appendix D More explanation on MiD computing

In the Sec 4.3 of our paper, we first convert the predicted scale ratio under different FPS settings to corresponding TTC value and then convert the TTC value to the scale ratio under the setting of 10Hz. Actually, the scale ratios computed under different FPS settings could convert to each other. Since the TTC ground-truth for the target frame is specific, we could get the relationship between the scale ratios (e.g. $\alpha_{m},\alpha_{n}$) under different FPS settings (e.g. $FPS_{m},FPS_{n}$) by Eq.(5) in our paper:

$$ $\alpha_{m}=\frac{1}{\frac{FPS_{n}}{FPS_{m}}(1/\alpha_{n}-1)+1}.$ (7) $$

In practice, the scale ratios obtained under different FPS settings are converted to the 10Hz setting via Eq ([7](#A4.E7)) directly.

## Appendix E Ablation Study

To validate the contribution of different components and hyper-parameters, we perform extensive experiments and report the results on the validation set unless otherwise specified. Default hyper-parameters are denoted in bold.

#### Number of Scale Bin.

To probe the suitable scale bins for our Pixel MSE, we conduct ablation experiments, as shown in Table [6](#A5.T6). The performance continues to boost until scale bin number reaches 125 and then becomes stable. Thus, we take the 125 bins as the default setting. To determine the optimal scale bin number $n$ for Deep Scale, we vary the value of $n$ from 10 to 30. As shown in Table [6](#A5.T6), the MiD and RTE continuously decrease until $n=20$, after which they tend to be stable. However, an increase in scale bins results in a larger computation cost. As a consequence, we set $n$ to 20 by default.

**Table 5: Influence of scale bins $n$ in Pixel MSE**
| $n$ | 50 | 75 | 100 | 125 | 150 |
| --- | --- | --- | --- | --- | --- |
| MiD | 42.5 | 41.8 | 41.3 | 41.0 | 41.0 |
| RTE($\%$) | 31.9 | 31.9 | 30.8 | 29.9 | 30.0 |
| Time(ms) | 10.0 | 13.6 | 15.5 | 18.5 | 21.2 |

#### Number of Frame Gap.

In this experiment, we validate the influence of frame gap for both Pixel MSE and Deep Scale. The minimum and maximum scale ratio for different frame gaps are adjusted according to Eq. ([7](#A4.E7)). For the Deep Scale, we train our model in different frame gaps. As for testing, we maintain the frame gap consistent with the training settings to ensure optimal results. We list detailed results in Table [7](#A5.T7). Larger frame gap brings more obvious scale changes and thus benefits the classification process. As a result, we set the default frame gap to 5.

**Table 7: Ablation on the frame gap for Pixel MSE and Deep Scale.**
|  | Gap | 1 | 2 | 3 | 4 | 5 |
| --- | --- | --- | --- | --- | --- | --- |
| PixelMSE | MiD | 102.1 | 61.2 | 46.4 | 41.2 | 41.0 |
| RTE($\%$) | 95.7 | 59.0 | 42.8 | 35.1 | 29.9 |  |
| DeepScale | MiD | 31.5 | 22.7 | 18.1 | 15.8 | 14.4 |
| RTE($\%$) | 29.5 | 20.1 | 15.9 | 13.5 | 12.1 |  |

#### Center Shift.

In this experiment, we present a comparison between the results obtained with and without center shift operation. We list the results for both pixel MSE and Deep scale, as shown in Table [9](#A5.T9). The center shift operation is effective in reducing the estimation error.

**Table 8: Ablation on the center shift operation for Pixel MSE and Deep Scale**
|  | Pixel MSE | Deep Scale |  |  |
| --- | --- | --- | --- | --- |
| w/ S | w/o S | w/ S | w/o S |  |
| MiD | 41.0 | 73.3 | 14.4 | 17.2 |
| RTE($\%$) | 29.9 | 37.6 | 12.1 | 14.6 |
| Time(ms) | 18.5 | 17.4 | 12.0 | 10.8 |

#### NeRF Augmentation.

To investigate the impact of supplementing NeRF data on the training process for the Deep Scale, we conducted ablation experiments by adding different numbers of NeRF sequences. The added NeRF sequences were randomly selected from the NeRF data we rendered. To avoid the potential impact of data randomness on the experimental results, we report the average results of five runs with different random seeds in Table [9](#A5.T9). The results show that padding NeRF sequences can effectively reduce the MiD error in crucial scenes. However, too many NeRF sequences lead to a slight decrease in overall performance. Therefore, we use 5K rendered NeRF sequences in our experiments.

#### On Plate Blur.

To verify whether the plate blur will influence the scale ratio estimation, we conduct ablation experiments. We test the MiD and RTE on the validation, and test set in w/ and w/o blur settings for the Pixel MSE. For the Deep Scale, we train the model on the blurred train/train+val set and report the result of val/test set in w/ and w/o blur settings. As shown in Table [10](#A5.T10), for both methods, the plate blur operation brings negligible differences. As a conclusion, we take the dataset with blurred license plates as the release version.

**Table 10: Ablation on plate blur for our methods**
|  | Pixel MSE | Deep Scale |  |  |  |
| --- | --- | --- | --- | --- | --- |
| w/ blur | w/o blur | w/ blur | w/o blur |  |  |
| Val | MiD | 41.0 | 41.0 | 14.4 | 14.4 |
| RTE(%) | 29.9 | 30.0 | 12.1 | 12.1 |  |
| Test | MiD | 40.3 | 40.3 | 14.8 | 14.8 |
| RTE(%) | 28.7 | 28.7 | 12.3 | 12.3 |  |

#### On Target Size.

In this experiment, we ablate the target size $W,H$ for grid sample in Deep Scale and we keep $W=H$ when conducting ablation for convenience. Table [12](#A5.T12) lists the result for different settings and we can observe that the performance continuously to boost until 50 and then becomes stable. As a consequence, we set the default target size to 50.

**Table 11: Influence of the target size for grid sampling.**
| Size | 10 | 25 | 50 | 75 | 100 |
| --- | --- | --- | --- | --- | --- |
| MiD | 20.0 | 14.9 | 14.4 | 14.8 | 14.9 |
| RTE($\%$) | 16.3 | 12.4 | 12.1 | 12.3 | 12.7 |

#### On Kernel Size.

Without large downsampling rate in our Deep Scale, the receptive field is mainly decided by the kernel size of the convolutional layers. To find the optimal kernel size, we train our model with the kernel size ranging from 1 to 9 and report the results in Table [12](#A5.T12). Although increasing the kernel size can improve the performance, it comes at the cost of longer inference latency. As a trade off, we set the default kernel size to 7.

## Appendix F More Visualization

In Fig. [8](#A7.F8), we present more samples from our dataset, covering different ranges of TTC, meteorological fluctuations, and models rendered using NeRF.

To get more intuitive understanding for different methods, we present more cases for visualization in Fig. [9](#A7.F9). In the first column of Fig. [9](#A7.F9), we plot the detection boxes of the target frames. In the second column, we show the boxes generated from detection and tracking model. For the last column, we show the scaled boxes obtained by GT, Pixel MSE and Deep Scale. As we can observe, the Pixel MSE produces unsatisfactory outcomes when object images encounter significant illumination changes or low quality, as exemplified in the first, second, and fourth cases. In contrast, the Deep Scale metric continues to perform robustly. Nonetheless, severe occlusion remains a challenge that adversely affects the performance of both Pixel MSE and Deep Scale, as demonstrated in the third case.

## Appendix G NeRF Script

For the scripts used for NeRF rendering, we list them in Table [13](#A7.T13). $v_{ego}$ and $v_{vehicle}$ denote the initial speed of ego and the target vehicle respectively. The $y$ denotes the relative distance in depth direction and we only consider the straight lane when setting the scripts. We permute and combine the speed of ego and vehicle to get more scenarios. For the rendered images, we also adopt the detection model to generate 2D bounding boxes and the truncated objects will be discarded to ensure the completeness.

Figure: Figure 8: More visualization for samples in real and NeRF scenes.
Refer to caption: /html/2309.01539/assets/x7.png

Figure: Figure 9: More visual comparison of the detection, tracking, and proposed methods, best viewed in color. In the second column, we use the blue and red color to distinguish the box from detection and tracking. For the last column, box with green, red and blue color denote the scaled box obtained by GT, Pixel MSE and Deep Scale.
Refer to caption: /html/2309.01539/assets/x8.png

**Table 13: Script for NeRF rendering.**
| No. | Initial Status | Script |  |  |
| --- | --- | --- | --- | --- |
| $v_{ego}(km/h)$ | $v_{vehicle}(km/h)$ | $y(m)$ |  |  |
| 1 | 40<br>60<br>80 | $v_{ego}$ | 50 | 1. Ego drives at $v_{ego}$ while the target vehicle decelerates at a speed of -3$m/s^{2}$.<br>2. After 3 seconds, ego decelerates with an acceleration of -4$m/s^{2}$ until its velocity matches that of the target vehicle. |
| 2 | 40<br>60<br>80 | $v_{ego}-$20 | 65 | 1. Ego drives at $v_{ego}$<br>2. At a distance range of (10, 50, 5)$m$ to the target vehicle, ego performs a lane change at a constant lateral relative speed of 2$m/s$, until it is completely in a different lane from the target vehicle. |
| 3 | 60<br>80 | 20<br>40 | 65 | 1. Ego gradually accelerates towards the target vehicle with an acceleration of range(0.5, 3, 0.5)$m/s^{2}$.<br>2. When the distance between ego and the target vehicle is within the range of (10, 50, 5)$m$, the target vehicle changes lanes with a constant lateral relative speed of $2m/s$ from a adjacent lane, until ego and the target vehicle are completely in same lane. At the same time, ego decelerates at -4$m/s^{2}$ within the same distance range of (10, 50, 5)$m$. |
| 4 | 60<br>80 | 60 | 65 | 1. Ego drives at $v_{ego}$ while the target vehicle decelerates at a speed of -3$m/s^{2}$.<br>2. After 3 seconds, ego decelerates with an acceleration of -4$m/s^{2}$ until its velocity matches that of the target vehicle. |
| 5 | 40<br>60 | 20<br>30 | 65 | 1. Ego drives at $v_{ego}$ while the target vehicle gradually accelerates with an acceleration range of (0.5, 3, 0.5)$m/s^{2}$.<br>2. At a distance range of (20, 60, 4)$m$ to the target vehicle, ego smoothly changes lanes with a lateral velocity range of (0.5, 1.5, 0.2)$m/s$, until ego and the target vehicle are completely in different lanes or the distance between them is less than 5$m$. |
| 6 | 40<br>60<br>80 | $v_{ego}-$30 | 65 | 1. Ego drives at $v_{ego}$ while the target vehicle gradually accelerates with an acceleration range of (0.5,3,0.5)$m/s^{2}$.<br>2. When the distance to the target vehicle is in the range of (10, 50, 4)$m$, ego gradually decelerates with an acceleration of -(1, 4, 0.5)$m/s^{2}$ until ego’s velocity matches the target vehicle’s velocity or the distance between them is less than 5$m$. |

## Peer Reviews

confidence: 4
contribution: 2
initial_rating: 5
presentation: 3
questions: See weakness.
soundness: 3
strengths: 1. The time-to-contact estimation task makes sense to me. Though some existing tasks like depth estimation and velocity estimation, or motion prediction can be used to solve this task as well, using TTC system as a redundancy system makes sense to me.
summary: This paper introduces a time-to-contact dataset for the safety requirements of the redundancy system in ADAS. In addition to being collected from real-world scenarios, the dataset also introduces NeRF scenes to further extend the number of safety critic scenarios. Other than the dataset, this paper also models the TTC estimation problem as estimating the scale ratio of 2D bounding boxes, thus making the TTC problem solvable using image pairs solely, and introduces Pixel MSE and Deep Scale accordingly. Experiments demonstrate the effectiveness,
weaknesses: I have concerns regarding to the following 3 aspects:

1. Dataset.
- Object range. The paper highlights their dataset contributions in Table 1 and bolds the object range tag. However, from the histogram in Figure 3, the objects farther than 200m are relatively few. I wish to see a histogram comparing to existing datasets, like Argoverse 2 [1] and Cityscapes3D [2] on a relative number of distant 3D objects.

- From L186, the paper mentions all real-world data are collected from commercial trucks. I am wondering what the object size of the trucks is. Whether the dataset is available for ADAS system on commercial cars, instead of large trucks.

- NeRF scenes. From Figure 8, I can see a visual domain gap from the NeRF reconstructed scenes and the real-world scenes. Thus, I am wondering the effectiveness of introducing Nerf scenes as well. Whether it can bring a better training performance, or whether it makes the testing harder? If it makes the testing scenarios harder, whether this difficulty comes from the challenges in domain gap?

[1] Argoverse 2: Next Generation Datasets for Self-Driving Perception and Forecasting

[2] Cityscapes 3D: Dataset and Benchmark for 9 DoF Vehicle Detection

2. Method.

- Method details. In L287, this papers mentions the Eq. (4) is derived from Eq. (1) and Eq. (3). However, it is not obvious to me how it achieves. I suggest the author to add more details on the combination.

3. Experiments.

- Redundancy design. The paper highlights TTC estimation as a redundancy design for ADAS system. Therefore, I am wondering, whether the TTC estimation helps the planning or the ADAS system. I suggest some experimental results demonstrating TTC estimation helps planning or other components in autonomous driving, instead solely experiments on TTC estimation. This is to show TTC estimation really helps.

- Some additional experiments. As the TTC estimation can either be achieved by scale difference estimation and depth-velocity estimation as well, (also, can be achieved by motion prediction as well?), I suggest the authors to compare their methods with other alternative methods.

- Distance breakdowns are suggested. TTC estimation errors with different object distance ranges.

---

confidence: 4
contribution: 3
initial_rating: 5
presentation: 2
questions: 1. It is unclear why object-level TTC is used rather than pixel-level TTC. It seems that pixel-level TTC is more informative than object-level TTC.

2. The objective of the proposed baseline is to estimate the ratio of objects. Can we use an object detection algorithm to perform such a task? Why should we use the proposed baselines? I have found that there is an object detection method (SOT) in the experiment. Is the SOT method retrained or finetuned on the proposed dataset?

3. What is the LIDAR model used in Table 2?

**Minors**
1. Line 064, what does "class 8" mean?

2. The authors state that "due to page limitation", the overall RTE metic is reported. The page limitation of ICLR is 10 pages, so please present more results.

3. Line 238: How do you obtain the velocity of the vehicle? Through using which data by what means? Please be specific. Is the velocity data provided by radar accurate?

4. Line 238, How exactly do you fit the velocity by the depth?
soundness: 2
strengths: 1. A Large dataset.

2. Promising performance.
summary: This work proposes a Time-to-Contact dataset and two baselines to estimate time-to-contact. Time-to-Contact (TTC), the time for an object to collide with the observer's plane, is an important metric in autonomous driving. Vision-based, especially RGB-based TTC estimation method is needed for cost-efficiency.
weaknesses: 1. It is unclear about the quality of the ground-truth labels. The authors should conduct experiments to show the quality of labels.

2. Albeit the dataset is large, what does the dataset bring? Can other methods benefit from using the dataset? In other words, a cross-dataset experiment is needed.

3. The introduction of the Nerf dataset is somewhat unclear. Why should it be used? How realistic is the dataset? 

4. The authors use the MiD metric as the main metric rather than the RTE metric by stating that "Due to the instability of TTC at larger value". This makes the reviewer wonder about the validity of the TTC metric and the correctness of the proposed approaches.

---

confidence: 5
contribution: 2
initial_rating: 5
presentation: 2
questions: 1. Please provide more details for the NeRF rendering concerning different weather and light conditions.
2. The trajectory feature is hard to maintain in complex driving scenes, and the solutions are preferred for reducing the impact of the cumulative errors in trajectories for final results.
soundness: 2
strengths: 1.	The author provides a very detailed explanation of the dataset processing.
2.	This work builds a large-scale TTC dataset and provides a simple yet effective TTC estimation algorithm as baselines for the community.
summary: This paper proposes a large-scale monocular Time-to-Collision (TTC) dataset for driving scenarios, including both 2D and 3D NeRF (Neural Radiance Field) image data. Additionally, it introduces two simple yet effective TTC estimation algorithms to validate the effectiveness of the proposed approach. Future work will focus on expanding the types of scenarios in the dataset or incorporating more safety-critical situations. Overall, this paper offers new insights into TTC estimation methods in the field of autonomous driving.
weaknesses: 1. The layout caption of Figure 2 on page 5 requires refinement. 
2. It is recommended that the author provide a flowchart to illustrate further details on the continuous monocular image generation of NeRF images.
3. Lighting conditions (such as nighttime or low-light environments) or weather (such as rain or snow) affect the quality of NeRF rendering? The author could include some statistics regarding these factors in the dataset, as these issues are highly relevant in autonomous driving scenarios.
4. In real driving scenarios, the motion trajectories of objects can be highly complex, which may lead to cumulative errors in speed and depth estimation, ultimately affecting the accuracy of TTC estimation. It is recommended that the author, after the derivation of the formulas, further discuss how to reduce the impact of these errors on the final results, for example, by using filtering or other smoothing techniques. 
5. In the future, it is necessary to increase the diversity of scene types in the dataset.

---

confidence: 3
contribution: 3
initial_rating: 5
presentation: 3
questions: - **Q1:** Could the authors provide a more detailed analysis of the impact of NeRF-generated data on the model’s generalization capabilities, especially for smaller TTC values? How much do these synthetic sequences contribute to performance improvements?

---

- **Q2:** The manuscript lacks ablation studies. Could the authors provide more details on the individual contributions of the components in the proposed methods, such as the center shift or scale bins? This would help clarify the relative importance of each element in the final performance.

---

- **Q3:** The paper does not discuss the computational complexity or real-time performance of the proposed methods. How do Pixel MSE and Deep Scale perform in terms of runtime, and are they suitable for real-time applications in ADAS?

---

- **Q4:** The dataset primarily focuses on vehicles in highway and urban scenarios. Do the authors have plans to extend the dataset to more complex environments, such as pedestrian-rich or mixed-traffic scenarios? If so, how would the proposed methods perform in these cases?
soundness: 3
strengths: (+) The TSTTC dataset is a valuable contribution to the community, filling a notable gap by providing a large-scale, real-world dataset specifically tailored for TTC estimation. The dataset’s focus on both urban and highway driving scenarios, combined with a wide depth range (up to 400 meters), makes it highly relevant for autonomous driving applications.

(+) The paper presents a solution to the problem of data scarcity in small TTC cases by augmenting the dataset with NeRF-generated sequences. This approach is proposed to address the imbalance in real-world data.

(+) The proposed TTC estimation methods (Pixel MSE and Deep Scale) are well-executed. The results on various metrics such as MiD and RTE demonstrate the efficacy of the methods in practical driving scenarios, providing useful baselines for future research.
summary: The manuscript introduces TSTTC, a large-scale dataset for Time-to-Contact (TTC) estimation in driving scenarios. 

TTC is a key metric in ADAS for assessing collision risks, which is essential for subsystems like Adaptive Cruise Control (ACC) and Automated Emergency Braking (AEB). The authors argue that there is a scarcity of real-world, large-scale TTC datasets, which has historically limited the effectiveness of deep learning-based TTC estimation methods.

To address this gap, the authors have constructed a dataset comprising 206K sequences from real-world driving scenes (highway and urban), supplemented by 1K sequences generated using NeRF for scenarios with small TTC values. Each sequence contains six consecutive frames captured at 10 Hz, annotated with 2D and 3D bounding boxes and ground-truth TTC values for vehicles.

Additionally, the manuscript proposes two baseline TTC estimation methods: Pixel MSE and Deep Scale. Both methods rely on calculating the scale ratio between consecutive frames to estimate TTC, with the latter using deep learning to enhance accuracy. 

The authors evaluate these methods on the TSTTC dataset, reporting some good improvements in terms of Motion-in-Depth (MiD) and Relative TTC Error (RTE). The results demonstrate that Deep Scale outperforms traditional depth estimation and other baselines.

The work highlights the benefits of their dataset for future TTC estimation research and emphasizes the importance of real-world datasets in improving the robustness of TTC predictions in autonomous driving systems.
weaknesses: (-) The addition of NeRF-generated sequences is an interesting idea, but the exact impact of these synthetic data on the model’s generalization capabilities is not sufficiently explored. More detailed analysis of how much NeRF data improves performance, especially on smaller TTC values, would be helpful.

(-) The manuscript lacks thorough ablation studies for the proposed Pixel MSE and Deep Scale methods. It would be beneficial to break down the impact of different components (e.g., center shift, different scale bins) and analyze their contributions to the final performance.

(-) The manuscript does not address the computational complexity or real-time performance of the proposed TTC estimation methods. In real-world applications like autonomous driving, it is crucial to assess the trade-off between accuracy and computational cost, especially for resource-constrained systems.

(-) The dataset is primarily focused on highway and urban driving scenes, which limits its applicability in more complex scenarios like pedestrian-rich environments or non-vehicle objects. Including data for other road users, such as pedestrians and cyclists, would broaden the scope of the dataset.

---

### Justification of Rating

While I do not have extensive experience in evaluating dataset papers, I can appreciate the significance of introducing the TSTTC dataset for TTC estimation in autonomous driving scenarios. 

The dataset fills a notable gap by providing large-scale, real-world data for both urban and highway driving, which will undoubtedly be useful for researchers working on Time-to-Contact estimation tasks. The inclusion of NeRF-generated sequences for small TTC cases is an innovative approach to addressing the imbalance in real-world data, although a more detailed analysis of the impact of this synthetic data is needed.

The proposed TTC estimation methods, Pixel MSE, and Deep Scale, provide useful baselines for further research, but the manuscript could be improved by discussing their computational complexity and real-time performance, which are crucial factors for practical deployment in ADAS systems. 

Additionally, the paper lacks thorough ablation studies and analysis of the individual contributions of different components in the methods. 

Given these factors, I would leave more room for other reviewers to determine the overall contribution and novelty of this work.

Meta-review: This paper's main contribution is a dataset for evaluating time-to-contact that assesses collision risk in ADAS (driver assistance) systems. The proposed dataset provides monocular videos and consists of manually selected (200) sequences sampled from thousands of hours of driving footage. The proposed approach utilizes NeRFs to render additional sequences/scenarios to train the model and increase data diversity. The paper also provides two reasonable baselines evaluated on the newly constructed dataset. 

However, reviewers also point out that (i) the constructed dataset lacks diversity (and focuses on highways and urban driving scenes, lacking pedestrian-populated environments); (ii) the addition of NeRF-generated sequences is not well justified (as W2A7 points out, the impact of synthetic data on model's generalization capability is not evaluated); (iii) were not convinced with the quality of provided labels, and, (iv) question whether methods, trained on the proposed dataset, can generalize across datasets. 

As the authors did not respond, reviewers unanimously recommended not accepting this paper (with final ratings 4, 5, 5, 5). AC agrees with this assessment.

Decision: Reject