image_tools::ROSCvMatContainer Class Reference

A potentially owning, potentially non-owning, container of a cv::Mat and ROS header. More...

#include <cv_mat_sensor_msgs_image_type_adapter.hpp>

Collaboration diagram for image_tools::ROSCvMatContainer:

Public Types
using	SensorMsgsImageStorageType = std::variant< std::nullptr_t, std::unique_ptr< sensor_msgs::msg::Image >, std::shared_ptr< sensor_msgs::msg::Image > >

Public Member Functions
IMAGE_TOOLS_PUBLIC	ROSCvMatContainer ()=default
IMAGE_TOOLS_PUBLIC	ROSCvMatContainer (const ROSCvMatContainer &other)
IMAGE_TOOLS_PUBLIC ROSCvMatContainer &	operator= (const ROSCvMatContainer &other)
IMAGE_TOOLS_PUBLIC	ROSCvMatContainer (std::unique_ptr< sensor_msgs::msg::Image > unique_sensor_msgs_image)
	Store an owning pointer to a sensor_msg::msg::Image, and create a cv::Mat that references it. More...
IMAGE_TOOLS_PUBLIC	ROSCvMatContainer (std::shared_ptr< sensor_msgs::msg::Image > shared_sensor_msgs_image)
	Store an owning pointer to a sensor_msg::msg::Image, and create a cv::Mat that references it. More...
IMAGE_TOOLS_PUBLIC	ROSCvMatContainer (const cv::Mat &mat_frame, const std_msgs::msg::Header &header, bool is_bigendian=is_bigendian_system)
	Shallow copy the given cv::Mat into this class, but do not own the data directly. More...
IMAGE_TOOLS_PUBLIC	ROSCvMatContainer (cv::Mat &&mat_frame, const std_msgs::msg::Header &header, bool is_bigendian=is_bigendian_system)
	Move the given cv::Mat into this class. More...
IMAGE_TOOLS_PUBLIC	ROSCvMatContainer (const sensor_msgs::msg::Image &sensor_msgs_image)
	Copy the sensor_msgs::msg::Image into this contain and create a cv::Mat that references it. More...
IMAGE_TOOLS_PUBLIC bool	is_owning () const
	Return true if this class owns the data the cv_mat references. More...
IMAGE_TOOLS_PUBLIC const cv::Mat &	cv_mat () const
	Const access the cv::Mat in this class. More...
IMAGE_TOOLS_PUBLIC cv::Mat	cv_mat ()
	Get a shallow copy of the cv::Mat that is in this class. More...
IMAGE_TOOLS_PUBLIC const std_msgs::msg::Header &	header () const
	Const access the ROS Header. More...
IMAGE_TOOLS_PUBLIC std_msgs::msg::Header &	header ()
	Access the ROS Header. More...
IMAGE_TOOLS_PUBLIC std::shared_ptr< const sensor_msgs::msg::Image >	get_sensor_msgs_msg_image_pointer () const
	Get shared const pointer to the sensor_msgs::msg::Image if available, otherwise nullptr. More...
IMAGE_TOOLS_PUBLIC std::unique_ptr< sensor_msgs::msg::Image >	get_sensor_msgs_msg_image_pointer_copy () const
	Get copy as a unique pointer to the sensor_msgs::msg::Image. More...
IMAGE_TOOLS_PUBLIC sensor_msgs::msg::Image	get_sensor_msgs_msg_image_copy () const
	Get a copy of the image as a sensor_msgs::msg::Image. More...
IMAGE_TOOLS_PUBLIC void	get_sensor_msgs_msg_image_copy (sensor_msgs::msg::Image &sensor_msgs_image) const
	Get a copy of the image as a sensor_msgs::msg::Image. More...
IMAGE_TOOLS_PUBLIC bool	is_bigendian () const
	Return true if the data is stored in big endian, otherwise return false. More...

Private Attributes
std_msgs::msg::Header	header_
cv::Mat	frame_
SensorMsgsImageStorageType	storage_
bool	is_bigendian_

Static Private Attributes
static constexpr bool	is_bigendian_system = detail::endian::native == detail::endian::big

Detailed Description

A potentially owning, potentially non-owning, container of a cv::Mat and ROS header.

The two main use cases for this are publishing user controlled data, and receiving data from the middleware that may have been a ROS message originally or may have been an cv::Mat originally.

In the first case, publishing user owned data, the user will want to provide their own cv::Mat. The cv::Mat may own the data or it may not, so in the latter case, it is up to the user to ensure the data the cv::Mat points to remains valid as long as the middleware needs it.

In the second case, receiving data from the middleware, the middleware will either give a new ROSCvMatContainer which owns a sensor_msgs::msg::Image or it will give a ROSCvMatContainer that was previously published by the user (in the case of intra-process communication). If the container owns the sensor_msgs::msg::Image, then the cv::Mat will just reference data field of this message, so the container needs to be kept. If the container was published by the user it may or may not own the data and the cv::Mat it contains may or may not own the data.

For these reasons, it is advisable to use cv::Mat::clone() if you intend to copy the cv::Mat and let this container go.

For more details about the ownership behavior of cv::Mat see documentation for these methods of cv::Mat:

• template<typename _Tp > cv::Mat::Mat(const std::vector<_Tp> &, bool)
• Mat & cv::Mat::operator=(const Mat &)
• void cv::Mat::addref()
• void cv::Mat::release()

Definition at line 94 of file cv_mat_sensor_msgs_image_type_adapter.hpp.

Member Typedef Documentation

SensorMsgsImageStorageType

using image_tools::ROSCvMatContainer::SensorMsgsImageStorageType = std::variant< std::nullptr_t, std::unique_ptr<sensor_msgs::msg::Image>, std::shared_ptr<sensor_msgs::msg::Image> >

Definition at line 99 of file cv_mat_sensor_msgs_image_type_adapter.hpp.

Constructor & Destructor Documentation

ROSCvMatContainer() [1/7]

IMAGE_TOOLS_PUBLIC image_tools::ROSCvMatContainer::ROSCvMatContainer ( )

default

ROSCvMatContainer() [2/7]

IMAGE_TOOLS_PUBLIC image_tools::ROSCvMatContainer::ROSCvMatContainer ( const ROSCvMatContainer &  other )

inlineexplicit

Definition at line 109 of file cv_mat_sensor_msgs_image_type_adapter.hpp.

  : header_(other.header_), frame_(other.frame_.clone()), is_bigendian_(other.is_bigendian_)
  {
    if (std::holds_alternative<std::shared_ptr<sensor_msgs::msg::Image>>(other.storage_)) {
      storage_ = std::get<std::shared_ptr<sensor_msgs::msg::Image>>(other.storage_);
    } else if (std::holds_alternative<std::unique_ptr<sensor_msgs::msg::Image>>(other.storage_)) {
      storage_ = std::make_unique<sensor_msgs::msg::Image>(
        *std::get<std::unique_ptr<sensor_msgs::msg::Image>>(other.storage_));
    }
  }

References storage_.

ROSCvMatContainer() [3/7]

image_tools::ROSCvMatContainer::ROSCvMatContainer ( std::unique_ptr< sensor_msgs::msg::Image >  unique_sensor_msgs_image )

explicit

Store an owning pointer to a sensor_msg::msg::Image, and create a cv::Mat that references it.

Definition at line 73 of file cv_mat_sensor_msgs_image_type_adapter.cpp.

: header_(NotNull(
      unique_sensor_msgs_image.get(),
      "unique_sensor_msgs_image cannot be nullptr"
).pointer->header),
  frame_(
    unique_sensor_msgs_image->height,
    unique_sensor_msgs_image->width,
    encoding2mat_type(unique_sensor_msgs_image->encoding),
    unique_sensor_msgs_image->data.data(),
    unique_sensor_msgs_image->step),
  storage_(std::move(unique_sensor_msgs_image))
{}

ROSCvMatContainer() [4/7]

image_tools::ROSCvMatContainer::ROSCvMatContainer ( std::shared_ptr< sensor_msgs::msg::Image >  shared_sensor_msgs_image )

explicit

Store an owning pointer to a sensor_msg::msg::Image, and create a cv::Mat that references it.

Definition at line 88 of file cv_mat_sensor_msgs_image_type_adapter.cpp.

: header_(shared_sensor_msgs_image->header),
  frame_(
    shared_sensor_msgs_image->height,
    shared_sensor_msgs_image->width,
    encoding2mat_type(shared_sensor_msgs_image->encoding),
    shared_sensor_msgs_image->data.data(),
    shared_sensor_msgs_image->step),
  storage_(shared_sensor_msgs_image)
{}

ROSCvMatContainer() [5/7]

image_tools::ROSCvMatContainer::ROSCvMatContainer	(	const cv::Mat &	mat_frame,
		const std_msgs::msg::Header &	header,
		bool	is_bigendian = is_bigendian_system
	)

Shallow copy the given cv::Mat into this class, but do not own the data directly.

Definition at line 100 of file cv_mat_sensor_msgs_image_type_adapter.cpp.

: header_(header),
  frame_(mat_frame),
  storage_(nullptr),
  is_bigendian_(is_bigendian)
{}

ROSCvMatContainer() [6/7]

image_tools::ROSCvMatContainer::ROSCvMatContainer	(	cv::Mat &&	mat_frame,
		const std_msgs::msg::Header &	header,
		bool	is_bigendian = is_bigendian_system
	)

Move the given cv::Mat into this class.

Definition at line 110 of file cv_mat_sensor_msgs_image_type_adapter.cpp.

: header_(header),
  frame_(std::forward<cv::Mat>(mat_frame)),
  storage_(nullptr),
  is_bigendian_(is_bigendian)
{}

ROSCvMatContainer() [7/7]

image_tools::ROSCvMatContainer::ROSCvMatContainer ( const sensor_msgs::msg::Image &  sensor_msgs_image )

explicit

Copy the sensor_msgs::msg::Image into this contain and create a cv::Mat that references it.

Definition at line 120 of file cv_mat_sensor_msgs_image_type_adapter.cpp.

: ROSCvMatContainer(std::make_unique<sensor_msgs::msg::Image>(sensor_msgs_image))
{}

Member Function Documentation

cv_mat() [1/2]

cv::Mat image_tools::ROSCvMatContainer::cv_mat

(

)

Get a shallow copy of the cv::Mat that is in this class.

Note that if you want to let this container go out of scope you should make a deep copy with cv::Mat::clone() beforehand.

Definition at line 138 of file cv_mat_sensor_msgs_image_type_adapter.cpp.

{
  return frame_;
}

References frame_.

cv_mat() [2/2]

const cv::Mat & image_tools::ROSCvMatContainer::cv_mat

(

)

const

Const access the cv::Mat in this class.

Definition at line 132 of file cv_mat_sensor_msgs_image_type_adapter.cpp.

{
  return frame_;
}

References frame_.

Referenced by callback(), and rclcpp::TypeAdapter< image_tools::ROSCvMatContainer, sensor_msgs::msg::Image >::convert_to_ros_message().

Here is the caller graph for this function:

get_sensor_msgs_msg_image_copy() [1/2]

IMAGE_TOOLS_PUBLIC sensor_msgs::msg::Image image_tools::ROSCvMatContainer::get_sensor_msgs_msg_image_copy

(

)

const

Get a copy of the image as a sensor_msgs::msg::Image.

Referenced by get_sensor_msgs_msg_image_pointer_copy().

Here is the caller graph for this function:

get_sensor_msgs_msg_image_copy() [2/2]

void image_tools::ROSCvMatContainer::get_sensor_msgs_msg_image_copy

(

sensor_msgs::msg::Image &

sensor_msgs_image

)

const

Get a copy of the image as a sensor_msgs::msg::Image.

Definition at line 173 of file cv_mat_sensor_msgs_image_type_adapter.cpp.

{
  sensor_msgs_image.height = frame_.rows;
  sensor_msgs_image.width = frame_.cols;
  switch (frame_.type()) {
    case CV_8UC1:
      sensor_msgs_image.encoding = "mono8";
      break;
    case CV_8UC3:
      sensor_msgs_image.encoding = "bgr8";
      break;
    case CV_16SC1:
      sensor_msgs_image.encoding = "mono16";
      break;
    case CV_8UC4:
      sensor_msgs_image.encoding = "rgba8";
      break;
    default:
      throw std::runtime_error("unsupported encoding type");
  }
  sensor_msgs_image.step = static_cast<sensor_msgs::msg::Image::_step_type>(frame_.step);
  size_t size = frame_.step * frame_.rows;
  sensor_msgs_image.data.resize(size);
  memcpy(&sensor_msgs_image.data[0], frame_.data, size);
  sensor_msgs_image.header = header_;
}

References frame_, and header_.

get_sensor_msgs_msg_image_pointer()

std::shared_ptr< const sensor_msgs::msg::Image > image_tools::ROSCvMatContainer::get_sensor_msgs_msg_image_pointer

(

)

const

Get shared const pointer to the sensor_msgs::msg::Image if available, otherwise nullptr.

Definition at line 156 of file cv_mat_sensor_msgs_image_type_adapter.cpp.

{
  if (!std::holds_alternative<std::shared_ptr<sensor_msgs::msg::Image>>(storage_)) {
    return nullptr;
  }
  return std::get<std::shared_ptr<sensor_msgs::msg::Image>>(storage_);
}

References storage_.

get_sensor_msgs_msg_image_pointer_copy()

std::unique_ptr< sensor_msgs::msg::Image > image_tools::ROSCvMatContainer::get_sensor_msgs_msg_image_pointer_copy

(

)

const

Get copy as a unique pointer to the sensor_msgs::msg::Image.

Definition at line 165 of file cv_mat_sensor_msgs_image_type_adapter.cpp.

{
  auto unique_image = std::make_unique<sensor_msgs::msg::Image>();
  this->get_sensor_msgs_msg_image_copy(*unique_image);
  return unique_image;
}

References get_sensor_msgs_msg_image_copy().

Here is the call graph for this function:

header() [1/2]

std_msgs::msg::Header & image_tools::ROSCvMatContainer::header

(

)

Access the ROS Header.

Definition at line 150 of file cv_mat_sensor_msgs_image_type_adapter.cpp.

{
  return header_;
}

References header_.

header() [2/2]

const std_msgs::msg::Header & image_tools::ROSCvMatContainer::header

(

)

const

Const access the ROS Header.

Definition at line 144 of file cv_mat_sensor_msgs_image_type_adapter.cpp.

{
  return header_;
}

References header_.

Referenced by callback(), and rclcpp::TypeAdapter< image_tools::ROSCvMatContainer, sensor_msgs::msg::Image >::convert_to_ros_message().

Here is the caller graph for this function:

is_bigendian()

bool image_tools::ROSCvMatContainer::is_bigendian

(

)

const

Return true if the data is stored in big endian, otherwise return false.

Definition at line 202 of file cv_mat_sensor_msgs_image_type_adapter.cpp.

{
  return is_bigendian_;
}

References is_bigendian_.

is_owning()

bool image_tools::ROSCvMatContainer::is_owning

(

)

const

Return true if this class owns the data the cv_mat references.

Note that this does not check if the cv::Mat owns its own data, only if this class owns a sensor_msgs::msg::Image that the cv::Mat references.

Definition at line 126 of file cv_mat_sensor_msgs_image_type_adapter.cpp.

{
  return std::holds_alternative<std::nullptr_t>(storage_);
}

References storage_.

operator=()

IMAGE_TOOLS_PUBLIC ROSCvMatContainer & image_tools::ROSCvMatContainer::operator= ( const ROSCvMatContainer &  other )

inline

Definition at line 121 of file cv_mat_sensor_msgs_image_type_adapter.hpp.

  {
    if (this != &other) {
      header_ = other.header_;
      frame_ = other.frame_.clone();
      is_bigendian_ = other.is_bigendian_;
      if (std::holds_alternative<std::shared_ptr<sensor_msgs::msg::Image>>(other.storage_)) {
        storage_ = std::get<std::shared_ptr<sensor_msgs::msg::Image>>(other.storage_);
      } else if (std::holds_alternative<std::unique_ptr<sensor_msgs::msg::Image>>(other.storage_)) {
        storage_ = std::make_unique<sensor_msgs::msg::Image>(
          *std::get<std::unique_ptr<sensor_msgs::msg::Image>>(other.storage_));
      } else if (std::holds_alternative<std::nullptr_t>(other.storage_)) {
        storage_ = nullptr;
      }
    }
    return *this;
  }

References frame_, header_, is_bigendian_, and storage_.

Member Data Documentation

frame_

cv::Mat image_tools::ROSCvMatContainer::frame_

private

Definition at line 225 of file cv_mat_sensor_msgs_image_type_adapter.hpp.

Referenced by cv_mat(), get_sensor_msgs_msg_image_copy(), and operator=().

header_

std_msgs::msg::Header image_tools::ROSCvMatContainer::header_

private

Definition at line 224 of file cv_mat_sensor_msgs_image_type_adapter.hpp.

Referenced by get_sensor_msgs_msg_image_copy(), header(), and operator=().

is_bigendian_

bool image_tools::ROSCvMatContainer::is_bigendian_

private

Definition at line 227 of file cv_mat_sensor_msgs_image_type_adapter.hpp.

Referenced by is_bigendian(), and operator=().

is_bigendian_system

constexpr bool image_tools::ROSCvMatContainer::is_bigendian_system = detail::endian::native == detail::endian::big

staticconstexprprivate

Definition at line 96 of file cv_mat_sensor_msgs_image_type_adapter.hpp.

storage_

SensorMsgsImageStorageType image_tools::ROSCvMatContainer::storage_

private

Definition at line 226 of file cv_mat_sensor_msgs_image_type_adapter.hpp.

Referenced by get_sensor_msgs_msg_image_pointer(), is_owning(), operator=(), and ROSCvMatContainer().

---

The documentation for this class was generated from the following files:

• smacc2_sm_reference_library/sm_husky_barrel_search_1/servers/opencv_perception_node/cv_mat_sensor_msgs_image_type_adapter.hpp
• smacc2_sm_reference_library/sm_husky_barrel_search_1/servers/opencv_perception_node/cv_mat_sensor_msgs_image_type_adapter.cpp