Feature Matching using Brute Force in OpenCV
Last Updated : 20 Feb, 2023
In this article, we will do feature matching using Brute Force in Python by using OpenCV library.
Prerequisites: OpenCV
OpenCV is a python library which is used to solve the computer vision problems.
OpenCV is an open source Computer Vision library. So computer vision is a way of teaching intelligence to machine and making them see things just like humans.
In other words, OpenCV is what that allows the computer to see and process visual data just like humans.
Installation:
For installing the openCV library, write the following command in your command prompt.
pip install opencv-python
Approach:
- Import the OpenCV library.
- Load the images using imread() function and pass the path or name of the image as a parameter.
- Create the ORB detector for detecting the features of the images.
- Using the ORB detector find the keypoints and descriptors for both of the images.
- Now after detecting the features of the images. Now write the Brute Force Matcher for matching the features of the images and stored it in the variable named as "brute_force".
- For matching we are using the brute_force.match() and pass the descriptors of first image and descriptors of the second image as a parameter.
- After finding the matches we have to sort that matches according to the humming distance between the matches, less will be the humming distance better will be the accuracy of the matches.
- Now after sorting according to humming distance we have to draw the feature matches for that we use drawMatches() function in which pass first image and keypoints of first image, second image and keypoints of second image and the best_matches as a parameter and stored it in the variable named as "output_image".
- Now after drawing the feature matches we have to see the matches for that we use imshow() function which comes in cv2 library and pass the window name and output_image.
- Now write the waitkey() function and write the destroyAllWindows() for destroying all the windows.
Oriented Fast and Rotated Brief (ORB) Detector
ORB detector stands for Oriented Fast and Rotated Brief, this is free of cost algorithm, the benefit of this algorithm is that it does not require GPU it can compute on normal CPU.
ORB is basically the combination of two algorithms involved FAST and BRIEF where FAST stands for Features from Accelerated Segments Test whereas BRIEF stands for Binary Robust Independent Elementary Features.
ORB detector first uses FAST algorithm, this FAST algorithm finds the key points then applies Harries corner measure to find top N numbers of key points among them, this algorithm quickly selects the key points by comparing the distinctive regions like the intensity variations.
This algorithm works on Key point matching, Key point is distinctive regions in an image like the intensity variations.
Now the role of BRIEF algorithm comes, this algorithm takes the key points and turn into the binary descriptor/binary feature vector that contains the combination of 0s and1s only.
The key points founded by FAST algorithm and Descriptors created by BRIEF algorithm both together represent the object. BRIEF is the faster method for feature descriptor calculation and it also provides a high recognition rate until and unless there is large in-plane rotation.
Brute Force Matcher
Brute Force Matcher is used for matching the features of the first image with another image.
It takes one descriptor of first image and matches to all the descriptors of the second image and then it goes to the second descriptor of first image and matches to all the descriptor of the second image and so on.
Example 1: Reading/Importing the images from their path using OpenCV library.
Python # importing openCV library import cv2 # function to read the images by taking there path def read_image(path1,path2): # reading the images from their using imread() function read_img1 = cv2.imread(path1) read_img2 = cv2.imread(path2) return (read_img1,read_img2) # function to convert images from RGB to gray scale def convert_to_grayscale(pic1,pic2): gray_img1 = cv2.cvtColor(pic1,cv2.COLOR_BGR2GRAY) gray_img2 = cv2.cvtColor(pic2,cv2.COLOR_BGR2GRAY) return (gray_img1,gray_img2) # main function if __name__ == '__main__': # giving the path of both of the images first_image_path = 'C:/UsersPython(ds)/1611755129039.jpg' second_image_path = 'C:/Users/Python(ds)/1611755720390.jpg' # reading the image from there path by calling the function img1, img2 = read_image(first_image_path,second_image_path) # converting the read images into the gray scale images by calling the function gray_pic1, gray_pic2 = convert_to_grayscale(img1,img2) cv2.imshow('Gray scaled image 1',gray_pic1) cv2.imshow('Gray scaled image 2',gray_pic2) cv2.waitKey() cv2.destroyAllWindows() Output:
Example 2: Creating ORB detector for finding the features in the images.
Python # importing openCV library import cv2 # function to read the images by taking there path def read_image(path1,path2): read_img1 = cv2.imread(path1) read_img2 = cv2.imread(path2) return (read_img1,read_img2) # function to convert images from RGB to gray scale def convert_to_grayscale(pic1,pic2): gray_img1 = cv2.cvtColor(pic1,cv2.COLOR_BGR2GRAY) gray_img2 = cv2.cvtColor(pic2,cv2.COLOR_BGR2GRAY) return (gray_img1,gray_img2) # function to detect the features by finding key points and descriptors from the image def detector(image1,image2): # creating ORB detector detect = cv2.ORB_create() # finding key points and descriptors of both images using detectAndCompute() function key_point1,descrip1 = detect.detectAndCompute(image1,None) key_point2,descrip2 = detect.detectAndCompute(image2,None) return (key_point1,descrip1,key_point2,descrip2) # main function if __name__ == '__main__': # giving the path of both of the images first_image_path = 'C:/Users/Python(ds)//1611755129039.jpg' second_image_path = 'C:/Users/Python(ds)/1611755720390.jpg' # reading the image from there paths img1, img2 = read_image(first_image_path,second_image_path) # converting the read images into the gray scale images gray_pic1, gray_pic2 = convert_to_grayscale(img1,img2) # storing the finded key points and descriptors of both of the images key_pt1,descrip1,key_pt2,descrip2 = detector(gray_pic1,gray_pic2) # showing the images with their key points finded by the detector cv2.imshow("Key points of Image 1",cv2.drawKeypoints(gray_pic1,key_pt1,None)) cv2.imshow("Key points of Image 2",cv2.drawKeypoints(gray_pic2,key_pt2,None)) # printing descriptors of both of the images print(f'Descriptors of Image 1 {descrip1}') print(f'Descriptors of Image 2 {descrip2}') print('------------------------------') # printing the Shape of the descriptors print(f'Shape of descriptor of first image {descrip1.shape}') print(f'Shape of descriptor of second image {descrip2.shape}') cv2.waitKey() cv2.destroyAllWindows() Output:
The first output image shows the drawn key points of both of the images.
KeyPoints are the point of interest, in simple words means that when the human will see the image at that time the features he notices in that image, in the similar way when the machine read the image it see some points of interest known as Key points.
The second output image shows the descriptors and the shape of the descriptors.
These Descriptors are basically array or bin of numbers. These are used to describe the features, using these descriptors we can match the two different images.
In the second output image, we can see first image descriptor shape and second image descriptor shape is (467, 32) and (500,32) respectively. So, Oriented Fast and Rotated Brief (ORB) detector try to find 500 features in the image by default, and for each descriptor, it will describe 32 values.
So, now how will we use these descriptors now? We can use a Brute Force Matcher (as discussed above in the article) to match these descriptors together and find how many similarities we are getting.
Example 3: Feature Matching using Brute Force Matcher.
Python # importing openCV library import cv2 # function to read the images by taking there path def read_image(path1,path2): read_img1 = cv2.imread(path1) read_img2 = cv2.imread(path2) return (read_img1,read_img2) # function to convert images from RGB to gray scale def convert_to_grayscale(pic1,pic2): gray_img1 = cv2.cvtColor(pic1,cv2.COLOR_BGR2GRAY) gray_img2 = cv2.cvtColor(pic2,cv2.COLOR_BGR2GRAY) return (gray_img1,gray_img2) # function to detect the features by finding key points # and descriptors from the image def detector(image1,image2): # creating ORB detector detect = cv2.ORB_create() # finding key points and descriptors of both images using # detectAndCompute() function key_point1,descrip1 = detect.detectAndCompute(image1,None) key_point2,descrip2 = detect.detectAndCompute(image2,None) return (key_point1,descrip1,key_point2,descrip2) # function to find best detected features using brute force # matcher and match them according to their humming distance def BF_FeatureMatcher(des1,des2): brute_force = cv2.BFMatcher(cv2.NORM_HAMMING,crossCheck=True) no_of_matches = brute_force.match(des1,des2) # finding the humming distance of the matches and sorting them no_of_matches = sorted(no_of_matches,key=lambda x:x.distance) return no_of_matches # function displaying the output image with the feature matching def display_output(pic1,kpt1,pic2,kpt2,best_match): # drawing the feature matches using drawMatches() function output_image = cv2.drawMatches(pic1,kpt1,pic2,kpt2,best_match,None,flags=2) cv2.imshow('Output image',output_image) # main function if __name__ == '__main__': # giving the path of both of the images first_image_path = 'C:/Users/Python(ds)/1611755129039.jpg' second_image_path = 'C:/Users/Python(ds)/1611755720390.jpg' # reading the image from there paths img1, img2 = read_image(first_image_path,second_image_path) # converting the read images into the gray scale images gray_pic1, gray_pic2 = convert_to_grayscale(img1,img2) # storing the finded key points and descriptors of both of the images key_pt1,descrip1,key_pt2,descrip2 = detector(gray_pic1,gray_pic2) # sorting the number of best matches obtained from brute force matcher number_of_matches = BF_FeatureMatcher(descrip1,descrip2) tot_feature_matches = len(number_of_matches) # printing total number of feature matches found print(f'Total Number of Features matches found are {tot_feature_matches}') # after drawing the feature matches displaying the output image display_output(gray_pic1,key_pt1,gray_pic2,key_pt2,number_of_matches) cv2.waitKey() cv2.destroyAllWindows() Output:
We are getting total of 178 feature matches. Total 178 matches are drawn, but they are sorted according to their humming distance in ascending order means that the distance of 178th feature is greater than the first feature, so first feature match is more accurate than the 178th feature match.
It looks messy because all the 178 feature matches are drawn, let's draw the top fifteen features (for the sake of visibility).
Example 4: First/Top fifteen Feature Matching using Brute Force Matcher.
Python # importing openCV library import cv2 # function to read the images by taking there path def read_image(path1,path2): read_img1 = cv2.imread(path1) read_img2 = cv2.imread(path2) return (read_img1,read_img2) # function to convert images from RGB to gray scale def convert_to_grayscale(pic1,pic2): gray_img1 = cv2.cvtColor(pic1,cv2.COLOR_BGR2GRAY) gray_img2 = cv2.cvtColor(pic2,cv2.COLOR_BGR2GRAY) return (gray_img1,gray_img2) # function to detect the features by finding key points # and descriptors from the image def detector(image1,image2): # creating ORB detector detect = cv2.ORB_create() # finding key points and descriptors of both images # using detectAndCompute() function key_point1,descrip1 = detect.detectAndCompute(image1,None) key_point2,descrip2 = detect.detectAndCompute(image2,None) return (key_point1,descrip1,key_point2,descrip2) # function to find best detected features using # brute force matcher and match them according to their humming distance def BF_FeatureMatcher(des1,des2): brute_force = cv2.BFMatcher(cv2.NORM_HAMMING,crossCheck=True) no_of_matches = brute_force.match(des1,des2) # finding the humming distance of the matches and sorting them no_of_matches = sorted(no_of_matches,key=lambda x:x.distance) return no_of_matches # function displaying the output image with the feature matching def display_output(pic1,kpt1,pic2,kpt2,best_match): # drawing first fifteen best feature matches using drawMatches() function output_image = cv2.drawMatches(pic1,kpt1,pic2, kpt2,best_match[:15],None,flags=2) cv2.imshow('Output image',output_image) # main function if __name__ == '__main__': # giving the path of both of the images first_image_path = 'C:/Users/Python(ds)/1611755129039.jpg' second_image_path = 'C:/Users/Python(ds)/1611755720390.jpg' # reading the image from there paths img1, img2 = read_image(first_image_path,second_image_path) # converting the read images into the gray scale images gray_pic1, gray_pic2 = convert_to_grayscale(img1,img2) # storing the finded key points and descriptors of both of the images key_pt1,descrip1,key_pt2,descrip2 = detector(gray_pic1,gray_pic2) # sorting the number of best matches obtained from brute force matcher number_of_matches = BF_FeatureMatcher(descrip1,descrip2) # after drawing the feature matches displaying the output image display_output(gray_pic1,key_pt1,gray_pic2,key_pt2,number_of_matches) cv2.waitKey() cv2.destroyAllWindows() Output:
The output image shows the first/top fifteen best feature matching using Brute Force Matcher.
From the above output, we can see that these matches are more accurate than all the remaining feature matches.
Let's take another example for feature matching.
Example 5: Feature matching using Brute Force.
Python # importing openCV library import cv2 # function to read the images by taking there path def read_image(path1,path2): read_img1 = cv2.imread(path1) read_img2 = cv2.imread(path2) return (read_img1,read_img2) # function to convert images from RGB to gray scale def convert_to_grayscale(pic1,pic2): gray_img1 = cv2.cvtColor(pic1,cv2.COLOR_BGR2GRAY) gray_img2 = cv2.cvtColor(pic2,cv2.COLOR_BGR2GRAY) return (gray_img1,gray_img2) # function to detect the features by finding key points and # descriptors from the image def detector(image1,image2): # creating ORB detector detect = cv2.ORB_create() # finding key points and descriptors of both images # using detectAndCompute() function key_point1,descrip1 = detect.detectAndCompute(image1,None) key_point2,descrip2 = detect.detectAndCompute(image2,None) return (key_point1,descrip1,key_point2,descrip2) # function to find best detected features using brute # force matcher and match them according to their humming distance def BF_FeatureMatcher(des1,des2): brute_force = cv2.BFMatcher(cv2.NORM_HAMMING,crossCheck=True) no_of_matches = brute_force.match(des1,des2) # finding the humming distance of the matches and sorting them no_of_matches = sorted(no_of_matches,key=lambda x:x.distance) return no_of_matches # function displaying the output image with the feature matching def display_output(pic1,kpt1,pic2,kpt2,best_match): # drawing the feature matches using drawMatches() function output_image = cv2.drawMatches(pic1,kpt1,pic2,kpt2, best_match[:30],None,flags=2) cv2.imshow('Output image',output_image) # main function if __name__ == '__main__': # giving the path of both of the images first_image_path = 'C:/Users/Python(ds)/Titan_1.jpg' second_image_path = 'C:/Users/Python(ds)/Titan_nor.jpg' # reading the image from there paths img1, img2 = read_image(first_image_path,second_image_path) # converting the read images into the gray scale images gray_pic1, gray_pic2 = convert_to_grayscale(img1,img2) # storing the finded key points and descriptors of both of the images key_pt1,descrip1,key_pt2,descrip2 = detector(gray_pic1,gray_pic2) # sorting the number of best matches obtained from brute force matcher number_of_matches = BF_FeatureMatcher(descrip1,descrip2) tot_feature_matches = len(number_of_matches) print(f'Total Number of Features matches found are {tot_feature_matches}') # after drawing the feature matches displaying the output image display_output(gray_pic1,key_pt1,gray_pic2,key_pt2,number_of_matches) cv2.waitKey() cv2.destroyAllWindows() Output:
In the above example we are getting total 147 best feature matches among them we are drawing only top 30 matches so that we can see the matches properly.
Example 6: Feature Matching using Brute Force Matcher by taking rotated train image.
Python # importing openCV library import cv2 # function to read the images by taking there path def read_image(path1,path2): read_img1 = cv2.imread(path1) read_img2 = cv2.imread(path2) return (read_img1,read_img2) # function to convert images from RGB to gray scale def convert_to_grayscale(pic1,pic2): gray_img1 = cv2.cvtColor(pic1,cv2.COLOR_BGR2GRAY) gray_img2 = cv2.cvtColor(pic2,cv2.COLOR_BGR2GRAY) return (gray_img1,gray_img2) # function to detect the features by finding key points # and descriptors from the image def detector(image1,image2): # creating ORB detector detect = cv2.ORB_create() # finding key points and descriptors of both images # using detectAndCompute() function key_point1,descrip1 = detect.detectAndCompute(image1,None) key_point2,descrip2 = detect.detectAndCompute(image2,None) return (key_point1,descrip1,key_point2,descrip2) # function to find best detected features using brute # force matcher and match them according to their humming distance def BF_FeatureMatcher(des1,des2): brute_force = cv2.BFMatcher(cv2.NORM_HAMMING,crossCheck=True) no_of_matches = brute_force.match(des1,des2) # finding the humming distance of the matches and sorting them no_of_matches = sorted(no_of_matches,key=lambda x:x.distance) return no_of_matches # function displaying the output image with the feature matching def display_output(pic1,kpt1,pic2,kpt2,best_match): # drawing the feature matches using drawMatches() function output_image = cv2.drawMatches(pic1,kpt1,pic2, kpt2,best_match[:30],None,flags=2) cv2.imshow('Output image',output_image) # main function if __name__ == '__main__': # giving the path of both of the images first_image_path = 'C:/Users/Python(ds)/Titan_1.jpg' second_image_path = 'C:/Users/Python(ds)/Titan_rotated.jpg' # reading the image from there paths img1, img2 = read_image(first_image_path,second_image_path) # converting the read images into the gray scale images gray_pic1, gray_pic2 = convert_to_grayscale(img1,img2) # storing the finded key points and descriptors of both of the images key_pt1,descrip1,key_pt2,descrip2 = detector(gray_pic1,gray_pic2) # sorting the number of best matches obtained from brute force matcher number_of_matches = BF_FeatureMatcher(descrip1,descrip2) tot_feature_matches = len(number_of_matches) print(f'Total Number of Features matches found are {tot_feature_matches}') # after drawing the feature matches displaying the output image display_output(gray_pic1,key_pt1,gray_pic2,key_pt2,number_of_matches) cv2.waitKey() cv2.destroyAllWindows() Output:
In this example when we have taken the rotated train image then we have found that there is little difference in the total number of best feature matches i.e, 148.
In the first output image, we have only drawn the top thirty best feature matches.
Similar Reads
Computer Vision Tutorial
Computer Vision is a branch of Artificial Intelligence (AI) that enables computers to interpret and extract information from images and videos, similar to human perception. It involves developing algorithms to process visual data and derive meaningful insights. Why Learn Computer Vision?High Demand
8 min read
Introduction to Computer Vision
Computer Vision - Introduction
Ever wondered how are we able to understand the things we see? Like we see someone walking, whether we realize it or not, using the prerequisite knowledge, our brain understands what is happening and stores it as information. Imagine we look at something and go completely blank. Into oblivion. Scary
3 min read
A Quick Overview to Computer Vision
Computer vision means the extraction of information from images, text, videos, etc. Sometimes computer vision tries to mimic human vision. It’s a subset of computer-based intelligence or Artificial intelligence which collects information from digital images or videos and analyze them to define the a
3 min read
Applications of Computer Vision
Have you ever wondered how machines can "see" and understand the world around them, much like humans do? This is the magic of computer vision—a branch of artificial intelligence that enables computers to interpret and analyze digital images, videos, and other visual inputs. From self-driving cars to
6 min read
Fundamentals of Image Formation
Image formation is an analog to digital conversion of an image with the help of 2D Sampling and Quantization techniques that is done by the capturing devices like cameras. In general, we see a 2D view of the 3D world. In the same way, the formation of the analog image took place. It is basically a c
7 min read
Satellite Image Processing
Satellite Image Processing is an important field in research and development and consists of the images of earth and satellites taken by the means of artificial satellites. Firstly, the photographs are taken in digital form and later are processed by the computers to extract the information. Statist
2 min read
Image Formats
Image formats are different types of file types used for saving pictures, graphics, and photos. Choosing the right image format is important because it affects how your images look, load, and perform on websites, social media, or in print. Common formats include JPEG, PNG, GIF, and SVG, each with it
5 min read
Image Processing & Transformation
Digital Image Processing Basics
Digital Image Processing means processing digital image by means of a digital computer. We can also say that it is a use of computer algorithms, in order to get enhanced image either to extract some useful information. Digital image processing is the use of algorithms and mathematical models to proc
7 min read
Difference Between RGB, CMYK, HSV, and YIQ Color Models
The colour spaces in image processing aim to facilitate the specifications of colours in some standard way. Different types of colour models are used in multiple fields like in hardware, in multiple applications of creating animation, etc. Let’s see each colour model and its application. RGBCMYKHSV
3 min read
Image Enhancement Techniques using OpenCV - Python
Image enhancement is the process of improving the quality and appearance of an image. It can be used to correct flaws or defects in an image, or to simply make an image more visually appealing. Image enhancement techniques can be applied to a wide range of images, including photographs, scans, and d
15+ min read
Image Transformations using OpenCV in Python
In this tutorial, we are going to learn Image Transformation using the OpenCV module in Python. What is Image Transformation? Image Transformation involves the transformation of image data in order to retrieve information from the image or preprocess the image for further usage. In this tutorial we
5 min read
How to find the Fourier Transform of an image using OpenCV Python?
The Fourier Transform is a mathematical tool used to decompose a signal into its frequency components. In the case of image processing, the Fourier Transform can be used to analyze the frequency content of an image, which can be useful for tasks such as image filtering and feature extraction. In thi
5 min read
Python | Intensity Transformation Operations on Images
Intensity transformations are applied on images for contrast manipulation or image thresholding. These are in the spatial domain, i.e. they are performed directly on the pixels of the image at hand, as opposed to being performed on the Fourier transform of the image. The following are commonly used
5 min read
Histogram Equalization in Digital Image Processing
A digital image is a two-dimensional matrix of two spatial coordinates, with each cell specifying the intensity level of the image at that point. So, we have an N x N matrix with integer values ranging from a minimum intensity level of 0 to a maximum level of L-1, where L denotes the number of inten
6 min read
Python - Color Inversion using Pillow
Color Inversion (Image Negative) is the method of inverting pixel values of an image. Image inversion does not depend on the color mode of the image, i.e. inversion works on channel level. When inversion is used on a multi color image (RGB, CMYK etc) then each channel is treated separately, and the
4 min read
Image Sharpening Using Laplacian Filter and High Boost Filtering in MATLAB
Image sharpening is an effect applied to digital images to give them a sharper appearance. Sharpening enhances the definition of edges in an image. The dull images are those which are poor at the edges. There is not much difference in background and edges. On the contrary, the sharpened image is tha
4 min read
Wand sharpen() function - Python
The sharpen() function is an inbuilt function in the Python Wand ImageMagick library which is used to sharpen the image. Syntax: sharpen(radius, sigma) Parameters: This function accepts four parameters as mentioned above and defined below: radius: This parameter stores the radius value of the sharpn
2 min read
Python OpenCV - Smoothing and Blurring
In this article, we are going to learn about smoothing and blurring with python-OpenCV. When we are dealing with images at some points the images will be crisper and sharper which we need to smoothen or blur to get a clean image, or sometimes the image will be with a really bad edge which also we ne
7 min read
Python PIL | GaussianBlur() method
PIL is the Python Imaging Library which provides the python interpreter with image editing capabilities. The ImageFilter module contains definitions for a pre-defined set of filters, which can be used with the Image.filter() method. PIL.ImageFilter.GaussianBlur() method create Gaussian blur filter.
1 min read
Apply a Gauss filter to an image with Python
A Gaussian Filter is a low-pass filter used for reducing noise (high-frequency components) and for blurring regions of an image. This filter uses an odd-sized, symmetric kernel that is convolved with the image. The kernel weights are highest at the center and decrease as you move towards the periphe
2 min read
Spatial Filtering and its Types
Spatial Filtering technique is used directly on pixels of an image. Mask is usually considered to be added in size so that it has specific center pixel. This mask is moved on the image such that the center of the mask traverses all image pixels. Classification on the basis of Linearity There are two
3 min read
Python PIL | MedianFilter() and ModeFilter() method
PIL is the Python Imaging Library which provides the python interpreter with image editing capabilities. The ImageFilter module contains definitions for a pre-defined set of filters, which can be used with the Image.filter() method. PIL.ImageFilter.MedianFilter() method creates a median filter. Pick
1 min read
Python | Bilateral Filtering
A bilateral filter is used for smoothening images and reducing noise, while preserving edges. This article explains an approach using the averaging filter, while this article provides one using a median filter. However, these convolutions often result in a loss of important edge information, since t
2 min read
Python OpenCV - Morphological Operations
Python OpenCV Morphological operations are one of the Image processing techniques that processes image based on shape. This processing strategy is usually performed on binary images. Morphological operations based on OpenCV are as follows: ErosionDilationOpeningClosingMorphological GradientTop hatB
7 min read
Erosion and Dilation of images using OpenCV in python
Morphological operations are a set of operations that process images based on shapes. They apply a structuring element to an input image and generate an output image. The most basic morphological operations are two: Erosion and Dilation Basics of Erosion: Erodes away the boundaries of the foreground
2 min read
Introduction to Resampling methods
While reading about Machine Learning and Data Science we often come across a term called Imbalanced Class Distribution, which generally happens when observations in one of the classes are much higher or lower than in other classes. As Machine Learning algorithms tend to increase accuracy by reducing
8 min read
Python | Image Registration using OpenCV
Image registration is a digital image processing technique that helps us align different images of the same scene. For instance, one may click the picture of a book from various angles. Below are a few instances that show the diversity of camera angles.Now, we may want to "align" a particular image
3 min read
Feature Extraction and Description
Feature Extraction Techniques - NLP
Introduction : This article focuses on basic feature extraction techniques in NLP to analyse the similarities between pieces of text. Natural Language Processing (NLP) is a branch of computer science and machine learning that deals with training computers to process a large amount of human (natural)
11 min read
SIFT Interest Point Detector Using Python - OpenCV
SIFT (Scale Invariant Feature Transform) Detector is used in the detection of interest points on an input image. It allows the identification of localized features in images which is essential in applications such as:Â Â Object Recognition in ImagesPath detection and obstacle avoidance algorithmsGest
4 min read
Feature Matching using Brute Force in OpenCV
In this article, we will do feature matching using Brute Force in Python by using OpenCV library. Prerequisites: OpenCV OpenCV is a python library which is used to solve the computer vision problems. OpenCV is an open source Computer Vision library. So computer vision is a way of teaching intelligen
13 min read
Feature detection and matching with OpenCV-Python
In this article, we are going to see about feature detection in computer vision with OpenCV in Python. Feature detection is the process of checking the important features of the image in this case features of the image can be edges, corners, ridges, and blobs in the images. In OpenCV, there are a nu
5 min read
Feature matching using ORB algorithm in Python-OpenCV
ORB is a fusion of FAST keypoint detector and BRIEF descriptor with some added features to improve the performance. FAST is Features from Accelerated Segment Test used to detect features from the provided image. It also uses a pyramid to produce multiscale-features. Now it doesn’t compute the orient
2 min read
Mahotas - Speeded-Up Robust Features
In this article we will see how we can get the speeded up robust features of image in mahotas. In computer vision, speeded up robust features (SURF) is a patented local feature detector and descriptor. It can be used for tasks such as object recognition, image registration, classification, or 3D rec
2 min read
Create Local Binary Pattern of an image using OpenCV-Python
In this article, we will discuss the image and how to find a binary pattern using the pixel value of the image. As we all know, image is also known as a set of pixels. When we store an image in computers or digitally, it’s corresponding pixel values are stored. So, when we read an image to a variabl
5 min read
Deep Learning for Computer Vision
Image Classification using CNN
The article is about creating an Image classifier for identifying cat-vs-dogs using TFLearn in Python. Machine Learning is now one of the hottest topics around the world. Well, it can even be said of the new electricity in today's world. But to be precise what is Machine Learning, well it's just one
7 min read
What is Transfer Learning?
Transfer learning is a machine learning technique where a model trained on one task is repurposed as the foundation for a second task. This approach is beneficial when the second task is related to the first or when data for the second task is limited. Leveraging learned features from the initial ta
11 min read
Top 5 PreTrained Models in Natural Language Processing (NLP)
Pretrained models are deep learning models that have been trained on huge amounts of data before fine-tuning for a specific task. The pre-trained models have revolutionized the landscape of natural language processing as they allow the developer to transfer the learned knowledge to specific tasks, e
7 min read
ML | Introduction to Strided Convolutions
Let us begin this article with a basic question - "Why padding and strided convolutions are required?" Assume we have an image with dimensions of n x n. If it is convoluted with an f x f filter, then the dimensions of the image obtained are [Tex](n-f+1) x (n-f+1)[/Tex]. Example: Consider a 6 x 6 ima
2 min read
Dilated Convolution
Prerequisite: Convolutional Neural Networks Dilated Convolution: It is a technique that expands the kernel (input) by inserting holes between its consecutive elements. In simpler terms, it is the same as convolution but it involves pixel skipping, so as to cover a larger area of the input. Dilated
5 min read
Continuous Kernel Convolution
Continuous Kernel convolution was proposed by the researcher of Verije University Amsterdam in collaboration with the University of Amsterdam in a paper titled 'CKConv: Continuous Kernel Convolution For Sequential Data'. The motivation behind that is to propose a model that uses the properties of co
6 min read
CNN | Introduction to Pooling Layer
Pooling layer is used in CNNs to reduce the spatial dimensions (width and height) of the input feature maps while retaining the most important information. It involves sliding a two-dimensional filter over each channel of a feature map and summarizing the features within the region covered by the fi
5 min read
CNN | Introduction to Padding
During convolution, the size of the output feature map is determined by the size of the input feature map, the size of the kernel, and the stride. if we simply apply the kernel on the input feature map, then the output feature map will be smaller than the input. This can result in the loss of inform
5 min read
What is the difference between 'SAME' and 'VALID' padding in tf.nn.max_pool of tensorflow?
Padding is a technique used in convolutional neural networks (CNNs) to preserve the spatial dimensions of the input data and prevent the loss of information at the edges of the image. It involves adding additional rows and columns of pixels around the edges of the input data. There are several diffe
14 min read
Convolutional Neural Network (CNN) Architectures
Convolutional Neural Network(CNN) is a neural network architecture in Deep Learning, used to recognize the pattern from structured arrays. However, over many years, CNN architectures have evolved. Many variants of the fundamental CNN Architecture This been developed, leading to amazing advances in t
11 min read
Deep Transfer Learning - Introduction
Deep transfer learning is a machine learning technique that utilizes the knowledge learned from one task to improve the performance of another related task. This technique is particularly useful when there is a shortage of labeled data for the target task, as it allows the model to leverage the know
8 min read
Introduction to Residual Networks
Recent years have seen tremendous progress in the field of Image Processing and Recognition. Deep Neural Networks are becoming deeper and more complex. It has been proved that adding more layers to a Neural Network can make it more robust for image-related tasks. But it can also cause them to lose a
4 min read
Residual Networks (ResNet) - Deep Learning
After the first CNN-based architecture (AlexNet) that win the ImageNet 2012 competition, Every subsequent winning architecture uses more layers in a deep neural network to reduce the error rate. This works for less number of layers, but when we increase the number of layers, there is a common proble
9 min read
ML | Inception Network V1
Inception net achieved a milestone in CNN classifiers when previous models were just going deeper to improve the performance and accuracy but compromising the computational cost. The Inception network, on the other hand, is heavily engineered. It uses a lot of tricks to push performance, both in ter
4 min read
Understanding GoogLeNet Model - CNN Architecture
Google Net (or Inception V1) was proposed by research at Google (with the collaboration of various universities) in 2014 in the research paper titled "Going Deeper with Convolutions". This architecture was the winner at the ILSVRC 2014 image classification challenge. It has provided a significant de
4 min read
Image Recognition with Mobilenet
Introduction: Image Recognition plays an important role in many fields like medical disease analysis, and many more. In this article, we will mainly focus on how to Recognize the given image, what is being displayed. We are assuming to have a pre-knowledge of Tensorflow, Keras, Python, MachineLearni
5 min read
VGG-16 | CNN model
A Convolutional Neural Network (CNN) architecture is a deep learning model designed for processing structured grid-like data, such as images. It consists of multiple layers, including convolutional, pooling, and fully connected layers. CNNs are highly effective for tasks like image classification, o
7 min read
Autoencoders in Machine Learning
An autoencoder is a type of artificial neural network that learns to represent data in a compressed form and then reconstructs it as closely as possible to the original input. Autoencoders consists of two components: Encoder: This compresses the input into a compact representation and capture the mo
9 min read
How Autoencoders works ?
Autoencoders is a type of neural network used for unsupervised learning particularly for tasks like dimensionality reduction, anomaly detection and feature extraction. It consists of two main parts: an encoder and a decoder. The goal of an autoencoder is to learn a more efficient representation of t
7 min read
Difference Between Encoder and Decoder
Combinational Logic is the concept in which two or more input states define one or more output states. The Encoder and Decoder are combinational logic circuits. In which we implement combinational logic with the help of boolean algebra. To encode something is to convert in piece of information into
9 min read
Implementing an Autoencoder in PyTorch
Autoencoders are neural networks that learn to compress and reconstruct data. In this guide we’ll walk you through building a simple autoencoder in PyTorch using the MNIST dataset. This approach is useful for image compression, denoising and feature extraction. Implementation of Autoencoder in PyTor
4 min read
Generative Adversarial Network (GAN)
Generative Adversarial Networks (GANs) were introduced by Ian Goodfellow and his colleagues in 2014. GANs are a class of neural networks that autonomously learn patterns in the input data to generate new examples resembling the original dataset. GAN's architecture consists of two neural networks: Ge
12 min read
Deep Convolutional GAN with Keras
Deep Convolutional GAN (DCGAN) was proposed by a researcher from MIT and Facebook AI research. It is widely used in many convolution-based generation-based techniques. The focus of this paper was to make training GANs stable. Hence, they proposed some architectural changes in the computer vision pro
9 min read
StyleGAN - Style Generative Adversarial Networks
Generative Adversarial Networks (GANs) are a type of neural network that consist two neural networks: a generator that creates images and a discriminator that evaluates them. The generator tries to produce realistic data while the discriminator tries to differentiate between real and generated data.
6 min read
Object Detection and Recognition
40+ Top Computer Vision Projects [2025 Updated]
Computer Vision is a branch of Artificial Intelligence (AI) that helps computers understand and interpret context of images and videos. It is used in domains like security cameras, photo editing, self-driving cars and robots to recognize objects and navigate real world using machine learning. This a
4 min read