feat: python bindings for image_transport and publish

image_transport/include/image_transport/image_transport.hpp

@@ -112,6 +112,12 @@ class ImageTransport
   IMAGE_TRANSPORT_PUBLIC
   explicit ImageTransport(rclcpp::Node::SharedPtr node);
 
+  IMAGE_TRANSPORT_PUBLIC
+  ImageTransport(const ImageTransport& other);
+
+  IMAGE_TRANSPORT_PUBLIC
+  ImageTransport& operator=(const ImageTransport& other);
+
   IMAGE_TRANSPORT_PUBLIC
   ~ImageTransport();
 
@@ -364,6 +370,11 @@ class ImageTransport
   std::unique_ptr<Impl> impl_;
 };
 
+struct ImageTransport::Impl
+{
+  rclcpp::Node::SharedPtr node_;
+};
+
 }  // namespace image_transport
 
 #endif  // IMAGE_TRANSPORT__IMAGE_TRANSPORT_HPP_

image_transport/src/image_transport.cpp

@@ -128,10 +128,8 @@ std::vector<std::string> getLoadableTransports()
   return loadableTransports;
 }
 
-struct ImageTransport::Impl
-{
-  rclcpp::Node::SharedPtr node_;
-};
+ImageTransport::ImageTransport(const ImageTransport& other)
+: impl_(std::make_unique<Impl>(*other.impl_)) {}
 
 ImageTransport::ImageTransport(rclcpp::Node::SharedPtr node)
 : impl_(std::make_unique<ImageTransport::Impl>())

image_transport_py/CHANGELOG.rst

@@ -0,0 +1,3 @@
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Changelog for package image_transport_py
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

image_transport_py/CMakeLists.txt

@@ -0,0 +1,66 @@
+cmake_minimum_required(VERSION 3.5)
+project(image_transport_py)
+
+# Default to C99
+if(NOT CMAKE_C_STANDARD)
+  set(CMAKE_C_STANDARD 99)
+endif()
+
+# Default to C++17
+if(NOT CMAKE_CXX_STANDARD)
+  set(CMAKE_CXX_STANDARD 17)
+  set(CMAKE_CXX_STANDARD_REQUIRED ON)
+endif()
+
+if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+  add_compile_options(-Wall -Wextra -Wpedantic)
+endif()
+
+# Figure out Python3 debug/release before anything else can find_package it
+if(WIN32 AND CMAKE_BUILD_TYPE STREQUAL "Debug")
+  find_package(python_cmake_module REQUIRED)
+  find_package(PythonExtra REQUIRED)
+
+  # Force FindPython3 to use the debug interpreter where ROS 2 expects it
+  set(Python3_EXECUTABLE "${PYTHON_EXECUTABLE_DEBUG}")
+endif()
+
+
+find_package(ament_cmake REQUIRED)
+find_package(ament_cmake_python REQUIRED)
+find_package(ament_cmake_ros REQUIRED)
+find_package(image_transport REQUIRED)
+find_package(pluginlib REQUIRED)
+find_package(rclcpp REQUIRED)
+find_package(sensor_msgs REQUIRED)
+
+# Find python before pybind11
+find_package(Python3 REQUIRED COMPONENTS Interpreter Development)
+
+find_package(pybind11_vendor REQUIRED)
+find_package(pybind11 REQUIRED)
+
+ament_python_install_package(${PROJECT_NAME})
+
+pybind11_add_module(_image_transport MODULE
+  src/image_transport_py/pybind_image_transport.cpp
+)
+
+target_include_directories(_image_transport PUBLIC
+  "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
+  "$<INSTALL_INTERFACE:include/${PROJECT_NAME}>")
+
+target_link_libraries(_image_transport PUBLIC
+  image_transport::image_transport
+  rclcpp::rclcpp
+  ${sensor_msgs_TARGETS}
+)
+
+# Install cython modules as sub-modules of the project
+install(
+  TARGETS
+    _image_transport
+  DESTINATION "${PYTHON_INSTALL_DIR}/${PROJECT_NAME}"
+)
+
+ament_package()

image_transport_py/image_transport_py/__init__.py

@@ -0,0 +1,30 @@
+# Copyright 2023 Open Source Robotics Foundation, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from rpyutils import add_dll_directories_from_env
+
+# Since Python 3.8, on Windows we should ensure DLL directories are explicitly added
+# to the search path.
+# See https://docs.python.org/3/whatsnew/3.8.html#bpo-36085-whatsnew
+with add_dll_directories_from_env('PATH'):
+    from image_transport_py._image_transport import (
+        ImageTransport,
+        Publisher,
+    )
+
+
+__all__ = [
+    'ImageTransport',
+    'Publisher',
+]

image_transport_py/include/image_transport_py/cast_image.hpp

@@ -0,0 +1,161 @@
+// Copyright 2023 Open Source Robotics Foundation, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// File generated by gen_ros_casters.py. Do not manually change.
+
+#ifndef IMAGE_TRANSPORT_PY__CAST_IMAGE_HPP_
+#define IMAGE_TRANSPORT_PY__CAST_IMAGE_HPP_
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "pybind11/operators.h"
+#include "pybind11/pybind11.h"
+#include "pybind11/stl.h"
+
+#include "sensor_msgs/msg/image.hpp"
+
+static inline bool is_ros_msg_type(pybind11::handle src, const std::string & msg_type_name)
+{
+  return pybind11::hasattr(src, "__module__") &&
+         src.attr("__module__").cast<std::string>() == msg_type_name;
+}
+
+namespace pybind11
+{
+namespace detail
+{
+
+using ContainerAllocator = std::allocator<void>;
+
+template <>
+struct type_caster<builtin_interfaces::msg::Time_<ContainerAllocator>>
+{
+public:
+  PYBIND11_TYPE_CASTER(
+    builtin_interfaces::msg::Time_<ContainerAllocator>,
+    const_name("builtin_interfaces::msg::Time_<ContainerAllocator>"));
+  bool load(handle src, bool)
+  {
+    if (!is_ros_msg_type(src, "builtin_interfaces.msg._time")) {
+      return false;
+    }
+    value.sec = src.attr("sec").cast<int32_t>();
+    value.nanosec = src.attr("nanosec").cast<uint32_t>();
+    return true;
+  }
+
+  static handle cast(
+    builtin_interfaces::msg::Time_<ContainerAllocator> cpp_msg, return_value_policy /* policy */,
+    handle /* parent */)
+  {
+    object mod = module::import("builtin_interfaces.msg._time");
+    object MsgType = mod.attr("Time");
+    object msg = MsgType();
+    msg.attr("sec") = pybind11::cast(cpp_msg.sec);
+    msg.attr("nanosec") = pybind11::cast(cpp_msg.nanosec);
+    msg.inc_ref();
+    return msg;
+  }
+};
+
+template <>
+struct type_caster<std_msgs::msg::Header_<ContainerAllocator>>
+{
+public:
+  PYBIND11_TYPE_CASTER(
+    std_msgs::msg::Header_<ContainerAllocator>,
+    const_name("std_msgs::msg::Header_<ContainerAllocator>"));
+  bool load(handle src, bool)
+  {
+    if (!is_ros_msg_type(src, "std_msgs.msg._header")) {
+      return false;
+    }
+    value.stamp = src.attr("stamp").cast<builtin_interfaces::msg::Time_<ContainerAllocator>>();
+    value.frame_id =
+      src.attr("frame_id")
+        .cast<std::basic_string<
+          char, std::char_traits<char>,
+          typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>>>();
+    return true;
+  }
+
+  static handle cast(
+    std_msgs::msg::Header_<ContainerAllocator> cpp_msg, return_value_policy /* policy */,
+    handle /* parent */)
+  {
+    object mod = module::import("std_msgs.msg._header");
+    object MsgType = mod.attr("Header");
+    object msg = MsgType();
+    msg.attr("stamp") = pybind11::cast(cpp_msg.stamp);
+    msg.attr("frame_id") = pybind11::cast(cpp_msg.frame_id);
+    msg.inc_ref();
+    return msg;
+  }
+};
+
+template <>
+struct type_caster<sensor_msgs::msg::Image_<ContainerAllocator>>
+{
+public:
+  PYBIND11_TYPE_CASTER(
+    sensor_msgs::msg::Image_<ContainerAllocator>,
+    const_name("sensor_msgs::msg::Image_<ContainerAllocator>"));
+  bool load(handle src, bool)
+  {
+    if (!is_ros_msg_type(src, "sensor_msgs.msg._image")) {
+      return false;
+    }
+    value.header = src.attr("header").cast<std_msgs::msg::Header_<ContainerAllocator>>();
+    value.height = src.attr("height").cast<uint32_t>();
+    value.width = src.attr("width").cast<uint32_t>();
+    value.encoding =
+      src.attr("encoding")
+        .cast<std::basic_string<
+          char, std::char_traits<char>,
+          typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>>>();
+    value.is_bigendian = src.attr("is_bigendian").cast<uint8_t>();
+    value.step = src.attr("step").cast<uint32_t>();
+    value.data =
+      src.attr("data")
+        .cast<std::vector<
+          uint8_t,
+          typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<uint8_t>>>();
+    return true;
+  }
+
+  static handle cast(
+    sensor_msgs::msg::Image_<ContainerAllocator> cpp_msg, return_value_policy /* policy */,
+    handle /* parent */)
+  {
+    object mod = module::import("sensor_msgs.msg._image");
+    object MsgType = mod.attr("Image");
+    object msg = MsgType();
+    msg.attr("header") = pybind11::cast(cpp_msg.header);
+    msg.attr("height") = pybind11::cast(cpp_msg.height);
+    msg.attr("width") = pybind11::cast(cpp_msg.width);
+    msg.attr("encoding") = pybind11::cast(cpp_msg.encoding);
+    msg.attr("is_bigendian") = pybind11::cast(cpp_msg.is_bigendian);
+    msg.attr("step") = pybind11::cast(cpp_msg.step);
+    msg.attr("data") = pybind11::cast(cpp_msg.data);
+    msg.inc_ref();
+    return msg;
+  }
+};
+
+}  // namespace detail
+}  // namespace pybind11
+
+#endif  // IMAGE_TRANSPORT_PY__CAST_IMAGE_HPP_

image_transport_py/package.xml

@@ -0,0 +1,34 @@
+<package format="3">
+  <name>image_transport_py</name>
+
+  <version>5.0.3</version>
+
+  <description>Python API for image_transport</description>
+
+  <author>Tamas Foldi</author>
+
+  <maintainer email="[email protected]">Alejandro Hernández</maintainer>
+  <maintainer email="[email protected]">John D'Angelo</maintainer>
+
+  <license>BSD</license>
+
+  <url type="repository">https://github.com/ros-perception/image_transport</url>
+  <url type="bugtracker">https://github.com/ros-perception/image_transport/issues</url>
+
+  <buildtool_depend>ament_cmake_ros</buildtool_depend>
+  <buildtool_depend>ament_cmake_python</buildtool_depend>
+  <buildtool_depend>python_cmake_module</buildtool_depend>
+
+  <depend>image_transport</depend>
+  <depend>pybind11_vendor</depend>
+  <depend>pluginlib</depend>
+  <depend>rclcpp</depend>
+  <depend>sensor_msgs</depend>
+
+  <exec_depend>rpyutils</exec_depend>
+
+  <export>
+    <build_type>ament_cmake</build_type>
+  </export>
+
+</package>

image_transport_py/src/image_transport_py/pybind11.hpp

@@ -0,0 +1,31 @@
+// Copyright 2023 Open Source Robotics Foundation, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef IMAGE_TRANSPORT_PY__PYBIND11_HPP_
+#define IMAGE_TRANSPORT_PY__PYBIND11_HPP_
+
+// Ignore -Wunused-value for clang.
+// Based on https://github.com/pybind/pybind11/issues/2225
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-value"
+#endif
+#include <pybind11/pybind11.h>
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#endif
+#include <pybind11/functional.h>
+#include <pybind11/stl.h>
+
+#endif  // IMAGE_TRANSPORT_PY__PYBIND11_HPP_