The GUI interface of yolov3 (simple, image detection)

I'm using AB The great god darknet edition yolov3, The default environment here has been configured

When yoloGui After writing the document, I found yolov3 Self contained darknet_images.py The detection function in the file keeps reporting errors , Later, I found a big guy's modified code that can be tested in batches , A little modification found available , When using, you need to yolov3 Change the relevant files of to your own path

stay darknet New under folder detect.py file , Copy the following

import argparse
import os
import glob
import random
import darknet
import time
import cv2
import numpy as np




def parser():
    parser = argparse.ArgumentParser(description="YOLO Object Detection")
    parser.add_argument("--input", type=str, default="",
                        help="image source. It can be a single image, a"
                        "txt with paths to them, or a folder. Image valid"
                        " formats are jpg, jpeg or png."
                        "If no input is given, ")
    parser.add_argument("--batch_size", default=1, type=int,
                        help="number of images to be processed at the same time")
    parser.add_argument("--weights", default="myData/backup/my_yolov3_last.weights",# Change to your own path 
                        help="yolo weights path")
    parser.add_argument("--dont_show", action='store_true',
                        help="windown inference display. For headless systems")
    parser.add_argument("--ext_output", action='store_true',
                        help="display bbox coordinates of detected objects")
    parser.add_argument("--save_labels", action='store_true',
                        help="save detections bbox for each image in yolo format")
    parser.add_argument("--config_file", default="./cfg/my_yolov3.cfg",
                        help="path to config file")
    parser.add_argument("--data_file", default="./cfg/my_data.data",
                        help="path to data file")
    parser.add_argument("--thresh", type=float, default=.25,
                        help="remove detections with lower confidence")
    return parser.parse_args()

def check_arguments_errors(args):
    assert 0 < args.thresh < 1, "Threshold should be a float between zero and one (non-inclusive)"
    if not os.path.exists(args.config_file):
        raise(ValueError("Invalid config path {}".format(os.path.abspath(args.config_file))))
    if not os.path.exists(args.weights):
        raise(ValueError("Invalid weight path {}".format(os.path.abspath(args.weights))))
    if not os.path.exists(args.data_file):
        raise(ValueError("Invalid data file path {}".format(os.path.abspath(args.data_file))))
    if args.input and not os.path.exists(args.input):
        raise(ValueError("Invalid image path {}".format(os.path.abspath(args.input))))


def check_batch_shape(images, batch_size):
    """
        Image sizes should be the same width and height
    """
    shapes = [image.shape for image in images]
    if len(set(shapes)) > 1:
        raise ValueError("Images don't have same shape")
    if len(shapes) > batch_size:
        raise ValueError("Batch size higher than number of images")
    return shapes[0]


def load_images(images_path):
    """
    If image path is given, return it directly
    For txt file, read it and return each line as image path
    In other case, it's a folder, return a list with names of each
    jpg, jpeg and png file
    """
    input_path_extension = images_path.split('.')[-1]
    if input_path_extension in ['jpg', 'jpeg', 'png']:
        return [images_path]
    elif input_path_extension == "txt":
        with open(images_path, "r") as f:
            return f.read().splitlines()
    else:
        return glob.glob(
            os.path.join(images_path, "*.jpg")) + \
            glob.glob(os.path.join(images_path, "*.png")) + \
            glob.glob(os.path.join(images_path, "*.jpeg"))


def prepare_batch(images, network, channels=3):
    width = darknet.network_width(network)
    height = darknet.network_height(network)

    darknet_images = []
    for image in images:
        image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
        image_resized = cv2.resize(image_rgb, (width, height),
                                   interpolation=cv2.INTER_LINEAR)
        custom_image = image_resized.transpose(2, 0, 1)
        darknet_images.append(custom_image)

    batch_array = np.concatenate(darknet_images, axis=0)
    batch_array = np.ascontiguousarray(batch_array.flat, dtype=np.float32)/255.0
    darknet_images = batch_array.ctypes.data_as(darknet.POINTER(darknet.c_float))
    return darknet.IMAGE(width, height, channels, darknet_images)


def image_detection(image_path,network, class_names, class_colors, thresh):
    # Darknet doesn't accept numpy images.
    # Create one with image we reuse for each detect
    width = darknet.network_width(network)
    height = darknet.network_height(network)
    darknet_image = darknet.make_image(width, height, 3)
   
    image = cv2.imread(image_path)
    image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
    image_resized = cv2.resize(image_rgb, (width, height),
                               interpolation=cv2.INTER_LINEAR)

    darknet.copy_image_from_bytes(darknet_image, image_resized.tobytes())
    detections = darknet.detect_image(network, class_names, darknet_image, thresh=thresh)
    darknet.free_image(darknet_image)
    image = darknet.draw_boxes(detections, image_resized, class_colors)
    #return cv2.cvtColor(image, cv2.COLOR_BGR2RGB), detections# Use this line when batch testing is required 
    return cv2.cvtColor(image, cv2.COLOR_BGR2RGB)# When using yoloGui Use this line when 


def batch_detection(network, images, class_names, class_colors,
                    thresh=0.25, hier_thresh=.5, nms=.45, batch_size=4):
    image_height, image_width, _ = check_batch_shape(images, batch_size)
    darknet_images = prepare_batch(images, network)
    batch_detections = darknet.network_predict_batch(network, darknet_images, batch_size, image_width,
                                                     image_height, thresh, hier_thresh, None, 0, 0)
    batch_predictions = []
    for idx in range(batch_size):
        num = batch_detections[idx].num
        detections = batch_detections[idx].dets
        if nms:
            darknet.do_nms_obj(detections, num, len(class_names), nms)
        predictions = darknet.remove_negatives(detections, class_names, num)
        images[idx] = darknet.draw_boxes(predictions, images[idx], class_colors)
        batch_predictions.append(predictions)
    darknet.free_batch_detections(batch_detections, batch_size)
    return images, batch_predictions


def image_classification(image, network, class_names):
    width = darknet.network_width(network)
    height = darknet.network_height(network)
    image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
    image_resized = cv2.resize(image_rgb, (width, height),
                                interpolation=cv2.INTER_LINEAR)
    darknet_image = darknet.make_image(width, height, 3)
    darknet.copy_image_from_bytes(darknet_image, image_resized.tobytes())
    detections = darknet.predict_image(network, darknet_image)
    predictions = [(name, detections[idx]) for idx, name in enumerate(class_names)]
    darknet.free_image(darknet_image)
    return sorted(predictions, key=lambda x: -x[1])


def convert2relative(image, bbox):
    """
    YOLO format use relative coordinates for annotation
    """
    x, y, w, h = bbox
    height, width, _ = image.shape
    return x/width, y/height, w/width, h/height


def save_annotations(name, image, detections, class_names):
    """
    Files saved with image_name.txt and relative coordinates
    """
    file_name = name.split(".")[:-1][0] + ".txt"
    with open(file_name, "w") as f:
        for label, confidence, bbox in detections:
            x, y, w, h = convert2relative(image, bbox)
            label = class_names.index(label)
            f.write("{} {:.4f} {:.4f} {:.4f} {:.4f}\n".format(label, x, y, w, h))


def batch_detection_example():
    args = parser()
    check_arguments_errors(args)
    batch_size = 3
    random.seed(3)  # deterministic bbox colors
    network, class_names, class_colors = darknet.load_network(
        args.config_file,
        args.data_file,
        args.weights,
        batch_size=batch_size
    )
    image_names = ['data/horses.jpg', 'data/horses.jpg', 'data/eagle.jpg']
    images = [cv2.imread(image) for image in image_names]
    images, detections,  = batch_detection(network, images, class_names,
                                           class_colors, batch_size=batch_size)
    for name, image in zip(image_names, images):
        cv2.imwrite(name.replace("data/", ""), image)
    print(detections)

def get_files(dir, suffix): 

    res = []

    for root, directory, files in os.walk(dir): 

        for filename in files:

            name, suf = os.path.splitext(filename) 

            if suf == suffix:

                #res.append(filename)

                res.append(os.path.join(root, filename))
    return res
def bbox2points_zs(bbox):
    """
    From bounding box yolo format
    to corner points cv2 rectangle
    """
    x, y, w, h = bbox
    xmin = int(round(x - (w / 2)))
    xmax = int(round(x + (w / 2)))
    ymin = int(round(y - (h / 2)))
    ymax = int(round(y + (h / 2)))
    return xmin, ymin, xmax, ymax

def main():
    args = parser()
    check_arguments_errors(args)
   
    input_dir = '/home/your/darknet'
    config_file = '/home/your/darknet/cfg/my_yolov3.cfg'
    data_file = '/home/your/darknet/cfg/my_data.data'
    weights = '/home/your/darknet/myData/backup/my_yolov3_last.weights'# Change to your own path 
    random.seed(3)  # deterministic bbox colors
    network, class_names, class_colors = darknet.load_network(
        config_file,
        data_file,
        weights,
        batch_size=args.batch_size
    )
    src_width = darknet.network_width(network)
    src_height = darknet.network_height(network)

    # Generate a folder to save the path of pictures 
    save_dir = os.path.join(input_dir, 'object_result')
    #  Remove the first space 
    save_dir=save_dir.strip()
    #  Remove the tail  \  Symbol 
    save_dir=save_dir.rstrip("\\")
    #  Determine if the path exists  #  There is      True #  non-existent    False
    isExists=os.path.exists(save_dir)
    #  Judge the result 
    if not isExists:
        #  Create a directory if it doesn't exist  #  Create directory manipulation functions 
        os.makedirs(save_dir) 

        print(save_dir+'  Create success ')
    else:
        #  If directory exists   Do not create , And prompt that the directory already exists 
        print(save_dir + '  directory already exists ')

    image_list = get_files(input_dir, '.jpg')
    total_len = len(image_list)
    index = 0
    #while True:
    for i in range(0, total_len):
        image_name = image_list[i]
        src_image = cv2.imread(image_name)
        cv2.imshow('src_image', src_image)
        cv2.waitKey(1)

        prev_time = time.time()
        image, detections = image_detection(
            image_name, network, class_names, class_colors, args.thresh)
        #'''
        file_name, type_name = os.path.splitext(image_name)
        #print(file_name)
        #print(file_name.split(r'/'))
        print(''.join(file_name.split(r'/')[-1]) + 'bbbbbbbbb')
        cut_image_name_list = file_name.split(r'/')[-1:] #cut_image_name_list is list
        save_dir_image = os.path.join(save_dir ,cut_image_name_list[0])
        if not os.path.exists(save_dir_image):
            os.makedirs(save_dir_image)
        cut_image_name = ''.join(cut_image_name_list) #list to str
        object_count = 0
        
        
        for label, confidence, bbox in detections:
            cut_image_name_temp = cut_image_name + "_{}.jpg".format(object_count)
            object_count += 1
            xmin, ymin, xmax, ymax = bbox2points_zs(bbox)
            print("aaaaaaaaa x,{} y,{} w,{} h{}".format(xmin, ymin, xmax, ymax))
            xmin_coordinary = (int)(xmin * src_image.shape[1] / src_width-0.5)
            ymin_coordinary = (int)(ymin * src_image.shape[0] / src_height-0.5)
            xmax_coordinary = (int)(xmax * src_image.shape[1] / src_width+0.5)
            ymax_coordinary = (int)(ymax * src_image.shape[0] / src_height+0.5)
            if xmin_coordinary>src_image.shape[1]:
                xmin_coordinary = src_image.shape[1]
            if ymin_coordinary>src_image.shape[0]:
                ymin_coordinary = src_image.shape[0]
            if xmax_coordinary>src_image.shape[1]:
                xmax_coordinary = src_image.shape[1]
            if ymax_coordinary>src_image.shape[0]:
                ymax_coordinary = src_image.shape[0]

            if xmin_coordinary < 0:
                xmin_coordinary = 0
            if ymin_coordinary < 0:
                ymin_coordinary = 0
            if xmax_coordinary < 0:
                xmax_coordinary = 0
            if ymax_coordinary < 0:
                ymax_coordinary = 0 

            print("qqqqqqqq   x,{} y,{} w,{} h{}".format(xmin_coordinary, ymin_coordinary, xmax_coordinary, ymax_coordinary))
            out_iou_img = np.full((ymax_coordinary - ymin_coordinary, xmax_coordinary - xmin_coordinary, src_image.shape[2]), 114, dtype=np.uint8)
            out_iou_img[:,:] = src_image[ymin_coordinary:ymax_coordinary,xmin_coordinary:xmax_coordinary]
            cv2.imwrite(os.path.join(save_dir_image,cut_image_name_temp),out_iou_img)
        #'''
        #if args.save_labels:
        #if True:
            #save_annotations(image_name, image, detections, class_names)
        darknet.print_detections(detections, args.ext_output)
        fps = int(1/(time.time() - prev_time))
        print("FPS: {}".format(fps))
        if not args.dont_show:
            #cv2.imshow('Inference', image)
            cv2.waitKey(1)
            #if cv2.waitKey() & 0xFF == ord('q'):
                #break
        index += 1

if __name__ == "__main__":
    # unconmment next line for an example of batch processing
    # batch_detection_example()
    main()

Next is yoloGui.py file , This document also refers to a big man , Then slightly modify , I can't find the specific blog , Thank you for this big guy , Before running, you must create it in the current directory img Folder , And put the pictures that need to be detected into img Folder , At the same time img Create in folder result Folder , Used to save test results . This file only supports image detection , If video stream detection is required , Can be modified by yourself . In the process of running, I found that I can only run 4-5 This will explode , It should be possible to load the weight file statically and globally , Welcome to correct .

It should be noted that each path is correct , Include cfg Documents, etc.

stay darknet New under folder yoloGui.py file , Copy the following

import cv2
import numpy as np
from PyQt5.QtWidgets import *
from PyQt5.QtGui import QIcon, QPixmap, QImage
import os
import sys
import detect
from PIL import Image
import darknet
import random
import string

crop = False
count = False


class MyClassImage(QWidget):
    def __init__(self):
        super().__init__()
        self.label2 = None
        self.label3 = None
        self.initUI()   #  Initialize the interface and display 
        self.openfile_name_image = ''   #  Choose the path of the file 
        self.image = None

    #  Define initialization components 
    def initUI(self):
        #  Set window size 
        self.resize(850, 400)
        #  Set window name 
        self.setWindowTitle(" Test pictures ")
        #  Create button 
        btn5 = QPushButton(" Exit detection picture ", self)
        btn5.clicked.connect(self.close)
        btn1 = QPushButton(" Select the detection picture ", self)

        #  Key click events , Click stop vomiting to start self.select_image function 
        btn1.clicked.connect(self.select_image)
        btn2 = QPushButton(" Start detection ", self)

        #  Key click events , Click stop vomiting to start self.detect function 
        btn2.clicked.connect(self.detect)

        #  Create a label , You can put text or pictures or empty 
        self.label2 = QLabel("", self)
        self.label2.resize(400, 300)
        self.label3 = QLabel("", self)
        self.label3.resize(400, 300)
        label4 = QLabel("               Original picture ", self)
        label5 = QLabel("               Test pictures ", self)
        #  Define grid layout 
        grid1 = QGridLayout()
        grid1.addWidget(label4, 0, 0)
        #  Grid layout   The first row and the second column prevent label5
        grid1.addWidget(label5, 0, 1)

        hlo = QHBoxLayout()
        hlo.addStretch()
        grid = QGridLayout()
        # vlo.addStretch(0)
        grid.addWidget(btn1, 0, 0)
        grid.addWidget(btn2, 0, 1)
        grid.addWidget(btn5, 0, 2)

        hlo1 = QHBoxLayout()
        hlo1.addWidget(self.label2)
        hlo1.addWidget(self.label3)

        vlo = QVBoxLayout(self)
        vlo.addLayout(grid)
        vlo.addLayout(hlo1)
        vlo.addStretch(1)
        vlo.addLayout(grid1)
        vlo.addStretch(0)
        self.show()

    def closeEvent(self, event):
        result = QMessageBox.question(self, " Tips ：", " Do you really want to exit the program ",
                                      QMessageBox.Yes | QMessageBox.No, QMessageBox.Yes)
        if result == QMessageBox.Yes:
            event.accept()
        else:
            event.ignore()

    def detect(self):
        if self.image is None:
            print(' No pictures ')
        elif self.image is not None:
            #  Test pictures 
            run_detect(self.openfile_name_image)
            #  Read the pictures after detection 
            img = cv2.imread('img/result/'+self.openfile_name_image.split('/')[-1])
            img = cv2.resize(img, (400, 300), interpolation=cv2.INTER_AREA)
            img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
            # cv2.imshow('test', img)
            # cv2.waitKey(20)
            #  Put the picture on the label self.label3 in 
            a = QImage(img.data, img.shape[1], img.shape[0], img.shape[1] * 3, QImage.Format_RGB888)
            self.label3.setPixmap(QPixmap.fromImage(a))
        pass

    def select_image(self):
        # temp Select the path of the file for    What opens here is this main.py Function under the same level directory img Folder 
        temp, _ = QFileDialog.getOpenFileName(self, " Select photo file ", r"./img/")
        if temp is not None:
            self.openfile_name_image = temp
        #      Read the selected picture 
        self.image = cv2.imread(self.openfile_name_image)
        # print(self.openfile_name_image)
        #  Put the pictures in the path after reading them self.label2
        self.label2.setPixmap(QPixmap(str(self.openfile_name_image)))
        self.label2.setScaledContents(True)
        #  Read shrink to (400, 300)
        self.label2.setMaximumSize(400, 300)
        self.label2.setScaledContents(True)


#  Rewrite this function 
def run_detect(path):
    try:
        image = Image.open(path)
    except:
        print('Open Error! Try again!')
    else:
    ## Here is the model checking function , Replace it with your own , This function returns the detected image , Then save it in the local peer directory img/result
        args = detect.parser()
        detect.check_arguments_errors(args)
        
        random.seed(3)  # deterministic bbox colors
        network, class_names, class_colors = darknet.load_network(
        args.config_file,
        args.data_file,
        args.weights,
        batch_size=args.batch_size
    )
        img_path = path
        r_image = detect.image_detection(img_path,network, class_names, class_colors, args.thresh)
        #r_image.save('img/result/' + path.split('/')[-1])# Have I reported here save The fault of this module , So it was changed to imwrite
        cv2.imwrite('img/result/' + path.split('/')[-1],r_image)


if __name__ == '__main__':
    app = QApplication(sys.argv)
    mc = MyClassImage()
    sys.exit(app.exec_())

Here is a screenshot of the run ：

  This is just a simple interface programming , I'm also in the beginner's stage , If there is better follow-up idea I will also share with you , If there is something wrong or imperfect, you are also welcome to criticize and correct . The interface will be beautified later , Then add some functions , Will find a way to solve out of memory The problem of

Beautify the interface , New output items label and number function yolov3 Of Gui Interface （2）-- Beautify the page + Output the name and quantity of the identified object _perfectdisaster The blog of -CSDN Blog

solve out of memory problem , New camera detection function

yolov3 Of GUI Interface （3）-- solve out of memory problem , New camera detection function