• 机器人制作开源方案 | 桌面级全向底盘--机器视觉

          机器视觉是人工智能正在快速发展的一个分支，简单说来机器视觉就是用机器代替人眼来做测量和判断。机器视觉系统是通过机器视觉产品（即图像摄取装置，分CMOS和CCD两种）将被摄取目标转换成图像信号，传送给专用的图像处理系统，得到被摄目标的形态信息，根据像素分布和亮度、颜色等信息，转变成数字化信号；图像系统对这些信号进行各种运算来抽取目标的特征，进而根据判别的结果来控制现场的设备动作。

    机器视觉基础主要包含形状识别、颜色检测、颜色追踪、二维码识别等。

          机器视觉系统最基本的特点就是提高生产的灵活性和自动化程度，在一些不适于人工作业的危险工作环境或者人工视觉难以满足要求的场合，常用机器视觉来替代人工视觉。同时在大批量重复性工业生产过程中，用机器视觉检测方法可以大大提高生产的效率和自动化程度。接下来我们将结合机器视觉基础，基于开源的机器人平台，进行形状识别、颜色检测、颜色追踪的应用开发。

    1. 形状识别-识别圆形

    实现思路

          利用摄像头采集图片信息识别圆形，在界面上显示出圆的圆心坐标。

    器材准备

          摄像头、红色和绿色两种圆形图（如下图所示）。

    操作步骤

    ① 下载文末资料中的参考程序visual_experiment_ws\src\shape_detection\scripts\shape_detection_victory.py：

    1. #!/usr/bin/env python
    2.  
    3. #!-*-coding=utf-8 -*-
    4.  
    5. import rospy
    6.  
    7. from sensor_msgs.msg import Image
    8.  
    9. import cv2
    10.  
    11. import numpy as np
    12.  
    13. from cv_bridge import CvBridge, CvBridgeError
    14.  
    15. import sys
    16.  
    17. import time
    18.  
    19. lower_blue=np.array([100,43,46])
    20.  
    21. upper_blue=np.array([124,255,255])
    22.  
    23. #lower_blue=np.array([14,143,80])
    24.  
    25. #upper_blue=np.array([23,255,200])
    26.  
    27. #lower_red=np.array([0,200,55])
    28.  
    29. #upper_red=np.array([10,255,130])
    30.  
    31. #lower_red=np.array([0,150,55])
    32.  
    33. #upper_red=np.array([10,255,130])
    34.  
    35. lower_red=np.array([0,43,46])
    36.  
    37. upper_red=np.array([10,255,255])
    38.  
    39. lower_green=np.array([40,43,46])
    40.  
    41. upper_green=np.array([77,255,255])
    42.  
    43. font = cv2.FONT_HERSHEY_SIMPLEX   # 设置字体样式
    44.  
    45. kernel = np.ones((5, 5), np.uint8)   # 卷积核
    46.  
    47. img_pub = rospy.Publisher('webcam/image_raw', Image, queue_size=2)
    48.  
    49. #cap = cv2.VideoCapture(0)
    50.  
    51. def areaCal(contour):
    52.  
    53.     area = 0
    54.  
    55.     for i in range(len(contour)):
    56.  
    57.         area += cv2.contourArea(contour[i])
    58.  
    59.     return area
    60.  
    61. def image_callback(msg):
    62.  
    63.            bridge = CvBridge()
    64.  
    65.            frame = bridge.imgmsg_to_cv2(msg, "bgr8")
    66.  
    67.            #cv2.imshow("source", frame)
    68.  
    69.            #ret, frame = Video.read()
    70.  
    71.            gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)   # 转换为灰色通道
    72.  
    73.            hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)   # 转换为HSV空间
    74.  
    75.            mask = cv2.inRange(hsv, lower_red, upper_red)   # 设定掩膜取值范围   [消除噪声]
    76.  
    77.            #mask = cv2.inRange(hsv, lower_green, upper_green)   # 设定掩膜取值范围 [消除噪声]
    78.  
    79.            opening = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel)   # 形态学开运算 [消除噪声]
    80.  
    81.            bila = cv2.bilateralFilter(mask, 10, 200, 200)   # 双边滤波消除噪声 [消除噪声]
    82.  
    83.            edges = cv2.Canny(opening, 50, 100)   # 边缘识别 [消除噪声]
    84.  
    85.            mask_green = cv2.inRange(hsv,lower_green,upper_green)
    86.  
    87.            opening_green = cv2.morphologyEx(mask_green, cv2.MORPH_OPEN, kernel)
    88.  
    89.            bila_green = cv2.bilateralFilter(mask_green, 10, 200, 200)
    90.  
    91.            edges_green = cv2.Canny(opening_green, 50, 100)
    92.  
    93.            images,contourss,hierarchvs = cv2.findContours(edges_green,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
    94.  
    95.            image,contours,hierarchv = cv2.findContours(edges,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
    96.  
    97.            scaling_factor = 0.5
    98.  
    99.            print "area_red=",areaCal(contours),"area_green=",areaCal(contourss)
    100.  
    101.            if(areaCal(contours)>50):
    102.  
    103.              #circles = cv2.HoughCircles(edges, cv2.HOUGH_GRADIENT, 1, 100, param1=100, param2=20, minRadius=20, maxRadius=500)
    104.  
    105.              circles = cv2.HoughCircles(edges, cv2.HOUGH_GRADIENT, 1, 100, param1=100, param2=20, minRadius=0, maxRadius=0)
    106.  
    107.              if circles is not None:   # 如果识别出圆
    108.  
    109.                #print "I found the red circle"
    110.  
    111.                for circle in circles[0]:
    112.  
    113.                  x_red=int(circle[0])
    114.  
    115.                  y_red=int(circle[1])
    116.  
    117.                  r_red=int(circle[2])
    118.  
    119.                  cv2.circle(frame, (x_red, y_red), r_red, (0, 0, 255), 3)   # 标记圆
    120.  
    121.                  cv2.circle(frame, (x_red, y_red), 3, (255, 255, 0), -1)   # 标记圆心
    122.  
    123.                  text = 'circle' + 'x:   '+str(x_red)+' y:   '+str(y_red)
    124.  
    125.                  cv2.putText(frame, text, (10, 30), font, 1, (0, 255, 0), 2, cv2.LINE_AA, 0)   # 显示圆心位置
    126.  
    127.            if(areaCal(contourss)>1000):
    128.  
    129.              #circles = cv2.HoughCircles(edges, cv2.HOUGH_GRADIENT, 1, 100, param1=100, param2=20, minRadius=20, maxRadius=500)
    130.  
    131.              circles = cv2.HoughCircles(edges_green, cv2.HOUGH_GRADIENT, 1, 100, param1=100, param2=20, minRadius=0, maxRadius=0)
    132.  
    133.              if circles is not None:   # 如果识别出圆
    134.  
    135.                #print "I found the green circle"
    136.  
    137.                for circle in circles[0]:
    138.  
    139.                  x_red=int(circle[0])
    140.  
    141.                  y_red=int(circle[1])
    142.  
    143.                  r_red=int(circle[2])
    144.  
    145.                  cv2.circle(frame, (x_red, y_red), r_red, (0, 0, 255), 3)   # 标记圆
    146.  
    147.                  cv2.circle(frame, (x_red, y_red), 3, (255, 255, 0), -1)   # 标记圆心
    148.  
    149.                  text = 'circle' + 'x:   '+str(x_red)+' y:   '+str(y_red)
    150.  
    151.                  cv2.putText(frame, text, (10, 60), font, 1, (0, 255, 0), 2, cv2.LINE_AA, 0)   # 显示圆心位置
    152.  
    153.            frame = cv2.resize(frame,None,fx=scaling_factor,fy=scaling_factor,interpolation=cv2.INTER_AREA)
    154.  
    155.            msg = bridge.cv2_to_imgmsg(frame, encoding="bgr8")
    156.  
    157.            img_pub.publish(msg)
    158.  
    159.            cv2.waitKey(3)
    160.  
    161.            '''
    163.            rate = rospy.Rate(20) # 5hz
    165.            scaling_factor = 0.5
    167.            bridge = CvBridge()
    169.            count = 0
    171.            while not rospy.is_shutdown():
    173.              if (True):
    175.                count = count + 1
    177.              else:
    179.                rospy.loginfo("Capturing image failed.")
    181.              if count == 2:
    183.                count = 0
    185.                frame = cv2.resize(frame,None,fx=scaling_factor,fy=scaling_factor,interpolation=cv2.INTER_AREA)
    187.                msg = bridge.cv2_to_imgmsg(frame, encoding="bgr8")
    189.                img_pub.publish(msg)
    191.            rate.sleep()         
    193.            '''
    194.  
    195. def webcamImagePub():
    196.  
    197.     rospy.init_node('webcam_puber', anonymous=True)
    198.  
    199. #    img_pub = rospy.Publisher('webcam/image_raw', Image, queue_size=2)
    200.  
    201.     rospy.Subscriber("/image_raw", Image, image_callback)
    202.  
    203.     rospy.spin()
    204.  
    205. if __name__ == '__main__':
    206.  
    207.     try:
    208.  
    209.         webcamImagePub()
    210.  
    211.     except rospy.ROSInterruptException:
    212.  
    213.         pass
    214.  
    215.     finally:
    216.  
    217.         webcamImagePub()
    218.  
    219.

    ② 打开第一个终端（Ctrl+Alt+T）并输入：roslaunch astra_camera astra.launch 命令（见下图）, 等待程序的运行。

    打开第二个终端（Ctrl+Shift+T）并输入命令：roslaunch shape_detection shape_detection_experiment.launch，等待界面的启动。

    ③ 放置待识别的圆形图（请把物品放置在摄像头可以采集到的区域），就可以在界面上看到识别结果。如下图所示是分别识别出红色圆形、绿色圆形轮廓，并显示识别出圆心的中心坐标x、y的值。

    端口、终端、机器视觉、开源机器人项目、 人工智能小车、桌面级全向底盘、桌面级应用型底盘、四驱全向底盘、开源机器人、应用型底盘机械设计、全向移动底盘、开源机器人操作系统、麦克纳姆

    2. 颜色识别（红绿蓝）

    实现思路

          当把物品放置在摄像头前时，摄像头采集到物品的颜色后，利用开源视觉库进行识别，然后在界面上显示识别颜色的结果（本实验中准备了红、绿、蓝三种物品）。

    颜色识别算法的核心原理

    RGB和HSV彩色模型：

          数字图像处理通常采用RGB（红、绿、蓝）和HSV（色调、饱和度、亮度）两种彩色模型，RGB虽然表示比较至直观，但R、G、B数值和色彩三属性并没有直接关系，模型通道并不能很好的反映出物体具体的颜色信息，而HSV模型更符合我们描述和解释颜色的方式，使用HSV的彩色描述会更加直观。

    RGB和HSV的区别：

    ①. RGB模型

    三维坐标：

    RGB：三原色（Red, Green, Blue）

          原点到白色顶点的中轴线是灰度线，r、g、b三分量相等，强度可以由三分量的向量表示。

          用RGB来理解色彩、深浅、明暗变化。

          色彩变化： 三个坐标轴RGB最大分量顶点与黄紫青YMC色顶点的连线

          深浅变化：RGB顶点和CMY顶点到原点和白色顶点的中轴线的距离

          明暗变化：中轴线的点的位置，到原点，就偏暗，到白色顶点就偏亮

    ②. HSV模型

    倒锥形模型：

    这个模型就是按色彩、深浅、明暗来描述的。

    H是色彩

    S是深浅， S = 0时，只有灰度

    V是明暗，表示色彩的明亮程度，但与光强无直接联系。

    ③. RGB与HSV的联系

          从上面的直观的理解，把RGB三维坐标的中轴线立起来，并扁化，就能形成HSV的锥形模型了。

          但V与强度无直接关系，因为它只选取了RGB的一个最大分量。而RGB则能反映光照强度（或灰度）的变化。

          v = max(r, g, b)

          由RGB到HSV的转换：

    ④.HSV色彩范围

    操作步骤

    ① 连接电路：请把摄像头与主机进行连接。

    ② 下载文末资料中的参考程序visual_experiment_ws\src\color_detection\scripts\color_test_one.py：

    1. #!/usr/bin/env python
    2.  
    3. #!-*-coding=utf-8 -*-
    4.  
    5. import rospy
    6.  
    7. from sensor_msgs.msg import Image
    8.  
    9. from cv_bridge import CvBridge, CvBridgeError
    10.  
    11. import cv2
    12.  
    13. import numpy as np
    14.  
    15. import serial
    16.  
    17. import time
    18.  
    19. import sys
    20.  
    21. from std_msgs.msg import UInt16
    22.  
    23. from std_msgs.msg import String
    24.  
    25. img_pub = rospy.Publisher('webcam/image_raw', Image, queue_size=2)
    26.  
    27. lower_blue=np.array([100,43,46])
    28.  
    29. upper_blue=np.array([124,255,255])
    30.  
    31. lower_red=np.array([0,43,46])
    32.  
    33. upper_red=np.array([10,255,255])
    34.  
    35. lower_green=np.array([40,43,46])
    36.  
    37. upper_green=np.array([77,255,255])
    38.  
    39. font = cv2.FONT_HERSHEY_SIMPLEX
    40.  
    41. kernel = np.ones((5, 5), np.uint8)
    42.  
    43. def areaCal(contour):
    44.  
    45.     area = 0
    46.  
    47.     for i in range(len(contour)):
    48.  
    49.         area += cv2.contourArea(contour[i])
    50.  
    51.     return area
    52.  
    53.    
    54.  
    55. def image_callback(msg):
    56.  
    57.   bridge = CvBridge()
    58.  
    59.   img = bridge.imgmsg_to_cv2(msg, "bgr8")
    60.  
    61.   #cv2.imshow("source", img)
    62.  
    63.   hsv = cv2.cvtColor(img,cv2.COLOR_BGR2HSV)
    64.  
    65.   mask_red = cv2.inRange(hsv,lower_red,upper_red)
    66.  
    67.   res = cv2.bitwise_and(img,img,mask=mask_red)
    68.  
    69.   scaling_factor = 0.5
    70.  
    71. #   cv2.imshow("res",res)
    72.  
    73.   image,contours,hierarchv = cv2.findContours(mask_red,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
    74.  
    75. #   print   "red=",areaCal(contours)
    76.  
    77.   if (areaCal(contours)>5000):
    78.  
    79. #    print "red color"
    80.  
    81.     text_red = 'the color is red'
    82.  
    83.     cv2.putText(img, text_red, (10, 30), font, 1, (0, 0, 255), 2, cv2.LINE_AA, 0)
    84.  
    85.   mask_blue= cv2.inRange(hsv, lower_blue, upper_blue)
    86.  
    87.   res_yellow = cv2.bitwise_and(img,img,mask=mask_blue)
    88.  
    89.   image,contours,hierarchv = cv2.findContours(mask_blue,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
    90.  
    91.   if(areaCal(contours)>8000):
    92.  
    93.     text_blue = 'the color is blue'
    94.  
    95. #    print "blue color"
    96.  
    97.     cv2.putText(img, text_blue, (10, 60), font, 1, (255, 0, 0), 2, cv2.LINE_AA, 0)
    98.  
    99.   mask_green=cv2.inRange(hsv, lower_green,upper_green)
    100.  
    101.   res_green = cv2.bitwise_and(img,img,mask=mask_blue)
    102.  
    103.   image,contours,hierarchv = cv2.findContours(mask_green,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
    104.  
    105.   if (areaCal(contours)>5000):
    106.  
    107.     text_green = 'the color is green'
    108.  
    109.     cv2.putText(img, text_green, (10, 90), font, 1, (0, 255, 0), 2, cv2.LINE_AA, 0)
    110.  
    111. #    print ("green color")
    112.  
    113. #   else:
    114.  
    115. #     print( "NONE COLOR" )
    116.  
    117.   frame = cv2.resize(img,None,fx=scaling_factor,fy=scaling_factor,interpolation=cv2.INTER_AREA)
    118.  
    119.   msg = bridge.cv2_to_imgmsg(frame, encoding="bgr8")
    120.  
    121.   img_pub.publish(msg)
    122.  
    123.   cv2.waitKey(3)
    124.  
    125. #   cv2.waitKey(1)
    126.  
    127. def main():
    128.  
    129.     rospy.init_node('image_listener',anonymous=True)
    130.  
    131.     #image_topic = "/camera/color/image_raw"
    132.  
    133.     #rospy.Subscriber("/camera/color/image_raw", Image, image_callback)
    134.  
    135.     rospy.Subscriber("/image_raw", Image, image_callback)
    136.  
    137.     rospy.spin()
    138.  
    139. if __name__ == '__main__':
    140.  
    141.     main()

     ③ 打开终端（Ctrl+Alt+T），输入roslaunch astra_camera astra.launch（见下图）, 等待程序的运行。

    打开第二个终端（Ctrl+Shift+T）输入命令：roslaunch color_detection color_detectioning.launch，等待程序的运行。

    ④ 界面启动后，放置物品（请把物品放置在摄像头可以采集到的区域），然后摄像头开始识别并在界面上显示识别结果。

    下面以蓝色物品为例，当摄像头识别到蓝色物品后，在界面显示结果（the color is blue）。

    机器视觉、开源机器人项目、 人工智能小车、桌面级全向底盘、桌面级应用型底盘、四驱全向底盘、开源机器人、应用型底盘机械设计、全向移动底盘、开源机器人操作系统、麦克纳姆

          大家也可以试着去放置红色、绿色物品，分别识别出的结果如下图所示。当摄像头识别到红色物品后，在界面显示结果（the color is red）；当摄像头识别到绿色物品后，在界面显示结果（the color is green）。

    检测到红色物品
    检测到绿色物品

    3. 颜色追踪

    实现思路

          摄像头采集到红色物品后，通过串口通信来发布消息，黑手底盘订阅消息后进行相应的运动。

    器材准备

          实验中需要用到的器材如下图所示（其中用红色的灭火器来代表待追踪的物体）。

    操作步骤

    ① 下载文末资料中Ros通信的参考程序visual_experiment_ws\src\color_tracking\scripts\ros_arduino_translation_test.py：

    1. #!/usr/bin/env python
    2.  
    3. #!coding=utf-8
    4.  
    5. import rospy
    6.  
    7. from sensor_msgs.msg import Image
    8.  
    9. from cv_bridge import CvBridge, CvBridgeError
    10.  
    11. import cv2
    12.  
    13. import numpy as np
    14.  
    15. import serial
    16.  
    17. import time
    18.  
    19. import sys
    20.  
    21. from std_msgs.msg import UInt16
    22.  
    23. from std_msgs.msg import String
    24.  
    25. #lower_blue=np.array([50,143,146])
    26.  
    27. #upper_blue=np.array([124,255,255])
    28.  
    29. #lower_blue=np.array([14,143,80])
    30.  
    31. #upper_blue=np.array([23,255,200])
    32.  
    33. lower_blue=np.array([100,43,46])
    34.  
    35. upper_blue=np.array([124,255,255])
    36.  
    37. #lower_red=np.array([0,200,55])
    38.  
    39. #upper_red=np.array([10,255,130])
    40.  
    41. #lower_red=np.array([0,150,55])
    42.  
    43. #upper_red=np.array([10,255,130])
    44.  
    45. lower_red=np.array([0,43,46])
    46.  
    47. upper_red=np.array([10,255,255])
    48.  
    49. lower_green=np.array([40,43,46])
    50.  
    51. upper_green=np.array([77,255,255])
    52.  
    53. #ser = serial.Serial('/dev/ttyACM0', 57600, timeout=2.0) #2020.8.28 source value=0.5
    54.  
    55. img_pub = rospy.Publisher('webcam/image_raw', Image, queue_size=2)
    56.  
    57. data_pub= rospy.Publisher('Color_center_point',String,queue_size=20)
    58.  
    59. red_flag=0
    60.  
    61. blue_flag=0
    62.  
    63. image_flags = 1
    64.  
    65. cx_string=""
    66.  
    67. cy_string=""
    68.  
    69. cx_cy_string=""
    70.  
    71. send_data = ""
    72.  
    73. count=0
    74.  
    75. scaling_factor = 1.0   #2020.8.28 source value=0.5
    76.  
    77. def areaCal(contour):
    78.  
    79.     area = 0
    80.  
    81.     for i in range(len(contour)):
    82.  
    83.         area += cv2.contourArea(contour[i])
    84.  
    85.     return area
    86.  
    87.    
    88.  
    89. def image_callback(msg):
    90.  
    91.   global count,send_data
    92.  
    93.   bridge = CvBridge()
    94.  
    95.   frame = bridge.imgmsg_to_cv2(msg, "bgr8")
    96.  
    97.   #cv2.imshow("source", frame)
    98.  
    99.   hsv = cv2.cvtColor(frame,cv2.COLOR_BGR2HSV)
    100.  
    101.   mask_red = cv2.inRange(hsv,lower_red,upper_red)
    102.  
    103.   res = cv2.bitwise_and(frame,frame,mask=mask_red)
    104.  
    105.   #cv2.imshow("res",res)
    106.  
    107.   image,contours,hierarchv = cv2.findContours(mask_red,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)  
    108.  
    109.   print "mianji=",areaCal(contours)
    110.  
    111.   if (areaCal(contours)>5000):
    112.  
    113.     if(areaCal(contours)>80000):
    114.  
    115.       send_data="back"
    116.  
    117.       #ser.write("back\n")
    118.  
    119.       #print "back"
    120.  
    121.     elif( areaCal(contours)<50000 and areaCal(contours)>5000 ):
    122.  
    123.       send_data="forward"
    124.  
    125.       #ser.write("forward\n")
    126.  
    127.       #print "forward"
    128.  
    129.     else:
    130.  
    131.       send_data="state"
    132.  
    133.     if len(contours) > 0:
    134.  
    135.       c = max(contours, key=cv2.contourArea)
    136.  
    137.       #print "c=",c
    138.  
    139.       cnt=contours[0]
    140.  
    141.       cv2.drawContours(frame, c, -1, (0, 0, 255), 3)#画轮廓
    142.  
    143.       #cv2.imshow("drawcontours",frame)
    144.  
    145.       M = cv2.moments(c)
    146.  
    147.       if M["m00"] !=0:
    148.  
    149.         cx = int(M['m10']/M['m00'])
    150.  
    151.         cy = int(M['m01']/M['m00'])
    152.  
    153.         center = (int(M["m10"] / M["m00"]), int(M["m01"] / M["m00"]))
    154.  
    155.         cv2.circle(frame, (cx,cy), 8, (0, 255, 0), -1)
    156.  
    157.         print "center=",center,"cx=",cx,"cy=",cy
    158.  
    159.         cx_string=str(cx)
    160.  
    161.         cy_string=str(cy)
    162.  
    163.         #cx_cy_string=(cx_string + "-" + cy_string + "\n").encode('utf-8')
    164.  
    165.         #cx_cy_string=(cx_string + "-" + cy_string + "-" + send_data + "\n").encode('utf-8')
    166.  
    167.         cx_cy_string=(cx_string + "-" + cy_string + "+" + send_data ).encode('utf-8')
    168.  
    169.         print (cx_cy_string)
    170.  
    171.         data_pub.publish(cx_cy_string)
    172.  
    173.       else:
    174.  
    175.         cx=0
    176.  
    177.         cy=0
    178.  
    179.     else:
    180.  
    181.       print "no red color something"
    182.  
    183.       #cv2.imshow("chanle", img)
    184.  
    185. #      if cv2.waitKey(1) & 0xFF == ord('q'):
    186.  
    187. #        #break
    188.  
    189. #        #continue
    190.  
    191.   if(image_flags==1):
    192.  
    193.     count = count+1
    194.  
    195.   else:
    196.  
    197.     rospy.loginfo("Capturing image failed.")
    198.  
    199.   if count == 2:
    200.  
    201.     count = 0
    202.  
    203.     frame = cv2.resize(frame,None,fx=scaling_factor,fy=scaling_factor,interpolation=cv2.INTER_AREA)
    204.  
    205.     msg = bridge.cv2_to_imgmsg(frame, encoding="bgr8")
    206.  
    207.     img_pub.publish(msg)
    208.  
    209.   cv2.waitKey(1)
    210.  
    211. def main():
    212.  
    213.     rospy.init_node('image_listener',anonymous=True)
    214.  
    215. #    img_pub = rospy.Publisher('webcam/image_raw', Image, queue_size=2)
    216.  
    217.     rospy.Subscriber("/image_raw", Image, image_callback)
    218.  
    219.     rospy.spin()
    220.  
    221. if __name__ == '__main__':
    222.  
    223.     main()
    224.  
    225.

    下载文末资料中控制黑手底盘运动的参考程序visual_experiment_ws\src\color_tracking\arduino_program\Color_Tracking_Arduino_Program\Color_Tracking_Arduino_Program.ino：

    1. /*
    3. * rosserial Publisher Example
    5. * Prints "hello world!"
    7. */
    8.  
    9. #include 
    10.  
    11. #include 
    12.  
    13. #include 
    14.  
    15. #include 
    16.  
    17. #include 
    18.  
    19. #define CTL_BAUDRATE 115200 //总线舵机波特率
    20.  
    21. #define mySerial Serial2
    22.  
    23. #define SerialBaudrate 57600
    24.  
    25. #define RGB_LED_NUMBERS 3
    26.  
    27. #define Bus_servo_Angle_inits 1500
    28.  
    29. #define ActionDelayTimes 1500
    30.  
    31. //
    32.  
    33. #define wheel_speed_forward 0.08    //car forward speed
    34.  
    35. #define wheel_speed_back -0.08      //car back speed
    36.  
    37. #define wheel_speed_stop 0.0        //car stop speed
    38.  
    39. #define wheel_speed_left 0.1       //car turnleft speed
    40.  
    41. #define wheel_speed_right -0.1     //car turnright speed
    42.  
    43. #define wheel_speed_left_translation 0.08   //speed of car left translation
    44.  
    45. #define wheel_speed_right_translation -0.08 //speed of car right translation
    46.  
    47. char cmd_return[200];
    48.  
    49. String receive_string="hello";
    50.  
    51. ros::NodeHandle   nh;
    52.  
    53. void messageCb( const std_msgs::String &toggle_msg){
    54.  
    55.    receive_string=toggle_msg.data;
    56.  
    57. }
    58.  
    59. ros::Subscriber sub("Color_center_point", &messageCb );
    60.  
    61. enum{FORWARD=1,BACK,LEFT,RIGHT,LEFT_TRANSLATION,RIGHT_TRANSLATION,STOP}; //the movement state of the car
    62.  
    63. void setup()
    64.  
    65. {
    66.  
    67.   delay(1100);
    68.  
    69.   Serial.begin(SerialBaudrate);
    70.  
    71.   mySerial.begin(CTL_BAUDRATE);  
    72.  
    73.   nh.initNode();
    74.  
    75.   nh.subscribe(sub);
    76.  
    77. }
    78.  
    79. void loop()
    80.  
    81. {
    82.  
    83.   if( (receive_string.length())<5 && (receive_string.length())>15 )
    84.  
    85.   {
    86.  
    87.      for(int i=0;i<1;i++){
    88.  
    89.      break;
    90.  
    91.      }
    92.  
    93.   }
    94.  
    95.     else{
    96.  
    97.        int SpacePosition[2] = {0,0};
    98.  
    99.        int Data_one = 0;
    100.  
    101.        int Data_two = 0;
    102.  
    103.        int numbers_left=0 ,numbers_right=0;
    104.  
    105.        char num_left[32] = {};
    106.  
    107.        char num_right[32] = {};
    108.  
    109.        String x_data="";
    110.  
    111.        String y_data="";
    112.  
    113.        String z_data="";
    114.  
    115.        String new_string = "";                                                                               
    116.  
    117.        SpacePosition[0] = receive_string.indexOf('-');
    118.  
    119.        x_data = receive_string.substring(0,SpacePosition[0]);
    120.  
    121.        //if(x_data.length()>=4){break;}
    122.  
    123.        new_string = receive_string.substring(SpacePosition[0]+1);
    124.  
    125.        SpacePosition[1] = new_string.indexOf('+');
    126.  
    127.        y_data = new_string.substring(0,SpacePosition[1]);
    128.  
    129.        z_data = new_string.substring(SpacePosition[1]+1);
    130.  
    131.       Data_one = x_data.toInt();
    132.  
    133.       Data_two = y_data.toInt();
    134.  
    135.       //if( (Data_one<=120) && (z_data =="state") ){Car_Move(LEFT_TRANSLATION);}
    136.  
    137.       if( (Data_one<=280) && (Data_one>=20)){Car_Move(LEFT_TRANSLATION);}
    138.  
    139.       else if ( (Data_one>=360) && (Data_one<=600) ){Car_Move(RIGHT_TRANSLATION);}
    140.  
    141.       else if( z_data == "forward" ){Car_Move(FORWARD);}
    142.  
    143.       else if( z_data == "back" ){Car_Move(BACK );}
    144.  
    145.       else {Car_Move(STOP);}
    146.  
    147.      
    148.  
    149.       receive_string = "";
    150.  
    151.       x_data="";
    152.  
    153.       y_data="";
    154.  
    155.       z_data="";
    156.  
    157.       new_string="";
    158.  
    159.     }  
    160.  
    161.   nh.spinOnce();
    162.  
    163.   delay(100);
    164.  
    165. }

    ② 打开终端（Alt＋ctrl＋T），输入roslaunch astra_camera astra.launch命令即可,见下图。

    打开第二个终端（shift＋ctrl＋T），输入roslaunch color_tracking camera_calibration.launch 命令，见下图。

    ③ 移动灭火器，观察黑手底盘跟随灭火器运动的效果。

         【注意：请把灭火器放置在摄像头可采集到的区域内；受硬件的影响，移动灭火器的速度建议稍微慢点，可以先把灭火器移动到一个位置，然后观察底盘追踪的效果】

         我们可以在rviz界面里看到摄像头采集到红色目标的中心坐标及面积，供追踪使用（如下图所示）。

    端口、终端、机器视觉、开源机器人项目、 人工智能小车、桌面级全向底盘、桌面级应用型底盘、四驱全向底盘、开源机器人、应用型底盘机械设计、全向移动底盘、开源机器人操作系统、麦克纳姆

    同时可以观察到底盘进行追踪红色的灭火器，直到运动到靠近灭火器的地方。

    程序源代码资料详见 桌面级全向底盘-机器视觉

  • 相关阅读:
    力扣第310场周赛总结与反思
    计算器(有qt界面)
    第十一章《搞懂算法:聚类是怎么回事》笔记
    基于TensorFlow+CNN+协同过滤算法的智能电影推荐系统——深度学习算法应用(含微信小程序、ipynb工程源码)+MovieLens数据集（五）
    flutterdart chacha20加密
    淘宝/天猫获取卖出的商品订单列表 API
    详解nvim内建LSP体系与基于nvim-cmp的代码补全体系
    微信支付费率降低到0.2%，商家收款开户手续费0.6%降低的操作方法
    结合el-input、el-select实现纯前端过滤树形el-table数据
    Pandas 2.2 中文官方教程和指南（十七）
  • 原文地址：https://blog.csdn.net/Robotway/article/details/132791619