Package Summary
| Version | 0.0.0 |
| License | MIT |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Description | |
| Checkout URI | https://github.com/vortexntnu/vortex-auv.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-18 |
| Dev Status | UNKNOWN |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Maintainers
- jorgen
Authors
line_filtering
Error-state IPDA filter for 2D line tracking.
Overview
This package tracks 2D lines detected by a sonar (or other sensor) using an
error-state formulation inspired by the quaternion error-state EKF used in
pose_filtering.
Why error-state for lines?
A 2D line in Hesse normal form (rho, theta) suffers from:
-
Angle wrapping – the
0 ↔ 2πseam makes Gaussian residuals invalid. -
Sign ambiguity –
(rho, theta)and(-rho, theta + π)describe the same geometric line, causingπ-jumps nearrho ≈ 0.
Instead we keep a nominal line (rho, n) where n is a unit normal and
filter a minimal 2D error state [δρ, δφ] in ℝ².
-
Log residual – sign-align the measurement normal, then compute
δφviaatan2(cross, dot). No raw angle subtraction. -
Exp update – apply
δρadditively and rotatenbyδφ, then reset.
Pipeline
- Subscribe to
LineSegment2DArray(pixel-space line detections). - Subscribe to
SonarInfofor pixel-to-metric conversion. - Convert pixel segments → metric (z = 0) in sonar frame.
- TF-transform endpoints to the
target_frame(typicallyodom). - Project to 2D (XY plane) and convert to
(rho, n)measurements. - Run the IPDA track manager (gating → update → confirm / delete → create).
- Publish confirmed tracks as
LineSegment3DArrayandMarkerArray.
Topics
| Direction | Topic | Type |
|---|---|---|
| Sub | /sonar/line_segments |
vortex_msgs/LineSegment2DArray |
| Sub | /sonar/sonar_info |
vortex_msgs/SonarInfo |
| Pub | /filtered_lines |
vortex_msgs/LineSegment3DArray |
| Pub | /filtered_lines_markers |
visualization_msgs/MarkerArray |
Launch
ros2 launch line_filtering line_filtering.launch.py
Library export and usage
The core tracking logic (LineTrackManager) is built and exported as a
shared library by this package so other packages can reuse the track
management functionality without pulling in the ROS node.
CMake / ament usage
In a consuming CMake-based package (ament_cmake) you can link against the library like this:
find_package(line_filtering REQUIRED)
add_executable(my_node src/my_node.cpp)
# Link to the exported library target (the package exports the target
# with the same name as the package: `line_filtering`)
target_link_libraries(my_node PRIVATE line_filtering)
The package installs its public headers under include/ so simply
including the header below in your code will work after linking:
#include <line_filtering/lib/line_track_manager.hpp>
int main() {
vortex::line_filtering::LineTrackManagerConfig cfg;
// configure cfg.nm (N/M confirmation/deletion) and
// cfg.default_config (gate, noise, PDAF parameters)
vortex::line_filtering::LineTrackManager manager(cfg);
std::vector<vortex::line_filtering::LineMeasurement> measurements;
double dt = 0.1; // seconds
manager.step(measurements, dt);
const auto& tracks = manager.get_tracks();
// iterate tracks for id, nominal line, hits/misses, confirmed, etc.
}
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake | |
| rclcpp | |
| rclcpp_components | |
| geometry_msgs | |
| visualization_msgs | |
| tf2 | |
| tf2_ros | |
| message_filters | |
| vortex_utils | |
| vortex_utils_ros | |
| vortex_filtering | |
| vortex_msgs |
System Dependencies
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged line_filtering at Robotics Stack Exchange
Package Summary
| Version | 0.0.0 |
| License | MIT |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Description | |
| Checkout URI | https://github.com/vortexntnu/vortex-auv.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-18 |
| Dev Status | UNKNOWN |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Maintainers
- jorgen
Authors
line_filtering
Error-state IPDA filter for 2D line tracking.
Overview
This package tracks 2D lines detected by a sonar (or other sensor) using an
error-state formulation inspired by the quaternion error-state EKF used in
pose_filtering.
Why error-state for lines?
A 2D line in Hesse normal form (rho, theta) suffers from:
-
Angle wrapping – the
0 ↔ 2πseam makes Gaussian residuals invalid. -
Sign ambiguity –
(rho, theta)and(-rho, theta + π)describe the same geometric line, causingπ-jumps nearrho ≈ 0.
Instead we keep a nominal line (rho, n) where n is a unit normal and
filter a minimal 2D error state [δρ, δφ] in ℝ².
-
Log residual – sign-align the measurement normal, then compute
δφviaatan2(cross, dot). No raw angle subtraction. -
Exp update – apply
δρadditively and rotatenbyδφ, then reset.
Pipeline
- Subscribe to
LineSegment2DArray(pixel-space line detections). - Subscribe to
SonarInfofor pixel-to-metric conversion. - Convert pixel segments → metric (z = 0) in sonar frame.
- TF-transform endpoints to the
target_frame(typicallyodom). - Project to 2D (XY plane) and convert to
(rho, n)measurements. - Run the IPDA track manager (gating → update → confirm / delete → create).
- Publish confirmed tracks as
LineSegment3DArrayandMarkerArray.
Topics
| Direction | Topic | Type |
|---|---|---|
| Sub | /sonar/line_segments |
vortex_msgs/LineSegment2DArray |
| Sub | /sonar/sonar_info |
vortex_msgs/SonarInfo |
| Pub | /filtered_lines |
vortex_msgs/LineSegment3DArray |
| Pub | /filtered_lines_markers |
visualization_msgs/MarkerArray |
Launch
ros2 launch line_filtering line_filtering.launch.py
Library export and usage
The core tracking logic (LineTrackManager) is built and exported as a
shared library by this package so other packages can reuse the track
management functionality without pulling in the ROS node.
CMake / ament usage
In a consuming CMake-based package (ament_cmake) you can link against the library like this:
find_package(line_filtering REQUIRED)
add_executable(my_node src/my_node.cpp)
# Link to the exported library target (the package exports the target
# with the same name as the package: `line_filtering`)
target_link_libraries(my_node PRIVATE line_filtering)
The package installs its public headers under include/ so simply
including the header below in your code will work after linking:
#include <line_filtering/lib/line_track_manager.hpp>
int main() {
vortex::line_filtering::LineTrackManagerConfig cfg;
// configure cfg.nm (N/M confirmation/deletion) and
// cfg.default_config (gate, noise, PDAF parameters)
vortex::line_filtering::LineTrackManager manager(cfg);
std::vector<vortex::line_filtering::LineMeasurement> measurements;
double dt = 0.1; // seconds
manager.step(measurements, dt);
const auto& tracks = manager.get_tracks();
// iterate tracks for id, nominal line, hits/misses, confirmed, etc.
}
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake | |
| rclcpp | |
| rclcpp_components | |
| geometry_msgs | |
| visualization_msgs | |
| tf2 | |
| tf2_ros | |
| message_filters | |
| vortex_utils | |
| vortex_utils_ros | |
| vortex_filtering | |
| vortex_msgs |
System Dependencies
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged line_filtering at Robotics Stack Exchange
Package Summary
| Version | 0.0.0 |
| License | MIT |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Description | |
| Checkout URI | https://github.com/vortexntnu/vortex-auv.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-18 |
| Dev Status | UNKNOWN |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Maintainers
- jorgen
Authors
line_filtering
Error-state IPDA filter for 2D line tracking.
Overview
This package tracks 2D lines detected by a sonar (or other sensor) using an
error-state formulation inspired by the quaternion error-state EKF used in
pose_filtering.
Why error-state for lines?
A 2D line in Hesse normal form (rho, theta) suffers from:
-
Angle wrapping – the
0 ↔ 2πseam makes Gaussian residuals invalid. -
Sign ambiguity –
(rho, theta)and(-rho, theta + π)describe the same geometric line, causingπ-jumps nearrho ≈ 0.
Instead we keep a nominal line (rho, n) where n is a unit normal and
filter a minimal 2D error state [δρ, δφ] in ℝ².
-
Log residual – sign-align the measurement normal, then compute
δφviaatan2(cross, dot). No raw angle subtraction. -
Exp update – apply
δρadditively and rotatenbyδφ, then reset.
Pipeline
- Subscribe to
LineSegment2DArray(pixel-space line detections). - Subscribe to
SonarInfofor pixel-to-metric conversion. - Convert pixel segments → metric (z = 0) in sonar frame.
- TF-transform endpoints to the
target_frame(typicallyodom). - Project to 2D (XY plane) and convert to
(rho, n)measurements. - Run the IPDA track manager (gating → update → confirm / delete → create).
- Publish confirmed tracks as
LineSegment3DArrayandMarkerArray.
Topics
| Direction | Topic | Type |
|---|---|---|
| Sub | /sonar/line_segments |
vortex_msgs/LineSegment2DArray |
| Sub | /sonar/sonar_info |
vortex_msgs/SonarInfo |
| Pub | /filtered_lines |
vortex_msgs/LineSegment3DArray |
| Pub | /filtered_lines_markers |
visualization_msgs/MarkerArray |
Launch
ros2 launch line_filtering line_filtering.launch.py
Library export and usage
The core tracking logic (LineTrackManager) is built and exported as a
shared library by this package so other packages can reuse the track
management functionality without pulling in the ROS node.
CMake / ament usage
In a consuming CMake-based package (ament_cmake) you can link against the library like this:
find_package(line_filtering REQUIRED)
add_executable(my_node src/my_node.cpp)
# Link to the exported library target (the package exports the target
# with the same name as the package: `line_filtering`)
target_link_libraries(my_node PRIVATE line_filtering)
The package installs its public headers under include/ so simply
including the header below in your code will work after linking:
#include <line_filtering/lib/line_track_manager.hpp>
int main() {
vortex::line_filtering::LineTrackManagerConfig cfg;
// configure cfg.nm (N/M confirmation/deletion) and
// cfg.default_config (gate, noise, PDAF parameters)
vortex::line_filtering::LineTrackManager manager(cfg);
std::vector<vortex::line_filtering::LineMeasurement> measurements;
double dt = 0.1; // seconds
manager.step(measurements, dt);
const auto& tracks = manager.get_tracks();
// iterate tracks for id, nominal line, hits/misses, confirmed, etc.
}
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake | |
| rclcpp | |
| rclcpp_components | |
| geometry_msgs | |
| visualization_msgs | |
| tf2 | |
| tf2_ros | |
| message_filters | |
| vortex_utils | |
| vortex_utils_ros | |
| vortex_filtering | |
| vortex_msgs |
System Dependencies
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged line_filtering at Robotics Stack Exchange
Package Summary
| Version | 0.0.0 |
| License | MIT |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Description | |
| Checkout URI | https://github.com/vortexntnu/vortex-auv.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-18 |
| Dev Status | UNKNOWN |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Maintainers
- jorgen
Authors
line_filtering
Error-state IPDA filter for 2D line tracking.
Overview
This package tracks 2D lines detected by a sonar (or other sensor) using an
error-state formulation inspired by the quaternion error-state EKF used in
pose_filtering.
Why error-state for lines?
A 2D line in Hesse normal form (rho, theta) suffers from:
-
Angle wrapping – the
0 ↔ 2πseam makes Gaussian residuals invalid. -
Sign ambiguity –
(rho, theta)and(-rho, theta + π)describe the same geometric line, causingπ-jumps nearrho ≈ 0.
Instead we keep a nominal line (rho, n) where n is a unit normal and
filter a minimal 2D error state [δρ, δφ] in ℝ².
-
Log residual – sign-align the measurement normal, then compute
δφviaatan2(cross, dot). No raw angle subtraction. -
Exp update – apply
δρadditively and rotatenbyδφ, then reset.
Pipeline
- Subscribe to
LineSegment2DArray(pixel-space line detections). - Subscribe to
SonarInfofor pixel-to-metric conversion. - Convert pixel segments → metric (z = 0) in sonar frame.
- TF-transform endpoints to the
target_frame(typicallyodom). - Project to 2D (XY plane) and convert to
(rho, n)measurements. - Run the IPDA track manager (gating → update → confirm / delete → create).
- Publish confirmed tracks as
LineSegment3DArrayandMarkerArray.
Topics
| Direction | Topic | Type |
|---|---|---|
| Sub | /sonar/line_segments |
vortex_msgs/LineSegment2DArray |
| Sub | /sonar/sonar_info |
vortex_msgs/SonarInfo |
| Pub | /filtered_lines |
vortex_msgs/LineSegment3DArray |
| Pub | /filtered_lines_markers |
visualization_msgs/MarkerArray |
Launch
ros2 launch line_filtering line_filtering.launch.py
Library export and usage
The core tracking logic (LineTrackManager) is built and exported as a
shared library by this package so other packages can reuse the track
management functionality without pulling in the ROS node.
CMake / ament usage
In a consuming CMake-based package (ament_cmake) you can link against the library like this:
find_package(line_filtering REQUIRED)
add_executable(my_node src/my_node.cpp)
# Link to the exported library target (the package exports the target
# with the same name as the package: `line_filtering`)
target_link_libraries(my_node PRIVATE line_filtering)
The package installs its public headers under include/ so simply
including the header below in your code will work after linking:
#include <line_filtering/lib/line_track_manager.hpp>
int main() {
vortex::line_filtering::LineTrackManagerConfig cfg;
// configure cfg.nm (N/M confirmation/deletion) and
// cfg.default_config (gate, noise, PDAF parameters)
vortex::line_filtering::LineTrackManager manager(cfg);
std::vector<vortex::line_filtering::LineMeasurement> measurements;
double dt = 0.1; // seconds
manager.step(measurements, dt);
const auto& tracks = manager.get_tracks();
// iterate tracks for id, nominal line, hits/misses, confirmed, etc.
}
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake | |
| rclcpp | |
| rclcpp_components | |
| geometry_msgs | |
| visualization_msgs | |
| tf2 | |
| tf2_ros | |
| message_filters | |
| vortex_utils | |
| vortex_utils_ros | |
| vortex_filtering | |
| vortex_msgs |
System Dependencies
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged line_filtering at Robotics Stack Exchange
Package Summary
| Version | 0.0.0 |
| License | MIT |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Description | |
| Checkout URI | https://github.com/vortexntnu/vortex-auv.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-18 |
| Dev Status | UNKNOWN |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Maintainers
- jorgen
Authors
line_filtering
Error-state IPDA filter for 2D line tracking.
Overview
This package tracks 2D lines detected by a sonar (or other sensor) using an
error-state formulation inspired by the quaternion error-state EKF used in
pose_filtering.
Why error-state for lines?
A 2D line in Hesse normal form (rho, theta) suffers from:
-
Angle wrapping – the
0 ↔ 2πseam makes Gaussian residuals invalid. -
Sign ambiguity –
(rho, theta)and(-rho, theta + π)describe the same geometric line, causingπ-jumps nearrho ≈ 0.
Instead we keep a nominal line (rho, n) where n is a unit normal and
filter a minimal 2D error state [δρ, δφ] in ℝ².
-
Log residual – sign-align the measurement normal, then compute
δφviaatan2(cross, dot). No raw angle subtraction. -
Exp update – apply
δρadditively and rotatenbyδφ, then reset.
Pipeline
- Subscribe to
LineSegment2DArray(pixel-space line detections). - Subscribe to
SonarInfofor pixel-to-metric conversion. - Convert pixel segments → metric (z = 0) in sonar frame.
- TF-transform endpoints to the
target_frame(typicallyodom). - Project to 2D (XY plane) and convert to
(rho, n)measurements. - Run the IPDA track manager (gating → update → confirm / delete → create).
- Publish confirmed tracks as
LineSegment3DArrayandMarkerArray.
Topics
| Direction | Topic | Type |
|---|---|---|
| Sub | /sonar/line_segments |
vortex_msgs/LineSegment2DArray |
| Sub | /sonar/sonar_info |
vortex_msgs/SonarInfo |
| Pub | /filtered_lines |
vortex_msgs/LineSegment3DArray |
| Pub | /filtered_lines_markers |
visualization_msgs/MarkerArray |
Launch
ros2 launch line_filtering line_filtering.launch.py
Library export and usage
The core tracking logic (LineTrackManager) is built and exported as a
shared library by this package so other packages can reuse the track
management functionality without pulling in the ROS node.
CMake / ament usage
In a consuming CMake-based package (ament_cmake) you can link against the library like this:
find_package(line_filtering REQUIRED)
add_executable(my_node src/my_node.cpp)
# Link to the exported library target (the package exports the target
# with the same name as the package: `line_filtering`)
target_link_libraries(my_node PRIVATE line_filtering)
The package installs its public headers under include/ so simply
including the header below in your code will work after linking:
#include <line_filtering/lib/line_track_manager.hpp>
int main() {
vortex::line_filtering::LineTrackManagerConfig cfg;
// configure cfg.nm (N/M confirmation/deletion) and
// cfg.default_config (gate, noise, PDAF parameters)
vortex::line_filtering::LineTrackManager manager(cfg);
std::vector<vortex::line_filtering::LineMeasurement> measurements;
double dt = 0.1; // seconds
manager.step(measurements, dt);
const auto& tracks = manager.get_tracks();
// iterate tracks for id, nominal line, hits/misses, confirmed, etc.
}
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake | |
| rclcpp | |
| rclcpp_components | |
| geometry_msgs | |
| visualization_msgs | |
| tf2 | |
| tf2_ros | |
| message_filters | |
| vortex_utils | |
| vortex_utils_ros | |
| vortex_filtering | |
| vortex_msgs |
System Dependencies
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged line_filtering at Robotics Stack Exchange
Package Summary
| Version | 0.0.0 |
| License | MIT |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Description | |
| Checkout URI | https://github.com/vortexntnu/vortex-auv.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-18 |
| Dev Status | UNKNOWN |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Maintainers
- jorgen
Authors
line_filtering
Error-state IPDA filter for 2D line tracking.
Overview
This package tracks 2D lines detected by a sonar (or other sensor) using an
error-state formulation inspired by the quaternion error-state EKF used in
pose_filtering.
Why error-state for lines?
A 2D line in Hesse normal form (rho, theta) suffers from:
-
Angle wrapping – the
0 ↔ 2πseam makes Gaussian residuals invalid. -
Sign ambiguity –
(rho, theta)and(-rho, theta + π)describe the same geometric line, causingπ-jumps nearrho ≈ 0.
Instead we keep a nominal line (rho, n) where n is a unit normal and
filter a minimal 2D error state [δρ, δφ] in ℝ².
-
Log residual – sign-align the measurement normal, then compute
δφviaatan2(cross, dot). No raw angle subtraction. -
Exp update – apply
δρadditively and rotatenbyδφ, then reset.
Pipeline
- Subscribe to
LineSegment2DArray(pixel-space line detections). - Subscribe to
SonarInfofor pixel-to-metric conversion. - Convert pixel segments → metric (z = 0) in sonar frame.
- TF-transform endpoints to the
target_frame(typicallyodom). - Project to 2D (XY plane) and convert to
(rho, n)measurements. - Run the IPDA track manager (gating → update → confirm / delete → create).
- Publish confirmed tracks as
LineSegment3DArrayandMarkerArray.
Topics
| Direction | Topic | Type |
|---|---|---|
| Sub | /sonar/line_segments |
vortex_msgs/LineSegment2DArray |
| Sub | /sonar/sonar_info |
vortex_msgs/SonarInfo |
| Pub | /filtered_lines |
vortex_msgs/LineSegment3DArray |
| Pub | /filtered_lines_markers |
visualization_msgs/MarkerArray |
Launch
ros2 launch line_filtering line_filtering.launch.py
Library export and usage
The core tracking logic (LineTrackManager) is built and exported as a
shared library by this package so other packages can reuse the track
management functionality without pulling in the ROS node.
CMake / ament usage
In a consuming CMake-based package (ament_cmake) you can link against the library like this:
find_package(line_filtering REQUIRED)
add_executable(my_node src/my_node.cpp)
# Link to the exported library target (the package exports the target
# with the same name as the package: `line_filtering`)
target_link_libraries(my_node PRIVATE line_filtering)
The package installs its public headers under include/ so simply
including the header below in your code will work after linking:
#include <line_filtering/lib/line_track_manager.hpp>
int main() {
vortex::line_filtering::LineTrackManagerConfig cfg;
// configure cfg.nm (N/M confirmation/deletion) and
// cfg.default_config (gate, noise, PDAF parameters)
vortex::line_filtering::LineTrackManager manager(cfg);
std::vector<vortex::line_filtering::LineMeasurement> measurements;
double dt = 0.1; // seconds
manager.step(measurements, dt);
const auto& tracks = manager.get_tracks();
// iterate tracks for id, nominal line, hits/misses, confirmed, etc.
}
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake | |
| rclcpp | |
| rclcpp_components | |
| geometry_msgs | |
| visualization_msgs | |
| tf2 | |
| tf2_ros | |
| message_filters | |
| vortex_utils | |
| vortex_utils_ros | |
| vortex_filtering | |
| vortex_msgs |
System Dependencies
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged line_filtering at Robotics Stack Exchange
Package Summary
| Version | 0.0.0 |
| License | MIT |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Description | |
| Checkout URI | https://github.com/vortexntnu/vortex-auv.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-18 |
| Dev Status | UNKNOWN |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Maintainers
- jorgen
Authors
line_filtering
Error-state IPDA filter for 2D line tracking.
Overview
This package tracks 2D lines detected by a sonar (or other sensor) using an
error-state formulation inspired by the quaternion error-state EKF used in
pose_filtering.
Why error-state for lines?
A 2D line in Hesse normal form (rho, theta) suffers from:
-
Angle wrapping – the
0 ↔ 2πseam makes Gaussian residuals invalid. -
Sign ambiguity –
(rho, theta)and(-rho, theta + π)describe the same geometric line, causingπ-jumps nearrho ≈ 0.
Instead we keep a nominal line (rho, n) where n is a unit normal and
filter a minimal 2D error state [δρ, δφ] in ℝ².
-
Log residual – sign-align the measurement normal, then compute
δφviaatan2(cross, dot). No raw angle subtraction. -
Exp update – apply
δρadditively and rotatenbyδφ, then reset.
Pipeline
- Subscribe to
LineSegment2DArray(pixel-space line detections). - Subscribe to
SonarInfofor pixel-to-metric conversion. - Convert pixel segments → metric (z = 0) in sonar frame.
- TF-transform endpoints to the
target_frame(typicallyodom). - Project to 2D (XY plane) and convert to
(rho, n)measurements. - Run the IPDA track manager (gating → update → confirm / delete → create).
- Publish confirmed tracks as
LineSegment3DArrayandMarkerArray.
Topics
| Direction | Topic | Type |
|---|---|---|
| Sub | /sonar/line_segments |
vortex_msgs/LineSegment2DArray |
| Sub | /sonar/sonar_info |
vortex_msgs/SonarInfo |
| Pub | /filtered_lines |
vortex_msgs/LineSegment3DArray |
| Pub | /filtered_lines_markers |
visualization_msgs/MarkerArray |
Launch
ros2 launch line_filtering line_filtering.launch.py
Library export and usage
The core tracking logic (LineTrackManager) is built and exported as a
shared library by this package so other packages can reuse the track
management functionality without pulling in the ROS node.
CMake / ament usage
In a consuming CMake-based package (ament_cmake) you can link against the library like this:
find_package(line_filtering REQUIRED)
add_executable(my_node src/my_node.cpp)
# Link to the exported library target (the package exports the target
# with the same name as the package: `line_filtering`)
target_link_libraries(my_node PRIVATE line_filtering)
The package installs its public headers under include/ so simply
including the header below in your code will work after linking:
#include <line_filtering/lib/line_track_manager.hpp>
int main() {
vortex::line_filtering::LineTrackManagerConfig cfg;
// configure cfg.nm (N/M confirmation/deletion) and
// cfg.default_config (gate, noise, PDAF parameters)
vortex::line_filtering::LineTrackManager manager(cfg);
std::vector<vortex::line_filtering::LineMeasurement> measurements;
double dt = 0.1; // seconds
manager.step(measurements, dt);
const auto& tracks = manager.get_tracks();
// iterate tracks for id, nominal line, hits/misses, confirmed, etc.
}
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake | |
| rclcpp | |
| rclcpp_components | |
| geometry_msgs | |
| visualization_msgs | |
| tf2 | |
| tf2_ros | |
| message_filters | |
| vortex_utils | |
| vortex_utils_ros | |
| vortex_filtering | |
| vortex_msgs |
System Dependencies
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged line_filtering at Robotics Stack Exchange
Package Summary
| Version | 0.0.0 |
| License | MIT |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Description | |
| Checkout URI | https://github.com/vortexntnu/vortex-auv.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-18 |
| Dev Status | UNKNOWN |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Maintainers
- jorgen
Authors
line_filtering
Error-state IPDA filter for 2D line tracking.
Overview
This package tracks 2D lines detected by a sonar (or other sensor) using an
error-state formulation inspired by the quaternion error-state EKF used in
pose_filtering.
Why error-state for lines?
A 2D line in Hesse normal form (rho, theta) suffers from:
-
Angle wrapping – the
0 ↔ 2πseam makes Gaussian residuals invalid. -
Sign ambiguity –
(rho, theta)and(-rho, theta + π)describe the same geometric line, causingπ-jumps nearrho ≈ 0.
Instead we keep a nominal line (rho, n) where n is a unit normal and
filter a minimal 2D error state [δρ, δφ] in ℝ².
-
Log residual – sign-align the measurement normal, then compute
δφviaatan2(cross, dot). No raw angle subtraction. -
Exp update – apply
δρadditively and rotatenbyδφ, then reset.
Pipeline
- Subscribe to
LineSegment2DArray(pixel-space line detections). - Subscribe to
SonarInfofor pixel-to-metric conversion. - Convert pixel segments → metric (z = 0) in sonar frame.
- TF-transform endpoints to the
target_frame(typicallyodom). - Project to 2D (XY plane) and convert to
(rho, n)measurements. - Run the IPDA track manager (gating → update → confirm / delete → create).
- Publish confirmed tracks as
LineSegment3DArrayandMarkerArray.
Topics
| Direction | Topic | Type |
|---|---|---|
| Sub | /sonar/line_segments |
vortex_msgs/LineSegment2DArray |
| Sub | /sonar/sonar_info |
vortex_msgs/SonarInfo |
| Pub | /filtered_lines |
vortex_msgs/LineSegment3DArray |
| Pub | /filtered_lines_markers |
visualization_msgs/MarkerArray |
Launch
ros2 launch line_filtering line_filtering.launch.py
Library export and usage
The core tracking logic (LineTrackManager) is built and exported as a
shared library by this package so other packages can reuse the track
management functionality without pulling in the ROS node.
CMake / ament usage
In a consuming CMake-based package (ament_cmake) you can link against the library like this:
find_package(line_filtering REQUIRED)
add_executable(my_node src/my_node.cpp)
# Link to the exported library target (the package exports the target
# with the same name as the package: `line_filtering`)
target_link_libraries(my_node PRIVATE line_filtering)
The package installs its public headers under include/ so simply
including the header below in your code will work after linking:
#include <line_filtering/lib/line_track_manager.hpp>
int main() {
vortex::line_filtering::LineTrackManagerConfig cfg;
// configure cfg.nm (N/M confirmation/deletion) and
// cfg.default_config (gate, noise, PDAF parameters)
vortex::line_filtering::LineTrackManager manager(cfg);
std::vector<vortex::line_filtering::LineMeasurement> measurements;
double dt = 0.1; // seconds
manager.step(measurements, dt);
const auto& tracks = manager.get_tracks();
// iterate tracks for id, nominal line, hits/misses, confirmed, etc.
}
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake | |
| rclcpp | |
| rclcpp_components | |
| geometry_msgs | |
| visualization_msgs | |
| tf2 | |
| tf2_ros | |
| message_filters | |
| vortex_utils | |
| vortex_utils_ros | |
| vortex_filtering | |
| vortex_msgs |
System Dependencies
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged line_filtering at Robotics Stack Exchange
Package Summary
| Version | 0.0.0 |
| License | MIT |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Description | |
| Checkout URI | https://github.com/vortexntnu/vortex-auv.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-18 |
| Dev Status | UNKNOWN |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Maintainers
- jorgen
Authors
line_filtering
Error-state IPDA filter for 2D line tracking.
Overview
This package tracks 2D lines detected by a sonar (or other sensor) using an
error-state formulation inspired by the quaternion error-state EKF used in
pose_filtering.
Why error-state for lines?
A 2D line in Hesse normal form (rho, theta) suffers from:
-
Angle wrapping – the
0 ↔ 2πseam makes Gaussian residuals invalid. -
Sign ambiguity –
(rho, theta)and(-rho, theta + π)describe the same geometric line, causingπ-jumps nearrho ≈ 0.
Instead we keep a nominal line (rho, n) where n is a unit normal and
filter a minimal 2D error state [δρ, δφ] in ℝ².
-
Log residual – sign-align the measurement normal, then compute
δφviaatan2(cross, dot). No raw angle subtraction. -
Exp update – apply
δρadditively and rotatenbyδφ, then reset.
Pipeline
- Subscribe to
LineSegment2DArray(pixel-space line detections). - Subscribe to
SonarInfofor pixel-to-metric conversion. - Convert pixel segments → metric (z = 0) in sonar frame.
- TF-transform endpoints to the
target_frame(typicallyodom). - Project to 2D (XY plane) and convert to
(rho, n)measurements. - Run the IPDA track manager (gating → update → confirm / delete → create).
- Publish confirmed tracks as
LineSegment3DArrayandMarkerArray.
Topics
| Direction | Topic | Type |
|---|---|---|
| Sub | /sonar/line_segments |
vortex_msgs/LineSegment2DArray |
| Sub | /sonar/sonar_info |
vortex_msgs/SonarInfo |
| Pub | /filtered_lines |
vortex_msgs/LineSegment3DArray |
| Pub | /filtered_lines_markers |
visualization_msgs/MarkerArray |
Launch
ros2 launch line_filtering line_filtering.launch.py
Library export and usage
The core tracking logic (LineTrackManager) is built and exported as a
shared library by this package so other packages can reuse the track
management functionality without pulling in the ROS node.
CMake / ament usage
In a consuming CMake-based package (ament_cmake) you can link against the library like this:
find_package(line_filtering REQUIRED)
add_executable(my_node src/my_node.cpp)
# Link to the exported library target (the package exports the target
# with the same name as the package: `line_filtering`)
target_link_libraries(my_node PRIVATE line_filtering)
The package installs its public headers under include/ so simply
including the header below in your code will work after linking:
#include <line_filtering/lib/line_track_manager.hpp>
int main() {
vortex::line_filtering::LineTrackManagerConfig cfg;
// configure cfg.nm (N/M confirmation/deletion) and
// cfg.default_config (gate, noise, PDAF parameters)
vortex::line_filtering::LineTrackManager manager(cfg);
std::vector<vortex::line_filtering::LineMeasurement> measurements;
double dt = 0.1; // seconds
manager.step(measurements, dt);
const auto& tracks = manager.get_tracks();
// iterate tracks for id, nominal line, hits/misses, confirmed, etc.
}
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake | |
| rclcpp | |
| rclcpp_components | |
| geometry_msgs | |
| visualization_msgs | |
| tf2 | |
| tf2_ros | |
| message_filters | |
| vortex_utils | |
| vortex_utils_ros | |
| vortex_filtering | |
| vortex_msgs |