Header Ads

Object Detection using Python

Abhay Kumar July 02, 2023

Introduction to Object Detection:

Object detection is a computer vision technique that involves the identification and localization of objects within an image or video. It is a fundamental task in the field of computer vision and has gained significant attention due to its wide range of applications.

The primary goal of object detection is to not only determine what objects are present in an image or video but also precisely locate them by drawing bounding boxes around them. This allows for a more detailed understanding of the visual content and enables various downstream tasks, such as tracking, recognition, and decision-making.

Object detection finds its applications in numerous fields, including:
  1. Surveillance and Security: Object detection plays a crucial role in security systems, where it can identify and track suspicious activities or objects in real time.
  2. Autonomous Vehicles: Object detection is a vital component of autonomous driving systems, helping vehicles identify and avoid obstacles, pedestrians, traffic signs, and other vehicles.
  3. Retail and E-commerce: Object detection is used in inventory management, shelf monitoring, and customer behavior analysis to optimize operations and enhance customer experiences.
  4. Medical Imaging: Object detection assists in medical diagnoses by automatically identifying and localizing abnormalities or specific anatomical structures in medical images.
  5. Robotics: Robots equipped with object detection capabilities can interact with their environment, recognize objects, and perform tasks such as object manipulation and navigation.
Python, being a popular programming language in the field of data science and machine learning, offers various libraries and frameworks to implement object detection. One of the widely used libraries is OpenCV, which provides a comprehensive set of tools and functions for computer vision tasks, including object detection.

In this blog post, we will explore how to leverage Python and OpenCV to perform object detection. We will learn how to load pre-trained models, configure them for specific tasks, detect objects in images and videos, and visualize the results.

By the end of this tutorial, you will have a solid foundation in object detection using Python and OpenCV, allowing you to apply this powerful technique to your own projects and explore the vast possibilities of computer vision.

Setting Up the Environment:

Before diving into object detection with Python, it's important to set up the necessary environment. Here are the steps to get started:

Step 1: Install Python:
Ensure that Python is installed on your system. You can download the latest version of Python from the official Python website (https://www.python.org) and follow the installation instructions for your operating system.

Step 2: Install OpenCV:
OpenCV (Open Source Computer Vision Library) is a popular open-source computer vision and machine learning library that provides various tools and algorithms for image and video processing tasks, including object detection. Install OpenCV by using pip, the Python package manager, with the following command:
pip install opencv-python

Step 3: Install Additional Dependencies:
Depending on the specific object detection models and frameworks you'll be using, you may need to install additional dependencies. For example, if you plan to use TensorFlow models for object detection, install TensorFlow by running:
pip install tensorflow

Similarly, for other frameworks like PyTorch, install the necessary packages as per their documentation.

Step 4: Download Pre-trained Models:
To perform object detection, you'll need pre-trained models. These models have been trained on large datasets and are capable of recognizing various objects. Different models are available for different tasks and datasets. You can find pre-trained models from popular sources like TensorFlow Model Zoo (https://github.com/tensorflow/models/blob/master/research/object_detection/g3doc/tf2_detection_zoo.md) or OpenCV's official GitHub repository.

Step 5: Set Up the Project Directory:
Create a new directory for your object detection project. This directory will contain your Python script, configuration files, pre-trained models, and any other resources required. Organizing your project in a structured manner will make it easier to manage and maintain.

Step 6: Import Libraries and Test Installation:
Create a new Python script in your project directory and import the necessary libraries, such as cv2 (for OpenCV) and other libraries specific to the frameworks or models you'll be using. To ensure everything is set up correctly, write a simple test script that loads an image and displays it. Run the script to verify that the libraries are installed and working correctly.

With the environment set up, you're ready to move on to the next steps of loading pre-trained models, configuring the model parameters, and performing object detection. Stay tuned for the next section of the blog post, where we'll dive deeper into these topics.

Note: It's recommended to use virtual environments (such as venv or conda) to isolate your project dependencies and ensure reproducibility. This allows you to have separate environments for different projects with specific versions of libraries and packages.

Loading the Pre-trained Model:

In order to perform object detection, we need to use pre-trained models that have been trained on large datasets to recognize various objects. These models are trained using deep learning techniques and can be downloaded from reliable sources. Here's how you can load a pre-trained model in Python using OpenCV:

Step 1: Download the Pre-trained Model:
First, identify the specific pre-trained model you want to use for object detection. There are several popular models available, such as SSD (Single Shot MultiBox Detector), Faster R-CNN (Region-based Convolutional Neural Network), and YOLO (You Only Look Once). These models differ in terms of accuracy and speed, so choose the one that best suits your requirements. Download the model files, which usually consist of a configuration file (.pbtxt or .config) and a frozen model file (.pb).

Step 2: Set the Model Configuration and Path:
Define the paths to the configuration file and the frozen model file. For example:
config_file = 'path_to_config_file.pbtxt'
frozen_model = 'path_to_frozen_model.pb'

Step 3: Load the Model using OpenCV:
In Python, we can use the cv2.dnn_DetectionModel() class from OpenCV's deep neural network (dnn) module to load the pre-trained model. Create an instance of the cv2.dnn_DetectionModel() class and pass the path to the frozen model file and the configuration file as parameters. Here's an example:
import cv2
model = cv2.dnn_DetectionModel(frozen_model, config_file)

Step 4: Set Input and Output Layers (if necessary):
Some pre-trained models may require you to specify the input and output layers explicitly. You can check the documentation or the model's configuration file to find the names of the input and output layers. Use the model.setInputParams() method to set the input and output layers accordingly.

Step 5: Configure Model Parameters (if necessary):
Depending on the model and your specific requirements, you may need to configure additional parameters such as input size, input scale, mean values, or swapRB (swap red and blue channels). These parameters can be set using methods provided by the cv2.dnn_DetectionModel() class. Refer to the model's documentation or the OpenCV documentation for the specific methods and their usage.

With the pre-trained model successfully loaded, you can now move on to performing object detection on images or videos. Stay tuned for the next section of the blog post, where we will explore how to perform object detection and visualize the results using the loaded model.

Note: Ensure that you have the necessary dependencies and versions compatible with the pre-trained model you are using. It's important to verify the model's requirements and the corresponding OpenCV version to avoid compatibility issues.

Configuring the Model:

After loading the pre-trained model, it's important to configure it properly to ensure accurate and effective object detection. The configuration parameters may vary depending on the model and your specific requirements. Here are some common configuration options you may need to consider:

Input Size:
The input size specifies the dimensions of the input image that the model expects. It's important to set the input size correctly to match the requirements of the loaded model. You can use the model.setInputSize() method provided by OpenCV to set the input size. For example:
model.setInputSize(width, height)

where width and height are the desired dimensions for the input image.

Input Scale:
The input scale is used to normalize the pixel values of the input image. It is typically a scaling factor applied to the pixel values to bring them within a certain range. You can use the model.setInputScale() method to set the input scale. For example, to scale the pixel values between 0 and 1:
model.setInputScale(1.0/255)

Input Mean:
The input mean is a set of mean values subtracted from each channel of the input image to center the pixel values around zero. It helps in improving the model's performance and convergence. You can use the model.setInputMean() method to set the input mean. For example, if the mean values are (R, G, B) = (mean_R, mean_G, mean_B):
model.setInputMean((mean_R, mean_G, mean_B))

SwapRB:
The swapRB parameter specifies whether to swap the red and blue channels of the input image. This is important because different models may expect images with different channel orders. Set swapRB to True if the model expects the channels in the order of blue-green-red (BGR), which is the default channel order in OpenCV. Use the model.setInputSwapRB() method to set the swapRB parameter. For example:
model.setInputSwapRB(True)

Note that the configuration parameters may vary depending on the model and the library/framework you are using. It's important to consult the documentation of the specific model and the corresponding library for accurate configuration options and their usage.

By configuring the model appropriately, you ensure that the input data is processed correctly and in a format that the model expects. This helps in obtaining accurate object detection results. In the next section of the blog post, we will explore how to perform object detection on images and visualize the detected objects using the configured model.

Stay tuned for the next section where we dive into object detection on images and visualization!

Performing Object Detection on Images:

Once you have loaded and configured the pre-trained model, you can perform object detection on images. Object detection allows you to identify and localize objects of interest within an image. Here's how you can perform object detection on images using the configured model:

Read and Display the Image:
Start by reading the input image using a library like OpenCV:
import cv2
img = cv2.imread('path_to_image.jpg')

You can display the image using a library like Matplotlib:
import matplotlib.pyplot as plt

plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
plt.axis('off')
plt.show()

This will display the image without the axis.

Perform Object Detection:
To perform object detection, pass the image through the model using the model.detect() method. This method returns the class indices, confidences, and bounding boxes of the detected objects. Here's an example:
classIndex, confidence, bbox = model.detect(img, confThreshold=0.5)

  • classIndex contains the indices of the detected classes.
  • confidence contains the confidence scores of the detected objects.
  • bbox contains the bounding boxes (x, y, width, height) of the detected objects.
Visualize the Detected Objects:
To visualize the detected objects, iterate over the detected class indices, confidences, and bounding boxes. Draw rectangles around the objects and add labels to them. Here's an example:
font_scale = 1
font = cv2.FONT_HERSHEY_PLAIN

for classInd, conf, boxes in zip(classIndex.flatten(), confidence.flatten(), bbox):
    cv2.rectangle(img, boxes, color=(255, 0, 0), thickness=2)
    cv2.putText(img, classLabels[classInd-1], (boxes[0]+10, boxes[1]+30), font, fontScale=font_scale, color=(255, 0, 0), thickness=2)

  • classLabels is a list of class labels corresponding to the class indices.
Display the Resulting Image:
Display the resulting image with the bounding boxes and labels using Matplotlib:
plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
plt.axis('off')
plt.show()

By following these steps, you can perform object detection on images using the pre-trained model. The detected objects will be highlighted with bounding boxes and labels. Stay tuned for the next section of the blog post, where we will explore how to perform object detection on videos and webcam streams.

Note: Adjust the confidence threshold (confThreshold) according to your needs. Objects with confidence scores below the threshold will not be considered for detection.

Visualizing the Detected Objects:

After performing object detection on images, it's important to visualize the detected objects to understand the results better. Visualization provides a way to overlay bounding boxes and labels on the original image, making it easier to interpret the detected objects. Here's how you can visualize the detected objects using the pre-trained model:

Iterate over the Detected Objects:
Start by iterating over the detected objects, which consist of class indices, confidences, and bounding boxes. You can use a loop to iterate over these arrays simultaneously. For example:
for classInd, conf, boxes in zip(classIndex.flatten(), confidence.flatten(), bbox):
    # Add visualization code here

Draw Bounding Boxes:
To draw bounding boxes around the detected objects, use the cv2.rectangle() function. Specify the coordinates of the top-left and bottom-right corners of the bounding box, along with the color and thickness of the rectangle. For example:
cv2.rectangle(img, (boxes[0], boxes[1]), (boxes[0]+boxes[2], boxes[1]+boxes[3]), color=(255, 0, 0), thickness=2)

  • (boxes[0], boxes[1]) represents the top-left corner of the bounding box.
  • (boxes[0]+boxes[2], boxes[1]+boxes[3]) represents the bottom-right corner of the bounding box.
Add Labels:
To add labels to the detected objects, use the cv2.putText() function. Specify the text, position, font, font scale, color, and thickness of the text. For example:
cv2.putText(img, classLabels[classInd-1], (boxes[0]+10, boxes[1]+30), font, fontScale=1, color=(255, 0, 0), thickness=2)

  • classLabels is a list of class labels corresponding to the class indices.
Display the Resulting Image:
After visualizing the detected objects, display the resulting image using a library like Matplotlib:
import matplotlib.pyplot as plt
plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
plt.axis('off')
plt.show()

By following these steps, you can visualize the detected objects by overlaying bounding boxes and labels on the original image. This provides a clear and informative representation of the objects identified by the object detection model. Stay tuned for the next section of the blog post, where we will explore how to perform object detection on videos and webcam streams.

Note: Adjust the color, font, font scale, and thickness parameters according to your preferences and visualization requirements.

Real-Time Object Detection with Video:

Performing object detection on videos allows you to detect and track objects in real-time. It enables applications such as video surveillance, autonomous vehicles, and robotics. Here's how you can implement real-time object detection on videos using the pre-trained model:

Video Capture:
Start by capturing the video using a library like OpenCV. You can capture video from a file or directly from a webcam. Here's an example to capture video from a file:
import cv2
cap = cv2.VideoCapture('path_to_video.mp4')

If you want to capture video from a webcam, use the following code:
cap = cv2.VideoCapture(0)

Configure Video Writer (Optional):
If you want to save the processed video with the detected objects, you can configure a video writer. Here's an example:
frame_width = int(cap.get(3))
frame_height = int(cap.get(4))
out = cv2.VideoWriter('output_video.mp4', cv2.VideoWriter_fourcc('M', 'J', 'P', 'G'), 10, (frame_width, frame_height))

  • 'output_video.mp4' is the name of the output video file.
  • 'M', 'J', 'P', 'G' is the four-character code for the video codec.
  • 10 is the frames per second (FPS) of the output video.
Process Frames:
Inside a loop, read frames from the video and perform object detection on each frame. Here's an example:
while True:
    ret, frame = cap.read()

    # Perform object detection on the frame
    classIndex, confidence, bbox = model.detect(frame, confThreshold=0.5)

    # Visualize the detected objects on the frame
    for classInd, conf, boxes in zip(classIndex.flatten(), confidence.flatten(), bbox):
        # Add visualization code here

    # Display the frame with detected objects
    cv2.imshow('Object Detection', frame)

    # Write the frame with detected objects to the output video (optional)
    out.write(frame)

    # Exit the loop if 'q' is pressed
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

Release Resources:
After the loop ends, release the video capture and video writer resources, and close any open windows. Here's an example:
cap.release()
out.release()
cv2.destroyAllWindows()

By following these steps, you can perform real-time object detection on videos using the pre-trained model. Detected objects will be displayed in each frame, and you have the option to save the processed video with the objects highlighted. This allows you to monitor and track objects in real-time scenarios.

Conclusion:

Object detection is a powerful technique that allows us to identify and locate objects of interest within images and videos. In this blog post, we explored how to perform object detection using Python and the OpenCV library. We learned how to set up the environment, load a pre-trained model, configure the model for object detection, and perform object detection on images, as well as real-time object detection on videos.

By leveraging pre-trained models like SSD MobileNet, we can quickly and accurately detect a wide range of objects in various scenarios. We also saw how to visualize the detected objects by overlaying bounding boxes and labels on the original images or frames, providing a clear and informative representation of the detected objects.

Object detection has numerous applications across domains such as computer vision, autonomous systems, surveillance, and robotics. It enables tasks like object recognition, tracking, and counting, contributing to enhanced understanding and decision-making in visual data analysis.

With the knowledge gained from this blog post, you can now embark on your own object detection projects. You can explore different pre-trained models, experiment with different confidence thresholds, and even fine-tune models on your own datasets for specific applications.

Object detection continues to evolve rapidly, with advancements in deep learning and computer vision. Stay updated with the latest research and techniques to keep pushing the boundaries of what can be achieved with object detection.

Now it's time to apply your newfound knowledge and explore the exciting world of object detection. Happy detecting!

Code:

import cv2
import matplotlib.pylab as plt

config_file = 'ssd_mobilenet_v3_large_coco_2020_01_14.pbtxt'
frozen_model = 'frozen_inference_graph.pb'

model = cv2.dnn_DetectionModel(frozen_model, config_file)

classLables = []
filename = 'labels.txt'
with open(filename, 'rt') as f:
    classLables = f.read().rstrip('\n').split('\n')

print(classLables)

print(len(classLables))

model.setInputSize(320, 320)
model.setInputScale(1.0/127.5)
model.setInputMean((127.5, 127.5, 127.5))
model.setInputSwapRB(True)

# Image
img = cv2.imread('boy.jpg')
plt.imshow(img)
plt.show()

classIndex, confidence, bbox = model.detect(img, confThreshold=0.5)
print(classIndex)

font_scale = 3
font = cv2.FONT_HERSHEY_PLAIN
for classInd, conf, boxes in zip(classIndex.flatten(), confidece.flatten(), bbox):
    cv2.rectangle(img, boxes, (255, 0, 0), 2)
    cv2.putText(img, classLables[classInd-1], (boxes[0]+10, boxes[1]+40),
                font, fontScale=font_scale, color=(0, 255, 0), thickness=3)

plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
plt.show()


cap = cv2.VideoCapture('video1.mp4')  # video
cap = cv2.VideoCapture(1)  # webcam
if not cap.isOpened():
    cap = cv2.VideoCapture(0)
if not cap.isOpened():
    raise IOError("Can't open the video")

while True:
    ret, frame = cap.read()
    classIndex, confidence, bbox = model.detect(frame, confThreshold=0.55)
    print(classIndex)
    if (len(classIndex) != 0):
        for classInd, conf, boxes in zip(classIndex.flatten(), confidence.flatten(), bbox):
            if (classInd <= 80):
                cv2.rectangle(frame, boxes, (255, 0, 0), 2)
                cv2.putText(frame, classLables[classInd-1], (boxes[0]+10, boxes[1]+40),
                            font, fontScale=font_scale, color=(0, 255, 0), thickness=3)
    cv2.imshow('Object Detection', frame)
    if cv2.waitKey(2) & 0xff == ord('q'):
        break
cap.release()
cv2.destroyAllWindows()


Output:






Explanation:

The provided code demonstrates how to perform object detection using a pre-trained model in OpenCV. Here's a breakdown of the code:

Import the necessary libraries:
import cv2
import matplotlib.pylab as plt

Set the paths for the configuration file and frozen model:
config_file = 'ssd_mobilenet_v3_large_coco_2020_01_14.pbtxt'
frozen_model = 'frozen_inference_graph.pb'

Create an instance of the cv2.dnn_DetectionModel class:
model = cv2.dnn_DetectionModel(frozen_model, config_file)

Load the class labels from a file:
classLabels = []
filename = 'labels.txt'
with open(filename, 'rt') as f:
    classLabels = f.read().rstrip('\n').split('\n')

Set the input parameters for the model:
model.setInputSize(320, 320)
model.setInputScale(1.0 / 127.5)
model.setInputMean((127.5, 127.5, 127.5))
model.setInputSwapRB(True)

Load an image and perform object detection on it:
img = cv2.imread('boy.jpg')
classIndex, confidence, bbox = model.detect(img, confThreshold=0.5)

Visualize the detected objects in the image:
font_scale = 3
font = cv2.FONT_HERSHEY_PLAIN
for classInd, conf, boxes in zip(classIndex.flatten(), confidence.flatten(), bbox):
    cv2.rectangle(img, boxes, (255, 0, 0), 2)
    cv2.putText(img, classLabels[classInd - 1], (boxes[0] + 10, boxes[1] + 40), font, fontScale=font_scale,
                color=(0, 255, 0), thickness=3)
plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
plt.show()

Open a video or webcam feed and perform object detection in real-time:
cap = cv2.VideoCapture('video1.mp4')  # video
cap = cv2.VideoCapture(1)  # webcam
if not cap.isOpened():
    cap = cv2.VideoCapture(0)
if not cap.isOpened():
    raise IOError("Can't open the video")

while True:
    ret, frame = cap.read()
    classIndex, confidence, bbox = model.detect(frame, confThreshold=0.65)
    if len(classIndex) != 0:
        for classInd, conf, boxes in zip(classIndex.flatten(), confidence.flatten(), bbox):
            if classInd <= 80:
                cv2.rectangle(frame, boxes, (255, 0, 0), 2)
                cv2.putText(frame, classLabels[classInd - 1], (boxes[0] + 10, boxes[1] + 40), font,
                            fontScale=font_scale, color=(0, 255, 0), thickness=3)
    cv2.imshow('Object Detection', frame)
    if cv2.waitKey(2) & 0xff == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

This code demonstrates object detection on both an image and video feed using the pre-trained model specified by the configuration file and frozen model. Detected objects are highlighted with bounding boxes and labeled with class names.






Related Links:






Tags:

Post a Comment

0 Comments

Ask Your Queries in the comments