Class template for data transformers which use the tf2_ros::Buffer.transform() method to perform transforms on ros messages. The class sets up publishers and subscribers using the provided node for the specified message type. The specified message type must have a tf2_ros::Buffer.doTransform specialization for its type in order for it to compile. More...

#include <frame_transformer.hpp>

Inheritance diagram for frame_transformer::Transformer< T >:

Collaboration diagram for frame_transformer::Transformer< T >:

Public Member Functions
	Transformer (Config config, std::shared_ptr< tf2_ros::Buffer > buffer, std::shared_ptr< carma_ros2_utils::CarmaLifecycleNode > node)
	Constructor which sets up the required publishers and subscribers. More...

bool	transform (const T &in, T &out, const std::string &target_frame, const std_ms timeout)
	Helper method which takes in an input message and transforms it to the provided frame. Returns false if the provided timeout is exceeded for getting the transform or the transform could not be computed. More...

void	input_callback (std::unique_ptr< T > in_msg)
	Callback for input data. Transforms the data then republishes it. More...

	FRIEND_TEST (frame_transformer_test, transform_test)

void	input_callback (std::unique_ptr< sensor_msgs::msg::PointCloud2 > in_msg)

Protected Attributes
carma_ros2_utils::SubPtr< T >	input_sub_

carma_ros2_utils::PubPtr< T >	output_pub_

Protected Attributes inherited from frame_transformer::TransformerBase
Config	config_
	Transformation configuration. More...

std::shared_ptr< tf2_ros::Buffer >	buffer_
	TF2 Buffer for storing transform history and looking up transforms. More...

std::shared_ptr< carma_ros2_utils::CarmaLifecycleNode >	node_
	Containing node which provides access to the ros network. More...

Additional Inherited Members
Protected Member Functions inherited from frame_transformer::TransformerBase
	TransformerBase (const Config &config, std::shared_ptr< tf2_ros::Buffer > buffer, std::shared_ptr< carma_ros2_utils::CarmaLifecycleNode > node)

Detailed Description

template<class T>
class frame_transformer::Transformer< T >

Class template for data transformers which use the tf2_ros::Buffer.transform() method to perform transforms on ros messages. The class sets up publishers and subscribers using the provided node for the specified message type. The specified message type must have a tf2_ros::Buffer.doTransform specialization for its type in order for it to compile.

Template Parameters

The	message type to transform. Must be supported by tf2_ros::Buffer.doTransform

Definition at line 43 of file frame_transformer.hpp.

Constructor & Destructor Documentation

◆ Transformer()

template<class T >

frame_transformer::Transformer< T >::Transformer	(	Config	config,
		std::shared_ptr< tf2_ros::Buffer >	buffer,
		std::shared_ptr< carma_ros2_utils::CarmaLifecycleNode >	node
	)

inline

Constructor which sets up the required publishers and subscribers.

See comments in TransformerBase for parameter descriptions

Definition at line 61 of file frame_transformer.hpp.

    : TransformerBase(config, buffer, node) {
 
      input_sub_ = node_->create_subscription<T>("input", config_.queue_size,
                                                  std::bind(&Transformer::input_callback, this, std_ph::_1));
 
      // Setup publishers
      output_pub_ = node_->create_publisher<T>("output", config_.queue_size);
    }

References frame_transformer::TransformerBase::config_, frame_transformer::Transformer< T >::input_callback(), frame_transformer::Transformer< T >::input_sub_, frame_transformer::TransformerBase::node_, frame_transformer::Transformer< T >::output_pub_, and frame_transformer::Config::queue_size.

Here is the call graph for this function:

Member Function Documentation

◆ FRIEND_TEST()

template<class T >

frame_transformer::Transformer< T >::FRIEND_TEST	(	frame_transformer_test	,
		transform_test
	)

◆ input_callback() [1/2]

void frame_transformer::Transformer< sensor_msgs::msg::PointCloud2 >::input_callback ( std::unique_ptr< sensor_msgs::msg::PointCloud2 > in_msg )

inline

Definition at line 130 of file frame_transformer.hpp.

                                                                                                                    {
 
    sensor_msgs::msg::PointCloud2 out_msg;
    out_msg.data.reserve(in_msg->data.size()); // Preallocate points vector
    
 
    if (!transform(*in_msg, out_msg, config_.target_frame, std_ms(config_.timeout)))
    {
      return;
    }
 
    // The following if block is added purely for ensuring consistency with Autoware.Auto (prevent "Malformed PointCloud2" error from ray_ground_filter)
    // It's a bit out of scope for this node to have this functionality here, 
    // but the alternative is to modify a 3rd party driver, an Autoware.Auto component, or make a new node just for this.
    // Therefore, the logic will live here until such a time as a better location presents itself.
    if (out_msg.height == 1) // 1d point cloud
    {
      out_msg.row_step = out_msg.data.size();
    }
 
    output_pub_->publish(out_msg);
  }

◆ input_callback() [2/2]

template<class T >

void frame_transformer::Transformer< T >::input_callback ( std::unique_ptr< T > in_msg )

inline

Callback for input data. Transforms the data then republishes it.

NOTE: This method can be specialized for unique preallocation approaches for large messages such as point clouds or images

Parameters

in_msg The input message to transform

Definition at line 111 of file frame_transformer.hpp.

    {
      T out_msg;
 
      if (!transform(*in_msg, out_msg, config_.target_frame, std_ms(config_.timeout)))
      {
        return;
      }
 
      output_pub_->publish(out_msg);
    }

References frame_transformer::TransformerBase::config_, frame_transformer::Transformer< T >::output_pub_, frame_transformer::Config::target_frame, frame_transformer::Config::timeout, and frame_transformer::Transformer< T >::transform().

Referenced by frame_transformer::Transformer< T >::Transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ transform()

template<class T >

bool frame_transformer::Transformer< T >::transform	(	const T &	in,
		T &	out,
		const std::string &	target_frame,
		const std_ms	timeout
	)

inline

Helper method which takes in an input message and transforms it to the provided frame. Returns false if the provided timeout is exceeded for getting the transform or the transform could not be computed.

Parameters

	in	The input message to transform
[out]	out	The preallocated location for the output message
	target_frame	The frame the out message data will be in
	timeout	A timeout in ms which if exceeded will result in a false return and invalid out value. This call may block for this period. If set to zero, then lookup will be attempted only once.

Returns: True if transform succeeded, false if timeout exceeded or transform could not be performed.

Definition at line 84 of file frame_transformer.hpp.

    {
 
      try
      {
        buffer_->transform(in, out, target_frame, timeout);
      }
      catch (tf2::TransformException &ex)
      {
        std::string error = ex.what();
        error = "Failed to get transform with exception: " + error;
        auto& clk = *node_->get_clock(); // Separate reference required for proper throttle macro call
        RCLCPP_WARN_THROTTLE(node_->get_logger(), clk, 1000, error.c_str());
 
        return false;
      }
 
      return true;
    }