computer vision is a field of artificial intelligence (ai) that enables machines to interpret and make decisions based on visual data as same as human vision. it involves acquiring, processing, analyzing and understanding images or videos to extract meaningful information. there are two important subdomains in computer vision which are as follows −

image recognition: this is the process of identifying objects, patterns or features in an image.
image matching this is the process of comparing and finding similarities between two or more images.

the above two techniques are widely used in various applications such as facial recognition, object detection, medical imaging, augmented reality (ar) and robotics.

in this chapter we are going to learn about image recognition and image matching in detail.

image recognition

image recognition is a fundamental task in computer vision which enable machines to identify and categorize objects in images or videos. it involves analyzing pixel data, extracting patterns and classifying visual information using machine learning (ml) and deep learning (dl) techniques. this capability of image recognition is widely used in autonomous vehicles, facial recognition, medical diagnostics, security systems and industrial automation.

key components of image recognition

following are the key components of image recognition in computer vision −

image preprocessing: this is one of the crucial steps in image recognition which enhances image quality and prepares data for feature extraction and classification. it ensures that models receive clean, standardized and optimized images by improving accuracy and efficiency.
feature extraction: it is a step in image recognition where meaningful patterns, edges, textures and key points are identified from an image. these extracted features are then used for object detection, classification and pattern recognition. this can be done using traditional computer vision techniques such as edge detection and keypoint descriptors or deep learning-based methods such as convolutional neural networks.
image classification: this is a fundamental task in computer vision that involves assigning a label or category to an image based on its content. it is widely used in applications such as face recognition, medical diagnosis, self-driving cars and object detection. there are main approaches to image classification −
- traditional machine learning-based classification using manually extracted features such as sift, hog and orb.
- deep learning-based classification using cnns, vision transformers and pre-trained models

steps in image recognition

to perform image recognition we need to follow the steps as mentioned below −

image acquisition and preprocessing

before analyzing an image, it must be cleaned and prepared.here are the preprocessing techniques of image recognition −

resizing & normalization: it is the process of standardizing image size and pixel values.
data augmentation: this is a technique used in computer vision to artificially increase the size of a dataset by applying transformations to existing images. the commonly used techniques such as rotation, flipping, cropping and contrast adjustments which helps to improve model robustness.
noise reduction:it is the process of removing unwanted distortions i.e., noise from images while preserving important features. noise can be caused by low-light conditions, sensor imperfections or transmission errors. by using filters like gaussian blur we can remove image noise.
color space conversion: this is the process of converting rgb images to grayscale when color information is unnecessary.

feature extraction

feature extraction identifies key attributes of an image such as edges, shapes and textures. following are the methods used to perform feature extraction −

edge detection: this method detects the object boundaries by identifying sudden intensity changes. the commonly used techniques are canny and sobel.
histogram of oriented gradients (hog): it extracts structural features by computing gradient orientations.
keypoint detection: this method detects unique points in an image for object tracking and recognition. the keypoint detection can be done by using the techniques such as sift, orb, surf.

classification using machine learning or deep learning

image classification is the process of assigning a label or category to an image based on its visual features. it is widely used in object detection, medical imaging and facial recognition. here are the approaches −

machine learning approach: this uses handcrafted features such as edges, shapes and textures to classify images.
deep learning approach: this uses neural networks such as cnns, transformers to automatically learn features.

training the model

model training is the process of teaching an algorithm to recognize patterns in images by feeding it labeled data. the model learns by adjusting its parameters i.e., weights and biases to minimize classification errors. here are the training methods −

supervised learning: in this model the data is trained on labeled datasets i.e., imagenet, coco.
transfer learning: this model can be trained with the pretrained models and fine-tuning them for specific tasks.

prediction and inference

the trained model analyzes new images and predicts object categories based on learned patterns.

example of image recognition

in this example, we are using the computer vision library to perform the image recognition of the given input image −

  
import cv2
import numpy as np

# load reference and test images in grayscale
reference_image = cv2.imread("tutorialspoint.jpg", cv2.imread_grayscale)  # known image
test_image = cv2.imread("tutorialspoint.jpg", cv2.imread_grayscale)  # image to recognize

# check if images are loaded
if reference_image is none or test_image is none:
    print("error: could not load images. check the file paths.")
    exit()

# initialize orb detector
orb = cv2.orb_create()

# detect keypoints and compute descriptors
keypoints1, descriptors1 = orb.detectandcompute(reference_image, none)
keypoints2, descriptors2 = orb.detectandcompute(test_image, none)

# create a bfmatcher (brute force matcher) and match descriptors
bf = cv2.bfmatcher(cv2.norm_hamming, crosscheck=true)
matches = bf.match(descriptors1, descriptors2)

# sort matches based on distance (lower is better)
matches = sorted(matches, key=lambda x: x.distance)

# draw the top 20 matches
match_image = cv2.drawmatches(reference_image, keypoints1, test_image, keypoints2, matches[:20], none, flags=cv2.drawmatchesflags_not_draw_single_points)

# show the matched features
cv2.imshow("matched features", match_image)
cv2.waitkey(0)
cv2.destroyallwindows()

# print similarity score
print(f"number of good matches: {len(matches)}")

input image:

following is the output of the above code −

number of good matches: 419

image matching

image matching is a one of the crucial task in computer vision that involves comparing two images to determine similarities or differences. this process is widely used in object recognition, augmented reality, image retrieval and 3d reconstruction. image matching algorithms extract the key features from images and use various techniques to establish correspondences between them.

key components of image matching

following are the key components of image matching in computer vision −

feature detection identifies key points in an image such as edges, corners or unique textures to extract useful information.
feature description is used to represents detected features in a format that allows efficient matching between different images.
feature matching compares feature descriptors between two images to find correspondences by using methods such as brute-force matching, flann or homography.
geometric verification ensures that the matched features align correctly using techniques such as ransac to remove incorrect matches.

steps in image matching

to perform image matching we need to follow the below mentioned steps −

image acquisition and preprocessing

before performing image matching the images must be preprocessed to enhance quality by performing below steps −

resizing & normalization method standardizes the image dimensions and pixel values.
noise reduction removes unwanted distortions using filters such as gaussian blur.
color space conversion is used to convert rgb images to grayscale to reduce computational complexity.

feature detection and extraction

feature detection identifies key attributes of an image such as edges, shapes and textures. common methods such as edge detection, histogram of oriented gradients (hog) and keypoint detection.

feature matching

once features are extracted then they are matched between two images using various algorithms as below −

brute-force matcher compares each feature descriptor in one image with all features in another.
flann (fast library for approximate nearest neighbors) uses optimized search algorithms for large datasets.
ransac (random sample consensus) filters incorrect matches by estimating a transformation model.

example of image matching

in this example, we use the opencv library to match features between two images −

  
import cv2
import numpy as np

# load reference and test images in grayscale
reference_image = cv2.imread("tutorialspoint.jpg", cv2.imread_grayscale)  # known image
test_image = cv2.imread("tutorialspoint.jpg", cv2.imread_grayscale)  # image to compare

# check if images are loaded
if reference_image is none or test_image is none:
    print("error: could not load images. check the file paths.")
    exit()

# initialize orb detector
orb = cv2.orb_create()

# detect keypoints and compute descriptors
keypoints1, descriptors1 = orb.detectandcompute(reference_image, none)
keypoints2, descriptors2 = orb.detectandcompute(test_image, none)

# create a bfmatcher (brute force matcher) and match descriptors
bf = cv2.bfmatcher(cv2.norm_hamming, crosscheck=true)
matches = bf.match(descriptors1, descriptors2)

# sort matches based on distance (lower is better)
matches = sorted(matches, key=lambda x: x.distance)

# draw the top 20 matches
match_image = cv2.drawmatches(reference_image, keypoints1, test_image, keypoints2, matches[:20], none, flags=cv2.drawmatchesflags_not_draw_single_points)

# show the matched features
cv2.imshow("matched features", match_image)
cv2.waitkey(0)
cv2.destroyallwindows()

# print similarity score
print(f"number of good matches: {len(matches)}")

following is the output of the above code −

number of good matches: 419

Save or share this article