Properties

Dataset map

The Dataset was collected in Pohang, South Korea, by following a 7.5 km long trajectory including a narrow canal area, inner/outer port area, and a near-coastal area.

File Format

All data are stored with acquisition times. The AHRS and GPS data are stored with the timestamp, images are named in sequence number and the corresponding timestamp is in timestamp.txt file, and LiDAR point cloud files are named in unix time (in nanoseconds).

AHRS Format

All AHRS data in a single sequence are stored in one file as ahrs.txt in the navigation folder. 11 values as the following table are written in tab-delimited format. (The orientation is expressed as a quaternion)

GPS Format

All GPS signals in a single sequence are stored in one file as gps.txt in the navigation folder. Eleven values as in the following table are written in a tab-delimited format for each timestamp.

Baseline Trajectory

The baseline trajectory was created by fusing GPS, AHRS, and LiDAR data into a graph SLAM framework using GTSAM. LiDAR-inertial odometry with GPS and AHRS attitude correction was utilized to estimate the vehicle trajectory in the canal area to the inner port area. The trajectory of the rest of the area was estimated without the LiDAR measurements. Figure below shows the overlay of the LiDAR point cloud map and trajectory to the satellite image.

The baseline trajectory is stored as baseline.txt in the navigation folder for each dataset. Eight values as in the following table are written in a tab-delimited format for each timestamp.

Timestamps

timestamp.txt

<timestamp> <sequence> in tab-delimited format

The timestamps of the stereo camera, infrared camera, omnidirectional camera, and radar images are saved in timestamp.txt for each folder. Each sequence corresponds to the image name. For instance, the line "1625206052.228731 000014" in the timestamp.txt of the stereo camera indicates that 000014.png files in left_images and right_images are collected in Unix time 1625206052.228731 (s).

Infrared Images

The infrared images are saved as 16-bit png images encoded with 14-bit thermal data. The temperature of each pixel can be calculated as:

temperature = 0.04 * pixel_value - 273.15 (celsius)

You can adjust the temperature range to get visible infrared images, as example below.

LiDAR Format

The LiDAR data is written in binary files as following order:

Reading LiDAR data on C++

The code below shows an example of how to read the LiDAR point cloud binary file in c++.

std::ifstream is(<pointcloud_path>, std::ios::in | std::ios::binary);

while(is) {

float x;

float y;

float z;

float intensity;

uint32_t time; //nanosecond

uint16_t reflectivity;

uint16_t ambient;

uint32_t range;

is.read((char*)&x, sizeof(float));

is.read((char*)&y, sizeof(float));

is.read((char*)&z, sizeof(float));

is.read((char*)&intensity, sizeof(float));

is.read((char*)&time, sizeof(uint32_t));

is.read((char*)&reflectivity, sizeof(uint16_t));

is.read((char*)&ambient, sizeof(uint16_t));

is.read((char*)&range, sizeof(uint32_t));

}

is.close();

Reading LiDAR data on Matlab

The 'fread' function in matlab can read one kind of format at once, so you might need to read each data type one by one. We can read the data by using the 'skip' parameter in the 'fread' function. The function format is as : "fread(fileID,sizeA,precision,skip)"

The following code is an example of reading x, y, z coordinates from the binary file.

fileID = fopen(lidar_path);

x = fread(fileID, inf, 'float', 24);

fseek(fileID, 4, 'bof');

y = fread(fileID, inf, 'float', 24);

fseek(fileID, 8, 'bof');

z = fread(fileID, inf, 'float', 24);

fseek(fileID, 12, 'bof');

intensity = fread(fileID, inf, 'float', 24);

Since the total size of one point is 28 (4 + 4 + 4 + 4 + 4 + 2 + 2 + 4) bytes, the number '24' is the skip number to read float data (28 - 4 = 24). Also, to read the data which starts after some elements, skipping bytes of the previous elements can be done by 'fseek' function.

For example, the x coordinates start first, so it does not need 'fseek' function, but for y coordinates, it starts after the x coordinate, so skipping 4 bytes after the beginning of first (bof) is required before reading the data.

If you want to read 'reflectivity', the code is as follows:

fseek(fileID, 20, 'bof');

reflectivity = fread(fileID, inf, 'uint16', 26);

You can read the rest of the data (time, reflectivity, ...) using the same principle.

Reading LiDAR data on Python Numpy

By setting the dtype following the binary file structure above, the "fromfile" function can load the lidar data. Code below shows an example of loading the point cloud binary file and getting the x, y, and z coordinates.

lidar_dtype=[('x', np.float32), ('y', np.float32), ('z', np.float32), ('intensity', np.float32), ('time', np.uint32), ('reflectivity', np.uint16), ('ambient', np.uint16), ('range', np.uint32)]

scan = np.fromfile(<binary_file_path>, dtype=lidar_dtype)

points = np.stack((scan['x'], scan['y'], scan['z']), axis=-1)

Timestamp for radar images

The timestamp_deg.txt in radar folder contains the updated portion of the radar image expressed in angles. The <Unix time> is the time when the updated radar signal has reached the <end degree>, image sequence is corresponding image in the images folder

Calibration

intrinsics.json

The intrinsics.json file contains the focal length, coordinates of the principal point, distortion coefficients, image height, and image width of each camera. The distortion coefficients are given as a vector containing five values, which follows the OpenCV representation.

extrinsics.json

The extrinsic.json file contains the pose of each sensor in the AHRS coordinate system. The (x, y, z) coordinates are given as a vector, "translation", and the rotation is provided as a quaternion (qx, qy, qz, qw), "quaternion".