摄像头画面传输

  2. import rclpy                        # ROS2 Python接口库
  3. from rclpy.node import Node         # ROS2 节点类
  4. from sensor_msgs.msg import Image   # 图像消息类型
  5. from cv_bridge import CvBridge      # ROS与OpenCV图像转换类
  6. import cv2                          # Opencv图像处理库
  8. """
  9. 创建一个发布者节点
  10. """
  11. class ImagePublisher(Node):
  13.     def __init__(self, name):
  14.         super().__init__(name)                                           # ROS2节点父类初始化
  15.         self.publisher_ = self.create_publisher(Image, 'image_raw', 10)  # 创建发布者对象（消息类型、话题名、队列长度）
  16.         self.timer = self.create_timer(0.1, self.timer_callback)         # 创建一个定时器（单位为秒的周期，定时执行的回调函数）
  17.         self.cap = cv2.VideoCapture(0)                                   # 创建一个视频采集对象，驱动相机采集图像（相机设备号）
  18.         self.cv_bridge = CvBridge()                                      # 创建一个图像转换对象，用于稍后将OpenCV的图像转换成ROS的图像消息
  20.     def timer_callback(self):
  21.         ret, frame = self.cap.read()                                     # 一帧一帧读取图像
  23.         if ret == True:                                                  # 如果图像读取成功
  24.             self.publisher_.publish(
  25.                 self.cv_bridge.cv2_to_imgmsg(frame, 'bgr8'))             # 发布图像消息
  27.         self.get_logger().info('Publishing video frame')                 # 输出日志信息，提示已经完成图像话题发布
  29. def main(args=None):                                 # ROS2节点主入口main函数
  30.     rclpy.init(args=args)                            # ROS2 Python接口初始化
  31.     node = ImagePublisher("topic_webcam_pub")        # 创建ROS2节点对象并进行初始化
  32.     rclpy.spin(node)                                 # 循环等待ROS2退出
  33.     node.destroy_node()                              # 销毁节点对象
  34.     rclpy.shutdown()                                 # 关闭ROS2 Python接口

摄像头画面订阅

  2. import rclpy                            # ROS2 Python接口库
  3. from rclpy.node import Node             # ROS2 节点类
  4. from sensor_msgs.msg import Image       # 图像消息类型
  5. from cv_bridge import CvBridge          # ROS与OpenCV图像转换类
  6. import cv2                              # Opencv图像处理库
  7. import numpy as np                      # Python数值计算库
  9. lower_red = np.array([0, 90, 128])      # 红色的HSV阈值下限
  10. upper_red = np.array([180, 255, 255])   # 红色的HSV阈值上限
  12. """
  13. 创建一个订阅者节点
  14. """
  15. class ImageSubscriber(Node):
  16.     def __init__(self, name):
  17.         super().__init__(name)                                  # ROS2节点父类初始化
  18.         self.sub = self.create_subscription(
  19.             Image, 'image_raw', self.listener_callback, 10)     # 创建订阅者对象（消息类型、话题名、订阅者回调函数、队列长度）
  20.         self.cv_bridge = CvBridge()                             # 创建一个图像转换对象，用于OpenCV图像与ROS的图像消息的互相转换
  22.     def object_detect(self, image):
  23.         hsv_img = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)        # 图像从BGR颜色模型转换为HSV模型
  24.         mask_red = cv2.inRange(hsv_img, lower_red, upper_red)   # 图像二值化
  25.         contours, hierarchy = cv2.findContours(
  26.             mask_red, cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)     # 图像中轮廓检测
  28.         for cnt in contours:                                    # 去除一些轮廓面积太小的噪声
  29.             if cnt.shape[0] < 150:
  30.                 continue
  32.             (x, y, w, h) = cv2.boundingRect(cnt)                # 得到苹果所在轮廓的左上角xy像素坐标及轮廓范围的宽和高
  33.             cv2.drawContours(image, [cnt], -1, (0, 255, 0), 2)  # 将苹果的轮廓勾勒出来
  34.             cv2.circle(image, (int(x+w/2), int(y+h/2)), 5,
  35.                        (0, 255, 0), -1)                         # 将苹果的图像中心点画出来
  37.         cv2.imshow("object", image)                             # 使用OpenCV显示处理后的图像效果
  38.         cv2.waitKey(10)
  40.     def listener_callback(self, data):
  41.         self.get_logger().info('Receiving video frame')         # 输出日志信息，提示已进入回调函数
  42.         image = self.cv_bridge.imgmsg_to_cv2(data, 'bgr8')      # 将ROS的图像消息转化成OpenCV图像
  43.         self.object_detect(image)                               # 苹果检测
  46. def main(args=None):                                        # ROS2节点主入口main函数
  47.     rclpy.init(args=args)                                   # ROS2 Python接口初始化
  48.     node = ImageSubscriber("topic_webcam_sub")              # 创建ROS2节点对象并进行初始化
  49.     rclpy.spin(node)                                        # 循环等待ROS2退出
  50.     node.destroy_node()                                     # 销毁节点对象
  51.     rclpy.shutdown()                                        # 关闭ROS2 Python接口

摄像头物体识别

接收摄像头的数据并进行识别,将识别的结果发布出去

  1. import rclpy                                       # ROS2 Python接口库
  2. from rclpy.node import Node                        # ROS2 节点类
  3. from sensor_msgs.msg import Image                  # 图像消息类型
  4. from cv_bridge import CvBridge                     # ROS与OpenCV图像转换类
  5. import cv2                                         # Opencv图像处理库
  6. import numpy as np                                 # Python数值计算库
  7. from learning_interface.msg import ObjectPosition  # 自定义的目标位置消息
  9. lower_red = np.array([0, 90, 128])                 # 红色的HSV阈值下限
  10. upper_red = np.array([180, 255, 255])              # 红色的HSV阈值上限
  12. """
  13. 创建一个订阅者节点
  14. """
  15. class ImageSubscriber(Node):
  17.     def __init__(self, name):
  18.         super().__init__(name)                                  # ROS2节点父类初始化
  19.         self.sub = self.create_subscription(
  20.             Image, 'image_raw', self.listener_callback, 10)     # 创建订阅者对象（消息类型、话题名、订阅者回调函数、队列长度）
  21.         self.pub = self.create_publisher(
  22.             ObjectPosition, "object_position", 10)              # 创建发布者对象（消息类型、话题名、队列长度）
  23.         self.cv_bridge = CvBridge()                             # 创建一个图像转换对象，用于OpenCV图像与ROS的图像消息的互相转换
  25.         self.objectX = 0
  26.         self.objectY = 0   
  28.     def object_detect(self, image):      
  29.         hsv_img = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)        # 图像从BGR颜色模型转换为HSV模型
  30.         mask_red = cv2.inRange(hsv_img, lower_red, upper_red)   # 图像二值化
  31.         contours, hierarchy = cv2.findContours(
  32.             mask_red, cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)     # 图像中轮廓检测
  33.         for cnt in contours:                                    # 去除一些轮廓面积太小的噪声
  34.             if cnt.shape[0] < 150:
  35.                 continue
  37.             (x, y, w, h) = cv2.boundingRect(cnt)                # 得到苹果所在轮廓的左上角xy像素坐标及轮廓范围的宽和高
  39.             cv2.drawContours(image, [cnt], -1, (0, 255, 0), 2)  # 将苹果的轮廓勾勒出来
  40.             cv2.circle(image, (int(x+w/2), int(y+h/2)), 5,      # 将苹果的图像中心点画出来
  41.                        (0, 255, 0), -1)   
  43.             self.objectX = int(x+w/2)
  44.             self.objectY = int(y+h/2)
  46.         cv2.imshow("object", image)                             # 使用OpenCV显示处理后的图像效果
  47.         cv2.waitKey(50)
  49.     def listener_callback(self, data):
  50.         self.get_logger().info('Receiving video frame')         # 输出日志信息，提示已进入回调函数
  51.         image = self.cv_bridge.imgmsg_to_cv2(data, 'bgr8')      # 将ROS的图像消息转化成OpenCV图像
  52.         position = ObjectPosition()
  53.         self.object_detect(image)                               # 苹果检测
  54.         position.x, position.y = int(self.objectX), int(self.objectY)
  55.         self.pub.publish(position)                              # 发布目标位置
  57. def main(args=None):                                        # ROS2节点主入口main函数
  58.     rclpy.init(args=args)                                   # ROS2 Python接口初始化
  59.     node = ImageSubscriber("topic_webcam_sub")              # 创建ROS2节点对象并进行初始化
  60.     rclpy.spin(node)                                        # 循环等待ROS2退出
  61.     node.destroy_node()                                     # 销毁节点对象
  62.     rclpy.shutdown()                                        # 关闭ROS2 Python接口

接收识别的结果,并打印结果

  3. import rclpy                                       # ROS2 Python接口库
  4. from rclpy.node   import Node                      # ROS2 节点类
  5. from std_msgs.msg import String                    # 字符串消息类型
  6. from learning_interface.msg import ObjectPosition  # 自定义的目标位置消息
  8. """
  9. 创建一个订阅者节点
  10. """
  11. class SubscriberNode(Node):
  12.     def __init__(self, name):
  13.         super().__init__(name)                                                    # ROS2节点父类初始化
  14.         self.sub = self.create_subscription(\
  15.             ObjectPosition, "/object_position", self.listener_callback, 10)       # 创建订阅者对象（消息类型、话题名、订阅者回调函数、队列长度
  17.     def listener_callback(self, msg):                                             # 创建回调函数，执行收到话题消息后对数据的处理
  18.         self.get_logger().info('Target Position: "(%d, %d)"' % (msg.x, msg.y))    # 输出日志信息，提示订阅收到的话题消息
  21. def main(args=None):                                 # ROS2节点主入口main函数
  22.     rclpy.init(args=args)                            # ROS2 Python接口初始化
  23.     node = SubscriberNode("interface_position_sub")  # 创建ROS2节点对象并进行初始化
  24.     rclpy.spin(node)                                 # 循环等待ROS2退出
  25.     node.destroy_node()                              # 销毁节点对象
  26.     rclpy.shutdown()                                 # 关闭ROS2 Python接口

ros2的摄像头节点

常用的usb相机驱动一般都是通用的，ROS中也集成了usb相机的标准驱动，我们只需要通过这样一行指令，就可以安装好，无论你用什么样的相机，只要符合usb接口协议，就可以直接使用ROS中的相机驱动节点，发布标准的图像话题了。

  1. sudo apt install ros-humble-usb-cam

打开摄像头节点

  1. ros2 run usb_cam usb_cam_node_exe