lidar_dataset/read_data.py

# This example loads a stereo pair together with LiDAR points associated with the stereo pair at that time instance
# The LiDAR data is returned in the following form
# 'lidar_points' is a list of 'lidar_points'
# where 'lidar_point' is a dictionary containing:
# 'backscatter': the backscatter profile scanned by the LiDAR
# 'azi': the azimuthal angle of the scanned ray
# 'elev': the elevation angle of the scanned ray
# In addition, if a cloud is detected from the backscatter, then 'lidar_point' also contains:
# 'lidar_depth': the depth from the LiDAR to the cloud
# 'right_cam_xy': the xy coordinates of the cloud in the right image
# 'right_cam_depth': the depth of the cloud to the right camera

from PIL import Image
import numpy as np
import cv2
import json
import glob
from collections import defaultdict

def main():
    # Choose input images to load
    date = '2021-10-22'
    hour = 12
    frame_idx = 50
    
    # Load metadata
    with open(f'calib.json', 'r') as fp:
        meta = json.load(fp)

    h, w = meta['h'], meta['w']
    right_intrinsic = np.array(meta['right_intrinsic'])
    lidar_to_right = np.array(meta['lidar_to_right_cam'])
    
    # Unused metadata in this example
    # right_cam2world = np.array(meta['right_cam2world'])
    # left_intrinsic = np.array(meta['left_intrinsic'])
    # left_cam2world = np.array(meta['left_cam2world'])
    # left_to_right = np.array(meta['left_to_right_pose'])


    # Load LiDAR data associated with this time
    lidar_files = glob.glob(f'lidar/{date}/{hour:0>2}*.hpl')
    lidar_data = load_lidar_data(date, hour, right_intrinsic, lidar_to_right)

    # ---------- Load Data --------- #
    left_video = cv2.VideoCapture(f'left_images/{date}/{date}_{hour:0>2}.mp4')
    right_video = cv2.VideoCapture(f'right_images/{date}/{date}_{hour:0>2}.mp4')
    
    for _ in range(frame_idx):
        left_video.read()
        right_video.read()
    
    _, left_image = left_video.read()
    _, right_image = right_video.read()
    
    # BGR To RGB
    left_image = cv2.cvtColor(left_image, cv2.COLOR_BGR2RGB).astype('uint8')
    right_image = cv2.cvtColor(right_image, cv2.COLOR_BGR2RGB).astype('uint8')
    
    # Ensure images match the expected size
    left_image = cv2.resize(left_image, (w, h))
    right_image = cv2.resize(left_image, (w, h))
    
    # See top of file for the format of 'lidar_points'
    lidar_points = lidar_data[frame_idx]

    return left_image, right_image, lidar_points
    
    
    
    
    
    
    
    
    
    
    
    


################ Define some helper functions ################
def load_lidar_data(date, hour, right_intrinsic, lidar_to_right):
    def flattenList(xss):
        return [x for xs in xss for x in xs]
    
    decimal_time = []
    azi = []
    elev = []
    distance = []
    backscatter = []
    
    lidar_files = glob.glob(f'lidar/{date}/{date}_{hour:0>2}*.hpl')

    for lidar_file in lidar_files:
        ld = LidarData.fromfile(lidar_file)
        
        data_locs = ld.data_locs
        decimal_time.append(list(data_locs[:,0]))
        azi.append(list(data_locs[:,1]))
        elev.append(list(data_locs[:,2]))
        distance.append(list(ld.getDistance()))
        backscatter.append(list(ld.getBackscatter()))
    
    decimal_time = np.array(flattenList(decimal_time), ndmin=1)
    azi = np.array(flattenList(azi), ndmin=1)
    elev = np.array(flattenList(elev), ndmin=1)
    distance = np.array(flattenList(distance), ndmin=1)
    backscatter = np.array(flattenList(backscatter), ndmin=1)
    
    # Go through all frames now
    camera_time = hour + 10/3600  # First frame starts 10 seconds into the hour
    
    lidar_output = defaultdict(list)

    # Simple unoptimised code for LiDAR loading
    for frame_idx in range(717):  # 717 frames per video
        
        for time in decimal_time:
            
            if np.abs(time-camera_time) < 2.5/3600:  # Associate each LiDAR point with the closest frame (1 frame per 5 seconds)
                i = list(decimal_time).index(time)

                # Check if there is a cloud
                _, cloud_depth = findCloud_in_backscatter(backscatter[i], int(500 / 3))  

                if cloud_depth is not None:
                    # Project lidar to right camera
                    lidar_right_xy, lidar_right_depth = project_lidar_to_right(lidar_to_right, right_intrinsic, azi[i],
                                                                            elev[i],
                                                                            cloud_depth)

                    
                    lidar_output[frame_idx].append({'lidar_depth': cloud_depth, 'azi': azi[i], 'elev': elev[i],
                                                    'right_cam_xy': lidar_right_xy, 'right_cam_depth': lidar_right_depth,
                                                    'backscatter': backscatter[i]})
                else:
                    lidar_output[frame_idx].append({'azi': azi[i], 'elev': elev[i], 'backscatter': backscatter[i]})
    
        camera_time += 5/3600

    return lidar_output
    
class LidarData():
    def __init__(self,
                 fname=None,
                 system_id=None,
                 num_gates=0,
                 gate_length=0,
                 gate_pulse_length=0,
                 pulses_per_ray=0,
                 start_time=None,
                 data=None,
                 data_locs=None):
        self.fname = fname
        self.system_id = system_id
        self.num_gates = num_gates
        self.gate_length = gate_length
        self.gate_pulse_length = gate_pulse_length
        self.pulses_per_ray = pulses_per_ray
        self.start_time = start_time
        self.data = data
        self.data_locs = data_locs

    @classmethod
    def fromfile(cls, filename):
        with open(filename) as f:
            header = [f.readline().split(':', maxsplit=1) for i in range(17)]
            
            fname = header[0][1].strip()
            system_id = header[1][1].strip()
            num_gates = int(header[2][1].strip())
            gate_length = header[3][1].strip()
            gate_pulse_length = header[4][1].strip()
            pulses_per_ray = header[5][1].strip()
            start_time = header[9][1].strip()
            data_locs_format = header[13][0].split(' ')[0].strip()
            data_format = header[15][0].split(' ')[0].strip()

            data = []
            data_locs = []
            while True:
                try:
                    data_locs_in = np.array(f.readline().split()).astype('float')
                    if len(data_locs_in) == 0:
                        break
                    data_locs.append(data_locs_in)
                    data.append(np.array(
                        [f.readline().split() for i in range(num_gates)]).astype('float'))
                except:
                    break
            data = np.array(data)
            data_locs = np.array(data_locs)

            return cls(
                 fname=fname,
                 system_id=system_id,
                 num_gates=num_gates,
                 gate_length=gate_length,
                 gate_pulse_length=gate_pulse_length,
                 pulses_per_ray=pulses_per_ray,
                 start_time=start_time,
                 data=data,
                 data_locs=data_locs)
        
    # starting all these at 20 means we avoid the peak at zero distance    
    def getDistance(self):
        return self.data[:,20:,0]*3 #multiply by 3 to get distance in m
    
    def getDoppler(self):
         return self.data[:,20:,1]
    
    def getBackscatter(self):
         return self.data[:,20:,2]
     
    def getBeta(self):
         return self.data[:,20:,3]


def project_lidar_to_right(lidar_to_right_cam, right_intrinsic, azi, elev, depth):
    # Convert from azi, elev, depth to lidar xyz
    azi = -azi + 270
    x = depth * np.cos(elev * np.pi / 180) * np.cos(azi * np.pi / 180)
    z = depth * np.cos(elev * np.pi / 180) * np.sin(azi * np.pi / 180)
    y = -depth * np.sin(elev * np.pi / 180) 
    
    lidar_xyz = np.stack((x, y, z), axis=0)

    # Go from lidar coordinate system to right camera coordinate system
    desired_shape = list(lidar_xyz.shape)
    desired_shape[0] = 1
    cam_xyz = lidar_to_right_cam @ np.concatenate((lidar_xyz, np.ones(desired_shape)), axis=0)

    # Note: here you can also use the left_to_right_pose to project onto the left camera

    # Project onto right camera
    projected_lidar = cam_xyz[:3] / cam_xyz[2]
    projected_lidar = right_intrinsic @ projected_lidar
    projected_lidar = projected_lidar[:2]

    # Get depth
    right_cam_depth = np.sqrt(np.sum(cam_xyz ** 2, axis=0))
    
    return projected_lidar, right_cam_depth

def findCloud_in_backscatter(backscatter, dist_thresh=300):
    if np.max(backscatter) > 10:
        # Building reflection
        return (None, None)
    
    cloud = np.argmax(backscatter[dist_thresh:])
    if backscatter[cloud+dist_thresh] - np.median(backscatter[dist_thresh:]) > 0.03: 
        # Found cloud
        return cloud+dist_thresh, (cloud+dist_thresh+20)*3 #cloud index, cloud distance
    else:
        # No cloud found
        return (None, None)
    
##############################################################



if __name__ == "__main__":
    left_image, right_image, lidar_points = main()