what is object detection?

object detection is a computer vision technique for locating instances of objects within images or videos.

the goal is to identify the presence of objects and draw bounding boxes around them to indicate their position. object detection combines image classification and object localization.

importance of object detection

object detection is important for various real-world applications, such as −

autonomous vehicles: detecting pedestrians, vehicles, and obstacles on the road.
surveillance: monitoring activities and identifying suspicious objects.
healthcare: detecting abnormalities in medical images.
robotics: enabling robots to interact with objects in their environment.

object detection techniques

there are various techniques for object detection, they are −

traditional methods
machine learning-based methods
deep learning-based methods

traditional methods

traditional methods for object detection depend on image processing techniques and custom-built features. these methods are often less accurate than modern machine learning-based approaches but are simpler and faster.

the commonly used traditional method is haar cascades. it uses a cascade of classifiers trained with positive and negative images to detect objects.

import cv2

# load the pre-trained haar cascade classifier for face detection
face_cascade = cv2.cascadeclassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
# read the input image
image = cv2.imread('image.jpg')
gray = cv2.cvtcolor(image, cv2.color_bgr2gray)
# detect faces
faces = face_cascade.detectmultiscale(gray, scalefactor=1.1, minneighbors=5, minsize=(30, 30))
# draw bounding boxes around detected faces
for (x, y, w, h) in faces:
    cv2.rectangle(image, (x, y), (x+w, y+h), (255, 0, 0), 2)
cv2.imshow('detected faces', image)
cv2.waitkey(0)
cv2.destroyallwindows()

machine learning-based methods

machine learning-based methods use algorithms that learn from data to detect objects. these methods often involve training classifiers on labeled datasets.

the most commonly used machine learning based method is histogram of oriented gradients (hog) + svm. this extracts hog features and uses a support vector machine (svm) to classify objects.

from skimage.feature import hog
from sklearn.svm import linearsvc
import joblib

# load the pre-trained hog + svm model
model = joblib.load('hog_svm_model.pkl')
# extract hog features from the input image
features, _ = hog(image, orientations=9, pixels_per_cell=(8, 8), cells_per_block=(2, 2), block_norm='l2-hys', visualize=true)
# predict the presence of objects using the trained svm model
prediction = model.predict([features])

deep learning-based methods

deep learning-based methods have transformed object detection with their high accuracy and ability to handle complex images. these methods use convolutional neural networks (cnns) to learn features and perform detection.

the common deep learning based methods are as shown below −

r-cnn (region-based convolutional neural networks): proposes candidate regions and uses a cnn to classify them.
yolo (you only look once): divides the image into a grid and predicts bounding boxes and class probabilities directly.
ssd (single shot multibox detector): similar to yolo, but uses a different architecture for faster and more accurate detection.

yolo (you only look once)

yolo is a popular and efficient object detection model. it divides the image into a grid and predicts bounding boxes and class probabilities for each grid cell.

you can go through the following steps to use yolo −

step 1: load the pre-trained yolo model.

import cv2
import numpy as np

# load yolo
net = cv2.dnn.readnet('yolov3.weights', 'yolov3.cfg')
layer_names = net.getlayernames()
output_layers = [layer_names[i[0] - 1] for i in net.getunconnectedoutlayers()]

step 2: prepare the input image.

# load the input image
image = cv2.imread('image.jpg')
height, width, channels = image.shape
# prepare the image for yolo
blob = cv2.dnn.blobfromimage(image, 0.00392, (416, 416), (0, 0, 0), true, crop=false)
net.setinput(blob)

step 3: run the model and get predictions.

# run the model
outs = net.forward(output_layers)

step 4: process the output and draw bounding boxes.

class_ids = []
confidences = []
boxes = []

for out in outs:
   for detection in out:
      scores = detection[5:]
      class_id = np.argmax(scores)
      confidence = scores[class_id]
      if confidence > 0.5:
         # object detected
         center_x = int(detection[0] * width)
         center_y = int(detection[1] * height)
         w = int(detection[2] * width)
         h = int(detection[3] * height)
         # rectangle coordinates
         x = int(center_x - w / 2)
         y = int(center_y - h / 2)
         boxes.append([x, y, w, h])
         confidences.append(float(confidence))
         class_ids.append(class_id)

# apply non-maximum suppression
indexes = cv2.dnn.nmsboxes(boxes, confidences, 0.5, 0.4)

# draw bounding boxes
for i in range(len(boxes)):
   if i in indexes:
      x, y, w, h = boxes[i]
      label = str(class_ids[i])
      cv2.rectangle(image, (x, y), (x + w, y + h), (0, 255, 0), 2)
      cv2.puttext(image, label, (x, y + 30), cv2.font_hershey_plain, 3, (0, 255, 0), 3)

cv2.imshow('object detection', image)
cv2.waitkey(0)
cv2.destroyallwindows()

Save or share this article