Two-Dimensional-Time-To-Collision

KO | EN

gitlite — search

#python #hacktoberfest #llm #android #rust #linux #windows #cli #kubernetes #vue #pytorch #ios #mcp #openai

Two-Dimensional-Time-To-Collision

(★ 61)

This repository allows for fast computation of two-dimensional Time-To-Collision (TTC), DRAC, and MTTC.

Two-Dimensional-Time-To-Collision Latest Version Download

Download Latest Version (.zip)

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# Two-Dimensional-Time-To-Collision
This repository was initiated in 2022 Oct. to allow for fast computation of two-dimensional Time-To-Collision (2D-TTC), and updated in 2023 Mar. as well as 2024 May. For a more diverse comparison, In 2025 Feb., new surrogate safety measures, i.e., Deceleration Rate to Avoid Collision (DRAC) and Modified Time-To-Collision (MTTC), are added following the same computation logic.

These indicators are particularly useful for benchmarking and evaluating the collision risk in urban traffic (e.g., at intersections), but for sure can also be used in the scenario of longitudinal highway traffic.

A document explaining my computation is provided [here](A_fast_calculation_of_2DTTC.pdf), where the core idea is 
$$TTC=\frac{DTC}{\Vert\boldsymbol{v}_{ij}\Vert},$$ 
where $DTC$ means a distance to collision, as shown in the figure below.

This enables parallel computation with matrix operations, thus significantly improving computing efficiency for large-scale samples. Following the same logic,

![DRAC equation](https://latex.codecogs.com/png.latex?DRAC%3D%5Cfrac%7B%5CVert%5Cboldsymbol%7Bv%7D_%7Bij%7D%5CVert%5E2%7D%7B2DTC%7D) ;

![MTTC equation](https://latex.codecogs.com/png.latex?MTTC%3D%5Cfrac%7B-%5CVert%5Cboldsymbol%7Bv%7D_%7Bij%7D%5CVert%20%5Cpm%20%5Csqrt%7B%5CVert%5Cboldsymbol%7Bv%7D_%7Bij%7D%5CVert%5E2%2B2(%5Cboldsymbol%7Ba%7D_i-%5Cboldsymbol%7Ba%7D_j)DTC%7D%7D%7B%5Cboldsymbol%7Ba%7D_i-%5Cboldsymbol%7Ba%7D_j%7D)

and are further filtered according to [Ozbay et al. (2008)](https://doi.org/10.3141/2083-12).

__Note__ that this method follows the classic definition of TTC assuming constant velocity at the time moment of evaluation (a reference can be found [here](https://www.ictct.net/wp-content/uploads/SMoS_Library/LIB_Tarko_2018.pdf)). Due to the drawback of the constant-velocity assumption, this method may not suit well for slow and conscious interactions. This also clearly differs from alternative definitions such as the 2D-TTC by [Guo et al. (2023)](https://doi.org/10.1016/j.aap.2023.107063) or Time Advantage (TAdv, [Laureshyn et al., 2010](https://doi.org/10.1016/j.aap.2010.03.021)), for an implementation of which another repository [SSMsOnPlane](https://github.com/Yiru-Jiao/SSMsOnPlane) is referred to.

If you use this software in your work, please kindly cite it using the following metadata:
```latex
@software{jiao2023ttc,
author = {Jiao, Yiru},
month = mar,
title = {{A fast calculation of two-dimensional Time-to-Collision}},
url = {https://github.com/Yiru-Jiao/Two-Dimensional-Time-To-Collision},
year = {2023}
}
```

## Libarary requirements
Any versions of `pandas` and `numpy`.

## Usage
The folder `src` includes two scripts, of which `TwoDimTTC` computes TTC only and `TwoDimSSM` computes TTC, DRAC, and MTTC. You may use the following example for computation.

````python   
import sys
sys.path.append('') # add the path where you save `TwoDimTTC.py` file
import TwoDimTTC

# To return a dataframe with the input vehicle pair samples, where 2D-TTC are saved in a new column named 'TTC'
samples = TwoDimTTC.TTC(samples, 'dataframe')

# To return a numpy array of 2D-TTC values
ttc = TwoDimTTC.TTC(samples, 'values')
````

````python   
import sys
sys.path.append('') # add the path where you save `TwoDimSSM.py` file
import TwoDimSSM

# To return a dataframe with the input vehicle pair samples, where the indicators are saved in new columns
samples = TwoDimSSM.TTC(samples, 'dataframe')
samples = TwoDimSSM.DRAC(samples, 'dataframe')
samples = TwoDimSSM.MTTC(samples, 'dataframe')
# or compute all indicators at once
samples = TwoDimSSM.TTC_DRAC_MTTC(samples, 'dataframe')

# To return a numpy array of the indicator values, change `dataframe` to `values`
indicator_func = TwoDimSSM.TTC # or TwoDimSSM.DRAC or TwoDimSSM.MTTC or TwoDimSSM.TTC_DRAC_MTTC
indicator = indicator_func(samples, 'values')
````

## Input
The first input is a pandas dataframe of vehicle pair samples, which should include the following columns. Note that the heading direction of a vehicle is not necessarily the direction of its velocity, especially when the vehicle is stopping or steering. The heading (hx, hy) is normalized to a unit vector in this function.
- `x_i`      :  x coordinate of the ego vehicle $i$ (usually assumed to be centroid)
- `y_i`      :  y coordinate of the ego vehicle $i$ (usually assumed to be centroid)
- `vx_i`     :  x coordinate of the velocity of the ego vehicle $i$
- `vy_i`     :  y coordinate of the velocity of the ego vehicle $i$
- `hx_i`     :  x coordinate of the heading direction of the ego vehicle $i$
- `hy_i`     :  y coordinate of the heading direction of the ego vehicle $i$
- `acc_i`    :  acceleration along the heading direction of the ego vehicle $i$ (only required if computing MTTC)
- `length_i` :  length of the ego vehicle $i$
- `width_i`  :  width of the ego vehicle $i$
- `x_j`      :  x coordinate of another vehicle $j$ (usually assumed to be centroid)
- `y_j`      :  y coordinate of another vehicle $j$ (usually assumed to be centroid)
- `vx_j`     :  x coordinate of the velocity of another vehicle $j$
- `vy_j`     :  y coordinate of the velocity of another vehicle $j$
- `hx_j`     :  x coordinate of the heading direction of another vehicle $j$
- `hy_j`     :  y coordinate of the heading direction of another vehicle $j$
- `acc_j`    :  acceleration along the heading direction of another vehicle $j$ (optional)
- `length_j` :  length of another vehicle $j$
- `width_j`  :  width of another vehicle $j$

The second input allows outputing a dataframe with inputed samples plus a new column named 'TTC', or mere TTC values.

## Output
The ego vehicle $i$ and another vehicle $j$ will never collide if they keep current speed when 
  - indicator==np.inf when indicator==TTC or indicator==MTTC, or
  - indicator==0 when indicator==DRAC.

A negative indicator value means the boxes of the ego vehicle $i$ and another vehicle $j$ are overlapping. This is due to approximating the space occupied by a vehicle with a rectangular. In other words, `indicator<0` in this computation means the collision between the two vehicles almost (or although seldom, already) occurred.

Note that the computation can return extreme small positive values (for TTC/MTTC) or extreme large values (for DRAC) even when the vehivles overlap a bit (so should be negative values). In order to improve the accuracy, please use function `CurrentD(samples, 'dataframe')` or `CurrentD(samples, 'values')` to further exclude overlapping vehicles. This function calculate current distance between the ego vehicle $i$ and another vehicle $j$, which indicate overlapping when the value is negative.

For example,
````python   
# Within pandas dataframe
samples = TwoDimTTC.TTC(samples, 'dataframe')
samples = TwoDimTTC.CurrentD(samples, 'dataframe')
samples.loc[(samples.CurrentD<0)&(samples.TTC<np.inf)&(samples.TTC>0),'TTC'] = -1

# Using numpy array of values
ttc = TwoDimTTC.TTC(samples, 'values')
current_dist = TwoDimTTC.CurrentD(samples, 'values')
ttc[(current_dist<0)&(ttc<np.inf)&(ttc>0)] = -1
````

## Efficiency
Use function `efficiency(samples, iterations)` to test the computation efficiency.

For example,
````python   
print('Average time cost = {:.4f} second(s)'.format(TwoDimTTC.efficiency(samples, 10)
````

The following table shows approximately needed computation time (tested for 10 iterations of experiments).
| number of vehicle pairs | computation time (s)|
|-------|-------|
| 1e4 | 0.0357 |
| 1e5 | 0.4342 |
| 1e6 | 7.1657 |

This work is licensed under the terms of the MIT license. For a copy, see <https://opensource.org/licenses/MIT>.

Two-Dimensional-Time-To-Collision

Two-Dimensional-Time-To-Collision Latest Version Download

Today's picks

Was this content helpful?

Recent Feedback

Two-Dimensional-Time-To-Collision

Two-Dimensional-Time-To-Collision Latest Version Download

Today's picks

Was this content helpful?

Recent Feedback

Download README