Human Body Detection OpenCV Python With Source Code

This article about Human Body Detection OpenCV Python will show how to build your own “smart” video camera. It will show how to take an image from the frame of a web camera, detect if there is a human in the frame, at the same time the system count if how many people or person detect on the video camera.

A Human Body Detection Python OpenCV is an intermediate level deep learning project on computer vision, which will help you to master the concepts and make you an expert in the field of Data Science.

Project Information’s

Project Name:Real Time Human Body Detection OpenCV Python
Language/s Used:Python OpenCV
Python version (Recommended):2.x or 3.x
Database:None
Type:Machine Learning
Developer:IT SOURCECODE
Updates:0
Real Time Human Body Detection OpenCV Python – Project Information

So, let’s build an exciting project. In this Full Body Detection OpenCV Python, we are going to build the Human Detection and Counting System through Webcam or you can give your own video or images.

There are a variety of computer applications that identify human body in digital images, like – pedestrian crossing, criminal identification, healthcare and so on.

The Detection Program in Python allows us to identify and locate objects. It is very important in area of research, where the detected object can be count, accurately determined.

About the Project

Moreover, the Detection OpenCV Python libraries functions are mainly aimed at real-time computer vision. In this article, we are going to develop a Pedestrian detection program. The OpenCV library has inbuilt methods to detect person’s

In this Full Body Detection Python OpenCV also includes a downloadable source code for free, just find the downloadable source code below and click to start downloading.

By the way if you are new to python programming and you don’t know what would be the the Python IDE to use, I have here a list of Best Python IDE for Windows, Linux, Mac OS that will suit for you. I also have here How to Download and Install Latest Version of Python on Windows.

To start creating a Real-Time Human Detection OpenCV Python, make sure that you have installed Python in your computer.

Real-Time Human Body Detection OpenCV Python : Project Prerequisites

The project in Python requires you to have basic knowledge of python programming and the OpenCV library. We will be needing following libraries:

  • OpenCV – A strong library used for machine learning
  • Imutils – To Image Processing
  • Numpy – Used for Scientific Computing. Image is stored in a numpy array.
  • Argparse – Used to give input in command line.

To install the required library, run the following code in your terminal.

pip install opencv-python
pip install imutils
pip install numpy

Histogram of Oriented Gradient Descriptor

HOG is a feature descriptor used in computer vision and image processing for the purpose of object detection.

This is one of the most popular techniques for object detection, to our fortune, OpenCV has already been implemented in an efficient way to combine the HOG Descriptor algorithm with Support Vector Machine or SVM.

Real-Time Human Body Detection OpenCV Python With Source Code : Steps on how to build the project

Time needed: 5 minutes.

These are the steps on how to build Real-Time Human Body Detection OpenCV Python With Source Code

  • Step 1: Import the libraries.

    human body detection import libraries

  • Step 2: Create a model which will detect Humans.

    As discussed earlier, We will use HOGDescriptor with SVM already implemented in OpenCV.  Below code will do this work.
    human body detection create model
    cv2.HOGDescriptor_getDefaultPeopleDetector() calls the pre-trained model for Human detection of OpenCV and then we will feed our support vector machine with it.

  • Step 3: Detect() method.

    A video combines a sequence of images to form a moving picture. We call these images as Frame. So in general we will detect the person in the frame.

    And show it one after another that it looks like a video. That is exactly what our Detect() method will do.  It will take a frame to detect a person in it. Make a box around a person and show the frame..and return the frame with person bounded by a green box.
    human body detection detect method

  • Step 4: HumanDetector() method.

    There are two ways of getting Video.

    1.)Web Camera
    2.)Path of file stored

    In this deep learning project, we can take images also. So our method will check if a path is given then search for the video or image in the given path and operate. Otherwise, it will open the webCam.
    human body detection human detector

  • Step 5: DetectByCamera() method.

    human body detection detect camera
    cv2.VideoCapture(0) passing 0 in this function means we want to record from a webcam. video.read() read frame by frame.

    It returns a check which is True if this was able to read a frame otherwise False. Now, For each Frame, we will call detect() method. Then we write the frame in our output file.

  • Step 6: DetectByPathVideo() method.

    This method is very similar to the previous method except we will give a path to the Video. First, we check if the video on the provided path is found or not.

    Note* – A full path must be given.
    human body detection detect by video
    The implementation is similar to the previous function except for each frame we will check that it successfully reads the frame or not. At the end when the frame is not read we will end the loop.

  • Step 7: DetectByPathimage() method.

    This method is used if a person needs to be detected from an image.
    human body detection detect by image

  • Step 8: Argparse() method.

    The function argparse() simply parses and returns as a dictionary the arguments passed through your terminal to our script. There will be Three arguments within the Parser.

    1.)Image: The path to the image file inside your system
    2.)Video: The path to the Video file inside your system
    3.)Camera: A variable that if set to ‘true’ will call the cameraDetect() method.
    human body detection argpasre method

  • Step 9: Main function.

    end of our project.
    human body detection main function
    Instead of declaring our model above, we can declare it in our main function.

Run the Human Body Detection Project

To run the human detection deep learning project, please run below-mentioned commands as per requirements

1. To give video file as input

python main.py -v ‘Path_to_video’

2. To give image file as input

python main.py -i ‘Path_to-image’

3. To use the camera

python main.py -c True

4. To save the output

Python main.py -c True -o ‘file_name’

Complete Source Code

import cv2
import imutils
import numpy as np
import argparse

def detect(frame):
    bounding_box_cordinates, weights =  HOGCV.detectMultiScale(frame, winStride = (4, 4), padding = (8, 8), scale = 0.5)
    
    person = 1
    for x,y,w,h in bounding_box_cordinates:
        cv2.rectangle(frame, (x,y), (x+w,y+h), (0,255,0), 2)
        cv2.putText(frame, f'person {person}', (x,y), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0,0,255), 1)
        person += 1
    
    cv2.putText(frame, 'Status : Detecting ', (40,40), cv2.FONT_HERSHEY_DUPLEX, 0.8, (255,0,0), 2)
    cv2.putText(frame, f'Total Persons : {person-1}', (40,70), cv2.FONT_HERSHEY_DUPLEX, 0.8, (255,0,0), 2)
    cv2.imshow('output', frame)

    return frame

def detectByPathVideo(path, writer):

    video = cv2.VideoCapture(path)
    check, frame = video.read()
    if check == False:
        print('Video Not Found. Please Enter a Valid Path (Full path of Video Should be Provided).')
        return

    print('Detecting people...')
    while video.isOpened():
        #check is True if reading was successful 
        check, frame =  video.read()

        if check:
            frame = imutils.resize(frame , width=min(800,frame.shape[1]))
            frame = detect(frame)
            
            if writer is not None:
                writer.write(frame)
            
            key = cv2.waitKey(1)
            if key== ord('q'):
                break
        else:
            break
    video.release()
    cv2.destroyAllWindows()

def detectByCamera(writer):
    video = cv2.VideoCapture(0)
    print('Detecting people...')

    while True:
        check, frame = video.read()

        frame = detect(frame)
        if writer is not None:
            writer.write(frame)

        key = cv2.waitKey(1)
        if key == ord('q'):
                break

    video.release()
    cv2.destroyAllWindows()

def detectByPathImage(path, output_path):
    image = cv2.imread(path)

    image = imutils.resize(image, width = min(800, image.shape[1])) 

    result_image = detect(image)

    if output_path is not None:
        cv2.imwrite(output_path, result_image)

    cv2.waitKey(0)
    cv2.destroyAllWindows()


def ouput_path(args):
    pass


def humanDetector(args):
    image_path = args["image"]
    video_path = args['video']
    if str(args["camera"]) == 'true' : camera = True 
    else : camera = False

    writer = None
    if args['output'] is not None and image_path is None:
        writer = cv2.VideoWriter(args['output'],cv2.VideoWriter_fourcc(*'MJPG'), 10, (600,600))

    if camera:
        print('[INFO] Opening Web Cam.')
        detectByCamera(writer)
    elif video_path is not None:
        print('[INFO] Opening Video from path.')
        detectByPathVideo(video_path, writer)
    elif image_path is not None:
        print('[INFO] Opening Image from path.')
        detectByPathImage(image_path, args['output'])

def argsParser():
    arg_parse = argparse.ArgumentParser()
    arg_parse.add_argument("-v", "--video", default=None, help="path to Video File ")
    arg_parse.add_argument("-i", "--image", default=None, help="path to Image File ")
    arg_parse.add_argument("-c", "--camera", default=False, help="Set true if you want to use the camera.")
    arg_parse.add_argument("-o", "--output", type=str, help="path to optional output video file")
    args = vars(arg_parse.parse_args())

    return args

if __name__ == "__main__":
    HOGCV = cv2.HOGDescriptor()
    HOGCV.setSVMDetector(cv2.HOGDescriptor_getDefaultPeopleDetector())

    args = argsParser()
    humanDetector(args)

Download Source Code below

Summary

In this Deep Learning Project, we have learned how to create a people counter using HOG and OpenCV to generate an efficient people counter.

We developed the project where you can supply the input as: video, image, or even live camera.

This is an intermediate level project, which will surely help you in mastering python and deep learning libraries.

Inquiries

If you have any questions or suggestions about Real-Time Human Body Detection OpenCV Python With Source Code, please feel free to leave a comment below.

Leave a Comment