Week3: Image Subscriber

Create the Detect_Pump Image-Processing Node

The next node will subscribe to the image topic and execute a series of processing steps to identify the pump's orientation relative to the horizontal image axis.

1. As before, create a basic ROS python node (detect_pump.py) and set its executable permissions:

   #!/usr/bin/env python
   import rospy
   
   
   def start_node():
       rospy.init_node('image_subcriber')
       rospy.loginfo('image_subcriber node started')
   
   if __name__ == '__main__':
       try:
           start_node()
       except rospy.ROSInterruptException:
           pass

   chmod u+x nodes/detect_pump.py

   • Note that we don't have to edit CMakeLists to create new build rules for each script, since python does not need to be compiled.

2. Add a ROS subscriber to the image topic, to provide the source for images to process.

   1. Import the Image message header

      from sensor_msgs.msg import Image

   2. Above the start_node function, create an empty callback (process_image) that will be called when a new Image message is received:

      def process_image(msg):
          try:
             pass
          except Exception as err:
              print err

      • The try/except error handling will allow our code to continue running, even if there are errors during the processing pipeline.

   3. In the start_node function, create a ROS Subscriber object:

      • subscribe to the image topic, monitoring messages of type Image
      • register the callback function we defined above

      rospy.Subscriber("image", Image, process_image)
      rospy.spin()

      • reference: rospy.Subscriber
      • reference: rospy.spin

   4. Run the new node and verify that it is subscribing to the topic as expected:

      rosrun detect_pump detect_pump.py
      rosnode info /detect_pump
      rqt_graph

3. Convert the incoming Image message to an OpenCV Image object and display it As before, we'll use the CvBridge module to do the conversion.

   1. Import the CvBridge modules:

      from cv_bridge import CvBridge

   2. In the process_image callback, add a call to the CvBridge imgmsg_to_cv2 method:

      # convert sensor_msgs/Image to OpenCV Image
      bridge = CvBridge()
      orig = bridge.imgmsg_to_cv2(msg, "bgr8")

      • This code (and all other image-processing code) should go inside the try block, to ensure that processing errors don't crash the node.
      • This should replace the placeholder pass command placed in the try block earlier

   3. Use the OpenCV imshow method to display the images received. We'll create a pattern that can be re-used to show the result of each image-processing step.

      1. Import the OpenCV cv2 module:

         import cv2

      2. Add a display helper function above the process_image callback:

         def showImage(img):
             cv2.imshow('image', img)
             cv2.waitKey(1)

      3. Copy the received image to a new "drawImg" variable:

         drawImg = orig

      4. Below the except block (outside its scope; at process_image scope, display the drawImg variable:

         # show results
         showImage(drawImg)

   4. Run the node and see the received image displayed.