Documentation Status

laser_pipeline: laser_assembler | laser_filters | laser_geometry

Package Summary

Released Documented

Assorted filters designed to operate on 2D planar laser scanners, which use the sensor_msgs/LaserScan type.

laser_pipeline: laser_assembler | laser_filters | laser_geometry

Package Summary

Released Continuous integration Documented

Assorted filters designed to operate on 2D planar laser scanners, which use the sensor_msgs/LaserScan type.

laser_pipeline: laser_assembler | laser_filters | laser_geometry

Package Summary

Released Continuous integration Documented

Assorted filters designed to operate on 2D planar laser scanners, which use the sensor_msgs/LaserScan type.

Overview

The primary content of the laser_filters package is a number of general purpose filters for processing sensor_msgs/LaserScan messages. These filters are exported as plugins designed to work with with the filters package. At the moment all of these filters run directly on sensor_msgs/LaserScan, but filters may be added in the future which process sensor_msgs/PointCloud instead. Please review the filters documentation for an overview of how filters and filter chains are intended to work.

This package provides two nodes that can run multiple filters internally. Using these nodes to run your filters is considered best practice, since it allows multiple nodes to consume the output while only performing the filtering computation once. The nodes are minimal wrappers around filter chains of the given type. The scan_to_scan_filter_chain applies a series of filters to a sensor_msgs/LaserScan. The scan_to_cloud_filter_chain first applies a series of filters to a sensor_msgs/LaserScan, transforms it into a sensor_msgs/PointCloud, and then applies a series of filters to the sensor_msgs/PointCloud.

Using Laser Filters

Each laser filter is a separate plugin exported by the laser_filters package. This allows them to be specified in a configuration file which can be loaded into an arbitrary filter_chain templated on a sensor_msgs/LaserScan. You can instantiate a laser filter into a filter_chain in C++ (example), or you can use the scan_to_scan_filter_chain and scan_to_cloud_filter_chain nodes which contain appropriate filter chains internally (example).

Filter chains are configured from the parameter server. They expect a parameter which is a list made up of repeating blocks of filter configurations. These should almost always be specified in a .yaml file to be pushed to the parameter server. Each filter specified in the chain will be applied in order.

The individual filters configurations contain a name which is used for debugging purposes, a type which is used to locate the plugin, and a params which is a dictionary of additional variables. Consult the documentation for the particular filter plugin to see what variables may be set in the params field.

For example, in a package, mypkg, to launch a scan_to_scan_filter_chain with two filters: LaserFilterClass1 and LaserFilterClass2, you could use the file:

my_laser_config.yaml:

  • scan_filter_chain:
    - name: unique_name1
      type: LaserFilterClass1
      params:
        param1: a
        param2: b
    - name: unique_name2
      type: LaserFilterClass2
      params:
        param1: a
        param2: b

You could then push this configuration to the parameter server using rosparam by running:

  • $ rosparam load my_laser_config.yaml scan_to_scan_filter_chain

And then launching the scan_to_scan_filter_chain:

  • $ rosrun laser_filters scan_to_scan_filter_chain

Laser Filter Nodes

scan_to_scan_filter_chain (new in laser_pipeline-0.5)

The scan_to_scan_filter_chain is a very minimal node which wraps an instance of a filters::FilterChain<sensor_msgs::LaserScan>. This node can be used to run any filter in this package on an incoming laser scan. If the ~tf_message_filter_target_frame parameter is set, it will wait for the transform between the laser and the target_frame to be available before running the filter chain.

scan_to_scan_filter_chain.png

ROS Parameters

~scan_filter_chain (list)

  • [Required] The list of laser filters to load.

~tf_message_filter_target_frame (string)

  • A target_frame for which a transform must exist at the current time before the filter_chain will be executed. This is the target_frame internally passed to the tf::MessageFilter. If this parameter is not set, the chain will simply be executed immediately upon the arrival of each new scan.

Subscribed Topics

scan (sensor_msgs/LaserScan)

  • The incoming laser scan to filter

Published Topics

scan_filtered (sensor_msgs/LaserScan)

  • The outgoing filtered laser scan

Example Launch File

my_laser_filter.launch:

  • <launch>
      <node pkg="laser_filters" type="scan_to_scan_filter_chain"
          name="laser_filter">
        <rosparam command="load" file="$(find mypkg)/my_laser_config.yaml" />
        <remap from="scan" to="base_scan" />
      </node>
    </launch>

my_laser_config.yaml:

  • scan_filter_chain:
    - name: shadows
      type: ScanShadowsFilter
      params:
        min_angle: 10
        max_angle: 170
        neighbors: 20
        window: 1
    - name: dark_shadows
      type: LaserScanIntensityFilter
      params: 
        lower_threshold: 100
        upper_threshold: 10000
        disp_histogram: 0

scan_to_cloud_filter_chain

The scan_to_cloud_filter_chain is a very minimal node which wraps an instances of filters::FilterChain<sensor_msgs::LaserScan> and filters::FilterChain<sensor_msgs::PointCloud>. This node can be used to run any filter in this package on an incoming laser scan. After performing the laser filtering, it will use the LaserProjection from laser_geometry to transform each scan into a point cloud. It will then run any cloud-based filtering, and finally publish the resultant cloud.

scan_to_cloud_filter_chain.png

ROS Parameters

~scan_filter_chain (list)

  • [Required] The list of laser filters to load.

~cloud_filter_chain (list)

  • [Required] The list of cloud filters to load.

~target_frame (string)

  • [Required] The frame to transform the point_cloud into.

~high_fidelity (bool, default: false)

  • Whether to perform a high fidelity transform. This approach assumes that the laser scanner is moving while capturing laser scans. High fidelity transform works only correctly, if the target frame is set to a fixed frame.

Subscribed Topics

scan (sensor_msgs/LaserScan)

  • The incoming laser scan to filter.

Published Topics

cloud_filtered (sensor_msgs/PointCloud)

  • The outgoing filtered point cloud.

Example Launch File

my_laser_cloud_filter.launch:

  • <launch>
      <node pkg="laser_filters" type="scan_to_cloud_filter_chain"
          name="tilt_shadow_filter">
        <rosparam command="load" file="$(find mypkg)/my_laser_config.yaml" />
        <rosparam command="load" file="$(find mypkg)/my_cloud_config.yaml" />
        <param name="high_fidelity" value="true" />
        <param name="target_frame" type="string" value="base_link" />
        <remap from="scan" to="tilt_scan" />
        <remap from="cloud_filtered" to="tilt_scan_cloud_filtered" />
      </node>
    </launch>

my_laser_config.yaml:

  • scan_filter_chain:
    - name: shadows
      type: ScanShadowsFilter
      params:
        min_angle: 10
        max_angle: 170
        neighbors: 20
        window: 1
    - name: dark_shadows
      type: LaserScanIntensityFilter
      params: 
        lower_threshold: 100
        upper_threshold: 10000
        disp_histogram: 0

my_cloud_config.yaml:

  • cloud_filter_chain:
    - type: PR2PointCloudFootprintFilter
      name: footprint_filter
      params:
        inscribed_radius: 0.325

Laser Filter Plugins

LaserArrayFilter

This filter internally makes use of the the filters implementation of float-array filters. It extracts the range and intensity values and treats each as an independent float array passed through an internal filter chain.

Parameters

range_filter_chain (FilterChain)

  • A nested filter chain description, describing an appropriate chain of MultiChannelMedianFilterFloat type filters.

intensity_filter_chain (FilterChain)

  • A nested filter chain description, describing an appropriate chain of MultiChannelMedianFilterFloat type filters.

Make sure to use both parameters ( range_filter_chain and intensity_filter_chain )

Example Configuration

  • scan_filter_chain:
    - type: laser_filters/LaserArrayFilter
      name: laser_median_filter
      params: 
        range_filter_chain:
          - name: median_5
            type: filters/MultiChannelMedianFilterFloat 
            params:
              number_of_observations: 5
              unused: 10
        intensity_filter_chain:
          - name: median_5
            type: filters/MultiChannelMedianFilterFloat 
            params:
              number_of_observations: 5
              unused: 10

ScanShadowsFilter

This filter removes laser readings that are most likely caused by the veiling effect when the edge of an object is being scanned. For any two points $$p_1$$ and $$p_2$$, we do this by computing the perpendicular angle. That is, assuming the origin of the laser is $$O$$, the angle formed $$\angle OP_1P_2$$. If the perpendicular angle is less than a particular min or greater than a particular max, we remove all neighbors further away than that point.

Parameters

min_angle (double)

  • Minimum perpendicular angle (degrees)

max_angle (double)

  • Maximum perpendicular angle (degrees)

window (int)

  • Number of consecutive measurements to consider angles inside of

neighbors (int)

  • Number of further-away neighbors to remove

Example configuration

  • scan_filter_chain:
    - name: shadows
      type: ScanShadowsFilter
      params:
        min_angle: 10
        max_angle: 170
        neighbors: 20
        window: 1

InterpolationFilter

For any measurement in the scan which is invalid, the interpolation comes up with a measurement which is an interpolation between the surrounding good values.

Parameters

NONE

Example configuration

  • scan_filter_chain:
    - name: interpolation
      type: InterpolationFilter

LaserScanIntensityFilter

This filter removes all measurements from the sensor_msgs/LaserScan which have an intensity greater than upper_threshold or less than lower_threshold. These points are "removed" by setting the corresponding range value to range_max + 1, which is assumed to be an error case.

Parameters

lower_threshold (double)

  • Intensity value below which readings will be dropped.

upper_threshold (double)

  • Intensity value above which readings will be dropped.

disp_histogram (int)

  • Whether or not to write an intensity histogram to standard out. (0 or 1)

Example configuration

  • scan_filter_chain:
    - name: intensity
      type: LaserScanIntensityFilter
      params:
        lower_threshold: 8000
        upper_threshold: 100000
        disp_histogram: 0

LaserScanRangeFilter

This filter removes all measurements from the sensor_msgs/LaserScan which are greater than upper_threshold or less than lower_threshold. These points are "removed" by setting the corresponding range value to NaN, which is assumed to be an error case or lower_replacement_value/upper_replacement_value. If use_message_range_limits is true, the range within the laserscan message is used.

Parameters

lower_threshold (double)

  • Lower range threshold

upper_threshold (double)

  • Upper range threshold

use_message_range_limits (bool)

  • Use the range_min and range_max values from the laserscan message as threshold. Defaults to false

lower_replacement_value (double)

  • Use this value for all measurements <lower_threshold. Default: NaN

upper_replacement_value (double)

  • Use this value for all measurements >upper_threshold. Default: NaN

Example configuration

  • scan_filter_chain:
    - name: range
      type: LaserScanRangeFilter
      params:
        use_message_range_limits: false
        lower_threshold: 0.3
        upper_threshold: .inf
        lower_replacement_value: -.inf
        upper_replacement_value: .inf

LaserScanAngularBoundsFilter

This filter removes points in a sensor_msgs/LaserScan outside of certain angular bounds by changing the minimum and maximum angle.

Parameters

lower_angle (double)

  • Minimum angle (radians)

upper_angle (double)

  • Maximum angle (radians)

Example configuration

  • scan_filter_chain:
    - name: angle
      type: LaserScanAngularBoundsFilter
      params:
        lower_angle: -1.57
        upper_angle: 1.57

LaserScanAngularBoundsFilterInPlace

This filter removes points in a sensor_msgs/LaserScan inside of certain angular bounds. These points are "removed" by setting the corresponding range value to range_max + 1, which is assumed to be an error case.

Parameters

lower_angle (double)

  • Minimum angle (radians)

upper_angle (double)

  • Maximum angle (radians)

Example configuration

  • scan_filter_chain:
    - name: angle
      type: LaserScanAngularBoundsFilterInPlace
      params:
        lower_angle: 0.685398163
        upper_angle: 0.885398163

LaserScanBoxFilter

This filter removes points in a sensor_msgs/LaserScan inside of a cartesian box. These points are "removed" by setting the corresponding range value to NaN which is assumed to be an error case.

Parameters

box_frame (string)

  • tf frame_id

min_x (double)

  • Minimum cartesian x

max_x (double)

  • Maximum cartesian x

min_y (double)

  • Minimum cartesian y

max_y (double)

  • Maximum cartesian y

min_z (double)

  • Minimum cartesian z

max_z (double)

  • Maximum cartesian z

Example configuration

  • scan_filter_chain:
    - name: box
      type: LaserScanBoxFilter
      params:
        box_frame: scan_link
        min_x: -1.0
        max_x: 1.0
        min_y: -1.0
        max_y: 1.0
        min_z: -1.0
        max_z: 1.0

Wiki: laser_filters (last edited 2017-10-04 15:31:20 by JannikAbbenseth)