Initial Commit

Author: rconsolo96

Data/.gitkeep

@@ -0,0 +1,15 @@
+function [XYZ] = calculateXYZ(Range)
+    % Setup Parameters
+    fov = 3*[1 1]; % [az el] adjust this to match sensor FOV
+    sensorLen = 128;
+
+    % Initialize matrices
+    az = linspace(-fov(1)/2,fov(1)/2,sensorLen);
+    el = linspace(-fov(2)/2,fov(2)/2,sensorLen);
+    az_matrix = repmat(az,[numel(el) 1]); %flip az as well to get same orientation as raw images
+    el_matrix= repmat(flip(el)',[1 numel(az)]);
+    
+    % Calculate cartesian coordinates from azimuth and elevation
+    [x_matrix,y_matrix,z_matrix] = sph2cart(az_matrix*pi/180,el_matrix*pi/180,Range);   
+    XYZ = cat(3,x_matrix,y_matrix,z_matrix);
+end

FlashLidarGIF.gif

@@ -0,0 +1,33 @@
+function [mask] = convertROItoMask(Image,ROI, RangeBuffer)
+% Initialize mask
+mask = false(size(Image));   
+
+if ~isempty(ROI)
+    % Create mask for all points inside bounding box
+    inROI = false(size(Image));
+    ROI = round(ROI);
+    inROI(ROI(2) :min(128,ROI(2)+ROI(4)), ROI(1):min(128,ROI(1)+ROI(3))) = true;
+    
+    % Calculate the "mode" of the range of the points within the bounding
+    % box, which is an estimate of the distance of the detected vehicle
+    % and eliminate all points that are too far or too close compared to the 
+    % estimated distance (Range +/- threshold 
+    rangeWindow = fix(Image(inROI & Image~=0)/1000)*1000;
+    midRange = mode(rangeWindow, "all"); 
+    inRange = (Image > midRange-RangeBuffer) & (Image < midRange+RangeBuffer);
+    
+    % Combine logical masks
+    mask = (inRange & inROI);
+    
+    % Morphological operations to improve estimated masks
+    % Fill holes
+    mask = imfill(mask, 'holes');
+    % Close mask
+    radius = 9;
+    decomposition = 0;
+    se = strel('disk', radius, decomposition);
+    mask = imclose(mask, se);
+end
+
+end
+

PreProcessingScripts/.gitkeep

@@ -0,0 +1,43 @@
+function [mask, cuboid] = convertROItoMask5Ch(Img5ch,maskSize, ROI, RangeBuffer, bgRange)
+% Improved version of ROI to Mask conversion function
+% This uses the same "mode" algorithm but also includes background removal, 
+% ground segmentation using SMRF, point cloud denoising, point cloud clustering,
+% and a cuboid fitting to also output the 3D cuboid ground truth on top of
+% the segmentation mask of the vehicle. 
+% Select the range channel from a 5-channel image
+RangeImg = Img5ch(:,:,5);   
+inROI = false(maskSize);
+ROI = round(ROI);
+% Mark pixels inside the provided ROI (clamped to 128x128 image)
+inROI(ROI(2) :min(128,ROI(2)+ROI(4)), ROI(1):min(128,ROI(1)+ROI(3))) = true;
+% Build a histogram of range values within ROI below background range (quantized to 10)
+rangeWindow = fix(RangeImg(inROI & (RangeImg < bgRange))./10).*10;
+% Estimate dominant range within the ROI
+midRange = mode(rangeWindow, "all");
+% Create a band-pass mask around the dominant range
+inRange = (RangeImg > midRange-RangeBuffer) & (RangeImg < midRange+RangeBuffer);
+mask = (inRange & inROI);
+XYZ = Img5ch(:,:,1:3);
+pCloud = pointCloud(XYZ);
+% Segment ground points and exclude them from the mask
+groundPtsIdx = segmentGroundSMRF(pCloud, ElevationThreshold=0.001);
+mask(groundPtsIdx) = false; 
+if nnz(mask) ~= 0
+    goodIdx = find(mask);
+    pCloudCrop = select(pCloud,goodIdx);
+    % Remove sparse outliers from the cropped point cloud
+    [~,~,outlierIndices] = pcdenoise(pCloudCrop, "NumNeighbors",10, "Threshold",2);
+    mask(goodIdx(outlierIndices)) = false;
+    
+    goodIdx = find(mask);
+    pCloudCrop = select(pCloud,goodIdx);
+    % Segment remaining points by distance and remove small/noise clusters
+    labels = pcsegdist(pCloudCrop,5);
+    outlierIndices = find(labels ~= mode(labels));
+    mask(goodIdx(outlierIndices)) = false;
+end
+goodIdx = find(mask);
+pCloudCrop = select(pCloud,goodIdx);
+% Fit a cuboid to the filtered point cloud
+cuboid = pcfitcuboid(pCloudCrop);
+end

PreProcessingScripts/calculateXYZ.m

@@ -0,0 +1,38 @@
+function generateFiveChanImages(dataFolder,imagesFolder)
+% Function that describes the creation of the 5 Channel images used to
+% train the SalsaNext model
+
+if ~exist(imagesFolder,'dir')
+    mkdir(imagesFolder);
+end
+
+rangeFolder = dir(fullfile(dataFolder,'*.png'));
+numFiles = size(rangeFolder,1);
+lowNoise = 1;
+highNoise = 1500;
+highInt = 3200;
+
+for ii = 1:numFiles
+    % Load images and calculate xyz
+    Img = im2double(imread(fullfile(dataFolder, rangeFolder(ii).name)));
+    Range = Img(:,:,1).* highNoise;
+    Intensity = Img(:,:,3) .* highInt;
+
+    % Set outliers to NaN
+    OutLog = Range < lowNoise | Range > highNoise;
+    Range(OutLog) = NaN;
+    Intensity(OutLog) = NaN;
+    XYZ = calculateXYZ(Range);
+
+    % Image are of 5-channels, namely x,y,z,intensity and range.
+    Img5ch = zeros([size(Img,[1,2]), 5]);
+    Img5ch(:,:,1:3) = XYZ;
+    Img5ch(:,:,4) = Intensity;
+    Img5ch(:,:,5) = Range;
+    
+    
+    % Store images and labels as .mat and .png files respectively.
+    imfile = fullfile(imagesFolder,[rangeFolder(ii).name(1:end-4), '.mat']);
+    save(imfile,'Img5ch');   
+end
+end

PreProcessingScripts/convertROItoMask.m

@@ -0,0 +1,110 @@
+# Flash LiDAR Vehicle Detection with MATLAB Dataset and Deep Learning Benchmarks
+
+![Flash Lidar Vehicle Tracking](FlashLidarGIF.gif)
+
+## Point Cloud Processing, Dataset Download, Deep Learning Models
+[![View <File Exchange Title> on File Exchange](https://www.mathworks.com/matlabcentral/images/matlab-file-exchange.svg)](https://www.mathworks.com/matlabcentral/fileexchange/182842-flash-lidar-vehicle-detection) 
+
+This repository provides code and workflows to test several state-of-the-art vehicle detection deep learning algorithms —including YOLOX, SalsaNext, and RandLA-Net— on a Flash Lidar dataset. The models are applied to 2D, 3D, and 5-channel data, supporting comprehensive benchmarking and research in autonomous vehicle perception. Also included are some point cloud processing techniques applied to the Flash Lidar to perform operations such as converting the raw data to images and point clouds, converting the ground truth bounding boxes to 2D/3D segmentation masks and cuboids, and more.  
+
+## Dataset Description
+This repository uses a Public Domain dataset collected specifically for benchmarking vehicle detection algorithms using a Flash LiDAR sensor. The dataset consists of 35 sequences featuring eight different vehicles—including seven four-wheel vehicles and a small plane. Each sequence was captured using a 128x128 Flash LiDAR sensor, recording range and intensity information for every detected point.
+
+The dataset is available in four distinct formats to support a variety of deep learning models:
+
+### 2D Image Format:
+
+Each image is a uint16 3 channel image, where range data is mapped to the 'red' channel and intensity data to the 'blue' channel. This format is recommended to test 2D object detection models such as YOLOX and other 2D segmentation models. Included with the images is the ground truth in form of bounding boxes and segmentation masks.
+
+### Point Cloud Format:
+
+Data is provided as PCD files, retaining both the spatial location and intensity for each point.
+Ideal for 3D detection and segmentation models like RandLA-Net. Included with the point clouds is the ground truth in form of cuboids and segmentation masks.
+
+
+### Multi-Channel Image Format:
+
+Each 128x128 image contains five channels: X, Y, Z, Range, and Intensity.
+Used for multi-channel models such as SalsaNext. Included with the images is the ground truth in form of bounding boxes, cuboids, and segmentation masks.
+
+
+### Raw Format:
+
+Two arrays of size 128x128xnFrames for each sequence, representing the unfiltered and unprocessed range and intensity recorded directly from the sensor. Included with the raw data is the ground truth in form of bounding boxes, cuboids, and segmentation masks.
+
+
+All data has been denoised by removing points beyond the 99th percentile of the standard deviation, and values are normalized and scaled to maximize detail in each format (e.g., stretching uint16 values to the full 0–2<sup>16</sup> range).
+
+
+## Setup 
+To Run:
+1. Download the Flash Lidar dataset from the links below in the format that works with the model that you want to test.
+2. Clone this repository and open it in MATLAB®.
+3. Extract the data and store it in the "Data\" directory of the repo.
+3. Follow the installation instructions below to set up required products and dependencies.
+4. Run the example scripts according to the model that you want to test.
+
+### Flash Lidar Dataset Download Links
+
+2D Data (PNG images + bounding box + mask ground truth)
+Download 2D Data (https://ssd.mathworks.com/supportfiles/lidar/data/FlashLidar/Data_2D.tar)
+
+3D Data (PCD Point cloud + cuboids + mask ground truth)
+Download 3D Data (https://ssd.mathworks.com/supportfiles/lidar/data/FlashLidar/Data_3D.tar)
+
+5-Channel Data (MAT 5-channel images [x, y, z, range, intensity] + bounding box + cuboids + mask ground truth)
+Download 5-Channel Data (https://ssd.mathworks.com/supportfiles/lidar/data/FlashLidar/Data_5Ch.tar)
+
+Raw Data (MAT arrays [range, intensity] + bounding box + cuboids + mask ground truth)
+Download Raw Data (https://ssd.mathworks.com/supportfiles/lidar/data/FlashLidar/Data_Raw.tar)
+
+Note that this dataset is very large and it can take several minutes to hours, depending on internet speed, to download the compressed folders using the links above.
+
+### Additional information about set up
+In order to run the examples in this repo you will need to install the MATLAB® products listed below.
+Additionally you will need to install the support package for each deep learning model that you want to train or test using the provided dataset. 
+
+Note that to run and train the deep learning models it is recommended to use a computer with a dedicated GPU. 
+
+ 
+### MathWorks Products (https://www.mathworks.com)
+
+- MATLAB®
+- Deep Learning Toolbox™
+- Computer Vision Toolbox™
+- Lidar Toolbox™
+- Automated Visual Inspection Library™
+- Parallel Computing Toolbox™ (Recommended)
+
+Requires MATLAB release R2024A or newer
+
+
+## Getting Started 
+
+This repository is organized to help you efficiently benchmark vehicle detection algorithms on Flash LiDAR data. Here’s how to navigate the folders and which dataset format to download for each deep learning workflow:
+
+"YOLOX_ObjectDetection/" 
+Contains code, scripts, and configurations for running the YOLOX 2D detection model.
+Required data: Download the 2D Image Format dataset (range and intensity as uint16x3 images).
+
+"SalsaNext_SemanticSegmentation/" 
+Includes all necessary code and scripts for the SalsaNext segmentation model, which operates on 5-channel LiDAR images.
+Required data: Download the 5-Channel Multi-Channel Image Format dataset (128x128 images with X, Y, Z, Range, Intensity channels).
+
+"RandLANet_SemanticSegmentation/" 
+Provides code and scripts for the RandLA-Net segmentation model, designed for processing point cloud (PCD) data.
+Required data: Download the Point Cloud Format dataset (point cloud files with location and intensity information).
+
+"PreProcessingScripts/" 
+Offers utilities and functions for general point cloud processing tasks such as filtering and visualization. These are the scripts that we used to convert the original raw data to the other formats downloadable in the repo. If you want to make modifications on how the data was processed you can use these as a starting point. 
+Required data: Download the Raw Data Format dataset (Array including the recorded range and intensity).
+
+## License
+
+The license for the scripts is available in the License.txt file in this GitHub repository.
+The license for the dataset is included in the compressed folder you can download from the links above in a separate License.txt file. 
+
+## Community Support
+[MATLAB Central](https://www.mathworks.com/matlabcentral)
+
+Copyright 2025 The MathWorks, Inc.

PreProcessingScripts/convertROItoMask5Ch.m

@@ -0,0 +1,22 @@
+function cmap = lidarColorMap()
+% Lidar color map for the pandaset classes
+
+% Copyright 2026 The MathWorks, Inc
+
+cmap = [[30,30,30];      % UnClassified
+        [0,255,0];       % Vegetation
+        [255, 150, 255]; % Ground
+        [255,0,255];     % Road
+        [255,0,0];       % Road Markings
+        [90, 30, 150];   % Side Walk
+        [245,150,100];   % Car
+        [250, 80, 100];  % Truck
+        [150, 60, 30];   % Other Vehicle
+        [255, 255, 0];   % Pedestrian
+        [0, 200, 255];   % Road Barriers
+        [170,100,150];   % Signs
+        [30, 30, 255]];  % Building
+
+cmap = cmap./255;
+
+end