Shulou(Shulou.com)06/02 Report--

Editor to share with you how the Python+OpenCV built-in method to achieve pedestrian detection, I believe that most people do not know much about it, so share this article for your reference, I hope you can learn a lot after reading this article, let's go to know it!

Did you know that OpenCV has a built-in way to perform pedestrian detection?

OpenCV comes with a pre-trained HOG + linear SVM model that can be used to perform pedestrian detection in image and video streams.

Today, we use the model that comes with Opencv to detect pedestrians in video streams by opening a new file, naming it detect.py, and adding code:

# import the necessary packagesfrom _ _ future__ import print_functionimport numpy as npimport argparseimport cv2import os

Import the required packages, and then define the methods required by the project.

Def nms (boxes, probs=None, overlapThresh=0.3): # if there are no boxes, return an empty list if len (boxes) = = 0: return [] # if the bounding boxes are integers, convert them to floats-- this # is important since we'll be doing a bunch of divisions if boxes.dtype.kind = = "I": boxes = boxes.astype ("float") # initialize the list of picked indexes pick = [] # grab the coordinates of the bounding boxes x1 = boxes [: 0] Y1 = boxes [:, 1] x2 = boxes [:, 2] y2 = boxes [:, 3] # compute the area of the bounding boxes and grab the indexes to sort # (in the case that no probabilities are provided, simply sort on the # bottom-left y-coordinate) area = (x2-x1 + 1) * (y2-y1 + 1) idxs = y2 # if probabilities are provided Sort on them instead if probs is not None: idxs = probs # sort the indexes idxs = np.argsort (idxs) # keep looping while some indexes still remain in the indexes list while len (idxs) > 0: # grab the last index in the indexes list and add the index value # to the list of picked indexes last = len (idxs)-1 I = idxs [last] pick.append (I) # find the largest (x Y) coordinates for the start of the bounding # box and the smallest (x, y) coordinates for the end of the bounding # box xx1 = np.maximum (x1 [I], x1 [idxs [: last]]) yy1 = np.maximum (y1 [I], y1 [idxs [: last]]) xx2 = np.minimum (x2 [I], x2 [idxs [: last]]) yy2 = np.minimum (y2 [I] Y2 [idxs [: last]]) # compute the width and height of the bounding box w = np.maximum (0, xx2-xx1 + 1) h = np.maximum (0, yy2-yy1 + 1) # compute the ratio of overlap overlap = (w * h) / area [idxs [: last]] # delete all indexes from the index list that have overlap greater # than the provided overlap threshold idxs = np.delete (idxs Np.concatenate (([last], np.where (overlap > overlapThresh) [0])) # return only the bounding boxes that were picked return boxespick] .astype ("int") image_types = (".jpg", ".jpeg", ".png", ".bmp", ".tif", ".tiff") def list_images (basePath) Contains=None): # return the set of files that are valid return list_files (basePath, validExts=image_types, contains=contains) def list_files (basePath, validExts=None, contains=None): # loop over the directory structure for (rootDir, dirNames, filenames) in os.walk (basePath): # loop over the filenames in the current directory for filename in filenames: # if the contains string is not none and the filename does not contain # the supplied string Then ignore the file if contains is not None and filename.find (contains) =-1: continue # determine the file extension of the current file ext = filename [filename.rfind ("."):] .lower () # check to see if the file is an image and should be processed if validExts is None or ext.endswith (validExts): # construct the Path to the image and yield it imagePath = os.path.join (rootDir Filename) yield imagePathdef resize (image, width=None, height=None, inter=cv2.INTER_AREA): dim = None (h W) = image.shape [: 2] # return if width is None and height is None directly if the height and width are None: return image # check whether the width is None if width is None: # calculate the height ratio and calculate the width r = height / float (h) dim = (int (w * r)) Height) # height is None else: # calculate width ratio And calculate the height r = width / float (w) dim = (width, int (h * r)) resized = cv2.resize (image, dim, interpolation=inter) # return the resized image return resized

Nms function: non-maximum suppression.

List_images: read pictures.

Resize: change the size proportionally.

# construct the argument parse and parse the argumentsap = argparse.ArgumentParser () ap.add_argument ("- I", "- images", default='test1', help= "path to images directory") args = vars (ap.parse_args ()) # initialize HOG descriptor / character detector hog = cv2.HOGDescriptor () hog.setSVMDetector (cv2.HOGDescriptor_getDefaultPeopleDetector ())

Define the folder path of the input picture.

Initialize the HOG detector.

# loop over the image pathsfor imagePath in list_images (args ["images"]): # load and resize the image to # (1) reduce detection time # (2) improve detection accuracy image = cv2.imread (imagePath) image = resize (image, width=min (400, image.shape [1]) orig = image.copy () print (image) # detect people in the image (rects, weights) = hog.detectMultiScale (image, winStride= (4) 4), padding= (8,8), scale=1.05) # draw the original bounding boxes print (rects) for (x, y, w, h) in rects: cv2.rectangle (orig, (x, y), (x + w, y + h), (0,0,255), 2) # uses a considerable overlap threshold to apply non-maximum suppression to the bounding box To try to keep the overlapping box rects = np.array ([[x, y, x + w, y + h] for (x, y, w, h) in rects]) pick = nms (rects, probs=None, overlapThresh=0.65) # draw the final bounding boxes for (xA, yA, xB, yB) in pick: cv2.rectangle (image, (xA, yA), (xB, yB), (0,255,0) 2) # show some information on the number of bounding boxes filename = imagePath [imagePath.rfind ("/") + 1:] print ("[INFO] {}: {} original boxes, {} after suppression" .format (filename, len (rects), len (pick)) # show the output images cv2.imshow ("Before NMS", orig) cv2.imshow ("After NMS", image) cv2.waitKey (0)

Iterate through the images in the images directory.

Then, adjust the image to a maximum width of 400 pixels. There are two reasons to try to reduce the size of an image:

Reducing the image size ensures that there are fewer sliding windows in the image pyramid that need to be evaluated (that is, extracting HOG features from the linear SVM and passing them to the linear SVM), thereby reducing detection time (and improving overall detection throughput).

Resizing our images also improves the overall accuracy of our pedestrian detection (that is, fewer false positives).

The pedestrians in the image are detected by calling the detectMultiScale method of the hog descriptor. The detectMultiScale method constructs an image pyramid with a scale of 1.05, and the sliding window steps are (4,4) pixels in the x and y directions, respectively.

The size of the sliding window is fixed at 64 x 128 pixels, as recommended by the groundbreaking Dalal and Triggs paper directional gradient histograms for human detection. The detectMultiScale function returns the 2 tuples of rects, or the bounding box (x, y) coordinates and weights of each person in the image, and SVM is the confidence value returned for each test.

A larger scale evaluates fewer layers in the image pyramid, which makes the algorithm run faster. However, too large (that is, there are fewer layers in the image pyramid) can prevent pedestrians from being detected. Similarly too small scale will significantly increase the number of image pyramid layers that need to be evaluated. This will not only cause a waste of calculation but also significantly increase the number of false positives detected by pedestrian detectors. In other words, the proportion is one of the most important parameters to adjust when performing pedestrian detection. I will examine each parameter more thoroughly in future blog posts to detect multiple scales.

Get the initial bounding boxes and draw them on the image.

However, for some images, you will notice that each person detects multiple overlapping bounding boxes.

In this case, we have two choices. We can detect whether one bounding box is fully contained in another bounding box. Or we can apply non-maximum suppression and suppress bounding boxes that overlap with important thresholds.

After applying non-maximum suppression, the final bounding box is obtained, and then the image is output.

Running result:

Before nms:

After nms:

The above is all the contents of the article "how to achieve pedestrian detection with Python+OpenCV built-in methods". Thank you for reading! I believe we all have a certain understanding, hope to share the content to help you, if you want to learn more knowledge, welcome to follow the industry information channel!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.