autoware_predicted_path_postprocessor

Purpose

The autoware_predicted_path_postprocessor performs post-processing on predicted paths.

Inner-workings / Algorithms

The following processors are supported:

• RefineBySpeed
  • Refine the paths of objects based on their current speed.

Inputs / Outputs

Input

Output

Quick Start

Launch ROS 2 Node

To use this package, you can launch it with the following command:

ros2 launch autoware_predicted_path_postprocessor autoware_predicted_path_postprocessor.launch.xml

Leverage Processor in Your Codebase

You can leverage the processor in your codebase by including the appropriate headers and using the ComposableProcessor class:

#include <autoware/predicted_path_postprocessor/processor/composable.hpp>
#include <autoware/predicted_path_postprocessor/processor/interface.hpp>

class SomeNode final : public rclcpp::Node
{
public:
  explicit SomeNode(const rclcpp::NodeOptions& options)
    : Node("some_node", options)
  {
    // Initialize your node here
    auto processors = declare_parameter<std::vector<std::string>>("processors");
    context_ = std::make_unique<autoware::predicted_path_postprocessor::processor::Context>();
    processor_ = std::make_unique<autoware::predicted_path_postprocessor::processor::ComposableProcessor>(this, processors);
  }

private:
  void callback(const autoware_perception_msgs::msg::PredictedObjects::ConstSharedPtr & msg)
  {
    auto objects = std::make_shared<autoware_perception_msgs::msg::PredictedObjects>(*msg);

    // update the context with the predicted objects
    context_->update(objects);

    // process the predicted objects using the processor
    const auto result = processor_->process(objects, context_);
    if (result) {
      const auto processed_objects = result.ok();
      // do something with the processed objects
      // ...
    } else {
      RCLCPP_ERROR(get_logger(), "Failed to process predicted objects");
    }
  }

  std::unique_ptr<autoware::predicted_path_postprocessor::processor::Context> context_;
  std::unique_ptr<autoware::predicted_path_postprocessor::processor::ComposableProcessor> processor_;
};

How to Add New Processor

Processors in this package should follow a structured naming convention as below:

As an example, let’s see how to add a new processor by using a processor called FilterBySomething.

1. Create a new processor class that inherits from ProcessorInterface:

```cpp class FilterBySomething final : public ProcessorInterface { public: FilterBySomething(rclcpp::Node * node_ptr, const std::string & processor_name)

File truncated at 100 lines see the full file

Changelog for package autoware_predicted_path_postprocessor

0.48.0 (2025-11-18)

• Merge remote-tracking branch 'origin/main' into humble

• feat(predicted_path_postprocessor): add a new package to perform post-process for predicted paths (#11421)

  • feat: add baseline
  • feat: add support of publishing debug information
  • refactor: modify input to mutable reference and not to return object
  • feat: add new processor to refine objecs paths by their speed
  • chore: remove sample processor
  • chore: rename namespace
  • docs: add processor naming rules to README
  • fix: consider monotonically increasing
  • feat: update to publish processing time and cyclic time in ms
  • refactor: replace IntermediatePublisher into DebugPublisher
  • feat: include processing time in intermediate reports
  • feat: add lanelet data to the context
  • feat: add Report class and apply it to proccesor output
  • refactor: rename launch arguments
  • refactor: aggregate parameter files
  • refactor: store objects message as shared_ptr in context to enable reflecting their processed result
  • chore: update README and add JSON schema
  • chore: fix typo
  • chore: update maintainers and codeowners
  • test: resolve test failure
  • feat: update processor interface

  * feat: enable to specify interpolation method from config ---------Co-authored-by: Taekjin LEE <<taekjin.lee@tier4.jp>>

• Contributors: Kotaro Uetake, Ryohsuke Mitsudome