Python+YOLO4+ZED相机实时检测

小咪咪 2023-03-01 12:57 138阅读 0赞

### 文章目录 ###

*  YOLO4+ZED相机实时检测
 *   *  系统环境
     *  环境配置
     *  代码
     *  运行图

# YOLO4+ZED相机实时检测 #

## 系统环境 ##

WIN10+Python+pycharm+pytorch+yolo4

## 环境配置 ##

见博客的YOLO4配置和ZED相机配置

## 代码 ##

- [ ] # -*- coding: utf-8 -*-
    ''' @Time : 20/04/25 15:49 @Author : huguanghao @File : demo.py @Noice : @Modificattion : @Author : @Time : @Detail : '''
    
    # import sys
    # import time
    # from PIL import Image, ImageDraw
    # from models.tiny_yolo import TinyYoloNet
    from tool.utils import *
    from tool.torch_utils import *
    from tool.darknet2pytorch import Darknet
    import argparse
    
    """hyper parameters"""
    use_cuda = True
    
    def detect_cv2(cfgfile, weightfile, imgfile):
        import cv2
        m = Darknet(cfgfile)
    
        m.print_network()
        m.load_weights(weightfile)
        print('Loading weights from %s... Done!' % (weightfile))
    
        if use_cuda:
            m.cuda()
    
        num_classes = m.num_classes
        if num_classes == 20:
            namesfile = 'data/voc.names'
        elif num_classes == 80:
            namesfile = 'data/coco.names'
        else:
            namesfile = 'data/x.names'
        class_names = load_class_names(namesfile)
    
        img = cv2.imread(imgfile)
        print(m.width,m.height)
        sized = cv2.resize(img, (m.width, m.height))
        sized = cv2.cvtColor(sized, cv2.COLOR_BGR2RGB)
    
        for i in range(2):
            start = time.time()
            boxes = do_detect(m, sized, 0.4, 0.6, use_cuda)
            finish = time.time()
            if i == 1:
                print('%s: Predicted in %f seconds.' % (imgfile, (finish - start)))
    
        plot_boxes_cv2(img, boxes[0], savename='predictions.jpg', class_names=class_names)
    
    
    def detect_cv2_camera(cfgfile, weightfile):
        import cv2
        """————————————————(2020/7/26)——————————————————"""
        import cv2
        import pyzed.sl as sl
    
        camera_settings = sl.VIDEO_SETTINGS.BRIGHTNESS
        str_camera_settings = "BRIGHTNESS"
        step_camera_settings = 1
        init = sl.InitParameters()
        cam = sl.Camera()
        if not cam.is_opened():
            print("Opening ZED Camera...")
        status = cam.open(init)
        if status != sl.ERROR_CODE.SUCCESS:
            print(repr(status))
            exit()
    
        runtime = sl.RuntimeParameters()
        mat = sl.Mat()
    
        print_camera_information(cam)
        print_help()
        key = ''
    
    
        """————————————————(2020/7/26)——————————————————"""
        m = Darknet(cfgfile)
    
        m.print_network()
        m.load_weights(weightfile)
        print('Loading weights from %s... Done!' % (weightfile))
    
        if use_cuda:
            m.cuda()
    
        cap = cv2.VideoCapture(0)
        # cap = cv2.VideoCapture("./test.mp4")
        cap.set(3, 1280)
        cap.set(4, 720)
        print("Starting the YOLO loop...")
    
        num_classes = m.num_classes
        if num_classes == 20:
            namesfile = 'data/voc.names'
        elif num_classes == 80:
            namesfile = 'data/coco.names'
        else:
            namesfile = 'data/x.names'
        class_names = load_class_names(namesfile)
    
        while True:
            """————————————————(2020/7/26)——————————————————"""
            err = cam.grab(runtime)
            if err == sl.ERROR_CODE.SUCCESS:
                cam.retrieve_image(mat, sl.VIEW.LEFT)
                img = mat.get_data()
    
            settings(key, cam, runtime, mat)
            """————————————————(2020/7/26)——————————————————"""
            # ret, img = cap.read()
            sized = cv2.resize(img, (m.width, m.height))
            sized = cv2.cvtColor(sized, cv2.COLOR_BGR2RGB)
    
            start = time.time()
            boxes = do_detect(m, sized, 0.4, 0.6, use_cuda)
            finish = time.time()
            print('Predicted in %f seconds.' % (finish - start))
    
            result_img = plot_boxes_cv2(img, boxes[0], savename=None, class_names=class_names)
    
            cv2.imshow('Yolo demo', result_img)
            cv2.waitKey(1)
    
        cap.release()
    
    
    def detect_skimage(cfgfile, weightfile, imgfile):
        from skimage import io
        from skimage.transform import resize
        m = Darknet(cfgfile)
    
        m.print_network()
        m.load_weights(weightfile)
        print('Loading weights from %s... Done!' % (weightfile))
    
        if use_cuda:
            m.cuda()
    
        num_classes = m.num_classes
        if num_classes == 20:
            namesfile = 'data/voc.names'
        elif num_classes == 80:
            namesfile = 'data/coco.names'
        else:
            namesfile = 'data/x.names'
        class_names = load_class_names(namesfile)
    
        img = io.imread(imgfile)
        sized = resize(img, (m.width, m.height)) * 255
    
        for i in range(2):
            start = time.time()
            boxes = do_detect(m, sized, 0.4, 0.4, use_cuda)
            finish = time.time()
            if i == 1:
                print('%s: Predicted in %f seconds.' % (imgfile, (finish - start)))
    
        plot_boxes_cv2(img, boxes, savename='predictions.jpg', class_names=class_names)
    
    
    def get_args():
        parser = argparse.ArgumentParser('Test your image or video by trained model.')
        parser.add_argument('-cfgfile', type=str, default='./cfg/yolov4.cfg',
                            help='path of cfg file', dest='cfgfile')
        """————————————————(2020/7/24)——————————————————"""
        # parser.add_argument('-weightfile', type=str,
        # default='./checkpoints/Yolov4_epoch1.pth',
        # help='path of trained model.', dest='weightfile')
        parser.add_argument('-weightfile', type=str,
                            default='./weight/yolov4.weights',
                            help='path of trained model.', dest='weightfile')
        """————————————————(2020/7/24)——————————————————"""
        parser.add_argument('-imgfile', type=str,
                            default='C:/Users/14624/Downloads/cocodata/train2017/000000000138.jpg',
                            help='path of your image file.', dest='imgfile')
        args = parser.parse_args()
    
        return args
    
    # ZED相机
    """————————————————(2020/7/26)——————————————————"""
    ########################################################################
    #
    # Copyright (c) 2020, STEREOLABS.
    #
    # All rights reserved.
    #
    # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
    # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
    # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
    # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
    # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
    # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
    # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
    # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
    # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
    # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
    # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    #
    ########################################################################
    
    """ Live camera sample showing the camera information and video in real time and allows to control the different settings. """
    
    
    
    
    def print_camera_information(cam):
        print("Resolution: {0}, {1}.".format(round(cam.get_camera_information().camera_resolution.width, 2), cam.get_camera_information().camera_resolution.height))
        print("Camera FPS: {0}.".format(cam.get_camera_information().camera_fps))
        print("Firmware: {0}.".format(cam.get_camera_information().camera_firmware_version))
        print("Serial number: {0}.\n".format(cam.get_camera_information().serial_number))
    
    
    def print_help():
        print("Help for camera setting controls")
        print(" Increase camera settings value: +")
        print(" Decrease camera settings value: -")
        print(" Switch camera settings: s")
        print(" Reset all parameters: r")
        print(" Record a video: z")
        print(" Quit: q\n")
    
    
    def settings(key, cam, runtime, mat):
        if key == 115:  # for 's' key
            switch_camera_settings()
        elif key == 43:  # for '+' key
            current_value = cam.get_camera_settings(camera_settings)
            cam.set_camera_settings(camera_settings, current_value + step_camera_settings)
            print(str_camera_settings + ": " + str(current_value + step_camera_settings))
        elif key == 45:  # for '-' key
            current_value = cam.get_camera_settings(camera_settings)
            if current_value >= 1:
                cam.set_camera_settings(camera_settings, current_value - step_camera_settings)
                print(str_camera_settings + ": " + str(current_value - step_camera_settings))
        elif key == 114:  # for 'r' key
            cam.set_camera_settings(sl.VIDEO_SETTINGS.BRIGHTNESS, -1)
            cam.set_camera_settings(sl.VIDEO_SETTINGS.CONTRAST, -1)
            cam.set_camera_settings(sl.VIDEO_SETTINGS.HUE, -1)
            cam.set_camera_settings(sl.VIDEO_SETTINGS.SATURATION, -1)
            cam.set_camera_settings(sl.VIDEO_SETTINGS.SHARPNESS, -1)
            cam.set_camera_settings(sl.VIDEO_SETTINGS.GAIN, -1)
            cam.set_camera_settings(sl.VIDEO_SETTINGS.EXPOSURE, -1)
            cam.set_camera_settings(sl.VIDEO_SETTINGS.WHITEBALANCE_TEMPERATURE, -1)
            print("Camera settings: reset")
        elif key == 122:  # for 'z' key
            record(cam, runtime, mat)
    
    
    def switch_camera_settings():
        global camera_settings
        global str_camera_settings
        if camera_settings == sl.VIDEO_SETTINGS.BRIGHTNESS:
            camera_settings = sl.VIDEO_SETTINGS.CONTRAST
            str_camera_settings = "Contrast"
            print("Camera settings: CONTRAST")
        elif camera_settings == sl.VIDEO_SETTINGS.CONTRAST:
            camera_settings = sl.VIDEO_SETTINGS.HUE
            str_camera_settings = "Hue"
            print("Camera settings: HUE")
        elif camera_settings == sl.VIDEO_SETTINGS.HUE:
            camera_settings = sl.VIDEO_SETTINGS.SATURATION
            str_camera_settings = "Saturation"
            print("Camera settings: SATURATION")
        elif camera_settings == sl.VIDEO_SETTINGS.SATURATION:
            camera_settings = sl.VIDEO_SETTINGS.SHARPNESS
            str_camera_settings = "Sharpness"
            print("Camera settings: Sharpness")
        elif camera_settings == sl.VIDEO_SETTINGS.SHARPNESS:
            camera_settings = sl.VIDEO_SETTINGS.GAIN
            str_camera_settings = "Gain"
            print("Camera settings: GAIN")
        elif camera_settings == sl.VIDEO_SETTINGS.GAIN:
            camera_settings = sl.VIDEO_SETTINGS.EXPOSURE
            str_camera_settings = "Exposure"
            print("Camera settings: EXPOSURE")
        elif camera_settings == sl.VIDEO_SETTINGS.EXPOSURE:
            camera_settings = sl.VIDEO_SETTINGS.WHITEBALANCE_TEMPERATURE
            str_camera_settings = "White Balance"
            print("Camera settings: WHITEBALANCE")
        elif camera_settings == sl.VIDEO_SETTINGS.WHITEBALANCE_TEMPERATURE:
            camera_settings = sl.VIDEO_SETTINGS.BRIGHTNESS
            str_camera_settings = "Brightness"
            print("Camera settings: BRIGHTNESS")
    
    
    def record(cam, runtime, mat):
        vid = sl.ERROR_CODE.FAILURE
        out = False
        while vid != sl.ERROR_CODE.SUCCESS and not out:
            filepath = input("Enter filepath name: ")
            record_param = sl.RecordingParameters(filepath)
            vid = cam.enable_recording(record_param)
            print(repr(vid))
            if vid == sl.ERROR_CODE.SUCCESS:
                print("Recording started...")
                out = True
                print("Hit spacebar to stop recording: ")
                key = False
                while key != 32:  # for spacebar
                    err = cam.grab(runtime)
                    if err == sl.ERROR_CODE.SUCCESS:
                        cam.retrieve_image(mat)
                        cv2.imshow("ZED", mat.get_data())
                        key = cv2.waitKey(5)
            else:
                print("Help: you must enter the filepath + filename + SVO extension.")
                print("Recording not started.")
        cam.disable_recording()
        print("Recording finished.")
        cv2.destroyAllWindows()
    
    """————————————————(2020/7/26)——————————————————"""
    
    if __name__ == '__main__':
        args = get_args()
        args.imgfile = False
        if args.imgfile:
            detect_cv2(args.cfgfile, args.weightfile, args.imgfile)
            # detect_imges(args.cfgfile, args.weightfile)
            # detect_cv2(args.cfgfile, args.weightfile, args.imgfile)
            # detect_skimage(args.cfgfile, args.weightfile, args.imgfile)
        else:
            detect_cv2_camera(args.cfgfile, args.weightfile)

## 运行图 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NjeTI2MTk4MzYyNg_size_16_color_FFFFFF_t_70]

不得不说YOLO4真的很牛逼，在gtx1070下都能跑出实时的效果

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NjeTI2MTk4MzYyNg_size_16_color_FFFFFF_t_70]: /images/20230208/d7c8bab3f72543ac87293223452ddb67.png