This paper was converted on www.awesomepapers.org from LaTeX by an anonymous user.
Want to know more? Visit the Converter page.

\corrauth

Andrew Kramer, University of Colorado Boulder, 1111 Engineering Dr, Boulder Colorado USA

ColoRadar: The Direct 3D Millimeter Wave Radar Dataset

Andrew Kramer11affiliationmark:    Kyle Harlow11affiliationmark:    Christopher Williams22affiliationmark:    and Christoffer Heckman11affiliationmark: 11affiliationmark: Department of Computer Science, University of Colorado Boulder, 1111 Engineering Dr, Boulder Colorado USA
22affiliationmark: Department of Aerospace Engineering, University of Colorado Boulder, 3775 Discovery Dr, Boulder Colorado USA
[email protected]
Abstract

Millimeter wave radar is becoming increasingly popular as a sensing modality for robotic mapping and state estimation. However, there are very few publicly available datasets that include dense, high-resolution millimeter wave radar scans and there are none focused on 3D odometry and mapping. In this paper we present a solution to that problem. The ColoRadar dataset includes 3 different forms of dense, high-resolution radar data from 2 FMCW radar sensors as well as 3D lidar, IMU, and highly accurate groundtruth for the sensor rig’s pose over approximately 2 hours of data collection in highly diverse 3D environments.

keywords:
dataset, radar, field robotics, SLAM, odometry, mapping

1 Introduction

1.1 Motivation and Contribution

Robots are being deployed in ever more challenging roles. In many environments GPS is unavailable so autonomous robots must be able to localize and map using only their onboard sensors. These tasks are normally accomplished using some combination of visual, lidar, and inertial sensors Hess et al. (2016); Leutenegger et al. (2013, 2015). However, the quality of the estimates from visual and lidar methods is severely handicapped in so-called visually degraded environments (VDEs). These include darkness, fog, smoke, and similar conditions that adversely affect sensing in the visible or near-visible spectrum. Such conditions are common in a variety of scenarios that are of keen interest for robotics research including disaster response and subterranean exploration.

Millimeter wave radars, of the type used in advanced driver assistance systems (ADAS), are an attractive option for perception in VDEs. These sensors do not require ambient light to operate and are unaffected by airborne particulates like smoke and fog. Additionally, automotive-grade system-on-chip (SoC) radars are lightweight and have low power requirements, making them attractive for vehicles with limited payload and power capacity, e.g. micro aerial vehicles (MAVs). Because of these attributes the number of robotic perception papers using automotive millimeter wave radar sensors has increased drastically in the last few years Schuster et al. (2016b, a); Rapp et al. (2017); Kramer et al. (2020); Lu et al. (2020); Xiaoxuan Lu et al. (2020).

However, several factors make the development of new radar-based methods extremely difficult. First, there are very few radar sensors available that are suitable for robotics work. Large 2D scanning sensors Cen and Newman (2018, 2019); Lakshay et al. (2020); Stefan Saftescu et al. (2020), and small 3D automovotive sensors dominate the market Schuster et al. (2016b, a); Rapp et al. (2017); Kramer et al. (2020); Lu et al. (2020); Xiaoxuan Lu et al. (2020). Second, almost all of the available radar sensors implement their own signal processing and target detection systems onboard Iovescu and Rao (2020). These are well adapted for ADAS but ill-suited to robotic perception tasks Lu et al. (2020). It would be ideal if researchers could implement their own target detection and/or signal processing algorithms, but most sensors do not allow the user access to their full data stream and those that do are not designed for streaming in real time. Hacking these sensors to stream data in real time takes both domain-specific expertise and a large time investment which is prohibitive for most researchers. The final nail in the coffin for most nascent radar-based robotics projects is there are no publicly available robotics datasets that include this data.

To remove these obstacles we present the first multi-sensor dataset designed for 6DoF radar-based state estimation and mapping. The dataset includes dense 4D data from millimeter wave radar sensors, 3D lidar pointclouds, IMU measurements, and groundtruth pose information. The dataset is available for download at arpg.colorado.edu/coloradar. We include radar data in 3 different forms, providing entry points of varying sophistication and difficulty for users. First, we provide unprocessed ADC samples from each radar measurement. Second, we provide dense 3D heatmaps for each radar measurement generated from signal processing on the raw ADC samples. Lastly, we provide point targets derived from the sensor’s onboard signal processing and target detection process. Although as previously stated, these point targets are not ideal for robotic state estimation and perception applications, we include point targets because several recent methods have made use of them Kramer et al. (2020); Lu et al. (2020); Xiaoxuan Lu et al. (2020). So including point targets provides a familiar entry point for many researchers.

1.2 Related Work

While there exist at least three publicly available robotics datasets containing radar data Barnes et al. (2020); Caesar et al. (2020); Leung et al. (2017), each dataset is limited in some manner. The Oxford Radar RobotCar dataset Barnes et al. (2020) and NuScenes dataset Caesar et al. (2020) both focus on autonomous road vehicles, limiting sensor movement largely to a 2D horizontal plane. In contrast, the Radar RobotCar dataset uses a different style of radar sensor, the NavTech CTS350-X, which provides dense 2D scans in the horizontal plane only. The NavTech sensor’s 2D output makes the Radar RobotCar dataset unsuitable for developing methods for 3D environments. Also, the NavTech sensor weighs 6kg and draws 24W, making it impractical for small, agile autonomous vehicles like MAVs. The Chilean underground mine dataset provides a different environment, it also uses a 2D scanning radar and is mostly confined to 2D movement. Leung et al. (2017). Lastly, a major limitation common to all of these datasets is that they do not include the raw ADC sample data from their radar sensors. This means users of these datasets must be satisfied with the signal processing and target detection algorithms implemented onboard their sensors. These algorithms are often very ill-suited to robotics tasks as previously stated.

The Euroc MAV dataset Burri et al. (2016) and the UZH FPV dataset Delmerico et al. (2019) are examples of datasets that are useful for the development of algorithms for small, agile robots operating in 3D environments. However, these are visual-inertial datasets that do not include radar. Currently there are no similar datasets that include radar data in any form.

Like the Euroc MAV and UZH FPV datasets Burri et al. (2016); Delmerico et al. (2019), our dataset includes both slow and rapid 6DoF motion. This means our dataset can be used in the development of state estimation and mapping methods for small, agile robots that operate in diverse 3D environments. Also, our dataset includes both raw ADC data and dense images from multiple types of 4D radar sensors. This allows users to develop new methods for signal processing and target detection which are specifically designed for robotics tasks. Lastly, we include data gathered in highly diverse indoor, outdoor, and subterranean environments. This allows users to develop methods for a wide variety of environments and scenarios. These are clear advantages over the currently-available radar datasets.

2 Sensor Platform

Our sensor platform is shown in Figure 1. It includes

  • Cascaded Imaging Radar Sensor: Texas Instruments MMWCAS-RF-EVM (details in Table 1)

  • Single Chip Radar Sensor: Texas Instruments AWR1843BOOST-EVM paired with a DCA1000-EVM for raw data capture (details in Table 1)

  • Lidar Sensor: Ouster OS1; 10Hz; 64 beams; 0.010.01^{\circ} angular accuracy; angular resolution 0.350.35^{\circ} horizontal, 0.70.7^{\circ} vertical; 3cm range accuracy; field of view 360360^{\circ} horizontal, 4545^{\circ} vertical; max range 120m; 65,536 points per scan

  • IMU: Lord Microstrain 3DM-GX5-25; 300Hz

Refer to caption
Figure 1: The sensor rig used to collect our dataset. Each sensor is labeled and its local coordinate frame is noted.

Note our sensor rig includes two Texas Instruments radar sensors. The single chip sensor is based on the AWR1843 radar on a chip. The cascaded sensor uses four AWR2243 radar chips which function as a single radar. The cascade sensor provides far better angular resolution at the expense of lower framerate, higher data rate, and higher power draw. But because both sensors use a frequency modulated continuous (FMCW) waveform the same signal processing and target detection algorithms may be used for either. The salient parameters of the two sensors are outlined in Table 1. Note for radar sensors “resolution” refers to the minimum separation between targets required to distinguish those targets in the sensor’s output. This is distinct from camera resolution, which is simply the dimensions of the camera’s output. For sensor control and data logging the sensor rig is equipped with an Intel NUC computer with an i7 processor, 16GB of memory, and 500GB of storage. The computer runs Ubuntu 18.04 and we use ROS Melodic Stanford Artificial Intelligence Laboratory et al. (2018) to control the sensors and log their data streams.

Single Chip Radar Cascaded Radar
Framerate 10Hz 5Hz
Frequency 77GHz 77GHz
Waveform FMCW FMCW
TX antennas 3 12
RX antennas 4 16
Range resolution 0.125m 0.117m
Max range 12m 15m
Doppler velocity resolution 0.04m/s 0.254m/s
Max Doppler velocity 2.56m/s 2.02m/s
Azimuth resolution 11.311.3^{\circ} 1.051.05^{\circ}
Elevation resolution 4545^{\circ} 22.522.5^{\circ}
Power consumption 2W 9.5W
Data rate 63Mbps 126Mbps
Table 1: Parameters of the radar sensors

3 Dataset

3.1 Radar Signal Processing

To understand the different types of radar data provided in our dataset, it is necessary to give a brief description of the typical signal processing pipeline for multi-input-multi-output (MIMO) frequency modulated continuous wave (FMCW) radar sensors.

3.1.1 Range-Doppler Velocity Processing

For simplicity we will initially consider the data format for a radar with a single receive (RX) and a single transmit (TX) antenna. Each radar measurement consists of repetitions of the same unit, referred to as a “chirp.” For each chirp, the TX antenna emits a pulse of RF energy with linearly increasing frequency. This pulse is reflected by objects in the environment and these reflections are detected by the RX antenna. The signal detected by the RX antenna is down-converted by mixing with the original transmitted signal, then this intermediate frequency (IF) signal is sampled by an analog-to-digital converter (ADC), creating an array of NSN_{S} complex samples. The sampling done over a single chirp is referred to as “fast-time.” The chirp is repeated NDN_{D} times, and the received signals from each chirp are stacked to form a 2D array referred to as a “frame,” shown in Figure 4. The height dimension of the frame is referred to as “slow time.”

Refer to caption
Figure 2: Example result of the 2D FFT run on a frame of data for a single antenna. Note the horizontal band of returns at Doppler velocity bin 0 represent static objects. The intensity peak at range 11 and range rate -0.8 indicates an object at 11m with range decreasing at 0.8m/s.

Complex fast Fourier transforms (FFTs) are then performed across the fast time and slow time dimensions of the array, resulting in a profile of the received power in fast and slow time. Luckily, there are linear relationships between fast time and range, and between slow time and range rate. So the FFT output can be easily converted to a plot of received power in range and range rate. Figure 2 shows the result of range-Doppler velocity processing processing for an example frame.

3.1.2 The MIMO Antenna Array

MIMO sensors, such as those used in our dataset, use NTN_{T} TX and NRN_{R} RX antennas. The signals transmitted by each TX antenna are multiplexed in the time domain, which allows us to split the signals detected by the RX antennas into the components caused by each transmitted signal. This means for each frame of radar data we have NTNRN_{T}N_{R} unique received signals.

Each RX-TX antenna pair can be considered as a “virtual” antenna element, the location of which is the centroid of the physical RX and TX antennas associated with it. Figure 3 demonstrates how the spatial layout of antennas in a MIMO array translates to a virtual antenna pattern. Because these virtual antennas are spatially distributed, the relative phase of the signal received by each antenna will depend on the angle of arrival of that signal. This is what allows us to do the angle of arrival processing step.

Refer to caption
Figure 3: Layer (a) shows an example of virtual antenna array synthesis created from the logical antenna layout (b) from a TI AWR1843 patch antenna array (c).

3.1.3 Angle Of Arrival Processing

For a MIMO antenna array, range-Doppler velocity processing is performed on the samples from each virtual antenna element. The outputs from the range-Doppler velocity processing step are then stacked to form a complex data cube as shown in Figure 4. Then a third FFT is performed across the virtual antenna dimension, resulting in a heat map of the signal power received by the sensor in the range, Doppler velocity, and azimuth angle dimensions. An example heat map is shown in Figure 5.

Refer to caption
Figure 4: Data cube format for a complete frame of radar data for a multiple virtual antennas. Each box represents a single complex ADC sample and each 2D matrix represents the samples for a full frame of data for a single virtual antenna.
Refer to caption
Figure 5: Example result of the angle of arrival FFT. Note the clear intensity peak visible at 8m range and +25+25^{\circ} azimuth. The Doppler velocity dimension is not shown for simplicity.

By using an antenna array with virtual elements distributed in two dimensions rather than just one as shown in Figure 3, this process can be extended one step further. Performing fast Fourier transforms across both dimensions of the antenna array results in a 4D heat map in the range, Doppler velocity, azimuth, and elevation dimensions.

In many off-the-shelf automotive radar sensors an additional target detection step is performed. A constant false alarm rate (CFAR) target detector Scharf and Demeure (1991) is used to detect peaks that stand out prominently from their surroundings in the range-Doppler velocity-angle heat map. The locations and intensities of these peaks are then returned to the user as a set of point targets. This reduces the size of each measurement substantially, but it also discards a large amount of potentially valuable information. The target detection process also introduces noise because a portion of the detected targets will be false alarms.

3.2 Data Description

Refer to caption Refer to caption Refer to caption
(a) (b) (c)
Refer to caption Refer to caption Refer to caption
(d) (e) f
Figure 6: Examples of various environments this dataset covers including (a) Intelligent Robotics Lab (b) Engineering Center hallways (c) Boulder Creek Path where the longboard data was captured (d) Edgar Mine (e) Autonomous Systems Programming Evaluating and Networking Lab motion capture space and (f) Engineering Center courtyard where the outdoor data was captured.

Data was collected in several unique environments with the goal of providing a diverse range of sensor data. The Intelligent Robotics Laboratory (IRL) and engineering center (EC) hallways sequences were taken in an indoor built environment and the EC courtyard sequences capture data in an outdoor built environment. In the Boulder Creek Path sequences the sensor rig moves rapidly through an outdoor environment with dynamic obstacles including pedestrians, cyclists, and road vehicles. There are two sets of sequences taken in Edgar Experimental Mine, a former silver and gold mine managed by Colorado School of Mines: Edgar Army sequences were taken in large, open areas of the mine and the Edgar Classroom sequences were taken in the mine’s tighter, more constrained passageways. The ASPEN Lab sequences were taken in a motion capture space with a variety of obstacles.

Example images of the various environments are shown in Figure 6. The amount of data collected at each location, along with their associated location file names are shown in Table 2.

Location File Root Time (mm:ss)
IRL arpg_lab 10:24
EC Hallways ec_hallways 15:07
Boulder Creek Path longboard 31:53
Edgar Army edgar_army 25:20
Edgar Classroom edgar_classroom 19:20
ASPEN Lab aspen 21:14
EC Courtyard outdoors 19:32
Table 2: Amount of data in time collected at each location

All sensor readings for a given sequence are grouped in a single compressed file named <date>_<location>_<sequence>.zip, where <date>, <location>, and <sequence> are placeholders for the recording date, location, and sequence number respectively. The directory structure is shown in Figure 7.

\dirtree

.1 ./. .2 ¡date¿_¡location¿_¡sequence¿.zip. .3 cascade/. .4 adc_samples/. .5 data/. .6 frame_¡number¿.bin. .5 timestamps.txt. .4 heatmaps/. .3 single_chip/. .4 adc_samples/. .5 data/. .6 frame_¡number¿.bin. .5 timestamps.txt. .4 heatmaps/. .4 pointclouds/. .3 lidar/. .4 pointclouds/. .5 lidar_pointcloud_¡number¿.bin. .4 timestamps.txt. .3 imu/. .4 imu_data.txt. .4 timestamps.txt. .3 groundtruth/. .4 groundtruth_poses.txt. .4 timestamps.txt. .3 vicon/. .4 vicon_poses.txt. .4 timestamps.txt. .2 calib.zip. .3 cascade/. .4 antenna_cfg.txt. .4 coupling_calib.txt. .4 phase_frequency_calib.txt. .4 waveform_cfg.txt. .4 heatmap_cfg.txt. .3 single_chip/. .4 antenna_cfg.txt. .4 coupling_calib.txt. .4 waveform_cfg.txt. .4 heatmap_cfg.txt. .3 transforms/. .4 base_to_imu.txt. .4 base_to_lidar.txt. .4 base_to_cascade.txt. .4 base_to_single_chip.txt. .4 base_to_vicon.txt.

Figure 7: Structure of the zip files for each sequence in the dataset.

Timestamps for each sensor reading are stored in a timestamps.txt file for each sensor. Each line in timestamps.txt gives the time of a sensor measurement in seconds.

As previously stated we provide three levels of processing for radar data: unprocessed ADC samples, 3D range-azimuth-elevation intensity-Doppler velocity heatmaps, and target detections from the single-chip radar sensor. The cascaded sensor does not do any signal processing or target detection onboard, so point targets are not provided for the cascade sensor. By providing these different data types will enable users to develop application specific methods for signal processing, target detection, scan alignment, etc.

3.2.1 Binary File Format

Radar and lidar sensor measurements are very large. Storing these measurements in human-readable format would be impractical due both to their size and the time required to access the data. So for these sensors we use a simple binary encoding that can be read in any language without external dependencies. Each binary file stores an array of numeric values in little-endian order. To obtain the array one only needs to read the file’s contents into a byte array and then convert to the appropriate type with memcpy or similar. The organization of the values in the resulting array differs for each measurement type and is described in detail below. We also provide both Python and MATLAB scripts demonstrating correct parsing of the binary files for each sensor type.

3.2.2 Raw Radar Data

Each frame of raw radar data is stored in a binary file frame_<number>.bin. Each of these files stores an array of 16 bit signed integer values. The values that make up the ADC sample for sample index ss, chirp index cc, receiver index rr, and transmitter index tt are indexed as

i=2(s+Ns(c+Nc(r+tNr)))i=2(s+N_{s}(c+N_{c}(r+tN_{r}))) (1)

the value at index ii make is the real (or I) component and value at index i+1i+1 is the imaginary (or Q) component. Python and MATLAB examples are provided to demonstrate correct parsing of these binary files.

3.2.3 Radar Heatmaps

Each radar heatmap is stored in a binary file heatmap_<number>.bin. Each of these files stores an array of 32 bit floating point values. The heatmaps have dimension Ne×Na×Nr×2N_{e}\times N_{a}\times N_{r}\times 2 where NeN_{e} is the number of elevation bins in the heatmap, NaN_{a} is the number of azimuth bins, and NrN_{r} is the number of range bins. The Doppler velocity dimension in the heatmaps has been collapsed, and the return in each range, azimuth, and elevation bin is represented by 2 32 bit floating point values: the intensity of the peak in the Doppler velocity spectrum for that location, and the range rate of that peak in meters per second. Negative range rates indicate motion toward the sensor and positive range rates indicate motion away from the sensor. The values that make up the intensity and range rate for range index rr, azimuth index aa, and elevation index ee are indexed as

i=2(r+Nr(a+eNa))i=2(r+N_{r}(a+eN_{a})) (2)

where the value at index ii is the intensity value and the value at index i+1i+1 is the range rate. As with the raw radar data, Python and MATLAB examples are provided to demonstrate correct parsing.

3.2.4 Radar Pointclouds

Each radar pointcloud is stored in a binary file radar_pointcloud_<number>.bin. Each of these files stores an array of 32 bit floating point values. Each radar point consists of 5 contiguous values: its (x,y,z)(x,y,z) location in meters in the sensor’s local frame, its intensity value, and its range rate in meters per second. As with the other data types, Python and MATLAB examples are provided to demonstrate correct parsing. The number of points per scan is not constant and depends on the number of detected targets in the scan, but there are generally less than 300 points per scan.

3.2.5 Lidar Pointclouds

Each lidar pointcloud is stored in a binary file lidar_pointcloud_<number>.bin. As with radar pointcloud files, each lidar pointcloud file stores an array of 32 bit floating point values. Each lidar point consists of 4 contiguous values: its (x,y,z)(x,y,z) location in meters in the sensor’s local frame and its intensity. There are 65,536 points per lidar scan. Python and MATLAB examples are provided to demonstrate correct parsing.

3.2.6 IMU

All IMU measurements are stored in a single text file, imu_data.txt, with one measurement per line. Each measurement consists of 6 space-delimited floating point values: the linear accelerations (ax,ay,az)(a_{x},a_{y},a_{z}) followed by the angular rates (αx,αy,αz)(\alpha_{x},\alpha_{y},\alpha_{z}). Python and MATLAB examples are provided to demonstrate correct parsing.

3.2.7 Groundtruth

Groundtruth poses of the sensor rig are generated from a globally optimized pose graph with IMU, lidar, and loop closures as constraints using the method described in Hess et al. (2016). All groundtruth poses for a sequence are given in a single text file groundtruth_poses.txt with one pose per line. Each pose consists of 7 space-delimited floating point values: the position (x,y,z)(x,y,z) followed by an orientation quaternion (x,y,z,w)(x,y,z,w). Groundtruth poses are given relative to the starting pose of the sequence. Python and MATLAB examples are provided to demonstrate correct parsing.

3.2.8 Vicon

All vicon poses for a sequence are given in a single text file vicon_poses.txt with one pose per line. As with the lidar-based groundtruth files, each pose consists of 7 space-delimited floating point values: the position (x,y,z)(x,y,z) followed by an orientation quaternion (x,y,z,w)(x,y,z,w). Vicon poses are given relative to the vicon system’s coordinate frame. Vicon poses are only available for sequences in the ASPEN lab. Python and MATLAB examples are provided to demonstrate correct parsing.

3.3 Development Tools

We provide development tools for manipulating our raw data on the ColoRadar website. These include example Python tools for reading and plotting the provided data files. These are described in detail in the README.md file provided with the development tools. Here we will briefly describe the tools and their functions. dataset_loaders.py provides functions to load sensor measurements and calibrations from dataset files. These functions parse the raw data and organize it into logical data structures. For instance, the function get_heatmap() reads bytes from a radar heatmap file, converts those bytes to intensity and range rate values, and returns them in a numpy array of dimension Ne×Na×Nr×2N_{e}\times N_{a}\times N_{r}\times 2. The function get_cascade_params() reads config files for the cascaded radar sensor and returns a dictionary where each key-value pair is a parameter for the radar sensor. plot_pointclouds.py demonstrates how the functions in dataset_loaders.py can be used to create an animation of the sensor readings and groundtruth poses in a sensor-centric reference frame. MATLAB equivalents of these tools are also provided.

4 Sensor Calibration

4.1 Radar Calibration

Four types of calibration parameters are provided for the radar sensor data. The first is a mapping of the location of the TX and RX antennas on each radar board. These are stored in text files found in calib/cascade/antenna_cfg.txt and calib/single_chip/antenna_cfg.txt.

The second type of calibration is the waveform parameters. These include the start frequency, frequency slope, ADC sample rate, and other parameters necessary for signal processing. These parameters are found in calib/cascade/waveform_cfg.txt and calib/single_chip/waveform_cfg.txt.

The third type is the antenna coupling calibration. Antenna coupling occurs when a current in one antenna element unintentionally induces a voltage in adjacent elements. Antenna coupling calibration compensates for this as

𝐑rcacalibrated=𝐑rcaraw𝐂rca\mathbf{R}_{rca}^{\text{calibrated}}=\mathbf{R}_{rca}^{\text{raw}}-\mathbf{C}_{rca} (3)

where 𝐑rcaraw\mathbf{R}_{rca}^{\text{raw}} is the uncalibrated range FFT output for range index rr, chirp index cc, and virtual antenna index aa, 𝐑rcacalibrated\mathbf{R}_{rca}^{\text{calibrated}} is the corresponding calibration result, and 𝐂rca\mathbf{C}_{rca} calibration value, i.e. the range FFT result at rr, cc, and aa when no targets are present.

Antenna coupling calibration files are provided in calib/cascade/coupling_calib.txt and calib/single_chip/coupling_calib.txt and Python code is provided to show how to apply the calibration.

The fourth type is phase and frequency calibration. These parameters are needed for the cascaded sensor only. This is because the cascaded sensor uses 4 separate chips to control different parts of the antenna array and there may be small mismatches in the frequency, phase, and amplitude across these 4 chips. Phase and frequency calibration corrects for this.

In frequency calibration, we start with a calibration vector 𝐟\mathbf{f} of dimension NrxNtxN_{\text{rx}}N_{\text{tx}}. From this we calculate a frequency calibration matrix 𝐅\mathbf{F} of dimension NrxNtx×NrangeN_{\text{rx}}N_{\text{tx}}\times N_{\text{range}} as

𝐅=2π𝐟fscalfslopefsfslopecal×𝐧\mathbf{F}=2\pi\mathbf{f}\frac{f_{\text{s}}^{\text{cal}}f_{\text{slope}}}{f_{\text{s}}f_{\text{slope}}^{\text{cal}}}\times\mathbf{n} (4)

where fsf_{\text{s}} is the ADC sampling rate, fscalf_{\text{s}}^{\text{cal}} is the sampling rate used in calibration, fslopef_{\text{slope}} is the frequency slope, fslopecalf_{\text{slope}}^{\text{cal}}is the frequency slope used in calibration, and 𝐧=[0,Nrange)\mathbf{n}=[0,N_{\text{range}}). The raw ADC samples for each chirp 𝐀c\mathbf{A}_{c} are then calibrated as

𝐀cfcal=𝐀cej𝐅\mathbf{A}_{c}^{\text{fcal}}=\mathbf{A}_{c}\odot e^{-j\mathbf{F}} (5)

where \odot denotes elementwise multiplication. Phase calibration is somewhat simpler. In phase calibration we start with a matrix 𝐏\mathbf{P} of dimension Nrx×NtxN_{\text{rx}}\times N_{\text{tx}}. 𝐏\mathbf{P} is applied to 𝐀rcfcal\mathbf{A}_{rc}^{\text{fcal}}, the frequency calibrated ADC samples from each antenna pair at range index rr and chirp index cc as

𝐀rcpcal=𝐀rcfcal𝐏\mathbf{A}_{rc}^{\text{pcal}}=\mathbf{A}_{rc}^{\text{fcal}}\oslash\mathbf{P} (6)

where \oslash denotes elementwise division.

Phase and frequency calibration vectors can be found in calib/cascade/phase_frequency_calib.txt and Python code is provided to show how to apply the calibration.

4.2 Extrinsic Calibration

Extrinsic transforms between sensors are given relative to the sensor rig’s base frame. The sensor rig’s base frame is coincident with the IMU in translation and oriented to align with the ENU frame (xx right, yy forward, zz up). Transformations between the base frame and each sensor are given in calib/transforms/base_to_<sensor>.txt. Each of these files has two lines. The first gives the translation (x,y,z)(x,y,z) and the second gives the rotation as a quaternion in the order (x,y,z,w)(x,y,z,w). The extrinsic transformations for all of the sensors are hand measured. The transformation between the lidar and radar sensors is further refined via the following process: we took a dataset in which the sensor rig was held static and two obstacles are clearly visible in the lidar pointcloud and the heatmaps for the single chip and and cascaded radar sensors. The extrinsic transformations for the lidar and single chip sensors are then manually adjusted until the locations of the obstacles in the lidar pointcloud and single chip heatmap coincide with those in the cascaded heatmap. The extrinsic transforms do not change appreciably between runs, so we include only one set of extrinsic transforms.

5 Summary and Future Work

In this paper we have presented a dataset focused on robotic perception using millimeter wave radar. We provide data in a diverse range of environments including indoor, outdoor, and subterranean environment and we include motion in 6DoF. We also include 4D radar measurements from two different sensors in three different formats. These factors make this dataset highly useful in research for autonomous robotics tasks such as odometry, mapping, and SLAM in diverse roles from disaster response to subterranean exploration. Currently, there is great interest in radar-based 3D odometry, mapping, and SLAM in the research community but very few published methods exist. The availability of a diverse dataset focused on these tasks will help spur development in this area. The usefulness of the dataset could be extended to object classification and semantic segmentation by adding semantic labeling to the lidar pointclouds. This is another potential direction for future work.

References

  • Barnes et al. (2020) Barnes D, Gadd M, Murcutt P, Newman P and Posner I (2020) The oxford radar robotcar dataset: A radar extension to the oxford robotcar dataset. In: Proceedings of the IEEE International Conference on Robotics and Automation (ICRA). Paris. URL https://arxiv.org/abs/1909.01300.
  • Burri et al. (2016) Burri M, Nikolic J, Gohl P, Schneider T, Rehder J, Omari S, Achtelik MW and Siegwart R (2016) The euroc micro aerial vehicle datasets. The International Journal of Robotics Research 10.1177/0278364915620033. URL http://ijr.sagepub.com/content/early/2016/01/21/0278364915620033.abstract.
  • Caesar et al. (2020) Caesar H, Bankiti V, Lang AH, Vora S, Liong VE, Xu Q, Krishnan A, Pan Y, Baldan G and Beijbom O (2020) nuscenes: A multimodal dataset for autonomous driving.
  • Cen and Newman (2018) Cen SH and Newman P (2018) Precise Ego-Motion Estimation with Millimeter-Wave Radar Under Diverse and Challenging Conditions. In: 2018 IEEE International Conference on Robotics and Automation (ICRA). Brisbane, QLD: IEEE. ISBN 978-1-5386-3081-5.
  • Cen and Newman (2019) Cen SH and Newman P (2019) Radar-only ego-motion estimation in difficult settings via graph matching. arXiv:1904.11476 [cs] URL http://arxiv.org/abs/1904.11476.
  • Delmerico et al. (2019) Delmerico J, Cieslewski T, Rebecq H, Faessler M and Scaramuzza D (2019) Are we ready for autonomous drone racing? the UZH-FPV drone racing dataset. In: IEEE Int. Conf. Robot. Autom. (ICRA).
  • Hess et al. (2016) Hess W, Kohler D, Rapp H and Andor D (2016) Real-time loop closure in 2d lidar slam. In: 2016 IEEE International Conference on Robotics and Automation (ICRA). pp. 1271–1278.
  • Iovescu and Rao (2020) Iovescu C and Rao S (2020) Fundamentals of millimeter wave sensors. Technical report, Texas Instruments, Dallas, Texas.
  • Kramer et al. (2020) Kramer A, Stahoviak C, Santamaria-Navarro A, Aghamohammadi A and Heckman C (2020) Radar-inertial ego-velocity estimation for visually degraded environments. In: 2020 IEEE International Conference on Robotics and Automation (ICRA).
  • Lakshay et al. (2020) Lakshay N, Iannucci PA and Humphreys TE (2020) All-Weather sub-50-cm Radar-Inertial Positioning. Technical report.
  • Leung et al. (2017) Leung K, Lühr D, Houshiar H, Inostroza F, Borrmann D, Adams M, Nüchter A and del Solar JR (2017) Chilean underground mine dataset. The International Journal of Robotics Research 36(1): 16–23. 10.1177/0278364916679497. URL https://doi.org/10.1177/0278364916679497.
  • Leutenegger et al. (2013) Leutenegger S, Furgale P, Rabaud V, Chli M, Konolige K and Siegwart R (2013) Keyframe-based visual-inertial slam using nonlinear optimization.
  • Leutenegger et al. (2015) Leutenegger S, Lynen S, Bosse M, Siegwart R and Furgale P (2015) Keyframe-based visual–inertial odometry using nonlinear optimization. The International Journal of Robotics Research 34(3): 314–334.
  • Lu et al. (2020) Lu CX, Rosa S, Zhao P, Wang B, Chen C, Stankovic JA, Trigoni N and Markham A (2020) See Through Smoke: Robust Indoor Mapping with Low-cost mmWave Radar : 1410.1145/3386901.3388945. URL https://doi.org/10.1145/3386901.3388945.
  • Rapp et al. (2017) Rapp M, Barjenbruch M, Hahn M, Dickmann J and Dietmayer K (2017) Probabilistic ego-motion estimation using multiple automotive radar sensors. Robotics and Autonomous Systems 89: 136–146. 10.1016/j.robot.2016.11.009.
  • Scharf and Demeure (1991) Scharf L and Demeure C (1991) Statistical Signal Processing: Detection, Estimation, and Time Series Analysis. Addison-Wesley series in electrical and computer engineering. Addison-Wesley Publishing Company. ISBN 9780201190380. URL https://books.google.com/books?id=y_dSAAAAMAAJ.
  • Schuster et al. (2016a) Schuster F, Keller CG, Rapp M, Haueis M and Curio C (2016a) Landmark based radar SLAM using graph optimization. In: 2016 IEEE 19th International Conference on Intelligent Transportation Systems (ITSC). pp. 2559–2564.
  • Schuster et al. (2016b) Schuster F, Wörner M, Keller CG, Haueis M and Curio C (2016b) Robust localization based on radar signal clustering. pp. 839–844.
  • Stanford Artificial Intelligence Laboratory et al. (2018) Stanford Artificial Intelligence Laboratory et al (2018) Robotic operating system. URL https://www.ros.org.
  • Stefan Saftescu et al. (2020) Stefan Saftescu S, Gadd M, de Martini D, Barnes D and Newman P (2020) Kidnapped radar: Topological radar localisation using rotationally-invariant metric learning. arXiv : 4358–4364.
  • Xiaoxuan Lu et al. (2020) Xiaoxuan Lu C, Risqi Saputra MU, Zhao P, Almalioglu Y, B de Gusmao PP, Chen C, Sun K, Trigoni N and Markham A (2020) milliEgo: Single-chip mmWave Radar Aided Egomotion Estimation via Deep Sensor Fusion mmWave radar IMU 6-DoF Pose Target Use Cases 10.1145/3384419.3430776.