Upload folder using huggingface_hub

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Temple Robotics and Artificial Intelligence Lab
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,3 +1,570 @@
----
-license: mit
----
+# Semantic2D: Enabling Semantic Scene Understanding with 2D Lidar Alone
+
+Implementation code for our paper ["Semantic2D: Enabling Semantic Scene Understanding with 2D Lidar Alone"](https://arxiv.org/pdf/2409.09899).
+Video demos can be found at [multimedia demonstrations](https://youtu.be/P1Hsvj6WUSY).
+The Semantic2D dataset can be found and downloaded at: https://doi.org/10.5281/zenodo.18350696.
+
+---
+
+## Related Resources
+
+- **Dataset Download:** https://doi.org/10.5281/zenodo.18350696
+- **SALSA (Dataset and Labeling Framework):** https://github.com/TempleRAIL/semantic2d
+- **S³-Net (Stochastic Semantic Segmentation):** https://github.com/TempleRAIL/s3_net
+- **Semantic CNN Navigation:** https://github.com/TempleRAIL/semantic_cnn_nav
+
+## Demos
+
+**S³-Net Segmentation**
+![S³-Net Segmentation](demos/1.lobby_s3net_segmentation.gif)
+
+**Semantic Mapping**
+![Semantic Mapping](demos/2.lobby_semantic_mapping.gif)
+
+**Semantic Navigation**
+![Semantic Navigation](demos/3.lobby_semantic_navigation.gif)
+
+## Table of Contents
+
+1. [Requirements](#requirements)
+2. [Installation](#installation)
+3. [Dataset Description](#semantic2d-dataset-description)
+4. [Semi-Automatic Labeling (SALSA)](#semi-automatic-labeling-usage)
+   - [Step 1: Data Collection](#step-1-data-collection)
+   - [Step 2: Manual Labeling](#step-2-manual-labeling)
+   - [Step 3: Automatic Labeling](#step-3-automatic-labeling)
+5. [Customizing for Different LiDAR Sensors](#customizing-for-different-lidar-sensors)
+6. [Visualization](#visualization)
+7. [Citation](#citation)
+
+---
+
+## Requirements
+
+- Ubuntu 20.04
+- ROS Noetic
+- Python 3.8
+- Labelme
+- scikit-learn
+- tqdm
+- PyTorch
+- NumPy
+- Pillow
+
+---
+
+## Installation
+
+```bash
+# Clone the repository
+git clone https://github.com/TempleRAIL/semantic2d.git
+cd semantic2d
+
+# Install Python dependencies
+pip install labelme scikit-learn tqdm torch numpy pillow
+
+# Install LabelMe configuration with pre-defined semantic classes
+cp salsa/manually_labeling/.labelmerc ~/.labelmerc
+```
+
+---
+
+## Semantic2D Dataset Description
+
+The dataset contains the following data types:
+
+| Folder | Description | Shape |
+|--------|-------------|-------|
+| `scans_lidar/` | 2D LiDAR range data | (N,) array |
+| `intensities_lidar/` | 2D LiDAR intensity data | (N,) array |
+| `line_segments/` | Extracted line segments | List of [x1,y1,x2,y2] |
+| `positions/` | Robot position in map frame | (3,) array [x, y, yaw] |
+| `velocities/` | Robot velocity commands | (2,) array [Vx, Wz] |
+| `semantic_label/` | Point-wise semantic labels | (N,) array |
+
+### Semantic Classes
+
+| ID | Class | Color (RGB) |
+|----|-------|-------------|
+| 0 | Other/Background | - |
+| 1 | Chair | (109, 0, 156) |
+| 2 | Door | (0, 46, 221) |
+| 3 | Elevator | (0, 164, 187) |
+| 4 | Person | (204, 204, 204) |
+| 5 | Pillar | (0, 155, 18) |
+| 6 | Sofa | (0, 225, 0) |
+| 7 | Table | (203, 249, 0) |
+| 8 | Trash bin | (255, 173, 0) |
+| 9 | Wall | (227, 0, 0) |
+
+---
+
+## Semi-Automatic Labeling Usage
+
+SALSA (Semi-Automatic Labeling framework for Semantic Annotation) consists of three steps:
+
+---
+
+### Step 1: Data Collection
+
+Collect and save data from a rosbag file. **Prerequisites:** You should have already created an environment map using a mapping package (e.g., `gmapping`) and collected raw rosbag data.
+
+#### 1.1 Configure Data Collection
+
+Edit `salsa/manually_labeling/dataset_collection.py`:
+
+```python
+################ CUSTOMIZATION REQUIRED ################
+
+# Number of LiDAR points (must match your sensor)
+POINTS = 1081  # Hokuyo: 1081, WLR-716: 811, RPLIDAR-S2: 1972
+
+# Output directory for collected data
+DATA_PATH = "~/semantic2d_data/2024-04-11-15-24-29"
+```
+
+#### 1.2 Configure Line Extraction Launch File
+
+The `laser_line_extraction` package extracts line features from LiDAR scans for ICP alignment. **You must configure it for your LiDAR sensor.**
+
+Edit `salsa/manually_labeling/semantic_data_collection_ws/src/laser_line_extraction/launch/example.launch`:
+
+```xml
+<launch>
+  <node name="line_extractor" pkg="laser_line_extraction" type="line_extraction_node">
+    <!--################ CUSTOMIZATION REQUIRED ################-->
+
+    <!-- LiDAR frame ID (from your URDF or tf tree) -->
+    <param name="~frame_id" value="rear_laser" />
+
+    <!-- LiDAR scan topic name -->
+    <param name="~scan_topic" value="scan" />
+
+    <!-- Sensor range parameters (must match your LiDAR) -->
+    <param name="~min_range" value="0.6" />
+    <param name="~max_range" value="60.0" />
+
+    <!--################ Usually no changes needed below ################-->
+    <param name="~frequency" value="30.0" />
+    <param name="~publish_markers" value="false" />
+    <param name="~bearing_std_dev" value="1e-5" />
+    <param name="~range_std_dev" value="0.02" />
+    <param name="~least_sq_angle_thresh" value="0.0001" />
+    <param name="~least_sq_radius_thresh" value="0.0001" />
+    <param name="~max_line_gap" value="1.0" />
+    <param name="~min_line_length" value="0.4" />
+    <param name="~min_split_dist" value="0.04" />
+    <param name="~outlier_dist" value="0.06" />
+    <param name="~min_line_points" value="15" />
+  </node>
+</launch>
+```
+
+**Key parameters to change:**
+
+| Parameter | Description | Example Values |
+|-----------|-------------|----------------|
+| `frame_id` | TF frame of your LiDAR | `laser`, `base_scan`, `rear_laser`, `rplidar_link` |
+| `scan_topic` | ROS topic for LiDAR scans | `scan`, `/scan`, `/rplidar/scan` |
+| `min_range` | Minimum valid range (m) | Hokuyo: 0.1, WLR-716: 0.15, RPLIDAR: 0.2 |
+| `max_range` | Maximum valid range (m) | Hokuyo: 60.0, WLR-716: 25.0, RPLIDAR: 30.0 |
+
+**How to find your frame_id:**
+```bash
+# Method 1: From rostopic
+rostopic echo /scan --noarr -n 1 | grep frame_id
+
+# Method 2: From tf tree
+rosrun tf view_frames  # Creates frames.pdf
+```
+
+#### 1.3 Configure ROS Topics for Data Collection
+
+The default ROS topic subscriptions in `dataset_collection.py` are:
+
+| Topic | Message Type | Description |
+|-------|--------------|-------------|
+| `scan` | `sensor_msgs/LaserScan` | LiDAR scan data |
+| `line_segments` | `laser_line_extraction/LineSegmentList` | Line features |
+| `bluetooth_teleop/cmd_vel` | `geometry_msgs/Twist` | Velocity commands |
+| `robot_pose` | `geometry_msgs/PoseStamped` | Robot pose |
+
+**To customize for your robot**, modify the subscribers in `dataset_collection.py`:
+
+```python
+# Example: For Hokuyo UTM-30LX-EW lidar
+self.scan_sub = rospy.Subscriber("/scan", LaserScan, self.scan_callback)
+self.dwa_cmd_sub = rospy.Subscriber('/cmd_vel', Twist, self.dwa_cmd_callback)
+self.robot_pose_pub = rospy.Subscriber('/amcl_pose', PoseWithCovarianceStamped, self.robot_pose_callback)
+
+# Example: For custom robot with namespaced topics
+self.scan_sub = rospy.Subscriber("/my_robot/laser/scan", LaserScan, self.scan_callback)
+```
+
+#### 1.4 Run Data Collection
+
+```bash
+# Terminal 1: Start ROS master
+roscore
+
+# Terminal 2: Compile and launch line extraction
+cd salsa/manually_labeling/semantic_data_collection_ws
+catkin_make
+source devel/setup.bash
+roslaunch laser_line_extraction example.launch
+
+# Terminal 3: Start data collection
+cd salsa/manually_labeling
+python dataset_collection.py
+
+# Terminal 4: Play rosbag
+rosbag play your_data.bag
+```
+
+#### 1.5 Generate Train/Dev/Test Splits
+
+After data collection, generate index files (`train.txt`, `dev.txt`, `test.txt`) that define the dataset splits.
+
+**Configure** `salsa/manually_labeling/generateTrainDevSet.py`:
+
+```python
+################ CUSTOMIZATION REQUIRED ################
+# The path of your dataset folder:
+train_folder = '~/semantic2d_data/2024-04-11-15-24-29'
+
+# Split percentages (must sum to 1.0)
+TRAIN_RATIO = 0.70  # 70% for training
+DEV_RATIO = 0.10    # 10% for validation/development
+TEST_RATIO = 0.20   # 20% for testing
+########################################################
+```
+
+**Run the script:**
+
+```bash
+cd salsa/manually_labeling
+python generateTrainDevSet.py
+```
+
+**Example output:**
+```
+Dataset folder: /home/user/semantic2d_data/2024-04-11-15-24-29
+Total samples: 20427
+Split ratios: Train=70%, Dev=10%, Test=20%
+Split sizes:  Train=14298, Dev=2042, Test=4087
+
+Generated split files:
+  - /home/user/.../train.txt
+  - /home/user/.../dev.txt
+  - /home/user/.../test.txt
+Done!
+```
+
+The script automatically:
+- Counts total samples in the `positions/` folder
+- Calculates split sizes based on the defined ratios
+- Shuffles data randomly before splitting
+- Generates the three `.txt` files with sample filenames
+
+---
+
+### Step 2: Manual Labeling
+
+Use LabelMe to manually label the environment map with semantic classes.
+
+#### 2.1 Run LabelMe
+
+```bash
+labelme
+
+# Optionally, use RViz to visualize RGB images while labeling:
+roscore
+rosbag play your_data.bag
+rviz  # Add Image display for camera topic
+```
+
+#### 2.2 Labeling Process
+
+1. **Open** your occupancy grid map image (`.pgm` or `.png`)
+2. **Create polygons** around each object (`Ctrl+N`)
+3. **Select class** from dropdown: Chair, Door, Elevator, Pillar, Sofa, Table, Trash bin, Wall
+4. **DO NOT label people** - they are automatically detected as dynamic objects
+5. **Save** as `.json` file
+
+**Demo: How to use LabelMe**
+![Labelme example](./salsa/manually_labeling/labelme_example.svg "labelme_example")
+
+![Labelme demo](./demos/labelme_demo.gif "How to use LabelMe for semantic labeling")
+
+
+**Keyboard shortcuts:**
+
+| Shortcut | Action |
+|----------|--------|
+| `Ctrl+N` | Create new polygon |
+| `Ctrl+S` | Save annotation |
+| `Ctrl+Z` | Undo |
+| `Delete` | Delete selected polygon |
+| `Ctrl+E` | Edit label |
+| `D` | Next image |
+| `A` | Previous image |
+
+#### 2.3 Export Labeled Map
+
+```bash
+# Export to label images
+labelme_export_json your_map.json -o labelme_output
+
+# For older labelme versions:
+# labelme_json_to_dataset your_map.json -o labelme_output
+```
+
+**Output structure** (see [labelme_output](./salsa/manually_labeling/labelme_output)):
+
+```
+labelme_output/
+├��─ img.png           # Original map image
+├── label.png         # Semantic label image (class IDs)
+├── label_viz.png     # Colored visualization
+└── label_names.txt   # Class name list
+```
+
+---
+
+### Step 3: Automatic Labeling
+
+Use ICP-based scan matching to automatically transfer labels from the map to each LiDAR scan.
+
+#### 3.1 Configure Automatic Labeling
+
+Edit `salsa/automatic_labeling/semi_automated_labeling_framework.py`:
+
+```python
+################ CUSTOMIZATION REQUIRED ################
+
+# Dataset paths
+DATASET_ODIR = "/home/user/semantic2d_data/2024-04-04-12-16-41"
+DATASET_NAME = "train"  # Options: train, dev, test
+
+# Map parameters (from your_map.yaml file)
+MAP_ORIGIN = np.array([-21.200000, -34.800000, 0.000000])  # [x, y, theta]
+MAP_RESOLUTION = 0.025000  # meters per pixel
+
+# Labeled map paths (from Step 2)
+MAP_LABEL_PATH = '../manually_labeling/labelme_output/label.png'
+MAP_PATH = '../manually_labeling/labelme_output/img.png'
+
+# LiDAR sensor parameters (see Customization section below)
+POINTS = 1081
+AGNLE_MIN = -2.356194496154785  # -135 degrees in radians
+AGNLE_MAX = 2.356194496154785   # +135 degrees in radians
+RANGE_MAX = 60.0
+
+# URDF: LiDAR to base_link transformation
+JOINT_XYZ = [-0.12, 0.0, 0.0]   # [x, y, z] translation
+JOINT_RPY = [0.0, 0.0, 0.0]     # [roll, pitch, yaw] rotation
+```
+
+#### 3.2 Run Automatic Labeling
+
+```bash
+cd salsa/automatic_labeling
+python semi_automated_labeling_framework.py
+```
+
+**What the algorithm does:**
+1. For each LiDAR scan:
+   - Extract line features (stable structures like walls)
+   - Use ICP to refine robot pose alignment with the map
+   - Project LiDAR points to map coordinates
+   - Match each point to semantic labels via pixel lookup
+   - Points in free space → labeled as "Person" (dynamic objects)
+
+---
+
+## Customizing for Different LiDAR Sensors
+
+### Supported Sensor Configurations
+
+The code includes pre-configured parameters for three sensors:
+
+| Parameter | Hokuyo UTM-30LX-EW | WLR-716 | RPLIDAR-S2 |
+|-----------|-------------------|---------|------------|
+| `POINTS` | 1081 | 811 | 1972 |
+| `ANGLE_MIN` (rad) | -2.356 (-135°) | -2.356 (-135°) | -3.142 (-180°) |
+| `ANGLE_MAX` (rad) | 2.356 (+135°) | 2.356 (+135°) | 3.142 (+180°) |
+| `RANGE_MIN` (m) | 0.1 | 0.15 | 0.2 |
+| `RANGE_MAX` (m) | 60.0 | 25.0 | 30.0 |
+| `JOINT_XYZ` | [-0.12, 0, 0] | [0.065, 0, 0.182] | [0.065, 0, 0.11] |
+| `JOINT_RPY` | [0, 0, 0] | [3.14, 0, 0] | [0, 0, 3.14] |
+| `frame_id` (launch) | `rear_laser` | `wlr716_link` | `rplidar_link` |
+| `scan_topic` (launch) | `scan` | `/wj716_base/scan` | `/rplidar_base/scan` |
+
+### How to Configure Your Own Sensor
+
+#### Method 1: From ROS Topic
+
+```bash
+# Get sensor parameters from ROS
+rostopic echo /scan --noarr -n 1
+
+# Output shows:
+# angle_min: -2.356...
+# angle_max: 2.356...
+# angle_increment: 0.00436...
+# range_max: 60.0
+# ranges: <array with N elements>
+```
+
+#### Method 2: Calculate from Specifications
+
+```python
+import numpy as np
+
+# From your sensor datasheet
+fov_degrees = 270           # Field of view
+angular_resolution = 0.25   # Degrees per point
+
+# Calculate parameters
+points = int(fov_degrees / angular_resolution) + 1  # = 1081
+angle_min = -np.radians(fov_degrees / 2)  # = -2.356
+angle_max = np.radians(fov_degrees / 2)   # = +2.356
+```
+
+### URDF Transformation (JOINT_XYZ, JOINT_RPY)
+
+Find the LiDAR mounting position from your robot's URDF file:
+
+```xml
+<!-- In your robot.urdf -->
+<joint name="laser_joint" type="fixed">
+  <origin xyz="-0.12 0.0 0.0" rpy="0 0 0"/>
+  <parent link="base_link"/>
+  <child link="laser_frame"/>
+</joint>
+```
+
+```python
+# Use these values in the config
+JOINT_XYZ = [-0.12, 0.0, 0.0]  # From xyz attribute
+JOINT_RPY = [0.0, 0.0, 0.0]    # From rpy attribute
+```
+
+### Complete Example: Adding a New Sensor
+
+In `semi_automated_labeling_framework.py`:
+
+```python
+################ CUSTOMIZATION REQUIRED ################
+
+# Comment out existing configuration
+# # Hokuyo UTM-30LX-EW:
+# POINTS = 1081
+# AGNLE_MIN = -2.356194496154785
+# ...
+
+# Add YOUR sensor configuration:
+# SICK TiM561:
+POINTS = 811              # From rostopic echo /scan
+AGNLE_MIN = -2.356        # -135 degrees
+AGNLE_MAX = 2.356         # +135 degrees
+RANGE_MAX = 10.0          # 10 meters
+
+# URDF transformation (from robot model)
+JOINT_XYZ = [0.15, 0.0, 0.2]   # Mounted 15cm forward, 20cm up
+JOINT_RPY = [0.0, 0.0, 0.0]    # No rotation
+```
+
+### Modifying Data Collection for Your Robot
+
+In `dataset_collection.py`:
+
+```python
+################ CUSTOMIZATION REQUIRED ################
+
+# 1. Set number of points for your sensor
+POINTS = 811  # Your sensor's point count
+
+# 2. Set output directory
+DATA_PATH = "~/my_robot_data/environment_1"
+
+# 3. Modify ROS subscribers for your topics (in __init__):
+
+# Original (Jackal robot):
+self.scan_sub = rospy.Subscriber("scan", LaserScan, self.scan_callback)
+self.dwa_cmd_sub = rospy.Subscriber('bluetooth_teleop/cmd_vel', Twist, self.dwa_cmd_callback)
+self.robot_pose_pub = rospy.Subscriber('robot_pose', PoseStamped, self.robot_pose_callback)
+
+# For YOUR robot (example):
+self.scan_sub = rospy.Subscriber("/my_robot/scan", LaserScan, self.scan_callback)
+self.dwa_cmd_sub = rospy.Subscriber('/my_robot/cmd_vel', Twist, self.dwa_cmd_callback)
+self.robot_pose_pub = rospy.Subscriber('/amcl_pose', PoseWithCovarianceStamped, self.robot_pose_callback)
+```
+
+### Quick Reference: Files to Modify
+
+| Task | File | Parameters to Change |
+|------|------|---------------------|
+| Line Extraction | `salsa/manually_labeling/semantic_data_collection_ws/src/laser_line_extraction/launch/example.launch` | `frame_id`, `scan_topic`, `min_range`, `max_range` |
+| Data Collection | `salsa/manually_labeling/dataset_collection.py` | `POINTS`, `DATA_PATH`, ROS topics |
+| Dataset Splits | `salsa/manually_labeling/generateTrainDevSet.py` | `train_folder`, `TRAIN_RATIO`, `DEV_RATIO`, `TEST_RATIO` |
+| Manual Labeling | `~/.labelmerc` | Label names/colors (optional) |
+| Auto Labeling | `salsa/automatic_labeling/semi_automated_labeling_framework.py` | `DATASET_ODIR`, `MAP_*`, `POINTS`, `ANGLE_*`, `JOINT_*` |
+| Visualization | `salsa/automatic_labeling/draw_semantic_label_sample.py` | `DATASET_ODIR`, `POINTS`, `ANGLE_*` |
+
+### Launch File Configurations for Different Sensors
+
+**Hokuyo UTM-30LX-EW (Jackal robot):**
+```xml
+<param name="~frame_id" value="rear_laser" />
+<param name="~scan_topic" value="scan" />
+<param name="~min_range" value="0.1" />
+<param name="~max_range" value="60.0" />
+```
+
+**WLR-716 (Custom robot):**
+```xml
+<param name="~frame_id" value="wlr716_link" />
+<param name="~scan_topic" value="/wj716_base/scan" />
+<param name="~min_range" value="0.15" />
+<param name="~max_range" value="25.0" />
+```
+
+**RPLIDAR-S2 (Custom robot):**
+```xml
+<param name="~frame_id" value="rplidar_link" />
+<param name="~scan_topic" value="/rplidar_base/scan" />
+<param name="~min_range" value="0.2" />
+<param name="~max_range" value="30.0" />
+```
+
+---
+
+## Visualization
+
+Plot the labeled semantic LiDAR data:
+
+```bash
+# Configure the same sensor parameters in draw_semantic_label_sample.py
+cd salsa/automatic_labeling
+python draw_semantic_label_sample.py
+```
+
+![semantic_lidar_data](demos/semantic_lidar_data_2000.png "semantic_lidar_data_2000")
+
+---
+
+## Citation
+
+```bibtex
+@article{xie2026semantic2d,
+  title={Semantic2D: Enabling Semantic Scene Understanding with 2D Lidar Alone},
+  author={Xie, Zhanteng and Pan, Yipeng and Zhang, Yinqiang and Pan, Jia and Dames, Philip},
+  journal={arXiv preprint arXiv:2409.09899},
+  year={2026}
+}
+```
+
+
+
+

dataset/README.md

@@ -0,0 +1,2 @@
+# Semantic2D: Enabling Semantic Scene Understanding with 2D Lidar Alone
+The Semantic2D Dataset and its raw rosbag data can be downloaded at: https://doi.org/10.5281/zenodo.13730200. 

salsa/automatic_labeling/draw_semantic_label_sample.py

@@ -0,0 +1,210 @@
+#!/usr/bin/env python
+#
+# file: $ISIP_EXP/tuh_dpath/exp_0074/scripts/decode.py
+#
+# revision history:
+#  20190925 (TE): first version
+#
+# usage:
+#  python decode.py odir mfile data
+#
+# arguments:
+#  odir: the directory where the hypotheses will be stored
+#  mfile: input model file
+#  data: the input data list to be decoded
+#
+# This script decodes data using a simple MLP model.
+#------------------------------------------------------------------------------
+
+# import pytorch modules
+#
+import torch
+from tqdm import tqdm
+
+# visualize:
+import matplotlib.pyplot as plt
+import numpy as np
+import matplotlib
+matplotlib.style.use('ggplot')
+import sys
+import os
+
+
+################ customized parameters #################
+################ please modify them based on your dataset #################
+DATASET_ODIR = "~/semantic2d_data/2024-04-04-12-16-41"  # the directory path of the raw data
+DATASET_NAME = "train" # select the train, dev, and test 
+SEMANTIC_MASK_ODIR = "./output"
+
+# Hokuyo UTM-30LX-EW:
+POINTS = 1081 # the number of lidar points
+AGNLE_MIN = -2.356194496154785
+AGNLE_MAX = 2.356194496154785
+RANGE_MAX = 60.0
+
+# # WLR-716:
+# POINTS = 811 # the number of lidar points
+# AGNLE_MIN = -2.356194496154785
+# AGNLE_MAX = 2.356194496154785
+# RANGE_MAX = 25.0
+# # RPLIDAR-S2:
+# POINTS = 1972 # the number of lidar points
+# AGNLE_MIN = -3.1415927410125732
+# AGNLE_MAX = 3.1415927410125732
+# RANGE_MAX = 16.0
+
+################# read dataset ###################
+NEW_LINE = "\n"
+# for reproducibility, we seed the rng
+#
+class Semantic2DLidarDataset(torch.utils.data.Dataset):
+    def __init__(self, img_path, file_name):
+        # initialize the data and labels
+        # read the names of image data:
+        self.scan_file_names = []
+        self.intensity_file_names = []
+        self.vel_file_names = []
+        self.label_file_names = []
+        # parameters:
+        self.s_max = 30
+        self.s_min = 0
+        # open train.txt or dev.txt:
+        fp_file = open(img_path+'/'+file_name+'.txt', 'r')
+
+        # for each line of the file:
+        for line in fp_file.read().split(NEW_LINE):
+            if('.npy' in line): 
+                self.scan_file_names.append(img_path+'/scans_lidar/'+line)
+                self.intensity_file_names.append(img_path+'/intensities_lidar/'+line)
+                self.label_file_names.append(img_path+'/semantic_label/'+line)
+        # close txt file:
+        fp_file.close()
+        self.length = len(self.scan_file_names)
+
+        print("dataset length: ", self.length)
+
+
+    def __len__(self):
+        return self.length
+
+    def __getitem__(self, idx):
+        # get the index of start point:
+        scan = np.zeros((1, POINTS))
+        intensity = np.zeros((1, POINTS))
+        label = np.zeros((1, POINTS))
+        
+        # get the scan data:
+        scan_name = self.scan_file_names[idx]
+        scan = np.load(scan_name)
+
+        # get the intensity data:
+        intensity_name = self.intensity_file_names[idx]
+        intensity = np.load(intensity_name)
+
+        # get the semantic label data:
+        label_name = self.label_file_names[idx]
+        label = np.load(label_name)
+        
+        # initialize:
+        scan[np.isnan(scan)] = 0.
+        scan[np.isinf(scan)] = 0.
+
+        intensity[np.isnan(intensity)] = 0.
+        intensity[np.isinf(intensity)] = 0.
+
+        scan[scan >= 15] = 0.
+
+        label[np.isnan(label)] = 0.
+        label[np.isinf(label)] = 0.
+
+        # transfer to pytorch tensor:
+        scan_tensor = torch.FloatTensor(scan)
+        intensity_tensor = torch.FloatTensor(intensity)
+        label_tensor =  torch.FloatTensor(label)
+
+        data = {
+                'scan': scan_tensor,
+                'intensity': intensity_tensor,
+                'label': label_tensor,
+                }
+
+        return data
+
+#------------------------------------------------------------------------------
+#
+# the main program starts here
+#
+#------------------------------------------------------------------------------
+
+# function: main
+#
+# arguments: none
+#
+# return: none
+#
+# This method is the main function.
+#
+if __name__ == '__main__':
+    # input parameters:
+    dataset_odir = DATASET_ODIR
+    dataset_name = DATASET_NAME
+    semantic_mask_odir = SEMANTIC_MASK_ODIR
+    # create the folder for the semantic label mask:
+    if not os.path.exists(semantic_mask_odir):
+        os.makedirs(semantic_mask_odir)
+
+    # read dataset:
+    eval_dataset = Semantic2DLidarDataset(dataset_odir, dataset_name)
+    eval_dataloader = torch.utils.data.DataLoader(eval_dataset, batch_size=1, num_workers=2, \
+                                                 shuffle=False, drop_last=True, pin_memory=True)
+    
+    # for each batch in increments of batch size:
+    cnt = 0
+    cnt_m = 0
+    # get the number of batches (ceiling of train_data/batch_size):
+    num_batches = int(len(eval_dataset)/eval_dataloader.batch_size)
+    for i, batch in tqdm(enumerate(eval_dataloader), total=num_batches):
+        # collect the samples as a batch: 10 timesteps
+        if(i % 200 == 0):
+            scans = batch['scan']
+            scans = scans.detach().cpu().numpy()
+            labels = batch['label']
+            labels = labels.detach().cpu().numpy()
+
+            # lidar data:
+            r = scans.reshape(POINTS) 
+            theta = np.linspace(AGNLE_MIN, AGNLE_MAX, num=POINTS, endpoint='true') 
+
+            ## plot semantic label:
+            fig = plt.figure(figsize=(12, 12))
+            ax = fig.add_subplot(1,1,1, projection='polar', facecolor='seashell')
+            smap = labels.reshape(POINTS)
+
+            # add the background label:
+            theta =  np.insert(theta, -1, np.pi)
+            r = np.insert(r, -1, 1)
+            smap = np.insert(smap, -1, 0)
+            label_val = np.unique(smap).astype(int)
+            print("label_values: ", label_val)
+
+            colors = smap 
+            area = 6
+            scatter = ax.scatter(theta, r, c=colors, s=area, cmap='nipy_spectral', alpha=0.95, linewidth=10)
+            ax.set_xticks(np.linspace(AGNLE_MIN, AGNLE_MAX, 8, endpoint='true'))
+            ax.set_thetamin(-135)
+            ax.set_thetamax(135)
+            ax.set_yticklabels([])
+            # produce a legend with the unique colors from the scatter
+            classes = ['Other', 'Chair', 'Door', 'Elevator', 'Person', 'Pillar', 'Sofa', 'Table', 'Trash bin', 'Wall']
+            plt.xticks(fontsize=16) 
+            plt.yticks(fontsize=16)     
+            plt.legend(handles=scatter.legend_elements(num=[j for j in label_val])[0], labels=[classes[j] for j in label_val], bbox_to_anchor=(0.5, -0.08), loc='lower center', fontsize=18)
+            ax.grid(False)
+            ax.set_theta_offset(np.pi/2)
+            
+            input_img_name = semantic_mask_odir + "/semantic_mask" + str(i)+ ".png"
+            plt.savefig(input_img_name, bbox_inches='tight')
+            plt.show()
+
+            print(i)
+            

salsa/automatic_labeling/semi_automated_labeling_framework.py

@@ -0,0 +1,461 @@
+#!/usr/bin/env python
+import os
+import numpy as np
+import PIL.Image
+import torch
+from tqdm import tqdm
+from typing import Optional, Tuple, Union
+from sklearn.neighbors import NearestNeighbors
+from scipy.spatial.transform import Rotation 
+
+################ customized parameters #################
+################ please modify them based on your dataset #################
+# dataset: 
+DATASET_ODIR = "/home/xzt/data/semantic_lidar_v2/2024-04-04-12-16-41"  # the directory path of the raw data
+DATASET_NAME = "train" # select the train, dev, and test 
+# map: parameters from the map configuration file
+MAP_ORIGIN = np.array([-21.200000, -34.800000, 0.000000]) 
+MAP_RESOLUTION = 0.025000
+# labeling:
+MAP_LABEL_PATH = '../manually_labeling/labelme_output/label.png'
+MAP_PATH = '../manually_labeling/labelme_output/img.png'
+
+# Hokuyo UTM-30LX-EW:
+POINTS = 1081 # the number of lidar points
+AGNLE_MIN = -2.356194496154785
+AGNLE_MAX = 2.356194496154785
+RANGE_MAX = 60.0
+# urdf: laser_joint
+JOINT_XYZ = [-0.12, 0.0, 0.0]
+JOINT_RPY = [0.0, 0.0, 0.0]
+
+# # WLR-716:
+# POINTS = 811 # the number of lidar points
+# AGNLE_MIN = -2.356194496154785
+# AGNLE_MAX = 2.356194496154785
+# RANGE_MAX = 25.0
+# # urdf: laser_joint
+# JOINT_XYZ = [0.065, 0.0, 0.182]
+# JOINT_RPY = [3.1415926, 0.0, 0.0]
+# # RPLIDAR-S2:
+# POINTS = 1972 # the number of lidar points
+# AGNLE_MIN = -3.1415927410125732
+# AGNLE_MAX = 3.1415927410125732
+# RANGE_MAX = 16.0
+# # urdf: laser_joint
+# JOINT_XYZ = [0.065, 0.0, 0.11]
+# JOINT_RPY = [0.0, 0.0, 3.1415926]
+
+################# read dataset ###################
+NEW_LINE = "\n"
+class Semantic2DLidarDataset(torch.utils.data.Dataset):
+    def __init__(self, img_path, file_name):
+        # initialize the data and labels
+        # read the names of image data:
+        self.scan_file_names = []
+        self.line_file_names = []
+        self.pos_file_names = []
+        self.vel_file_names = []
+        # open train.txt or dev.txt:
+        fp_file = open(img_path+'/'+file_name+'.txt', 'r')
+        # for each line of the file:
+        for line in fp_file.read().split(NEW_LINE):
+            if('.npy' in line):
+                self.scan_file_names.append(img_path+'/scans_lidar/'+line)
+                self.line_file_names.append(img_path+'/line_segments/'+line)
+                self.pos_file_names.append(img_path+'/positions/'+line)
+                self.vel_file_names.append(img_path+'/velocities/'+line)
+        # close txt file:
+        fp_file.close()
+        self.length = len(self.scan_file_names)
+
+        print("dataset length: ", self.length)
+
+    def __len__(self):
+        return self.length
+
+    def __getitem__(self, idx):
+        scan = np.zeros(POINTS)
+        position = np.zeros(3)
+        vel = np.zeros(2)
+        # get the scan data:
+        scan_name = self.scan_file_names[idx]
+        scan = np.load(scan_name)
+
+        # get the line segments data:
+        line_name = self.line_file_names[idx]
+        line_segs = np.load(line_name)
+       
+        # get the scan_ur data:
+        pos_name = self.pos_file_names[idx]
+        position = np.load(pos_name)
+
+        # get the velocity data:
+        vel_name = self.vel_file_names[idx]
+        vel = np.load(vel_name)
+        
+        # initialize:
+        scan[np.isnan(scan)] = 0.
+        scan[np.isinf(scan)] = 0.
+        scan[scan==60] = 0.
+
+        position[np.isnan(position)] = 0.
+        position[np.isinf(position)] = 0.
+
+        vel[np.isnan(vel)] = 0.
+        vel[np.isinf(vel)] = 0.
+
+        # transfer to pytorch tensor:
+        scan_tensor = torch.FloatTensor(scan)
+        line_tensor = torch.FloatTensor(line_segs)
+        pose_tensor = torch.FloatTensor(position)
+        vel_tensor =  torch.FloatTensor(vel)
+
+        data = {
+                'scan': scan_tensor,
+                'line': line_tensor,
+                'position': pose_tensor,
+                'velocity': vel_tensor, 
+                }
+
+        return data
+
+################# ICP algorithm ###################
+class MapICP:
+    def __init__(self, map_pts):
+        # map_pts: 2xN numpy.ndarray of points
+        self.map_pts = map_pts
+        self.neighbors = NearestNeighbors(n_neighbors=1).fit(self.map_pts.T)
+
+    def setMapPoints(self, pts: np.ndarray) -> None:
+        '''
+        Initializes a set of points to match against
+        Inputs:
+            pts: 2xN numpy.ndarray of 2D points
+        '''
+        assert pts.shape[0] == 2
+        self.map_pts = pts
+        self.neighbors = NearestNeighbors(n_neighbors=1).fit(pts.T)
+
+    def nearestNeighbor(self, pts: np.ndarray) -> Tuple[np.array, np.array]:
+        '''
+        Find the nearest (Euclidean) neighbor in for each point in pts
+        Input:
+            pts: 2xN array of points
+        Output:
+            distances: np.array of Euclidean distances of the nearest neighbor
+            indices: np.array of indices of the nearest neighbor
+        '''
+        assert pts.shape[0] == 2
+        distances, indices = self.neighbors.kneighbors(pts.T, return_distance=True)
+
+        return distances.ravel(), indices.ravel()
+
+    def bestFitTransform(self, pts: np.array, map_pts: np.array) -> np.ndarray: #indices: np.array) -> np.ndarray:
+        '''
+        Calculates the least-squares best-fit transform that maps pts on to map_pts
+        Input:
+            pts: 2xN numpy.ndarray of points
+            # indices: 1xN numpy.array of corresponding map_point indices
+            map_pts: 2xN numpy.ndarray of points
+        Returns:
+            T: 3x3 homogeneous transformation matrix that maps pts on to map_pts
+        '''
+        # get number of dimensions
+        m = pts.shape[0]
+        assert m == 2
+
+        # Extract points
+        map = map_pts # self.map_pts[:,indices]
+        assert pts.shape == map.shape
+
+        # translate points to their centroids
+        centroid_pts = np.mean(pts, axis=1)
+        centroid_map = np.mean(map, axis=1)
+        PTS = pts - centroid_pts.reshape((-1,1))
+        MAP = map - centroid_map.reshape((-1,1))
+
+        # rotation matrix
+        H = MAP @ PTS.T
+        U, _, Vt = np.linalg.svd(H)
+        R = U @ Vt
+
+        # special reflection case
+        if np.linalg.det(R) < 0:
+            Vt[:,-1] *= -1
+            R = U @ Vt
+
+        # translation
+        t = centroid_map - R @ centroid_pts
+
+        # homogeneous transformation
+        T = np.identity(m+1)
+        T[:m, :m] = R
+        T[:m, m] = t
+
+        return T
+
+    def icp(self, pts: np.ndarray, init_pose: Optional[Union[np.array, None]]=None, max_iterations: Optional[int]=20, tolerance: Optional[float]=0.05) -> Tuple[np.ndarray, np.array, int]:
+        '''
+        The Iterative Closest Point method: finds best-fit transform that maps points A on to points B
+        Input:
+            pts: 2xN numpy.ndarray of source points
+            init_pose: 3x3 homogeneous transformation
+            max_iterations: exit algorithm after max_iterations
+            tolerance: convergence criteria
+        Outputs:
+            T: final homogeneous transformation that maps pts on to map_pts
+            distances: Euclidean distances (errors) of the nearest neighbor
+            i: number of iterations to converge
+        '''
+        # Get number of dimensions
+        m = pts.shape[0]
+        assert m == 2
+
+        # Make points homogeneous, copy them to maintain the originals
+        src = np.ones((m+1, pts.shape[1]))
+        dst = np.ones((m+1, self.map_pts.shape[1]))
+        src[:m,:] = np.copy(pts)
+        dst[:m,:] = np.copy(self.map_pts)
+
+        # Apply the initial pose estimate
+        T = np.eye(3)
+        if init_pose is not None:
+            src = init_pose @ src
+            T = init_pose @ T
+
+        # Run ICP
+        prev_error = 1e6
+        for i in range(max_iterations):
+            # find the nearest neighbors between the current source and destination points
+            distances, indices = self.nearestNeighbor(src[:m,:])
+            map_pts = self.map_pts[:, indices]
+            # compute the transformation between the current source and nearest destination points
+            T_delta = self.bestFitTransform(src[:m,:], map_pts) #indices)
+
+            # update the current source and transform
+            src = T_delta @ src
+            T = T_delta @ T
+
+            # check error
+            mean_error = np.mean(distances)
+            if np.abs(prev_error - mean_error) < tolerance:
+                break
+            prev_error = mean_error
+
+        #T = self.bestFitTransform(pts, src[:m,:]) 
+        # Calculate final transformation
+        return T, distances, i
+
+################# map converter: homogeneous transformation  ###################
+class MapConverter:
+    # Constructor
+    def __init__(self, label_file, origin=np.array([-12.200000, -12.200000, 0.000000]), resolution=0.05):
+        # map parameters
+        self.origin = origin 
+        self.resolution = resolution 
+        # homogeneous transformation matrix:
+        self.map_T_pixel = np.array([[np.cos(self.origin[2]), -np.sin(self.origin[2]), self.origin[0]],
+                                [np.sin(self.origin[2]),  np.cos(self.origin[2]), self.origin[1]],
+                                [0, 0, 1]
+                                ])
+        self.pixel_T_map = np.linalg.inv(self.map_T_pixel)
+        # load semantic map
+        label_map = np.asarray(PIL.Image.open(label_file))
+        self.label_map = label_map.T # transpose 90 
+        self.x_lim = self.label_map.shape[0]
+        self.y_lim = self.label_map.shape[1]
+        print(self.x_lim, self.y_lim)
+    
+    def coordinate2pose(self, px, py):
+        pixel_pose = np.array([px*self.resolution, py*self.resolution, 1])
+        map_pose = np.matmul(self.map_T_pixel, pixel_pose.T)
+        x = map_pose[0]
+        y = map_pose[1]
+
+        return x, y
+
+    def pose2coordinate(self, x, y):
+        map_pose = np.array([x, y, 1])
+        pixel_pose = np.matmul(self.pixel_T_map, map_pose.T)
+        px = int(pixel_pose[0] / self.resolution)
+        py = int(pixel_pose[1] / self.resolution)
+
+        return px, py
+
+    def get_semantic_label(self, x, y):
+        px, py = self.pose2coordinate(x, y)
+        py = self.y_lim - py # the y axis is inverse
+        label_loc = np.zeros(10) # 10 labels
+        # filtering:
+        for i in range(px-2, px+2):
+            for j in range(py-2, py+2):
+                if(i >= 0 and i < self.x_lim and j >=0 and j < self.y_lim):
+                    label = self.label_map[i, j]
+                    if(label != 0):
+                        label_loc[label] += 1
+
+        if(np.sum(label_loc) == 0): # people
+            semantic_label = 4
+        else:   # static objects
+            semantic_label = np.argmax(label_loc)
+       
+        return semantic_label
+    
+    def transform_lidar_points(self, points_sensor, xyz, rpy, inverse=True):
+        """
+        Transform 2D lidar points from sensor frame to robot base frame, given URDF translation and RPY.
+        Args:
+            points_sensor (Nx2 ndarray): Lidar points [x, y] in the sensor frame.
+            translation (3-tuple/list/ndarray): [x, y, z] translation from base to sensor (URDF).
+            rpy (3-tuple/list/ndarray): [roll, pitch, yaw] rotation from base to sensor (URDF, radians).
+            inverse (bool): If True (default), transforms from sensor to base frame (i.e., applies inverse transform).
+                            If False, transforms from base to sensor frame.
+        Returns:
+            Nx2 ndarray: Transformed points in base frame.
+        """
+        translation = np.asarray(xyz).reshape((3,))
+        rpy = np.asarray(rpy).reshape((3,))
+        
+        rot = Rotation.from_euler('xyz', rpy)  # Roll, Pitch, Yaw
+        
+        N = points_sensor.shape[0]
+        # Add z=0 to points
+        points_3d = np.hstack([points_sensor, np.zeros((N, 1))])  # Nx3
+
+        if inverse:
+            # Transform from sensor -> base: x_base = R.T @ (x_sensor - t)
+            points_shifted = points_3d - translation
+            points_base = rot.inv().apply(points_shifted)
+        else:
+            # Transform from base -> sensor: x_sensor = R @ x_base + t
+            points_base = rot.apply(points_3d) + translation
+
+        return points_base[:, :2]
+
+    def lidar2map(self, lidar_pos, lidar_scan):
+        # get laser points: polar to cartesian
+        points_laser = np.zeros((POINTS, 2))
+        angles = np.linspace(AGNLE_MIN, AGNLE_MAX, num=POINTS) #np.linspace(-(135*np.pi/180), 135*np.pi/180, num=POINTS)
+        dis = lidar_scan
+        points_laser[:, 0] = dis*np.cos(angles)
+        points_laser[:, 1] = dis*np.sin(angles)
+        #lidar_points[:, 2] = 1
+        
+        # coordinate transformation: lidar -> footprint
+        lidar_points = self.transform_lidar_points(points_sensor=points_laser, xyz=JOINT_XYZ, rpy=JOINT_RPY)
+
+        # coordinate transformation: footprint -> map
+        lidar_points_in_map = np.zeros((POINTS, 2))
+        lidar_points_in_map[:, 0] = lidar_points[:, 0]*np.cos(lidar_pos[2]) - lidar_points[:, 1]*np.sin(lidar_pos[2]) + lidar_pos[0]
+        lidar_points_in_map[:, 1] = lidar_points[:, 0]*np.sin(lidar_pos[2]) + lidar_points[:, 1]*np.cos(lidar_pos[2]) + lidar_pos[1]
+
+        return lidar_points_in_map, points_laser
+
+
+if __name__ == '__main__':
+    # input parameters:
+    dataset_odir = DATASET_ODIR
+    dataset_name = DATASET_NAME
+    scan_label_odir = dataset_odir + "/" + "semantic_label"
+    if not os.path.exists(scan_label_odir):
+        os.makedirs(scan_label_odir)
+
+    map_path = MAP_PATH
+    map_label_path = MAP_LABEL_PATH
+
+    map_origin = MAP_ORIGIN
+    map_resolution = MAP_RESOLUTION
+
+    # initialize semantic scan label:
+    scan_label = np.zeros(POINTS)
+
+    # initialize the map converter: homogeneous transformation  
+    mc = MapConverter(map_label_path, origin=map_origin, resolution=map_resolution)
+
+    ## extract the valid map points fromt the map image:
+    # load map image:
+    map_img = np.asarray(PIL.Image.open(map_path)) 
+    map_img = map_img.T # transpose 90 
+    print(map_img.shape)
+    # get map valid points:
+    map_idx = np.where(map_img == 0)
+    map_idx_x = map_idx[0]
+    map_idx_y = map_idx[1]
+    map_points = []
+    for n in range(len(map_idx_x)):
+        px = map_idx_x[n]
+        py = map_idx_y[n]
+        py = map_img.shape[1] - py # the x axis is inverse
+        [x, y] = mc.coordinate2pose(px, py)
+        map_points.append([x, y])
+    map_pts = np.array(map_points)
+
+    # initialize ICP:
+    icp = MapICP(map_pts.T)
+
+    # load dataset:
+    eval_dataset = Semantic2DLidarDataset(dataset_odir, dataset_name)
+    eval_dataloader = torch.utils.data.DataLoader(eval_dataset, batch_size=1, \
+                                                   shuffle=False, drop_last=True) #, pin_memory=True)
+    
+    # get the number of batches (ceiling of train_data/batch_size):
+    num_batches = int(len(eval_dataset)/eval_dataloader.batch_size)
+    for i, batch in tqdm(enumerate(eval_dataloader), total=num_batches):
+        # collect the samples as a batch:
+        scan = batch['scan']
+        scan = scan.detach().cpu().numpy()
+        lines = batch['line']
+        lines = lines.detach().cpu().numpy()
+        position = batch['position']
+        position = position.detach().cpu().numpy()
+
+        # transfer lidar points: 
+        lidar_pos = position.reshape(3)
+        lidar_pos[0] += LIDAR_BASE_DIS # the distance from lidar_mount to base_link
+        lidar_scan = scan.reshape(POINTS)
+        lidar_points_in_map, lidar_points = mc.lidar2map(lidar_pos, lidar_scan)
+
+        # use line segments (key line features) to remove outliers in the lidar scan:
+        correspondences = []
+        for line in lines[0]:
+            x1, y1, x2, y2 = line
+            # construct line formular: y = ax +b
+            a = (y2 - y1) / (x2 - x1 + 1e-10)
+            b = y1 - a*x1
+            for n in range(POINTS):
+                x, y = lidar_points[n, :]
+                if(x >= x1-1 and x <= x2+1 and y >= y1-1 and y <= y2+1): # in the area of the line
+                    if(abs(y - (a*x+b)) <= 0.3): # on the line
+                        correspondences.append([x, y])
+
+        correspondences = np.array(correspondences)
+        correspondences_length = len(correspondences)
+
+        if(correspondences_length > 280): # reliable correspondences
+            # coordinate transformation: lidar -> map
+            correspondences_in_map = np.zeros((correspondences_length, 2))
+            correspondences_in_map[:, 0] = correspondences[:, 0]*np.cos(lidar_pos[2]) - correspondences[:, 1]*np.sin(lidar_pos[2]) + lidar_pos[0]
+            correspondences_in_map[:, 1] = correspondences[:, 0]*np.sin(lidar_pos[2]) + correspondences[:, 1]*np.cos(lidar_pos[2]) + lidar_pos[1]
+            
+            # use ICP scan matching to correct lidar pose:
+            mapc_T_map, _, _ = icp.icp(correspondences_in_map.T, max_iterations=500, tolerance=1e-6)
+
+            # corrected lidar pose:
+            lidar_pose_corrected = np.matmul(mapc_T_map, np.array([lidar_pos[0], lidar_pos[1], 1]))
+            lidar_points_in_map_old =  np.concatenate((lidar_points_in_map, np.ones((POINTS, 1))), axis=1)
+            point_corrected = np.matmul(mapc_T_map, lidar_points_in_map_old.T)
+        else: # no icp correction
+            lidar_pose_corrected = lidar_pos
+            point_corrected = lidar_points_in_map.T
+
+        # semantic pixel mataching:
+        for j in range(POINTS):
+            if(point_corrected[0, j] == lidar_pose_corrected[0] and point_corrected[1, j] == lidar_pose_corrected[1]): # scan == 0
+                scan_label[j] = 0
+            else:
+                scan_label[j] = mc.get_semantic_label(point_corrected[0, j], point_corrected[1, j])
+
+        # write scan_label in lidar frame into np.array:
+        scan_label_name = scan_label_odir + "/" + str(i).zfill(7) 
+        np.save(scan_label_name, scan_label)

salsa/manually_labeling/.labelmerc

@@ -0,0 +1,116 @@
+auto_save: false
+display_label_popup: true
+store_data: true
+keep_prev: false
+keep_prev_scale: false
+keep_prev_brightness: false
+keep_prev_contrast: false
+logger_level: info
+
+flags: null
+label_flags: null
+labels: [Chair, Door, Elevator, Person, Pillar, Sofa, Table, Trash bin, Wall] # null
+file_search: null
+sort_labels: false #true
+validate_label: null
+
+default_shape_color: [0, 255, 0]
+shape_color: manual #auto  # null, 'auto', 'manual'
+shift_auto_shape_color: 0
+label_colors: {Chair:[109, 0, 156], Door:[0, 46, 221], Elevator:[0, 164, 187], Person:[204, 204, 204], Pillar:[0, 155, 18], Sofa:[0, 225, 0], Table:[203, 249, 0], Trash bin:[255, 173, 0], Wall:[227, 0, 0]}  #null
+
+shape:
+  # drawing
+  line_color: [0, 255, 0, 128]
+  fill_color: [0, 0, 0, 64]
+  vertex_fill_color: [0, 255, 0, 255]
+  # selecting / hovering
+  select_line_color: [255, 255, 255, 255]
+  select_fill_color: [0, 255, 0, 155]
+  hvertex_fill_color: [255, 255, 255, 255]
+  point_size: 8
+
+# main
+flag_dock:
+  show: true
+  closable: true
+  movable: true
+  floatable: true
+label_dock:
+  show: true
+  closable: true
+  movable: true
+  floatable: true
+shape_dock:
+  show: true
+  closable: true
+  movable: true
+  floatable: true
+file_dock:
+  show: true
+  closable: true
+  movable: true
+  floatable: true
+
+# label_dialog
+show_label_text_field: true
+label_completion: startswith
+fit_to_content:
+  column: true
+  row: false
+
+# canvas
+epsilon: 10.0
+canvas:
+  fill_drawing: true
+  # None: do nothing
+  # close: close polygon
+  double_click: close
+  # The max number of edits we can undo
+  num_backups: 10
+  # show crosshair
+  crosshair:
+    polygon: false
+    rectangle: true
+    circle: false
+    line: false
+    point: false
+    linestrip: false
+    ai_polygon: false
+
+shortcuts:
+  close: Ctrl+W
+  open: Ctrl+O
+  open_dir: Ctrl+U
+  quit: Ctrl+Q
+  save: Ctrl+S
+  save_as: Ctrl+Shift+S
+  save_to: null
+  delete_file: Ctrl+Delete
+
+  open_next: [D, Ctrl+Shift+D]
+  open_prev: [A, Ctrl+Shift+A]
+
+  zoom_in: [Ctrl++, Ctrl+=]
+  zoom_out: Ctrl+-
+  zoom_to_original: Ctrl+0
+  fit_window: Ctrl+F
+  fit_width: Ctrl+Shift+F
+
+  create_polygon: Ctrl+N
+  create_rectangle: Ctrl+R
+  create_circle: null
+  create_line: null
+  create_point: null
+  create_linestrip: null
+  edit_polygon: Ctrl+J
+  delete_polygon: Delete
+  duplicate_polygon: Ctrl+D
+  copy_polygon: Ctrl+C
+  paste_polygon: Ctrl+V
+  undo: Ctrl+Z
+  undo_last_point: Ctrl+Z
+  add_point_to_edge: Ctrl+Shift+P
+  edit_label: Ctrl+E
+  toggle_keep_prev_mode: Ctrl+P
+  remove_selected_point: [Meta+H, Backspace]

salsa/manually_labeling/dataset_collection.py

@@ -0,0 +1,161 @@
+#!/usr/bin/env python
+from random import choice
+import rospy
+import tf
+# custom define messages:
+from geometry_msgs.msg import Point, PoseStamped, Twist, TwistStamped, Pose, PoseArray, PoseWithCovarianceStamped
+from sensor_msgs.msg import Image, LaserScan
+from nav_msgs.msg import Odometry, OccupancyGrid, Path
+from laser_line_extraction.msg import LineSegmentList, LineSegment
+# python: 
+import os
+import numpy as np
+import threading
+
+################ customized parameters #################
+################ please modify them based on your dataset #################
+POINTS = 1081
+DATA_PATH = "~/semantic2d_data/2024-04-11-15-24-29"
+
+class DataCollection:
+    # Constructor
+    def __init__(self):
+        
+        # initialize data:  
+        self.scan_lidar = np.zeros(POINTS)
+        self.intensities_lidar = np.zeros(POINTS)
+        self.lines = []
+        self.vel_cmd = np.zeros(2)
+        self.pos = np.zeros(3)
+        self.record = True
+        self.rosbag_cnt = 0
+        self.rosbag_cnt_reg = np.array([-4, -3, -2, -1])
+        self.reg_cnt = 0
+        
+        # store directory:
+        data_odir = DATA_PATH
+        self.scan_lidar_odir = data_odir + "/" + "scans_lidar"
+        if not os.path.exists(self.scan_lidar_odir):
+            os.makedirs(self.scan_lidar_odir)
+        self.intensities_lidar_odir = data_odir + "/" + "intensities_lidar"
+        if not os.path.exists(self.intensities_lidar_odir):
+            os.makedirs(self.intensities_lidar_odir)
+        self.line_odir = data_odir + "/" + "line_segments"
+        if not os.path.exists(self.line_odir):
+            os.makedirs(self.line_odir)
+        self.vel_odir = data_odir + "/" + "velocities"
+        if not os.path.exists(self.vel_odir):
+            os.makedirs(self.vel_odir)
+        self.pos_odir = data_odir + "/" + "positions"
+        if not os.path.exists(self.pos_odir):
+            os.makedirs(self.pos_odir)
+
+        # timer:
+        self.timer = None
+        self.rate = 20  # 20 Hz velocity controller
+        self.idx = 0
+        # Lock
+        self.lock = threading.Lock() 
+
+        # initialize ROS objects:
+        self.tf_listener = tf.TransformListener()
+        self.scan_sub = rospy.Subscriber("scan", LaserScan, self.scan_callback)
+        self.line_sub = rospy.Subscriber("line_segments", LineSegmentList, self.line_segments_callback)
+        self.dwa_cmd_sub = rospy.Subscriber('bluetooth_teleop/cmd_vel', Twist, self.dwa_cmd_callback) #, queue_size=1)
+        self.robot_pose_pub = rospy.Subscriber('robot_pose', PoseStamped, self.robot_pose_callback)
+
+
+    # Callback function for the scan measurement subscriber
+    def scan_callback(self, laserScan_msg):
+        # get the laser scan data:
+        scan_data = np.array(laserScan_msg.ranges, dtype=np.float32)
+        scan_data[np.isnan(scan_data)] = 0.
+        scan_data[np.isinf(scan_data)] = 0.
+        self.scan_lidar = scan_data
+        # get the laser intensity data:
+        intensity_data = np.array(laserScan_msg.intensities, dtype=np.float32)
+        intensity_data[np.isnan(intensity_data)] = 0.
+        intensity_data[np.isinf(intensity_data)] = 0.
+        self.intensities_lidar = intensity_data
+        self.rosbag_cnt += 1
+    
+    # Callback function for the line segments subscriber
+    def line_segments_callback(self, lineSeg_msg):
+        self.lines = []
+        # get the laser line segments data:
+        line_segs = lineSeg_msg.line_segments
+        for line_seg in line_segs:
+            line = [line_seg.start[0], line_seg.start[1], line_seg.end[0], line_seg.end[1]]
+            self.lines.append(line)
+
+    # Callback function for the local map subscriber
+    def dwa_cmd_callback(self, robot_vel_msg):
+        self.vel_cmd = np.array([robot_vel_msg.linear.x, robot_vel_msg.angular.z])
+
+    # Callback function for the current robot pose subscriber
+    def robot_pose_callback(self, robot_pose_msg):
+        # Cartesian coordinate:
+        #self.pos = np.array([robot_pose_msg.pose.position.x, robot_pose_msg.pose.position.y, robot_pose_msg.pose.orientation.z])
+        quaternion = [
+            robot_pose_msg.pose.orientation.x, robot_pose_msg.pose.orientation.y,
+            robot_pose_msg.pose.orientation.z, robot_pose_msg.pose.orientation.w
+        ]
+        roll, pitch, yaw = tf.transformations.euler_from_quaternion(quaternion)
+        self.pos = np.array([robot_pose_msg.pose.position.x, robot_pose_msg.pose.position.y, yaw])
+
+        # start the timer if this is the first path received
+        if self.timer is None:
+            self.start()
+                
+    # Start the timer that calculates command velocities
+    def start(self):
+        # initialize timer for controller update
+        self.timer = rospy.Timer(rospy.Duration(1./self.rate), self.timer_callback)
+
+    # function that runs every time the timer finishes to ensure that vae data are sent regularly
+    def timer_callback(self, event):  
+        # lock data:
+        #self.lock.acquire()
+        scan_ranges = self.scan_lidar
+        scan_intensities = self.intensities_lidar
+        line_segs = self.lines
+        rob_pos = self.pos
+        vel_cmd = self.vel_cmd
+        #self.lock.release()
+        # check if the rosbag is done:
+        if(self.reg_cnt > 3): 
+            self.reg_cnt = 0
+
+        self.rosbag_cnt_reg[self.reg_cnt] = self.rosbag_cnt
+        self.reg_cnt += 1
+        cnt_unique = np.unique(self.rosbag_cnt_reg)
+        # write array into npy:
+        if(self.record and len(cnt_unique)>1): #and self.idx < 15000):
+            # write lidar scan in lidar frame into np.array:
+            scan_name = self.scan_lidar_odir + "/" + str(self.idx).zfill(7) 
+            np.save(scan_name, scan_ranges)
+            # write lidar intensity in lidar frame into np.array:
+            intensity_name = self.intensities_lidar_odir + "/" + str(self.idx).zfill(7) 
+            np.save(intensity_name, scan_intensities)
+            # write line segments in lidar frame into np.array:
+            line_name = self.line_odir + "/" + str(self.idx).zfill(7) 
+            np.save(line_name, line_segs)
+            # write velocoties into np.array:
+            vel_name = self.vel_odir + "/" + str(self.idx).zfill(7)
+            np.save(vel_name, vel_cmd)
+            # write robot position into np.array:
+            pos_name = self.pos_odir + "/" + str(self.idx).zfill(7)
+            np.save(pos_name, rob_pos)
+
+            #img.show()
+            self.idx +=  1
+            print("idx: ", self.idx)
+        else:
+            print("idx: ", self.idx)
+        
+if __name__ == '__main__':
+    rospy.init_node('data_collection')
+    data = DataCollection()
+    rospy.spin()
+
+

salsa/manually_labeling/generateTrainDevSet.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python
+"""
+Generate train/dev/test split files for Semantic2D dataset.
+Automatically calculates the number of samples based on percentages.
+"""
+import os
+from os import listdir, getcwd
+from os.path import join, expanduser
+import random
+
+if __name__ == '__main__':
+    ################ CUSTOMIZATION REQUIRED ################
+    # The path of your dataset folder:
+    train_folder = '~/semantic2d_data/2024-04-11-15-24-29'
+
+    # Split percentages (must sum to 1.0)
+    TRAIN_RATIO = 0.70  # 70% for training
+    DEV_RATIO = 0.10    # 10% for validation/development
+    TEST_RATIO = 0.20   # 20% for testing
+    ########################################################
+
+    # Expand user path (handle ~)
+    train_folder = expanduser(train_folder)
+
+    # Verify ratios sum to 1.0
+    assert abs(TRAIN_RATIO + DEV_RATIO + TEST_RATIO - 1.0) < 1e-6, \
+        f"Ratios must sum to 1.0, got {TRAIN_RATIO + DEV_RATIO + TEST_RATIO}"
+
+    # The index files of datasets:
+    train_txt = train_folder + '/train.txt'
+    dev_txt = train_folder + '/dev.txt'
+    test_txt = train_folder + '/test.txt'
+
+    # Get the list of data files:
+    positions_folder = train_folder + '/positions'
+    if not os.path.exists(positions_folder):
+        print(f"Error: Folder not found: {positions_folder}")
+        print("Please check the train_folder path.")
+        exit(1)
+
+    train_files = os.listdir(positions_folder)
+
+    # Filter only .npy files
+    train_list = [f for f in train_files if f.endswith(".npy")]
+
+    # Sort the list according to the name without extension:
+    train_list.sort(key=lambda x: int(x[:-4]))
+
+    # Shuffle the list
+    random.shuffle(train_list)
+
+    # Calculate split sizes based on percentages
+    total_samples = len(train_list)
+    NUM_TRAIN = int(total_samples * TRAIN_RATIO)
+    NUM_DEV = int(total_samples * DEV_RATIO)
+    NUM_TEST = total_samples - NUM_TRAIN - NUM_DEV  # Remaining samples go to test
+
+    print(f"Dataset folder: {train_folder}")
+    print(f"Total samples: {total_samples}")
+    print(f"Split ratios: Train={TRAIN_RATIO:.0%}, Dev={DEV_RATIO:.0%}, Test={TEST_RATIO:.0%}")
+    print(f"Split sizes:  Train={NUM_TRAIN}, Dev={NUM_DEV}, Test={NUM_TEST}")
+
+    # Open txt files:
+    train_file = open(train_txt, 'w')
+    dev_file = open(dev_txt, 'w')
+    test_file = open(test_txt, 'w')
+
+    # Write to txt files based on calculated splits:
+    for idx, file_name in enumerate(train_list):
+        if idx < NUM_TRAIN:  # train
+            train_file.write(file_name + '\n')
+        elif idx < NUM_TRAIN + NUM_DEV:  # dev
+            dev_file.write(file_name + '\n')
+        else:  # test
+            test_file.write(file_name + '\n')
+
+    train_file.close()
+    dev_file.close()
+    test_file.close()
+
+    print(f"\nGenerated split files:")
+    print(f"  - {train_txt}")
+    print(f"  - {dev_txt}")
+    print(f"  - {test_txt}")
+    print("Done!")

salsa/manually_labeling/labelme_output/label_names.txt

@@ -0,0 +1,10 @@
+_background_
+Chair
+Door
+Elevator
+People
+Pillar
+Sofa
+Table
+Trash bin
+Wall

salsa/manually_labeling/semantic_data_collection_ws/src/laser_line_extraction/CMakeLists.txt

@@ -0,0 +1,53 @@
+cmake_minimum_required(VERSION 2.8.3)
+project(laser_line_extraction)
+
+find_package(catkin REQUIRED COMPONENTS
+  cmake_modules
+  geometry_msgs
+  message_generation
+  roscpp
+  rospy
+  sensor_msgs
+  visualization_msgs
+)
+
+find_package(Eigen3 REQUIRED)
+
+add_message_files(
+  FILES
+  LineSegment.msg
+  LineSegmentList.msg
+)
+
+generate_messages(
+  DEPENDENCIES
+  sensor_msgs
+)
+
+catkin_package(
+  INCLUDE_DIRS include
+  LIBRARIES line line_extraction line_extraction_ros
+  CATKIN_DEPENDS geometry_msgs message_runtime roscpp sensor_msgs visualization_msgs
+)
+
+add_library(line src/line.cpp)
+target_link_libraries(line ${catkin_LIBRARIES})
+
+add_library(line_extraction src/line_extraction.cpp)
+target_link_libraries(line_extraction ${catkin_LIBRARIES})
+
+add_library(line_extraction_ros src/line_extraction_ros.cpp)
+target_link_libraries(line_extraction_ros line line_extraction ${catkin_LIBRARIES})
+add_dependencies(line_extraction_ros laser_line_extraction_generate_messages_cpp)
+
+add_executable(line_extraction_node src/line_extraction_node.cpp)
+target_link_libraries(line_extraction_node line_extraction_ros ${catkin_LIBRARIES})
+
+include_directories(include ${catkin_INCLUDE_DIRS})
+include_directories(include ${EIGEN3_INCLUDE_DIRS})
+
+# catkin_add_gtest(${PROJECT_NAME}-test test/test_laser_line_extraction.cpp)
+
+install(TARGETS line_extraction_node RUNTIME DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION})
+install(TARGETS line_extraction_ros line_extraction line ARCHIVE DESTINATION ${CATKIN_PACKAGE_LIB_DESTINATION} LIBRARY DESTINATION ${CATKIN_PACKAGE_LIB_DESTINATION} RUNTIME DESTINATION ${CATKIN_GLOBAL_BIN_DESTINATION})
+install(DIRECTORY include/${PROJECT_NAME}/ DESTINATION ${CATKIN_PACKAGE_INCLUDE_DESTINATION})

salsa/manually_labeling/semantic_data_collection_ws/src/laser_line_extraction/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2014, Marc Gallant
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the {organization} nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

salsa/manually_labeling/semantic_data_collection_ws/src/laser_line_extraction/README.md

@@ -0,0 +1,84 @@
+# Laser Line Extraction
+Laser Line Extraction is a [Robot Operating System (ROS)](http://www.ros.org) package that extracts line segments form [LaserScan](http://docs.ros.org/api/sensor_msgs/html/msg/LaserScan.html) messages. Created by [Marc Gallant](http://marcgallant.ca), originally for use in the [Mining Systems Laboratory](http://msl.engineering.queensu.ca). Here is what the Laser Line Extraction package looks like in action:
+
+![Laser line extraction](images/line_extraction.gif)
+
+In the above image, the white dots are points in a LaserScan message, and the red lines are what is extracted by Laser Line Extraction. This data was collected by driving a robot through Beamish-Munro Hall at Queen's University. A SICK LMS111 laser scanner was mounted to the robot. The extraction algorithm is very configurable; the above image used the parameters configured in the `example.launch` launch file.
+
+After applying some filters to remove outlying points, Laser Line Extraction implements a split-and-merge algorithm to determine which points belong to lines. Next, it implements the weighted line fitting algorithm by Pfister *et al.* [1] to find the best fit lines and their respective covariance matrices.
+
+## Usage
+I recommend making a copy of `example.launch` in the launch directory and configuring the parameters until you reach a desirable outcome. The parameters in `example.launch` are a good starting point. Then simply use roslaunch, e.g.,
+
+```
+roslaunch laser_line_extraction example.launch
+```
+
+## Messages
+Laser Line Extraction has two messages types:
+
+#### LineSegment.msg
+```
+float32 radius
+float32 angle
+float32[4] covariance
+float32[2] start
+float32[2] end
+```
+`radius` (m) and `angle` (rad) are the polar parameterization of the line segment. `covariance` is the 2x2 covariance matrix of `radius` and `angle` (listed in row-major order). Finally `start` and `end` are the (x, y) coordinates of the start and end of the line segment.
+
+#### LineSegmentList.msg
+```
+Header header
+LineSegment[] line_segments
+```
+An array of LineSegment.msg with a header.
+
+## Topics
+
+Laser Line Extraction subscribes to a single topic and publishes one or two topics.
+
+### Subscribed topics
+- `/scan` ([sensor_msgs/LaserScan](http://docs.ros.org/api/sensor_msgs/html/msg/LaserScan.html))
+	- The name of this topic can be configured (see Parameters).
+
+### Published topics
+- `/line_segments` (laser\_line\_extraction/LineSegmentList)
+	- A list of line segments extracted from a laser scan.
+- `/line_markers` ([visualization_msgs/Marker](http://docs.ros.org/api/visualization_msgs/html/msg/Marker.html))
+	- (optional) Markers so that the extracted lines can be visualized in rviz (see above image). Can be toggled (see Parameters).
+
+## Parameters
+The parameters are listed in alphabetical order.
+
+- `bearing_std_dev` (default: 0.001)
+	- The standard deviation of bearing uncertainty in the laser scans (rad).
+- `frame_id` (default: "laser")
+	- The frame in which the line segments are published.
+- `least_sq_angle_thresh` (default: 0.0001)
+	- Change in angle (rad) threshold to stop iterating least squares (`least_sq_radius_thresh` must also be met).
+- `least_sq_radius_thresh` (default: 0.0001)
+	- Change in radius (m) threshold to stop iterating least squares (`least_sq_angle_thresh` must also be met).
+- `max_line_gap` (default: 0.4)
+	- The maximum distance between two points in the same line (m).
+- `min_line_length` (default: 0.5)
+	- Lines shorter than this are not published (m).
+- `min_line_points` (default: 9)
+	- Lines with fewer points than this are not published.
+- `min_range` (default: 0.4)
+	- Points closer than this are ignored (m).
+- `max_range` (default: 10000.0)
+	- Points farther than this are ignored (m).
+- `min_split_dist` (default: 0.05)
+	- When performing "split" step of split and merge, a split between two points results when the two points are at least this far apart (m).
+- `outlier_dist` (default: 0.05)
+	- Points who are at least this distance from all their neighbours are considered outliers (m).
+- `publish_markers` (default: false)
+	- Whether or not markers are published.
+- `range_std_dev` (default: 0.02)
+	- The standard deviation of range uncertainty in the laser scans (m).
+- `scan_topic` (default: "scan")
+	- The LaserScan topic.
+
+## References
+[1] S. T. Pfister, S. I. Roumeliotis, and J. W. Burdick, "Weighted line fitting algorithms for mobile robot map building and efficient data representation" in Proc. IEEE Intl. Conf. on Robotics and Automation (ICRA), Taipei, Taiwan, 14-19 Sept., 2003. 

salsa/manually_labeling/semantic_data_collection_ws/src/laser_line_extraction/include/laser_line_extraction/line.h

@@ -0,0 +1,67 @@
+#ifndef LINE_EXTRACTION_LINE_H
+#define LINE_EXTRACTION_LINE_H
+
+#include <vector>
+#include <boost/array.hpp>
+#include "laser_line_extraction/utilities.h"
+
+namespace line_extraction
+{
+
+class Line
+{
+
+public:
+  // Constructor / destructor
+  Line(const CachedData&, const RangeData&, const Params&, std::vector<unsigned int>);
+  Line(double angle, double radius, const boost::array<double, 4> &covariance,
+       const boost::array<double, 2> &start, const boost::array<double, 2> &end,
+       const std::vector<unsigned int> &indices);
+  ~Line();
+  // Get methods for the line parameters
+  double                           getAngle() const;
+  const boost::array<double, 4>&   getCovariance() const;
+  const boost::array<double, 2>&   getEnd() const;
+  const std::vector<unsigned int>& getIndices() const;
+  double                           getRadius() const;
+  const boost::array<double, 2>&   getStart() const;
+  // Methods for line fitting
+  double       distToPoint(unsigned int);
+  void         endpointFit();
+  void         leastSqFit();
+  double       length() const;
+  unsigned int numPoints() const;
+  void         projectEndpoints();
+
+private:
+  std::vector<unsigned int> indices_;
+  // Data structures
+  CachedData c_data_;
+  RangeData r_data_;
+  Params params_;
+  PointParams p_params_;
+  // Point variances used for least squares
+  std::vector<double> point_scalar_vars_;
+  std::vector<boost::array<double, 4> > point_covs_;
+  double p_rr_;
+  // Line parameters
+  double angle_;
+  double radius_;
+  boost::array<double, 2> start_;
+  boost::array<double, 2> end_;
+  boost::array<double, 4> covariance_;
+  // Methods
+  void    angleFromEndpoints();
+  void    angleFromLeastSq();
+  double  angleIncrement();
+  void    calcCovariance();
+  void    calcPointCovariances();
+  void    calcPointParameters();
+  void    calcPointScalarCovariances();
+  void    radiusFromEndpoints();
+  void    radiusFromLeastSq();
+}; // class Line
+
+} // namespace line_extraction
+
+#endif

salsa/manually_labeling/semantic_data_collection_ws/src/laser_line_extraction/include/laser_line_extraction/line_extraction.h

@@ -0,0 +1,62 @@
+#ifndef LINE_EXTRACTION_H
+#define LINE_EXTRACTION_H
+
+#include <cmath>
+#include <vector>
+#include <boost/array.hpp>
+#include <Eigen/Dense>
+#include "laser_line_extraction/utilities.h"
+#include "laser_line_extraction/line.h"
+
+namespace line_extraction
+{
+
+class LineExtraction
+{
+
+public:
+  // Constructor / destructor
+  LineExtraction();
+  ~LineExtraction();
+  // Run
+  void extractLines(std::vector<Line>&);
+  // Data setting
+  void setCachedData(const std::vector<double>&, const std::vector<double>&,
+                     const std::vector<double>&, const std::vector<unsigned int>&);
+  void setRangeData(const std::vector<double>&);
+  // Parameter setting
+  void setBearingVariance(double);
+  void setRangeVariance(double);
+  void setLeastSqAngleThresh(double);
+  void setLeastSqRadiusThresh(double);
+  void setMaxLineGap(double);
+  void setMinLineLength(double);
+  void setMinLinePoints(unsigned int);
+  void setMinRange(double);
+  void setMaxRange(double);
+  void setMinSplitDist(double);
+  void setOutlierDist(double);
+
+private:
+  // Data structures
+  CachedData c_data_;
+  RangeData r_data_;
+  Params params_;
+  // Indices after filtering
+  std::vector<unsigned int> filtered_indices_;
+  // Line data
+  std::vector<Line> lines_;
+  // Methods
+  double chiSquared(const Eigen::Vector2d&, const Eigen::Matrix2d&,
+                    const Eigen::Matrix2d&);
+  double distBetweenPoints(unsigned int index_1, unsigned int index_2);
+  void   filterCloseAndFarPoints();
+  void   filterOutlierPoints();
+  void   filterLines();
+  void   mergeLines();
+  void   split(const std::vector<unsigned int>&);
+};
+
+} // namespace line_extraction
+
+#endif

salsa/manually_labeling/semantic_data_collection_ws/src/laser_line_extraction/include/laser_line_extraction/line_extraction_ros.h

@@ -0,0 +1,52 @@
+#ifndef LINE_EXTRACTION_ROS_H
+#define LINE_EXTRACTION_ROS_H
+
+#include <vector>
+#include <string>
+#include <ros/ros.h>
+#include <sensor_msgs/LaserScan.h>
+#include <visualization_msgs/Marker.h>
+#include <geometry_msgs/Point.h>
+#include "laser_line_extraction/LineSegment.h"
+#include "laser_line_extraction/LineSegmentList.h"
+#include "laser_line_extraction/line_extraction.h"
+#include "laser_line_extraction/line.h"
+
+namespace line_extraction
+{
+
+class LineExtractionROS
+{
+
+public:
+  // Constructor / destructor
+  LineExtractionROS(ros::NodeHandle&, ros::NodeHandle&);
+  ~LineExtractionROS();
+  // Running
+  void run();
+
+private:
+  // ROS
+  ros::NodeHandle nh_;
+  ros::NodeHandle nh_local_;
+  ros::Subscriber scan_subscriber_;
+  ros::Publisher line_publisher_;
+  ros::Publisher marker_publisher_;
+  // Parameters
+  std::string frame_id_;
+  std::string scan_topic_;
+  bool pub_markers_;
+  // Line extraction
+  LineExtraction line_extraction_;
+  bool data_cached_; // true after first scan used to cache data
+  // Members
+  void loadParameters();
+  void populateLineSegListMsg(const std::vector<Line>&, laser_line_extraction::LineSegmentList&);
+  void populateMarkerMsg(const std::vector<Line>&, visualization_msgs::Marker&);
+  void cacheData(const sensor_msgs::LaserScan::ConstPtr&);
+  void laserScanCallback(const sensor_msgs::LaserScan::ConstPtr&);
+};
+
+} // namespace line_extraction
+
+#endif

salsa/manually_labeling/semantic_data_collection_ws/src/laser_line_extraction/include/laser_line_extraction/utilities.h

@@ -0,0 +1,65 @@
+#ifndef LINE_EXTRACTION_UTILITIES_H
+#define LINE_EXTRACTION_UTILITIES_H
+
+#include <vector>
+#include <cmath>
+
+namespace line_extraction
+{
+
+struct CachedData
+{
+  std::vector<unsigned int> indices;
+  std::vector<double> bearings;
+  std::vector<double> cos_bearings;
+  std::vector<double> sin_bearings;
+};
+
+struct RangeData
+{
+  std::vector<double> ranges;
+  std::vector<double> xs;
+  std::vector<double> ys;
+};
+
+struct Params
+{
+  double bearing_var;
+  double range_var;
+  double least_sq_angle_thresh;
+  double least_sq_radius_thresh;
+  double max_line_gap;
+  double min_line_length;
+  double min_range;
+  double max_range;
+  double min_split_dist;
+  double outlier_dist;
+  unsigned int min_line_points;
+};
+
+struct PointParams
+{
+  std::vector<double> a;
+  std::vector<double> ap;
+  std::vector<double> app;
+  std::vector<double> b;
+  std::vector<double> bp;
+  std::vector<double> bpp;
+  std::vector<double> c;
+  std::vector<double> s;
+};
+
+// Inlining this function will be faster
+// and also get rid of multiple definitions
+// error
+inline double pi_to_pi(double angle)
+{
+  angle = fmod(angle, 2 * M_PI);
+  if (angle >= M_PI)
+    angle -= 2 * M_PI;
+  return angle;
+}
+
+} // namespace line_extraction
+
+#endif

salsa/manually_labeling/semantic_data_collection_ws/src/laser_line_extraction/launch/debug.launch

@@ -0,0 +1,8 @@
+<launch>
+  <node name="line_extractor" pkg="laser_line_extraction" type="line_extraction_node" output="screen" launch-prefix="nemiver">
+    <param name="~scan_topic" value="front_lidar/scan" />
+    <param name="~frequency" value="50.0" />
+    <param name="~publish_markers" value="true" />
+  </node>
+</launch>
+

salsa/manually_labeling/semantic_data_collection_ws/src/laser_line_extraction/launch/example.launch

@@ -0,0 +1,29 @@
+<launch>
+  <node name="line_extractor" pkg="laser_line_extraction" type="line_extraction_node">
+    <!--################ CUSTOMIZATION REQUIRED ################-->
+
+    <!-- LiDAR frame ID (from your URDF or tf tree) -->
+    <param name="~frame_id" value="rear_laser" />
+
+    <!-- LiDAR scan topic name -->
+    <param name="~scan_topic" value="scan" />
+
+    <!-- Sensor range parameters (must match your LiDAR) -->
+    <param name="~min_range" value="0.6" />
+    <param name="~max_range" value="60.0" />
+
+    <!--################ Usually no changes needed below ################-->
+    <param name="~frequency" value="30.0" />
+    <param name="~publish_markers" value="false" />
+    <param name="~bearing_std_dev" value="1e-5" />
+    <param name="~range_std_dev" value="0.02" />
+    <param name="~least_sq_angle_thresh" value="0.0001" />
+    <param name="~least_sq_radius_thresh" value="0.0001" />
+    <param name="~max_line_gap" value="1.0" />
+    <param name="~min_line_length" value="0.4" />
+    <param name="~min_split_dist" value="0.04" />
+    <param name="~outlier_dist" value="0.06" />
+    <param name="~min_line_points" value="15" />
+  </node>
+</launch>
+

salsa/manually_labeling/semantic_data_collection_ws/src/laser_line_extraction/msg/LineSegment.msg

@@ -0,0 +1,5 @@
+float32 radius
+float32 angle
+float32[4] covariance
+float32[2] start
+float32[2] end

salsa/manually_labeling/semantic_data_collection_ws/src/laser_line_extraction/msg/LineSegmentList.msg

@@ -0,0 +1,2 @@
+Header header
+LineSegment[] line_segments

salsa/manually_labeling/semantic_data_collection_ws/src/laser_line_extraction/package.xml

@@ -0,0 +1,25 @@
+<?xml version="1.0"?>
+<package>
+  <name>laser_line_extraction</name>
+  <version>0.1.0</version>
+  <description>
+      A ROS package to extract line segments from LaserScan messages.
+  </description>
+  <maintainer email="m.gallant@queensu.ca">Marc Gallant</maintainer>
+  <license>BSD</license>
+  <buildtool_depend>catkin</buildtool_depend>
+  <build_depend>cmake_modules</build_depend>
+  <build_depend>eigen</build_depend>
+  <build_depend>geometry_msgs</build_depend>
+  <build_depend>message_generation</build_depend>
+  <build_depend>roscpp</build_depend>
+  <build_depend>rospy</build_depend>
+  <build_depend>sensor_msgs</build_depend>
+  <build_depend>visualization_msgs</build_depend>
+  <run_depend>geometry_msgs</run_depend>
+  <run_depend>message_runtime</run_depend>
+  <run_depend>roscpp</run_depend>
+  <run_depend>rospy</run_depend>
+  <run_depend>sensor_msgs</run_depend>
+  <run_depend>visualization_msgs</run_depend>
+</package>

salsa/manually_labeling/semantic_data_collection_ws/src/laser_line_extraction/src/line.cpp

@@ -0,0 +1,304 @@
+#include "laser_line_extraction/line.h"
+
+namespace line_extraction
+{
+
+///////////////////////////////////////////////////////////////////////////////
+// Constructor / destructor
+///////////////////////////////////////////////////////////////////////////////
+Line::Line(const CachedData &c_data, const RangeData &r_data, const Params &params, 
+           std::vector<unsigned int> indices):
+  c_data_(c_data),
+  r_data_(r_data),
+  params_(params),
+  indices_(indices)
+{
+}
+
+Line::Line(double angle, double radius, const boost::array<double, 4> &covariance,
+       const boost::array<double, 2> &start, const boost::array<double, 2> &end,
+       const std::vector<unsigned int> &indices):
+  angle_(angle),
+  radius_(radius),
+  covariance_(covariance),
+  start_(start),
+  end_(end),
+  indices_(indices)
+{
+}
+
+Line::~Line()
+{
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Get methods for line parameters
+///////////////////////////////////////////////////////////////////////////////
+double Line::getAngle() const
+{
+  return angle_;
+}
+
+const boost::array<double, 4>& Line::getCovariance() const
+{
+  return covariance_;
+}
+
+const boost::array<double, 2>& Line::getEnd() const
+{
+  return end_;
+}
+
+const std::vector<unsigned int>& Line::getIndices() const
+{
+  return indices_;
+}
+
+double Line::getRadius() const
+{
+  return radius_;
+}
+
+const boost::array<double, 2>& Line::getStart() const
+{
+  return start_;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Utility methods
+///////////////////////////////////////////////////////////////////////////////
+double Line::distToPoint(unsigned int index)
+{
+  double p_rad = sqrt(pow(r_data_.xs[index], 2) + pow(r_data_.ys[index], 2));
+  double p_ang = atan2(r_data_.ys[index], r_data_.xs[index]);
+  return fabs(p_rad * cos(p_ang - angle_) - radius_);
+}
+
+double Line::length() const
+{
+  return sqrt(pow(start_[0] - end_[0], 2) + pow(start_[1] - end_[1], 2));
+}
+
+unsigned int Line::numPoints() const
+{
+  return indices_.size();  
+}
+
+void Line::projectEndpoints()
+{
+  double s = -1.0 / tan(angle_);
+  double b = radius_ / sin(angle_);
+  double x = start_[0];
+  double y = start_[1];
+  start_[0] = (s * y + x - s * b) / (pow(s, 2) + 1);
+  start_[1] = (pow(s, 2) * y + s * x + b) / (pow(s, 2) + 1);
+  x = end_[0];
+  y = end_[1];
+  end_[0] = (s * y + x - s * b) / (pow(s, 2) + 1);
+  end_[1] = (pow(s, 2) * y + s * x + b) / (pow(s, 2) + 1);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Methods for endpoint line fitting
+///////////////////////////////////////////////////////////////////////////////
+void Line::endpointFit()
+{
+  start_[0] = r_data_.xs[indices_[0]]; 
+  start_[1] = r_data_.ys[indices_[0]]; 
+  end_[0] = r_data_.xs[indices_.back()]; 
+  end_[1] = r_data_.ys[indices_.back()]; 
+  angleFromEndpoints();
+  radiusFromEndpoints();
+}
+
+void Line::angleFromEndpoints()
+{
+  double slope;
+  if (fabs(end_[0] - start_[0]) > 1e-9)
+  {
+    slope = (end_[1] - start_[1]) / (end_[0] - start_[0]);
+    angle_ = pi_to_pi(atan(slope) + M_PI/2);
+  }
+  else
+  {
+    angle_ = 0.0;
+  }
+}
+
+void Line::radiusFromEndpoints()
+{
+  radius_ = start_[0] * cos(angle_) + start_[1] * sin(angle_);
+  if (radius_ < 0)
+  {
+    radius_ = -radius_;
+    angle_ = pi_to_pi(angle_ + M_PI);
+  }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Methods for least squares line fitting
+///////////////////////////////////////////////////////////////////////////////
+void Line::leastSqFit()
+{
+  calcPointCovariances();
+  double prev_radius = 0.0;
+  double prev_angle = 0.0;
+  while (fabs(radius_ - prev_radius) > params_.least_sq_radius_thresh ||
+         fabs(angle_ - prev_angle) > params_.least_sq_angle_thresh) 
+  {
+    prev_radius = radius_;
+    prev_angle = angle_;
+    calcPointScalarCovariances();
+    radiusFromLeastSq();
+    angleFromLeastSq();
+  }
+  calcCovariance();
+  projectEndpoints();
+}
+
+void Line::angleFromLeastSq()
+{
+  calcPointParameters();
+  angle_ += angleIncrement();
+}
+
+double Line::angleIncrement()
+{
+  const std::vector<double> &a = p_params_.a;
+  const std::vector<double> &ap = p_params_.ap;
+  const std::vector<double> &app = p_params_.app;
+  const std::vector<double> &b = p_params_.b;
+  const std::vector<double> &bp = p_params_.bp;
+  const std::vector<double> &bpp = p_params_.bpp;
+  const std::vector<double> &c = p_params_.c;
+  const std::vector<double> &s = p_params_.s;
+
+  double numerator = 0; 
+  double denominator = 0;
+  for (std::size_t i = 0; i < a.size(); ++i)
+  {
+    numerator += (b[i] * ap[i] - a[i] * bp[i]) / pow(b[i], 2);
+    denominator += ((app[i] * b[i] - a[i] * bpp[i]) * b[i] - 
+                    2 * (ap[i] * b[i] - a[i] * bp[i]) * bp[i]) / pow(b[i], 3);
+  }
+  return -(numerator/denominator);
+}
+
+void Line::calcCovariance()
+{
+  covariance_[0] = p_rr_;
+
+  const std::vector<double> &a = p_params_.a;
+  const std::vector<double> &ap = p_params_.ap;
+  const std::vector<double> &app = p_params_.app;
+  const std::vector<double> &b = p_params_.b;
+  const std::vector<double> &bp = p_params_.bp;
+  const std::vector<double> &bpp = p_params_.bpp;
+  const std::vector<double> &c = p_params_.c;
+  const std::vector<double> &s = p_params_.s;
+
+  double G = 0;
+  double A = 0;
+  double B = 0;
+  double r, phi;
+  for (std::size_t i = 0; i < a.size(); ++i)
+  {
+    r = r_data_.ranges[indices_[i]]; // range
+    phi = c_data_.bearings[indices_[i]]; // bearing
+    G += ((app[i] * b[i] - a[i] * bpp[i]) * b[i] - 2 * (ap[i] * b[i] - a[i] * bp[i]) * bp[i]) / pow(b[i], 3);
+    A += 2 * r * sin(angle_ - phi) / b[i];
+    B += 4 * pow(r, 2) * pow(sin(angle_ - phi), 2) / b[i];
+  }
+  covariance_[1] = p_rr_ * A / G;
+  covariance_[2] = covariance_[1];
+  covariance_[3] = pow(1.0 / G, 2) * B;
+}
+
+void Line::calcPointCovariances()
+{
+  point_covs_.clear();
+  double r, phi, var_r, var_phi;
+  for (std::vector<unsigned int>::const_iterator cit = indices_.begin(); cit != indices_.end(); ++cit)
+  {
+    r = r_data_.ranges[*cit]; // range
+    phi = c_data_.bearings[*cit]; // bearing
+    var_r = params_.range_var; // range variance
+    var_phi = params_.bearing_var; // bearing variance
+    boost::array<double, 4> Q; 
+    Q[0] = pow(r, 2) * var_phi * pow(sin(phi), 2) + var_r * pow(cos(phi), 2);
+    Q[1] = -pow(r, 2) * var_phi * sin(2 * phi) / 2.0 + var_r * sin(2 * phi) / 2.0;
+    Q[2] = Q[1]; 
+    Q[3] = pow(r, 2) * var_phi * pow(cos(phi), 2) + var_r * pow(sin(phi), 2);
+    point_covs_.push_back(Q);
+  }
+}
+
+void Line::calcPointParameters()
+{
+  p_params_.a.clear();
+  p_params_.ap.clear();
+  p_params_.app.clear();
+  p_params_.b.clear();
+  p_params_.bp.clear();
+  p_params_.bpp.clear();
+  p_params_.c.clear();
+  p_params_.s.clear();
+
+  double r, phi, var_r, var_phi;
+  double a, ap, app, b, bp, bpp, c, s;
+  for (std::vector<unsigned int>::const_iterator cit = indices_.begin(); cit != indices_.end(); ++cit)
+  {
+    r = r_data_.ranges[*cit]; // range
+    phi = c_data_.bearings[*cit]; // bearing
+    var_r = params_.range_var; // range variance
+    var_phi = params_.bearing_var; // bearing variance
+    c = cos(angle_ - phi);
+    s = sin(angle_ - phi);
+    a = pow(r * c - radius_, 2);
+    ap = -2 * r * s * (r * c - radius_);
+    app = 2 * pow(r, 2) * pow(s, 2) - 2 * r * c * (r * c - radius_);
+    b = var_r * pow(c, 2) + var_phi * pow(r, 2) * pow(s, 2);
+    bp = 2 * (pow(r, 2) * var_phi - var_r) * c * s;
+    bpp = 2 * (pow(r, 2) * var_phi - var_r) * (pow(c, 2) - pow(s, 2));
+    p_params_.a.push_back(a);
+    p_params_.ap.push_back(ap);
+    p_params_.app.push_back(app);
+    p_params_.b.push_back(b);
+    p_params_.bp.push_back(bp);
+    p_params_.bpp.push_back(bpp);
+    p_params_.c.push_back(c);
+    p_params_.s.push_back(s);
+  }
+}
+
+void Line::calcPointScalarCovariances()
+{
+  point_scalar_vars_.clear();
+  double P;
+  double inverse_P_sum = 0;
+  for (std::vector<boost::array<double, 4> >::const_iterator cit = point_covs_.begin();
+       cit != point_covs_.end(); ++cit)
+  {
+    P = (*cit)[0] * pow(cos(angle_), 2) + 2 * (*cit)[1] * sin(angle_) * cos(angle_) +
+        (*cit)[3] * pow(sin(angle_), 2);
+    inverse_P_sum += 1.0 / P;
+    point_scalar_vars_.push_back(P);
+  }
+  p_rr_ = 1.0 / inverse_P_sum;
+}
+
+void Line::radiusFromLeastSq()
+{
+  radius_ = 0;
+  double r, phi;
+  for (std::vector<unsigned int>::const_iterator cit = indices_.begin(); cit != indices_.end(); ++cit)
+  {
+    r = r_data_.ranges[*cit]; // range
+    phi = c_data_.bearings[*cit]; // bearing
+    radius_ += r * cos(angle_ - phi) / point_scalar_vars_[cit - indices_.begin()]; // cit to index
+  }
+  
+  radius_ *= p_rr_;
+}
+
+} // namespace line_extraction

salsa/manually_labeling/semantic_data_collection_ws/src/laser_line_extraction/src/line_extraction.cpp

@@ -0,0 +1,363 @@
+#include "laser_line_extraction/line_extraction.h"
+#include <algorithm>
+#include <Eigen/Dense>
+#include <iostream>
+
+namespace line_extraction
+{
+
+///////////////////////////////////////////////////////////////////////////////
+// Constructor / destructor
+///////////////////////////////////////////////////////////////////////////////
+LineExtraction::LineExtraction()
+{
+}
+
+LineExtraction::~LineExtraction()
+{
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Main run function
+///////////////////////////////////////////////////////////////////////////////
+void LineExtraction::extractLines(std::vector<Line>& lines) 
+{
+  // Resets
+  filtered_indices_ = c_data_.indices;
+  lines_.clear();
+
+  // Filter indices
+  filterCloseAndFarPoints();
+  filterOutlierPoints();
+
+  // Return no lines if not enough points left
+  if (filtered_indices_.size() <= std::max(params_.min_line_points, static_cast<unsigned int>(3)))
+  {
+    return;
+  }
+
+  // Split indices into lines and filter out short and sparse lines
+  split(filtered_indices_);
+  filterLines();
+
+  // Fit each line using least squares and merge colinear lines
+  for (std::vector<Line>::iterator it = lines_.begin(); it != lines_.end(); ++it)
+  {
+    it->leastSqFit();
+  }
+  
+  // If there is more than one line, check if lines should be merged based on the merging criteria
+  if (lines_.size() > 1)
+  {
+    mergeLines();
+  }
+
+  lines = lines_;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Data setting
+///////////////////////////////////////////////////////////////////////////////
+void LineExtraction::setCachedData(const std::vector<double>& bearings,
+                                   const std::vector<double>& cos_bearings,
+                                   const std::vector<double>& sin_bearings,
+                                   const std::vector<unsigned int>& indices)
+{
+  c_data_.bearings = bearings;
+  c_data_.cos_bearings = cos_bearings;
+  c_data_.sin_bearings = sin_bearings;
+  c_data_.indices = indices;
+}
+
+void LineExtraction::setRangeData(const std::vector<double>& ranges)
+{
+  r_data_.ranges = ranges;
+  r_data_.xs.clear();
+  r_data_.ys.clear();
+  for (std::vector<unsigned int>::const_iterator cit = c_data_.indices.begin(); 
+       cit != c_data_.indices.end(); ++cit)
+  {
+    r_data_.xs.push_back(c_data_.cos_bearings[*cit] * ranges[*cit]);
+    r_data_.ys.push_back(c_data_.sin_bearings[*cit] * ranges[*cit]);
+  }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Parameter setting
+///////////////////////////////////////////////////////////////////////////////
+void LineExtraction::setBearingVariance(double value)
+{
+  params_.bearing_var = value;
+}
+
+void LineExtraction::setRangeVariance(double value)
+{
+  params_.range_var = value;
+}
+
+void LineExtraction::setLeastSqAngleThresh(double value)
+{
+  params_.least_sq_angle_thresh = value;
+}
+
+void LineExtraction::setLeastSqRadiusThresh(double value)
+{
+  params_.least_sq_radius_thresh = value;
+}
+
+void LineExtraction::setMaxLineGap(double value)
+{
+  params_.max_line_gap = value;
+}
+
+void LineExtraction::setMinLineLength(double value)
+{
+  params_.min_line_length = value;
+}
+
+void LineExtraction::setMinLinePoints(unsigned int value)
+{
+  params_.min_line_points = value;
+}
+
+void LineExtraction::setMinRange(double value)
+{
+  params_.min_range = value;
+}
+
+void LineExtraction::setMaxRange(double value)
+{
+  params_.max_range = value;
+}
+
+void LineExtraction::setMinSplitDist(double value)
+{
+  params_.min_split_dist = value;
+}
+
+void LineExtraction::setOutlierDist(double value)
+{
+  params_.outlier_dist = value;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Utility methods
+///////////////////////////////////////////////////////////////////////////////
+double LineExtraction::chiSquared(const Eigen::Vector2d &dL, const Eigen::Matrix2d &P_1,
+                                  const Eigen::Matrix2d &P_2)
+{
+  return dL.transpose() * (P_1 + P_2).inverse() * dL;
+}
+
+double LineExtraction::distBetweenPoints(unsigned int index_1, unsigned int index_2)
+{
+  return sqrt(pow(r_data_.xs[index_1] - r_data_.xs[index_2], 2) + 
+              pow(r_data_.ys[index_1] - r_data_.ys[index_2], 2));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Filtering points
+///////////////////////////////////////////////////////////////////////////////
+void LineExtraction::filterCloseAndFarPoints()
+{
+  std::vector<unsigned int> output;
+  for (std::vector<unsigned int>::const_iterator cit = filtered_indices_.begin(); 
+       cit != filtered_indices_.end(); ++cit)
+  {
+    const double& range = r_data_.ranges[*cit];
+    if (range >= params_.min_range && range <= params_.max_range)
+    {
+      output.push_back(*cit);
+    }
+  }
+  filtered_indices_ = output;
+}
+
+void LineExtraction::filterOutlierPoints()
+{
+  if (filtered_indices_.size() < 3)
+  {
+    return;
+  }
+
+  std::vector<unsigned int> output;
+  unsigned int p_i, p_j, p_k;
+  for (std::size_t i = 0; i < filtered_indices_.size(); ++i)
+  {
+
+    // Get two closest neighbours
+
+    p_i = filtered_indices_[i];
+    if (i == 0) // first point
+    {
+      p_j = filtered_indices_[i + 1];
+      p_k = filtered_indices_[i + 2];
+    }
+    else if (i == filtered_indices_.size() - 1) // last point
+    {
+      p_j = filtered_indices_[i - 1];
+      p_k = filtered_indices_[i - 2];
+    }
+    else // middle points
+    {
+      p_j = filtered_indices_[i - 1];
+      p_k = filtered_indices_[i + 1];
+    }
+
+    // Check if point is an outlier
+
+    if (fabs(r_data_.ranges[p_i] - r_data_.ranges[p_j]) > params_.outlier_dist &&
+        fabs(r_data_.ranges[p_i] - r_data_.ranges[p_k]) > params_.outlier_dist) 
+    {
+      // Check if it is close to line connecting its neighbours
+      std::vector<unsigned int> line_indices;
+      line_indices.push_back(p_j);
+      line_indices.push_back(p_k);
+      Line line(c_data_, r_data_, params_, line_indices);
+      line.endpointFit();
+      if (line.distToPoint(p_i) > params_.min_split_dist)
+      {
+        continue; // point is an outlier
+      }
+    }
+
+    output.push_back(p_i);
+  }
+
+  filtered_indices_ = output;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Filtering and merging lines
+///////////////////////////////////////////////////////////////////////////////
+void LineExtraction::filterLines()
+{
+  std::vector<Line> output;
+  for (std::vector<Line>::const_iterator cit = lines_.begin(); cit != lines_.end(); ++cit)
+  {
+    if (cit->length() >= params_.min_line_length && cit->numPoints() >= params_.min_line_points)
+    {
+      output.push_back(*cit);
+    }
+  }
+  lines_ = output;
+}
+
+void LineExtraction::mergeLines()
+{
+  std::vector<Line> merged_lines;
+
+  for (std::size_t i = 1; i < lines_.size(); ++i)
+  {
+    // Get L, P_1, P_2 of consecutive lines
+    Eigen::Vector2d L_1(lines_[i-1].getRadius(), lines_[i-1].getAngle());
+    Eigen::Vector2d L_2(lines_[i].getRadius(), lines_[i].getAngle());
+    Eigen::Matrix2d P_1;
+    P_1 << lines_[i-1].getCovariance()[0], lines_[i-1].getCovariance()[1],
+           lines_[i-1].getCovariance()[2], lines_[i-1].getCovariance()[3];
+    Eigen::Matrix2d P_2;
+    P_2 << lines_[i].getCovariance()[0], lines_[i].getCovariance()[1],
+           lines_[i].getCovariance()[2], lines_[i].getCovariance()[3];
+
+    // Merge lines if chi-squared distance is less than 3
+    if (chiSquared(L_1 - L_2, P_1, P_2) < 3)
+    {
+      // Get merged angle, radius, and covariance
+      Eigen::Matrix2d P_m = (P_1.inverse() + P_2.inverse()).inverse();
+      Eigen::Vector2d L_m = P_m * (P_1.inverse() * L_1 + P_2.inverse() * L_2);
+      // Populate new line with these merged parameters
+      boost::array<double, 4> cov;
+      cov[0] = P_m(0,0);
+      cov[1] = P_m(0,1);
+      cov[2] = P_m(1,0);
+      cov[3] = P_m(1,1);
+      std::vector<unsigned int> indices;
+      const std::vector<unsigned int> &ind_1 = lines_[i-1].getIndices();
+      const std::vector<unsigned int> &ind_2 = lines_[i].getIndices();
+      indices.resize(ind_1.size() + ind_2.size());
+      indices.insert(indices.end(), ind_1.begin(), ind_1.end());
+      indices.insert(indices.end(), ind_2.begin(), ind_2.end());
+      Line merged_line(L_m[1], L_m[0], cov, lines_[i-1].getStart(), lines_[i].getEnd(), indices);
+      // Project the new endpoints
+      merged_line.projectEndpoints();
+      lines_[i] = merged_line;
+    }
+    else
+    {
+      merged_lines.push_back(lines_[i-1]);
+    }
+
+    if (i == lines_.size() - 1)
+    {
+      merged_lines.push_back(lines_[i]);
+    }
+  }
+  lines_ = merged_lines;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Splitting points into lines
+///////////////////////////////////////////////////////////////////////////////
+void LineExtraction::split(const std::vector<unsigned int>& indices)
+{
+  // Don't split if only a single point (only occurs when orphaned by gap)
+  if (indices.size() <= 1)
+  {
+    return;
+  }
+
+  Line line(c_data_, r_data_, params_, indices);
+  line.endpointFit();
+  double dist_max = 0;
+  double gap_max = 0;
+  double dist, gap;
+  int i_max, i_gap;
+
+  // Find the farthest point and largest gap
+  for (std::size_t i = 1; i < indices.size() - 1; ++i)
+  {
+    dist = line.distToPoint(indices[i]);
+    if (dist > dist_max)
+    {
+      dist_max = dist;
+      i_max = i;
+    }
+    gap = distBetweenPoints(indices[i], indices[i+1]);
+    if (gap > gap_max)
+    {
+      gap_max = gap;
+      i_gap = i;
+    }
+  }
+
+  // Check for gaps at endpoints
+  double gap_start = distBetweenPoints(indices[0], indices[1]);
+  if (gap_start > gap_max)
+  {
+    gap_max = gap_start;
+    i_gap = 1;
+  }
+  double gap_end = distBetweenPoints(indices.rbegin()[1], indices.rbegin()[0]);
+  if (gap_end > gap_max)
+  {
+    gap_max = gap_end;
+    i_gap = indices.size() - 1;
+  }
+
+  // Check if line meets requirements or should be split
+  if (dist_max < params_.min_split_dist && gap_max < params_.max_line_gap)
+  {
+    lines_.push_back(line);
+  }
+  else
+  {
+    int i_split = dist_max >= params_.min_split_dist ? i_max : i_gap;
+    std::vector<unsigned int> first_split(&indices[0], &indices[i_split - 1]);
+    std::vector<unsigned int> second_split(&indices[i_split], &indices.back());
+    split(first_split);
+    split(second_split);
+  }
+
+}
+
+} // namespace line_extraction

salsa/manually_labeling/semantic_data_collection_ws/src/laser_line_extraction/src/line_extraction_node.cpp

@@ -0,0 +1,32 @@
+#include "laser_line_extraction/line_extraction_ros.h"
+#include <ros/console.h>
+
+int main(int argc, char **argv)
+{
+
+  if (ros::console::set_logger_level(ROSCONSOLE_DEFAULT_NAME, ros::console::levels::Debug)) 
+  {
+     ros::console::notifyLoggerLevelsChanged();
+  }
+
+  ROS_DEBUG("Starting line_extraction_node.");
+
+  ros::init(argc, argv, "line_extraction_node");
+  ros::NodeHandle nh;
+  ros::NodeHandle nh_local("~");
+  line_extraction::LineExtractionROS line_extractor(nh, nh_local);
+
+  double frequency;
+  nh_local.param<double>("frequency", frequency, 25);
+  ROS_DEBUG("Frequency set to %0.1f Hz", frequency);
+  ros::Rate rate(frequency);
+
+  while (ros::ok())
+  {
+    line_extractor.run();
+    ros::spinOnce();
+    rate.sleep();
+  }
+  return 0;
+}
+

salsa/manually_labeling/semantic_data_collection_ws/src/laser_line_extraction/src/line_extraction_ros.cpp

@@ -0,0 +1,220 @@
+#include "laser_line_extraction/line_extraction_ros.h"
+#include <cmath>
+#include <ros/console.h>
+
+
+namespace line_extraction
+{
+
+///////////////////////////////////////////////////////////////////////////////
+// Constructor / destructor
+///////////////////////////////////////////////////////////////////////////////
+LineExtractionROS::LineExtractionROS(ros::NodeHandle& nh, ros::NodeHandle& nh_local):
+  nh_(nh),
+  nh_local_(nh_local),
+  data_cached_(false)
+{
+  loadParameters();
+  line_publisher_ = nh_.advertise<laser_line_extraction::LineSegmentList>("line_segments", 1);
+  scan_subscriber_ = nh_.subscribe(scan_topic_, 1, &LineExtractionROS::laserScanCallback, this);
+  if (pub_markers_)
+  {
+    marker_publisher_ = nh_.advertise<visualization_msgs::Marker>("line_markers", 1);
+  }
+}
+
+LineExtractionROS::~LineExtractionROS()
+{
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Run
+///////////////////////////////////////////////////////////////////////////////
+void LineExtractionROS::run()
+{
+  // Extract the lines
+  std::vector<Line> lines;
+  line_extraction_.extractLines(lines);
+
+  // Populate message
+  laser_line_extraction::LineSegmentList msg;
+  populateLineSegListMsg(lines, msg);
+  
+  // Publish the lines
+  line_publisher_.publish(msg);
+
+  // Also publish markers if parameter publish_markers is set to true
+  if (pub_markers_)
+  {
+    visualization_msgs::Marker marker_msg;
+    populateMarkerMsg(lines, marker_msg);
+    marker_publisher_.publish(marker_msg);
+  }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Load ROS parameters
+///////////////////////////////////////////////////////////////////////////////
+void LineExtractionROS::loadParameters()
+{
+  
+  ROS_DEBUG("*************************************");
+  ROS_DEBUG("PARAMETERS:");
+
+  // Parameters used by this node
+  
+  std::string frame_id, scan_topic;
+  bool pub_markers;
+
+  nh_local_.param<std::string>("frame_id", frame_id, "laser");
+  frame_id_ = frame_id;
+  ROS_DEBUG("frame_id: %s", frame_id_.c_str());
+
+  nh_local_.param<std::string>("scan_topic", scan_topic, "scan");
+  scan_topic_ = scan_topic;
+  ROS_DEBUG("scan_topic: %s", scan_topic_.c_str());
+
+  nh_local_.param<bool>("publish_markers", pub_markers, false);
+  pub_markers_ = pub_markers;
+  ROS_DEBUG("publish_markers: %s", pub_markers ? "true" : "false");
+
+  // Parameters used by the line extraction algorithm
+
+  double bearing_std_dev, range_std_dev, least_sq_angle_thresh, least_sq_radius_thresh,
+         max_line_gap, min_line_length, min_range, max_range, min_split_dist, outlier_dist;
+  int min_line_points;
+
+  nh_local_.param<double>("bearing_std_dev", bearing_std_dev, 1e-3);
+  line_extraction_.setBearingVariance(bearing_std_dev * bearing_std_dev);
+  ROS_DEBUG("bearing_std_dev: %f", bearing_std_dev);
+
+  nh_local_.param<double>("range_std_dev", range_std_dev, 0.02);
+  line_extraction_.setRangeVariance(range_std_dev * range_std_dev);
+  ROS_DEBUG("range_std_dev: %f", range_std_dev);
+
+  nh_local_.param<double>("least_sq_angle_thresh", least_sq_angle_thresh, 1e-4);
+  line_extraction_.setLeastSqAngleThresh(least_sq_angle_thresh);
+  ROS_DEBUG("least_sq_angle_thresh: %f", least_sq_angle_thresh);
+  
+  nh_local_.param<double>("least_sq_radius_thresh", least_sq_radius_thresh, 1e-4);
+  line_extraction_.setLeastSqRadiusThresh(least_sq_radius_thresh);
+  ROS_DEBUG("least_sq_radius_thresh: %f", least_sq_radius_thresh);
+
+  nh_local_.param<double>("max_line_gap", max_line_gap, 0.4);
+  line_extraction_.setMaxLineGap(max_line_gap);
+  ROS_DEBUG("max_line_gap: %f", max_line_gap);
+
+  nh_local_.param<double>("min_line_length", min_line_length, 0.5);
+  line_extraction_.setMinLineLength(min_line_length);
+  ROS_DEBUG("min_line_length: %f", min_line_length);
+
+  nh_local_.param<double>("min_range", min_range, 0.4);
+  line_extraction_.setMinRange(min_range);
+  ROS_DEBUG("min_range: %f", min_range);
+
+  nh_local_.param<double>("max_range", max_range, 10000.0);
+  line_extraction_.setMaxRange(max_range);
+  ROS_DEBUG("max_range: %f", max_range);
+
+  nh_local_.param<double>("min_split_dist", min_split_dist, 0.05);
+  line_extraction_.setMinSplitDist(min_split_dist);
+  ROS_DEBUG("min_split_dist: %f", min_split_dist);
+
+  nh_local_.param<double>("outlier_dist", outlier_dist, 0.05);
+  line_extraction_.setOutlierDist(outlier_dist);
+  ROS_DEBUG("outlier_dist: %f", outlier_dist);
+
+  nh_local_.param<int>("min_line_points", min_line_points, 9);
+  line_extraction_.setMinLinePoints(static_cast<unsigned int>(min_line_points));
+  ROS_DEBUG("min_line_points: %d", min_line_points);
+
+  ROS_DEBUG("*************************************");
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Populate messages
+///////////////////////////////////////////////////////////////////////////////
+void LineExtractionROS::populateLineSegListMsg(const std::vector<Line> &lines,
+                                                laser_line_extraction::LineSegmentList &line_list_msg)
+{
+  for (std::vector<Line>::const_iterator cit = lines.begin(); cit != lines.end(); ++cit)
+  {
+    laser_line_extraction::LineSegment line_msg;
+    line_msg.angle = cit->getAngle(); 
+    line_msg.radius = cit->getRadius(); 
+    line_msg.covariance = cit->getCovariance(); 
+    line_msg.start = cit->getStart(); 
+    line_msg.end = cit->getEnd(); 
+    line_list_msg.line_segments.push_back(line_msg);
+  }
+  line_list_msg.header.frame_id = frame_id_;
+  line_list_msg.header.stamp = ros::Time::now();
+}
+
+void LineExtractionROS::populateMarkerMsg(const std::vector<Line> &lines, 
+                                           visualization_msgs::Marker &marker_msg)
+{
+  marker_msg.ns = "line_extraction";
+  marker_msg.id = 0;
+  marker_msg.type = visualization_msgs::Marker::LINE_LIST;
+  marker_msg.scale.x = 0.1;
+  marker_msg.color.r = 1.0;
+  marker_msg.color.g = 0.0;
+  marker_msg.color.b = 0.0;
+  marker_msg.color.a = 1.0;
+  for (std::vector<Line>::const_iterator cit = lines.begin(); cit != lines.end(); ++cit)
+  {
+    geometry_msgs::Point p_start;
+    p_start.x = cit->getStart()[0];
+    p_start.y = cit->getStart()[1];
+    p_start.z = 0;
+    marker_msg.points.push_back(p_start);
+    geometry_msgs::Point p_end;
+    p_end.x = cit->getEnd()[0];
+    p_end.y = cit->getEnd()[1];
+    p_end.z = 0;
+    marker_msg.points.push_back(p_end);
+  }
+  marker_msg.header.frame_id = frame_id_;
+  marker_msg.header.stamp = ros::Time::now(); 
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Cache data on first LaserScan message received
+///////////////////////////////////////////////////////////////////////////////
+void LineExtractionROS::cacheData(const sensor_msgs::LaserScan::ConstPtr &scan_msg)
+{
+  std::vector<double> bearings, cos_bearings, sin_bearings;
+  std::vector<unsigned int> indices;
+  const std::size_t num_measurements = std::ceil(
+      (scan_msg->angle_max - scan_msg->angle_min) / scan_msg->angle_increment);
+  for (std::size_t i = 0; i < num_measurements; ++i)
+  {
+    const double b = scan_msg->angle_min + i * scan_msg->angle_increment;
+    bearings.push_back(b);
+    cos_bearings.push_back(cos(b));
+    sin_bearings.push_back(sin(b));
+    indices.push_back(i);
+  }
+
+  line_extraction_.setCachedData(bearings, cos_bearings, sin_bearings, indices);
+  ROS_DEBUG("Data has been cached.");
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Main LaserScan callback
+///////////////////////////////////////////////////////////////////////////////
+void LineExtractionROS::laserScanCallback(const sensor_msgs::LaserScan::ConstPtr &scan_msg)
+{
+  if (!data_cached_)
+  {
+    cacheData(scan_msg); 
+    data_cached_ = true;
+  }
+
+  std::vector<double> scan_ranges_doubles(scan_msg->ranges.begin(), scan_msg->ranges.end());
+  line_extraction_.setRangeData(scan_ranges_doubles);
+}
+
+} // namespace line_extraction
+