Real-Time Counting People using OpenCV in Python

Real-Time Counting People using OpenCV in Python With Source Code

The Real-Time Counting People OpenCV Python was developed using Python OpenCV, in this Python project we are going to build the Human Detection and Counting System through a Webcam or you can give your own video or images.

A Counting People OpenCV Python 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.

The project in Python requires you to have basic knowledge of Python programming and the OpenCV library.

This OpenCV Python Project also includes a downloadable Python Project With 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 don’t know how to use the Python IDE, I have here a list of the Best Python IDE for Windows, Linux, and Mac OS that will suit you.

I also have here How to Download and Install the Latest Version of Python on Windows.

To start executing Real-Time Counting People OpenCV Python With Source Code, make sure that you have installed Python 3.9 and PyCharm on your computer.

How to run the Real-Time Human Detection and Counting using OpenCV Python: Step-by-step Guide with source code

Time needed: 5 minutes

These are the steps on how to run Real-Time Counting People OpenCV Python With Source Code

  • Step 1: Download the given source code below.

    First, download the given source code below and unzip the source code.
    Count people download source code

  • Step 2: Import the project to your PyCharm IDE.

    Next, import the source code you’ve downloaded to your PyCharm IDE.
    count people open project

  • Step 3: Run the project.

    Lastly, run the project with the command “py main.py”
    count people run project

Installed Libraries

import cv2
import imutils
import numpy as np
import argparse

Complete Source Code

import cv2
import imutils
import numpy as np
import argparse
#frame
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 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 ")#command
    arg_parse.add_argument("-i", "--image", default=None, help="path to Image File ")#command
    arg_parse.add_argument("-c", "--camera", default=False, help="Set true if you want to use the camera.")#command
    arg_parse.add_argument("-o", "--output", type=str, help="path to optional output video file")#command
    args = vars(arg_parse.parse_args())

    return args

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

    args = argsParser()
    humanDetector(args)

#main module of the system

Download the 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 a 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.

Related Articles

Inquiries

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

2 thoughts on “Real-Time Counting People using OpenCV in Python”

Leave a Comment