基于opencv与yolo的目标识别案例

# import the necessary packages
import numpy as np
import argparse
import time
import cv2
import os
 
# construct the argument parse and parse the arguments
ap = argparse.ArgumentParser（）
ap.add_argument（“-i“ “--image“ required=True
    help=“path to input image“）
ap.add_argument（“-y“ “--yolo“ required=True
    help=“base path to YOLO directory“）
ap.add_argument（“-c“ “--confidence“ type=float default=0.5
    help=“minimum probability to filter weak detections“）
ap.add_argument（“-t“ “--threshold“ type=float default=0.3
    help=“threshold when applying non-maxima suppression“）
args = vars（ap.parse_args（））

# load the COCO class labels our YOLO model was trained on
labelsPath = os.path.sep.join（[args[“yolo“] “coco.names“]）
LABELS = open（labelsPath）.read（）.strip（）.split（“
“）
 
# initialize a list of colors to represent each possible class label
np.random.seed（42）
COLORS = np.random.randint（0 255 size=（len（LABELS） 3）
    dtype=“uint8“）

# derive the paths to the YOLO weights and model configuration
weightsPath = os.path.sep.join（[args[“yolo“] “yolov3.weights“]）
configPath = os.path.sep.join（[args[“yolo“] “yolov3.cfg“]）
 
# load our YOLO object detector trained on COCO dataset （80 classes）
print（“[INFO] loading YOLO from disk...“）
net = cv2.dnn.readNetFromDarknet（configPath weightsPath）

# load our input image and grab its spatial dimensions
image = cv2.imread（args[“image“]）
（H W） = image.shape[:2]
 
# determine only the *output* layer names that we need from YOLO
ln = net.getlayerNames（）
ln = [ln[i[0] - 1] for i in net.getUnconnectedOutlayers（）]
 
# construct a blob from the input image and then perform a forward
# pass of the YOLO object detector giving us our bounding boxes and
# associated probabilities
blob = cv2.dnn.blobFromImage（image 1 / 255.0 （416 416）
    swapRB=True crop=False）
net.setInput（blob）
start = time.time（）
layerOutputs = net.forward（ln）
end = time.time（）
 
# show timing information on YOLO
print（“[INFO] YOLO took {:.6f} seconds“.format（end - start））

# initialize our lists of detected bounding boxes confidences and
# class IDs respectively
boxes = []
confidences = []
classIDs = []

# loop over each of the layer outputs
for output in layerOutputs:
    # loop over each of the detections
    for detection in output:
        # extract the class ID and confidence （i.e. probability） of
        # the current object detection
        scores = detection[5:]
        classID = np.argmax（scores）
        confidence = scores[classID]
 
        # filter out weak predictions by ensuring the detected
        # probability is greater than the minimum probability
        if confidence > args[“confidence“]:
            # scale the bounding box coordinates back relative to the
            # size of the image keeping in mind that YOLO actually
            # returns the center （x y）-coordinates of the bounding
            # box followed by