文件名称：test_autobot.py
文件路径：/home/examples-gpu/object-detection/test_autobot.py
在这里插入图片描述

导入基础包作用详解

#导入包介绍开始
#Scripting Layer for Android (SL4A) 是一个开源项目，目标是为android系统提供脚本语言的支持，
#使用户可以直接在android平台上进行脚本语言的编辑、解释和执行。
#这些脚本语言已经可是使用很多封装好的android API来开发功能丰富的android应用程序，
#并且使开发变得更加的简单和高效!
#导入SL4A，使用户可以直接在android平台上进行脚本语言的编辑、解释和执行。
import android

#导入python时间控制包
import time

#sys模块包括了一组非常实用的服务，内含很多函数方法和变量，用来处理Python运行时配置以及资源，从而可以与前当程序之外的系统环境交互。 
import sys

#cvs包是Aid内置的代替cv2的包，基本上cv2支持的函数cvs一样支持，cvs包在X模式下和非X模式下一样执行
#cvs更多详细介绍查看官网文档OpenCVhttps://www.aidlearning.net/showdoc/web/#/5?page_id=45
from cvs import *

#os --- 操作系统接口模块
import os

#NumPy(Numerical Python) 是 Python 语言的一个扩展程序库，支持大量的维度数组与矩阵运算，
#此外也针对数组运算提供大量的数学函数库。在机器学习算法中大部分都是调用Numpy库来完成基础数值计算的。
import numpy as np

# tflite_gpu，GPU加速代码由AID提供，TensorFlow Lite 支持多种硬件加速器。GPU 是设计用来完成高吞吐量的大规模并行工作的。
# 因此，它们非常适合用在包含大量运算符的神经网络上，一些输入张量可以容易的被划分为更小的工作负载且可以同时执行，通常这会导致更低的延迟。
# 在最佳情况下，用 GPU 在实时应用程序上做推理运算已经可以运行的足够快，而这在以前是不可能的。
import tflite_gpu

#【TensorFlow】基于ssd_mobilenet模型实现目标检测
from utils.ssd_mobilenet_utils import *

#一种简单的MATLAB粒子跟踪算法，可以处理间隙
#simpletracker.m正如它的名字所说，是一个跟踪算法的简单实现，可以处理间隙。当在一帧中检测到的一个粒子在下一帧中没有检测到时，就会出现间隙。
# 如果不处理，这将在粒子消失的帧中生成一个轨道中断或间隙，并在粒子重新出现的帧中生成一个错误的新轨道。
from utils.SimpleTracker import SimpleTracker

#导入包介绍结束

构建GUI显示窗体，最后执行main函数

#创建操作android系统对象
droid = android.Android()

#初始化对话框的标题栏内容
title = "AidBot Laucher..." 

#初始化对话框显示的文本 
sstr = "initing and Loading models..."

#创建一个水平进度条对话框，第一个参数是标题栏，第二个参数是对话框显示的内容，第三个参数是进度条最大值为100%
droid.dialogCreateHorizontalProgress(title,sstr,100)

#显示对话框 
droid.dialogShow() 

#进度条快进到50%，每隔0.001ms走1%
for x in range(0,50):
    time.sleep(0.001)
    # 设置进度条的当前值。 
    droid.dialogSetCurrentProgress(x) 

#设置进度条为60%
droid.dialogSetCurrentProgress(60) 

#创建aid封装好的GPU加速对象
tflite=tflite_gpu.tflite()

#设置进度条为70%
droid.dialogSetCurrentProgress(70) 

#定义一个名为 MyApp的类，用于构建程序的图形化
class MyApp(App):

    #初始化函数，self表示创建实例本身， *args传递可变参数，__init__()的第一个参数永远是self
    def __init__(self, *args):
        #这是对继承自父类的属性进行初始化。而且是用父类的初始化方法来初始化继承的属性。
        #也就是说，子类继承了父类的所有属性和方法，父类属性自然会用父类方法来进行初始化。
        super(MyApp, self).__init__(*args)
    
    #设置标签的值
    def idle(self):
        #idle function called every update cycle
        #设置标签控件中文本的值为cvs中全局变量的值。
        #并未清空cvs.getLbs() 中的值，目的是为了动态的显示程序运行的图片识别的速率情况（程序每秒识别几张图片）。
        self.lbl.set_text(cvs.getLbs())
        #刷新摄像头
        self.aidcam.update()
        #pass是python中的占位语句，不做任何操作
        pass
    
    #构建图形界面的主函数    
    def main(self):
        #creating a container VBox type, vertical (you can use also HBox or Widget)
        #定义变量main_container,它的作用是整个图形界面的主框架，用于包含其他APP中的控件，相当于容器
        #gui.VBox这段代码是在手机上画出一个宽度为360px,高度为680px的程序主框架范围。
        #style是它的样式，margin:0 auto;相当于margin:0 auto 0 auto;即上下是0，左右是自动。
        #这时main_container中的元素会水平居中
        main_container = VBox(width=360, height=520, style={'margin':'0px auto'})
        #设置main_container的宽度为手机屏幕的宽度的98%
        main_container.css_width = "98%"
        
        #添加摄像头控件
        #OpencvVideoWidget函数是在手机 画一个用于显示调用手机摄像头拍摄图像的框，宽度340px，高度480px,
        #将它赋值给self.aidcam，aidcam表示摄像头控件。
        self.aidcam = OpencvVideoWidget(self, width=360, height=320)
        #摄像头框架的边界和主框架相隔2%，主框架布满屏幕98%
        self.aidcam.css_width = "98%"
        #给aidcam控件一个标记
        self.aidcam.identifier="myimage_receiver"
        #将设置好的摄像头显示框添加到APP主框架中
        main_container.append(self.aidcam)
        
        #设置默认文本为'This show fps!'，宽度360px,高度30px，边界为50px的标签控件，将它赋值给self.lbl，self.lbl是标签控件
        self.lbl = Label('This show fps!', width=360, height=30,  margin='50px',)
        #将设置好的标签控件添加到APP 主框架中
        main_container.append(self.lbl)
		#main函数返回设置好的VBox主框架控件
        return main_container

#设置进度条为70%
droid.dialogSetCurrentProgress(100) 
#销毁对话框
droid.dialogDismiss()
#执行main函数
main()

main函数——通过摄像头识别人和其他物体，跟踪镜头前的人，使用gpu加速模式，通过usb控制小车前进，给不同的物体绘制不同颜色的矩形外框

def main():
    # Load TFLite model and allocate tensors.加载TFLite模型并分配张量
    # import tflite_runtime.interpreter as tflite

    #输入图像单位是字节，输入图像type: uint8[1,300,300,3]
    inShape =[1 * 300 * 300 *3,]
    #输出图像类型type: float32
    outShape= [1 * 10*4*4,1*10*4,1*10*4,1*4]
    #模型路径
    model_path="model_data/ssdlite_mobilenet_v3.tflite"
    #4表示4个线程，0表示gpu，-1表示cpu，1表示NNAPI
    print('gpu:',tflite.NNModel(model_path,inShape,outShape,4,0))
    
    #图片的尺寸大小，深度学习的图片尺寸不用那么大300*300就可以了
    #该模型输入的图片尺寸是300*300
    input_shape=[300,300]

    # label
    # 物体分类名称，存储在文本文件中，这里只用了高频使用的大约80种分类，可以扩展到1000多种
    class_names = read_classes('model_data/coco_classes.txt')
    # Generate colors for drawing bounding boxes.生成用于绘制边界框的颜色，不同的分类，颜色不同
    colors = generate_colors(class_names)
    
    #开始连接usb
    print("connecting to usb bot")
    #连接usb，返回串口硬件的值
    r=droid.connectUsb()
    print(r)
    print("sendIndicatorToVehicle: 0")
    #初始化轮子驱动指示器
    droid.sendIndicatorToVehicle(0)
    #设定轮子滚动速度范围是1-250,经过测试92比较适中
    speed=92;#range(1,250)
    #执行实时驱动小车的函数,传入参数是droid(安卓操作对象)，speed（小车速度），input_shape（输入图像数据）
    #color(物体的外框颜色)，class_names（物体分类名称）
    real_time_object_detection(droid,speed,input_shape, colors,class_names)

real_time_object_detection函数——实时跟踪物体，驱动小车

#实时驱动小车的函数,传入参数是droid(安卓操作对象)，speed（小车速度），input_shape（输入图像数据）
#color(物体的外框颜色)，class_names（物体分类名称）
def real_time_object_detection(droid,speed,input_shape, colors,class_names):
    #读取摄像头，0是后置摄像头，1是前置摄像头
    camera = cvs.VideoCapture(0)
    #初始化左轮子
    leftControl=0.0
    #初始化右轮子
    rightControl=0.0
    #初始化跟踪
    tracker = SimpleTracker(max_lost=3)  # Initialize tracker
    #阈值：判断物体
    threshold=0.6

    #初始化速度统计变量，每隔10帧统计下
    countInvoke = 0
    breakInvoke = 10
    arr_fps = []
    arr_time = []
    avg_fps = 0
    avg_time = 0

    #开始一直循环读取摄像头中的每一帧，直到程序退出
    while True:
        #开始时间
        start = time.time()
        #读取摄像头中的图像
        frame = cvs.read() 
        #判断摄像头是否读取到图像,如果有图像开始执行
        if frame is not None:
            # image_data = preprocess_image_for_tflite(frame, model_image_size=300)
            #预处理图像为uint8类型，大小300*300
            image_data = preprocess_image_for_tflite_uint8(frame, model_image_size=300)

            # print(image_data)
            #获得小车运行中的物体识别后的out_scores分数， out_boxes,外框，out_classes物体类别
            out_scores, out_boxes, out_classes = run_detection(input_shape,image_data)
            # print("out_boxes",out_boxes)
            # print("out_scores",out_scores)
            # print("out_classes",out_classes)
            #视频结束时间
            end = time.time()
            
            #out_boxes的左上角和右下角的坐标，out_classes[i] == 1要保证类别是1（person），out_scores[i] > threshold置信度大于阈值 out_boxes[i][3]-out_boxes[i][1]>0.1]右边框比左边框大一点
            #reshpe大意是说，数组新的 shape 属性应该要与原来的配套，如果等于 -1 的话，那么Numpy会根据剩下的维度计算出数组的另外一个 newshape 属性值。
            detections_bbox = np.array([[out_boxes[i][0], out_boxes[i][1], out_boxes[i][2], out_boxes[i][3]] for i in range(len(out_boxes)) if
                out_classes[i] == 1 and out_scores[i] > threshold and out_boxes[i][3]-out_boxes[i][1]>0.1]).reshape(-1, 4)
            
            #更新识别中物体
            objects = tracker.update(detections_bbox)
            #初始化左轮和右轮
            leftControl,rightControl=(0.0,0.0)
            
            #读取usb信息
            buf = droid.UsbRead()
            #buf: Result(id=831, result='["OK"]', error=None) frame(640, 480, 3) frame.shape w,h: 480 640
            #id=831是框的唯一值
            #frame(640, 480, 3)，是摄像头的像素是640*480,rgb3通道
            #w 480是视频的宽度，h 640是视频的高度
            print('buf:',buf,frame.shape)
            
            # print("objects:",objects)
            #w,h: 480 640，视频流的大小
            h,w,_ = frame.shape
            
            #应该是根据框来确定id,时间上连续的帧上检测框相近就认为是一个id,意思从不同的帧中检测到人，这个人的框就是这个id，就跟踪他前进
            #centroid是中心点坐标
            #ID 3 [570 360]
            #ID 3 [492 358]
            #ID 3 [434 358]
            #ID 3 [434 358]
            for (objectID, centroid) in objects.items():
                text = "ID {}".format(objectID)
                print(text,centroid)
                #cv.putText(img, text, org, fontFace,fontScale,color[, thickness[, lineType[, bottomLeftOrigin]]])
                #各参数依次是：图片，添加的文字，左上角坐标，字体，字体大小，颜色，字体粗细
                #在图框中心点偏移10像素位置添加文字
                cv2.putText(frame, text, (centroid[0] - 10, centroid[1] - 10), cv2.FONT_HERSHEY_SIMPLEX,

                #cv2.circle(img, center, radius, color[, thickness[, lineType[, shift]]])
                #各参数依次是：img：输入的图片，center：圆心位置，radius：圆的半径，color：圆的颜色，thickness：圆形轮廓的粗细（如果为正）。负厚度表示要绘制实心圆。lineType： 圆边界的类型。shift：中心坐标和半径值中的小数位数。
                #这里只用了前五项
                cv2.circle(frame, (centroid[0], centroid[1]), 4,  (0, 255, 0), -1)            
                
                # centerX=(left+right)/2
                #中心的X坐标
                centerX=centroid[0]
                
                #判断是驱动左轮还是右轮的参考值，w是图框的宽度，如果中心点靠镜头范围480像素的右侧，则驱动右轮，靠镜头范围的左侧则驱动左轮
                #乘以2是为了保证中心点在frame中右侧除以w的值大于1
                x_pos_norm = 1.0 - 2.0 * centerX / w;
                #大于0证明中心点在图框的右侧，驱动右轮，小于0证明中心点在frame的左侧，驱动左轮
                if x_pos_norm >0:
                    leftControl = 1.0
                    rightControl = 1.0 + x_pos_norm
                else :
                    leftControl = 1.0 - x_pos_norm
                    rightControl = 1.0
                #跳出循环    
                break;
            
            #Draw bounding boxes on the image file
            result = draw_boxes_and_turn(frame, out_scores, out_boxes, out_classes, class_names, colors)
            
            #发送驱动信号，驱动小车左右轮移动
            droid.sendControlToVehicle(int(leftControl*speed),int(rightControl*speed))
            

            # fps是测量用于保存、显示动态视频的信息数量，每秒钟帧数越多，所显示的动作就会越流畅。
            t = end - start
            fps  = "time: {:.2f}".format(t*1000)
            #cv.putText(img, text, org, fontFace,fontScale,color[, thickness[, lineType[, bottomLeftOrigin]]])
            #各参数依次是：图片，添加的文字，左上角坐标，字体，字体大小，颜色，字体粗细
            cv2.putText(frame, fps, (10, 30),
		                cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2, cv2.LINE_AA)
        
            lbs = 'Average FPS: '+ str(1 /t)
            #将结果赋值给cvs中的 全局变量
            cvs.setLbs(lbs)
            fpsNum = int(100/t)/100.
            fpsTime = t*1000
            arr_fps.append(fpsNum)
            arr_time.append(fpsTime)
            countInvoke=countInvoke+1
            #每个10帧统计下速度
            if countInvoke == breakInvoke:
                avg_fps=np.sum(arr_fps)/breakInvoke
                avg_time=np.sum(arr_time)/breakInvoke
                avg_str = 'avg_fps:'+str(avg_fps)+',avg_time'+str(avg_time)
                print(avg_str)
                arr_fps=[]
                arr_time=[]
                countInvoke = 0
            #将画好的框和名字显示出来
            cvs.imshow(frame)
            #当按‘q’时退出  
            # cv2.waitKey(20)表示当20ns内如果有按键则返回按键值的ascii，
            # 如果20ns内没有操作则返回-1。 ord(‘q’)返回‘q’的ascii（113） cv2.waitKey(20) & 0xFF， 
            # 与位运算，当按‘q’时返回ascii=113
            if cv2.waitKey(5) & 0xFF == ord('q'):
                break

run_detection函数——对摄像头中的物体进行分类

#开始识别跟踪的物体，输入数据大小数组和图像
def run_detection(input_shape,image):
    # Run model: start to detect
    # Sets the value of the input tensor.
    #分配内存，将图像处理为int8类型,input_shape[1]=300
    tflite.setTensor_Int8(image,input_shape[1],input_shape[1])
    # Invoke the interpreter.
    #开始执行
    tflite.invoke()
    
    # print(input_details.shape,output_details.shape)
    # get results
    #获得物体外部框
    boxes = tflite.getTensor_Fp32(0)
    #获得物体的类型
    classes = tflite.getTensor_Fp32(1)
    #获得物体的分数高于阈值0.6就是该物体
    scores = tflite.getTensor_Fp32(2)
    #获得物体的数量，这里未使用该变量
    num = tflite.getTensor_Fp32(3)
    
    #将数据转换为10*4大小的二维数组
    box=boxes.reshape((10,4))
    # print("boxes",box)
    # print("scores",scores)
    # print("classes",classes)
    # print("num",num)
    #从数组的形状中删除单维度条目，即把shape中为1的维度去掉，astype将classes转换为int32类型
    box, scores, classes = np.squeeze(box), np.squeeze(scores), np.squeeze(classes + 1).astype(np.int32)
    
    # print("boxes1",boxes)
    # print("scores1",scores)
    # print("classes1",classes)
    # print("num1",num)
    #删除掉那些与之前的选择的边框具有很高相识度的边框，只保留一个边框
    out_scores, out_boxes, out_classes = non_max_suppression(scores, box, classes)

    #返回out_scores物体的分数，out_boxes外框， out_classes物体类别        
    return out_scores, out_boxes, out_classes