Tag Archives: opencv python

Log Transformation

Log transformation means replacing each pixel value with its logarithm. The general form of log transformation function is

s = T(r) = c*log(1+r)

Where, ‘s’ and ‘r’ are the output and input pixel values and c is the scaling constant represented by the following expression (for 8-bit)

c = 255/(log(1 + max_input_pixel_value))

The value of c is chosen such that we get the maximum output value corresponding to the bit size used. e.g for 8 bit image, c is chosen such that we get max value equal to 255.

For an 8-bit image, log transformation looks like this

Clearly, the low intensity values in the input image are mapped to a wider range of output levels. The opposite is true for the higher values.

Applications:

Expands the dark pixels in the image while compressing the brighter pixels
Compresses the dynamic range (display of Fourier transform).

Dynamic range refers to the ratio of max and min intensity values. When the dynamic range of the image is greater than that of displaying device(like in Fourier transform), the lower values are suppressed. To overcome this issue, we use log transform. Log transformation first compresses the dynamic range and then upscales the image to a dynamic range of the display device. In this way, lower values are enhanced and thus the image shows significantly more details.

The code below shows how to apply log transform using OpenCV Python

import cv2
import numpy as np
# Load the image
img = cv2.imread('D:/downloads/pasta.JPG')
# Apply log transform
img_log = (np.log(img+1)/(np.log(1+np.max(img))))*255
# Specify the data type
img_log = np.array(img_log,dtype=np.uint8)
# Display the image
cv2.imshow('log_image',img_log )
cv2.imshow('original_img',img)
cv2.waitKey(0)

import cv2

import numpy as np

# Load the image

img = cv2.imread('D:/downloads/pasta.JPG')

# Apply log transform

img_log = (np.log(img+1)/(np.log(1+np.max(img))))*255

# Specify the data type

img_log = np.array(img_log,dtype=np.uint8)

# Display the image

cv2.imshow('log_image',img_log )

cv2.imshow('original_img',img)

cv2.waitKey(0)

Thus, a logarithmic transform is appropriate when we want to enhance the low pixel values at the expense of loss of information in the high pixel values.

Be careful, if most of the details are present in the high pixel values, then applying the log transform results in the loss of information as shown below

In the next blog, we will discuss Power law or Gamma transformation. Hope you enjoy reading.

If you have any doubt/suggestion please feel free to ask and I will do my best to help or improve myself. Good-bye until next time.

Image Negatives or inverting images using OpenCV

Leave a reply

Image negatives, most of you might have heard this term, in good old days were used to produce images. Film Photography has not yet become obsolete as some wedding photographers are still shooting film. Because one has to pay for the film rolls and processing fees, most people have now switched to digital.

I recently heard of Foveon X3 direct image sensor which claims to combine the power of digital sensor with the essence of the film. (Check here)

Image negative is produced by subtracting each pixel from the maximum intensity value. e.g. for an 8-bit image, the max intensity value is 2⁸– 1 = 255, thus each pixel is subtracted from 255 to produce the output image.

Thus, the transformation function used in image negative is

s = T(r) = L – 1 – r

Where L-1 is the max intensity value and s, and r are the output and input pixel values respectively.

For grayscale images, light areas appear dark and vice versa. For color images, colors are replaced by their complementary colors. Thus, red areas appear cyan, greens appear magenta, and blues appear yellow, and vice versa.

import cv2
import numpy as np
# Load the image
img = cv2.imread('D:/downloads/forest.jpg')
# Check the datatype of the image
print(img.dtype)
# Subtract the img from max value(calculated from dtype)
img_neg = 255 - img
# Show the image
cv2.imshow('negative',img_neg)
cv2.waitKey(0)

import cv2

import numpy as np

# Load the image

img = cv2.imread('D:/downloads/forest.jpg')

# Check the datatype of the image

print(img.dtype)

# Subtract the img from max value(calculated from dtype)

img_neg = 255 - img

# Show the image

cv2.imshow('negative',img_neg)

cv2.waitKey(0)

The output looks like this

Method 2

OpenCV provides a built-in function cv2.bitwise_not() that inverts every bit of an array. This takes as input the original image and outputs the inverted image. Below is the code for this.

import cv2

# Load the image
img = cv2.imread('D:/downloads/forest.jpg')

# Invert the image using cv2.bitwise_not
img_neg = cv2.bitwise_not(img)

# Show the image
cv2.imshow('negative',img_neg)
cv2.waitKey(0)

import cv2

# Load the image

img = cv2.imread('D:/downloads/forest.jpg')

# Invert the image using cv2.bitwise_not

img_neg = cv2.bitwise_not(img)

# Show the image

cv2.imshow('negative',img_neg)

cv2.waitKey(0)

There is a long debate going on whether black on white or white on black is better. To my knowledge, Image negative favors black on white thus it is suited for enhancing the white or gray information embedded in the dark regions of the image especially when the black areas are dominant in size.

Application: In grayscale images, when the background is black, the foreground gray levels are not clearly visible. So, converting background to white, the gray levels now become more visible.

In the next blog, we will discuss Log transformations in detail. Hope you enjoy reading.

If you have any doubt/suggestion please feel free to ask and I will do my best to help or improve myself. Good-bye until next time.

Intensity Transformation

Leave a reply

Intensity transformation as the name suggests, we transform the pixel intensity value using some transformation function or mathematical expression.

Intensity transformation operation is usually represented in the form

s = T(r)

where, r and s denotes the pixel value before and after processing and T is the transformation that maps pixel value r into s.

Basic types of transformation functions used for image enhancement are

Linear (Negative and Identity Transformation)
Logarithmic (log and inverse-log transformation)
Power law transformation

The below figure summarize these functions. Here, L denotes the intensity value (for 8-bit, L = [0,255])

**source: R. C. Gonzalez**, **R. E. Woods, Digital Image Processing**

This is a spatial domain technique which means that all the operations are done directly on the pixels. Also known as a point processing technique (output depend only on the single pixel) as opposed to neighborhood processing techniques(like filtering) which we will discuss later.

Applications:

To increase the contrast between certain intensity values or image regions.

For image thresholding or segmentation

In the next blog, we will discuss these different transformation functions in detail. Hope you enjoy reading.

If you have any doubt/suggestion please feel free to ask and I will do my best to help or improve myself. Good-bye until next time.

Image Processing – Bicubic Interpolation

1 Reply

In the last blog, we discussed what is Bi-linear interpolation and how it is performed on images. In this blog, we will learn Bi-cubic interpolation in detail.

Note: We will be using some concepts from the Nearest Neighbour and Bilinear interpolation blog. Check them first before moving forward.

Difference between Bi-linear and Bi-cubic:

Bi-linear uses 4 nearest neighbors to determine the output, while Bi-cubic uses 16 (4×4 neighbourhood).
Weight distribution is done differently.

So, the only thing we need to know is how weights are distributed and rest is same as Bi-linear.

In OpenCV, weights are distributed according to the following code (whole code can be found here)

const float A = -0.75f;

coeffs[0] = ((A*(x + 1) - 5*A)*(x + 1) + 8*A)*(x + 1) - 4*A;
coeffs[1] = ((A + 2)*x - (A + 3))*x*x + 1;
coeffs[2] = ((A + 2)*(1 - x) - (A + 3))*(1 - x)*(1 - x) + 1;
coeffs[3] = 1.f - coeffs[0] - coeffs[1] - coeffs[2];

const float A = -0.75f;

coeffs[0] = ((A*(x + 1) - 5*A)*(x + 1) + 8*A)*(x + 1) - 4*A;

coeffs[1] = ((A + 2)*x - (A + 3))*x*x + 1;

coeffs[2] = ((A + 2)*(1 - x) - (A + 3))*(1 - x)*(1 - x) + 1;

coeffs[3] = 1.f - coeffs[0] - coeffs[1] - coeffs[2];

x used in the above code is calculated from below code where x = fx

fx = (float)((dx+0.5)*scale_x - 0.5);
sx = cvFloor(fx);
fx -= sx;

fx = (float)((dx+0.5)*scale_x - 0.5);

sx = cvFloor(fx);

fx -= sx;

Similarly, for y, replace x with fy and fy can be obtained by replacing dx and scale_x in the above code by dy and scale_y respectively (Explained in the previous blog).

Note: For Matlab, use A= -0.50

Let’s see an example. We take the same 2×2 image from the previous blog and want to upscale it by a factor of 2 as shown below

Steps:

In the last blog, we calculated for P1. This time let’s take ‘P2’. First, we find the position of P2 in the input image as we did before. So, we find P2 coordinate as (0.75,0.25) with dx = 1 and dy=0.
Because cubic needs 4 pixels (2 on left and 2 on right) so, we pad the input image.
OpenCV has different methods to add borders which you can check here. Here, I used cv2.BORDER_REPLICATE method. You can use any. After padding the input image looks like this

**After padding, Blue square is the input image**

To find the value of P2, let’s first visualize where P2 is in the image. Yellow is the input image before padding. We take the blue 4×4 neighborhood as shown below

For P2, using dx and dy we calculate fx and fy from code above. We get, fx=0.25 and fy=0.75
Now, we substitute fx and fy in the above code to calculate the four coefficients. Thus we get coefficients = [-0.0351, 0.2617,0.8789, -0.1055] for fy =0.75 and for fx=0.25 we get coefficients = [ -0.1055 , 0.8789, 0.2617, -0.0351]
First, we will perform cubic interpolation along rows( as shown in the above figure inside blue box) with the above calculated weights for fx as
-0.1055 *10 + 0.8789*10 + 0.2617*20 -0.0351*20 = 12.265625
-0.1055 *10 + 0.8789*10 + 0.2617*20 -0.0351*20 = 12.265625
-0.1055 *10 + 0.8789*10 + 0.2617*20 -0.0351*20 = 12.265625
-0.1055 *30 + 0.8789*30 + 0.2617*40 -0.0351*40 = 32.265625
Now, using above calculated 4 values, we will interpolate along columns using calculated weights for fy as
-0.0351*12.265 + 0.2617*12.265 + 0.8789*12.265 -0.1055*32.625 = 10.11702
Similarly, repeat for other pixels.

The final result we get is shown below:

This produces noticeably sharper images than the previous two methods and balances processing time and output quality. That’s why it is used widely (e.g. Adobe Photoshop etc.)

In the next blog, we will see these interpolation methods using OpenCV functions on real images. Hope you enjoy reading.

If you have any doubt/suggestion please feel free to ask and I will do my best to help or improve myself. Good-bye until next time.

Image Processing – Bilinear Interpolation

11 Replies

In the previous blog, we learned how to find the pixel coordinate in the input image and then we discussed nearest neighbour algorithm. In this blog, we will discuss Bi-linear interpolation method in detail.

Bi-linear interpolation means applying a linear interpolation in two directions. Thus, it uses 4 nearest neighbors, takes their weighted average to produce the output

So, let’s first discuss what is linear interpolation and how it is performed?

Linear interpolation means we estimate the value using linear polynomials. Suppose we have 2 points having value 10 and 20 and we want to guess the values in between them. Simple Linear interpolation looks like this

More weight is given to the nearest value(See 1/3 and 2/3 in the above figure). For 2D (e.g. images), we have to perform this operation twice once along rows and then along columns that is why it is known as Bi-Linear interpolation.

Algorithm for Bi-linear Interpolation:

Suppose we have 4 pixels located at (0,0), (1,0), (0,1) and (1,1) and we want to find value at (0.3,0.4).

First, find the value along rows i.e at position A:(0,0.4) and B:(1,0.4) by linear interpolation.
After getting the values at A and B, apply linear interpolation for point (0.3,0.4) between A and B and this is the final result.

Let’s see how to do this for images. We take the same 2×2 image from the previous blog and want to upscale it by a factor of 2 as shown below

Same assumptions as we took in the last blog, pixel is of size 1 and is located at the center.

Let’s take ‘P1’. First, we find the position of P1 in the input image. By projecting the 4×4 image on the input 2×2 image we get the coordinates of P1 as (0.25,0.25). (For more details, See here)
Since P1 is the border pixel and has no values to its left, so OpenCV replicates the border pixel. This means the row or column at the very edge of the original is replicated to the extra border(padding). OpenCV has different methods to add borders which you can check here.
So, now our input image (after border replication) looks like this. Note the values in red shows the input image.

To find the value of P1, let’s first visualize where P1 is in the input image (previous step image). Below figure shows the upper left 2×2 input image region and the location of P1 in that.

Before applying Bi-linear interpolation let’s see how weights are distributed.

Both Matlab and OpenCV yield different results for interpolation because their weight distribution is done differently. Here, I will only explain for OpenCV.

In OpenCV, weights are distributed according to this equation

fx = (float)((dx+0.5)*scale_x - 0.5);
sx = cvFloor(fx);
fx -= sx;

fx = (float)((dx+0.5)*scale_x - 0.5);

sx = cvFloor(fx);

fx -= sx;

Where dx is the column index of the unknown pixel and fx is the weight that is assigned to the right pixel, 1-fx is given to the left pixel. Scale_x is the ratio of input width by output width. Similarly, for y, dy is the row index and scale_y is the ratio of heights now.

After knowing how weights are calculated let’s get back to the problem again.

For P1, both row and column index i.e dx, and dy =0 so, fx = 0.75 and fy =0.75.
We apply linear interpolation with weights fx for both A and B(See Image-1) as 0.75*10(right) + 0.25*10 = 10 (Explained in the Algorithm above)
Now, for P1 apply linear interpolation between A and B with the weights fy as 0.75*10(B) +0.25*10(A) = 10
So, we get P1 =10. Similarly, repeat for other pixels.

The final result we get is shown below:

This produces smoother results than the nearest neighbor but, the results for sharp transitions like edges, are not ideal.

In the next blog, we will discuss Bi-cubic interpolation. Hope you enjoy reading.

If you have any doubt/suggestion please feel free to ask and I will do my best to help or improve myself. Good-bye until next time.

Image Processing – Nearest Neighbour Interpolation

2 Replies

In the previous blog, we discussed image interpolation, its types and why we need interpolation. In this blog, we will discuss the Nearest Neighbour, a non-adaptive interpolation method in detail.

Algorithm: We assign the unknown pixel to the nearest known pixel.

Let’s see how this works. Suppose, we have a 2×2 image and let’s say we want to upscale this by a factor of 2 as shown below.

Let’s pick up the first pixel (denoted by ‘P1’) in the unknown image. To assign it a value, we must find its nearest pixel in the input 2×2 image. Let’s first see some facts and assumptions used in this.

Assumption: a pixel is always represented by its center value. Each pixel in our input 2×2 image is of unit length and width.

Indexing in OpenCV starts from 0 while in matlab it starts from 1. But for the sake of simplicity, we will start indexing from 0.5 which means that our first pixel is at 0.5 next at 1.5 and so on as shown below.

So for the above example, the location of each pixel in input image is {’10’:(0.5,0.5), ’20’:(1.5,0.5), ’30’:(0.5,1.5), ’40’:(1.5,1.5)}.

After finding the location of each pixel in the input image, follow these 2 steps

First, find the position of each pixel (of the unknown image) in the input image. This is done by projecting the 4×4 image on the 2×2 image. So, we can easily find out the coordinates of each unknown pixel e.g location of ‘P1’ in the input image is (0.25,0.25), for ‘P2’ (0.75,0.25) and so on.
Now, compare the above-calculated coordinates of each unknown pixel with the input image pixels to find out the nearest pixel e.g. ‘P1′(0.25,0.25) is nearest to 10 (0.5,0.5) so we assign ‘P1’ value of 10. Similarly, for other pixels, we can find their nearest pixel.

The final result we get is shown in figure below:

This is the fastest interpolation method as it involves little calculation. This results in a pixelated or blocky image. This has the effect of simply making each pixel bigger

Application: To resize bar-codes.

Shortcut: Simply duplicate the rows and columns to get the interpolated or zoomed image e.g. for 2x, we duplicate each row and column 2 times.

In the next blog, we will discuss Bi-linear interpolation method. Hope you enjoy reading.

If you have any doubt/suggestion please feel free to ask and I will do my best to help or improve myself. Good-bye until next time.

Arithmetic Operations for Image Enhancement

Leave a reply

In this blog, we will learn how simple arithmetic operations like addition, subtraction etc can be used for image enhancement. First, let’s start with image addition also known as Image averaging.

Image Averaging

This is based on the assumption that noise present in the image is purely random(uncorrelated) and thus has zero average value. So, if we average n noisy images of same source, the noise will cancel out and what we get is approximately the original image.

Applicability Conditions: Images should be taken under identical conditions with same camera settings like in the field of astronomy.

Advantages: Reduce noise without compromising image details unlike most other operations like filtering.

Disadvantages: Increases time and storage as now one needs to take multiple photos of the same object. Only applicable for random noise. Must follow the above applicability condition.

Below is the code where first I generated 20 images by adding random noise to the original image and then average these images to get the approx. original image.

cv2.randn(image, mean, standard deviation) fills the image with normally distributed random numbers with specified mean and standard deviation.

import cv2
import numpy as np
# Load original image
img = cv2.imread('D:/downloads/forest.jpg')
# Create list to store noisy images
images = []
# Generate noisy images using cv2.randn. Can use your own mean and std.
for _ in range(20):
    img1 = img.copy() 
    cv2.randn(img1,(0,0,0),(50,50,50))
    images.append(img+img1)
# For averaging create an empty array, then add images to this array.
img_avg=np.zeros((img.shape[0],img.shape[1],img.shape[2]),np.float32)
for im in images:
    img_avg=img_avg+im/20
# Round the float values. Always specify the dtype
img_avg=np.array(np.round(img_avg),dtype=np.uint8)
# Display the images
cv2.imshow('average_image',img_avg)
cv2.imshow('original_image',img)
cv2.imshow('noise_image',images[1])
cv2.waitKey(0)

import cv2

import numpy as np

# Load original image

img = cv2.imread('D:/downloads/forest.jpg')

# Create list to store noisy images

images = []

# Generate noisy images using cv2.randn. Can use your own mean and std.

for _ in range(20):

img1 = img.copy()

cv2.randn(img1,(0,0,0),(50,50,50))

images.append(img+img1)

# For averaging create an empty array, then add images to this array.

img_avg=np.zeros((img.shape[0],img.shape[1],img.shape[2]),np.float32)

for im in images:

img_avg=img_avg+im/20

# Round the float values. Always specify the dtype

img_avg=np.array(np.round(img_avg),dtype=np.uint8)

# Display the images

cv2.imshow('average_image',img_avg)

cv2.imshow('original_image',img)

cv2.imshow('noise_image',images[1])

cv2.waitKey(0)

Image Subtraction

This is mainly used to enhance the difference between images. Used for background subtraction for detecting moving objects, in medical science for detecting blockage in the veins etc a field known as mask mode radiography. In this, we take 2 images, one before injecting a contrast medium and other after injecting. Then we subtract these 2 images to know how that medium propagated, is there any blockage or not.

Image Multiplication

This can be used to extract Region of interest (ROI) from an image. We simply create a mask and multiply the image with the mask to get the area of interest. Other applications can be shading correction which we will discuss in detail in the next blogs.

In the next blog, we will discuss intensity transformation, a spatial domain image enhancement technique. Hope you enjoy reading.

If you have any doubt/suggestion please feel free to ask and I will do my best to help or improve myself. Good-bye until next time.

Understanding Color Models using OpenCV-Python

Leave a reply

In this blog, we will see how to convert images from one color model to another and how different colors can be obtained from these color models.

In OpenCV, the command for converting an image to another color-space is

cv2.cvtColor(input_image, conversion_method)

for example, BGR to HSV conversion can be done by using cv2.COLOR_BGR2HSV method

out_img = cv2.cvtColor(input_img, cv2.COLOR_BGR2HSV)

1	out_img = cv2.cvtColor(input_img, cv2.COLOR_BGR2HSV)

In OpenCV, more than 150 color-space conversion methods are available. To get the other conversion methods, type the following commands

>>> import cv2
>>> conver_method = [i for i in dir(cv2) if i.startswith('COLOR_')]
>>> print (conver_method)

>>> import cv2

>>> conver_method = [i for i in dir(cv2) if i.startswith('COLOR_')]

>>> print (conver_method)

In the previous blog, we learned how we can construct all colors from each model. Now, let’s get the feeling of this with OpenCV.

Here, I will create three trackbars to specify each of B, G, R colors and a window which shows the color obtained by combining different proportions of B, G, R. Similarly for HSI and CMYK models.

In OpenCV, Trackbar can be created using the cv2.createTrackbar() and its position at any moment can be found using cv2.getTrackbarPos().

RGB Trackbar

import cv2
import numpy as np

def nothing(x):
    pass

# Create a black image, a window
img = np.zeros((512,512,3), np.uint8)
cv2.namedWindow('image',cv2.WINDOW_NORMAl)

# create trackbars for color change
cv2.createTrackbar('R','image',0,255,nothing)
cv2.createTrackbar('G','image',0,255,nothing)
cv2.createTrackbar('B','image',0,255,nothing)


while True:
    cv2.imshow('image',img)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break
    
    # get current positions of three trackbars
    r = cv2.getTrackbarPos('R','image')
    g = cv2.getTrackbarPos('G','image')
    b = cv2.getTrackbarPos('B','image')

    img[:] = [b,g,r]

cv2.destroyAllWindows()

import cv2

import numpy as np

def nothing(x):

pass

# Create a black image, a window

img = np.zeros((512,512,3), np.uint8)

cv2.namedWindow('image',cv2.WINDOW_NORMAl)

# create trackbars for color change

cv2.createTrackbar('R','image',0,255,nothing)

cv2.createTrackbar('G','image',0,255,nothing)

cv2.createTrackbar('B','image',0,255,nothing)

while True:

cv2.imshow('image',img)

if cv2.waitKey(1) & 0xFF == ord('q'):

break

# get current positions of three trackbars

r = cv2.getTrackbarPos('R','image')

g = cv2.getTrackbarPos('G','image')

b = cv2.getTrackbarPos('B','image')

img[:] = [b,g,r]

cv2.destroyAllWindows()

You can move these trackbars to obtain different colors. A snapshot of output is shown below

HSI Trackbar

import cv2
import numpy as np

def nothing(x):
    pass

# Create a black image, a window
img = np.zeros((512,512,3), np.uint8)
cv2.namedWindow('image',cv2.WINDOW_NORMAL)

# create trackbars for color change
cv2.createTrackbar('H','image',0,180,nothing)
cv2.createTrackbar('S','image',0,255,nothing)
cv2.createTrackbar('I','image',0,255,nothing)

while(True):
    cv2.imshow('image',img)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

    # get current positions of four trackbars
    r = cv2.getTrackbarPos('H','image')
    g = cv2.getTrackbarPos('S','image')
    b = cv2.getTrackbarPos('I','image')

    img[:,:] = [r,g,b]
    img = cv2.cvtColor(img, cv2.COLOR_HSV2BGR)

cv2.destroyAllWindows()

import cv2

import numpy as np

def nothing(x):

pass

# Create a black image, a window

img = np.zeros((512,512,3), np.uint8)

cv2.namedWindow('image',cv2.WINDOW_NORMAL)

# create trackbars for color change

cv2.createTrackbar('H','image',0,180,nothing)

cv2.createTrackbar('S','image',0,255,nothing)

cv2.createTrackbar('I','image',0,255,nothing)

while(True):

cv2.imshow('image',img)

if cv2.waitKey(1) & 0xFF == ord('q'):

break

# get current positions of four trackbars

r = cv2.getTrackbarPos('H','image')

g = cv2.getTrackbarPos('S','image')

b = cv2.getTrackbarPos('I','image')

img[:,:] = [r,g,b]

img = cv2.cvtColor(img, cv2.COLOR_HSV2BGR)

cv2.destroyAllWindows()

We get the following output as

Similarly, you can create trackbar for any color model. Play with these trackbars to get intuition about color models. Hope you enjoy reading.

If you have any doubt/suggestion please feel free to ask and I will do my best to help or improve myself. Good-bye until next time.

Object Tracking Using Color Models OpenCV-Python

Leave a reply

In this tutorial, we will learn how we can use color models for object tracking. You can use any color model. Here, I have used HSI because it is easier to represent a color using the HSI model (as it separates the color component from greyscale). Let’s see how to do this

Steps

Open the camera using cv2.VideoCapture()
Create 3 Trackbars of H, S, and I using cv2.createTrackbar()
Read frame by frame
Record the current trackbar position using cv2.getTrackbarPos()
Convert from BGR to HSV using cv2.cvtColor()
Threshold the HSV image based on current trackbar position using cv2.inRange()
Extract the desired result

Code

import cv2
import numpy as np

def nothing(x):
    pass

cap = cv2.VideoCapture(0) 

# Create a window
cv2.namedWindow('image',cv2.WINDOW_NORMAL)


# create trackbars for color change
cv2.createTrackbar('lowH','image',0,179,nothing)
cv2.createTrackbar('highH','image',179,179,nothing)

cv2.createTrackbar('lowS','image',0,255,nothing)
cv2.createTrackbar('highS','image',255,255,nothing)

cv2.createTrackbar('lowV','image',0,255,nothing)
cv2.createTrackbar('highV','image',255,255,nothing)

while(True):
    ret, frame = cap.read()

    # get current positions of the trackbars
    ilowH = cv2.getTrackbarPos('lowH', 'image')
    ihighH = cv2.getTrackbarPos('highH', 'image')
    ilowS = cv2.getTrackbarPos('lowS', 'image')
    ihighS = cv2.getTrackbarPos('highS', 'image')
    ilowV = cv2.getTrackbarPos('lowV', 'image')
    ihighV = cv2.getTrackbarPos('highV', 'image')

    hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
    lower_hsv = np.array([ilowH, ilowS, ilowV])
    higher_hsv = np.array([ihighH, ihighS, ihighV])
    mask = cv2.inRange(hsv, lower_hsv, higher_hsv)

    frame = cv2.bitwise_and(frame, frame, mask=mask)
    cv2.imshow('image', frame)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

import cv2

import numpy as np

def nothing(x):

pass

cap = cv2.VideoCapture(0)

# Create a window

cv2.namedWindow('image',cv2.WINDOW_NORMAL)

# create trackbars for color change

cv2.createTrackbar('lowH','image',0,179,nothing)

cv2.createTrackbar('highH','image',179,179,nothing)

cv2.createTrackbar('lowS','image',0,255,nothing)

cv2.createTrackbar('highS','image',255,255,nothing)

cv2.createTrackbar('lowV','image',0,255,nothing)

cv2.createTrackbar('highV','image',255,255,nothing)

while(True):

ret, frame = cap.read()

# get current positions of the trackbars

ilowH = cv2.getTrackbarPos('lowH', 'image')

ihighH = cv2.getTrackbarPos('highH', 'image')

ilowS = cv2.getTrackbarPos('lowS', 'image')

ihighS = cv2.getTrackbarPos('highS', 'image')

ilowV = cv2.getTrackbarPos('lowV', 'image')

ihighV = cv2.getTrackbarPos('highV', 'image')

hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)

lower_hsv = np.array([ilowH, ilowS, ilowV])

higher_hsv = np.array([ihighH, ihighS, ihighV])

mask = cv2.inRange(hsv, lower_hsv, higher_hsv)

frame = cv2.bitwise_and(frame, frame, mask=mask)

cv2.imshow('image', frame)

if cv2.waitKey(1) & 0xFF == ord('q'):

break

cap.release()

cv2.destroyAllWindows()

Open in full screen and play with trackbar to get more intuition about HSI model. Hope you enjoy reading.

If you have any doubt/suggestion please feel free to ask and I will do my best to help or improve myself. Good-bye until next time.

Image Interpolation using OpenCV-Python

Leave a reply

In the previous blogs, we discussed the algorithm behind the

nearest neighbor
bilinear and
bicubic interpolation methods using a 2×2 image.

Now, let’s do the same using OpenCV on a real image. First, let’s take an image, either you can load one or can make own image. Loading an image from the device looks like this

import cv2
import numpy as np

img = cv2.imread('C:/New folder/apple.jpg')

import cv2

import numpy as np

img = cv2.imread('C:/New folder/apple.jpg')

This is a 20×22 apple image that looks like this.

Now, let’s zoom it 10 times using each interpolation method. The OpenCV command for doing this is

dst = cv2.resize(src, dsize[, fx[, fy[, interpolation]]]])

1	dst = cv2.resize(src, dsize[, fx[, fy[, interpolation]]]])

where fx and fy are scale factors along x and y, dsize refers to the output image size and the interpolation flag refers to which method we are going to use. Either you specify (fx, fy) or dsize, OpenCV calculates the other automatically. Let’s see how to use this function

Nearest Neighbor Interpolation

In this we use cv2.INTER_NEAREST as the interpolation flag in the cv2.resize() function as shown below

near_img = cv2.resize(img,None, fx = 10, fy = 10, interpolation = cv2.INTER_NEAREST)

1	near_img = cv2.resize(img,None, fx = 10, fy = 10, interpolation = cv2.INTER_NEAREST)

Output:

Clearly, this produces a pixelated or blocky image. Also, it doesn’t introduce any new data.

Bilinear Interpolation

In this we use cv2.INTER_LINEAR flag as shown below

bilinear_img = cv2.resize(img,None, fx = 10, fy = 10, interpolation = cv2.INTER_LINEAR)

1	bilinear_img = cv2.resize(img,None, fx = 10, fy = 10, interpolation = cv2.INTER_LINEAR)

Output:

This produces a smooth image than the nearest neighbor but the results for sharp transitions like edges are not ideal because the results are a weighted average of 2 surrounding pixels.

Bicubic Interpolation

In this we use cv2.INTER_CUBIC flag as shown below

bicubic_img = cv2.resize(img,None, fx = 10, fy = 10, interpolation = cv2.INTER_CUBIC)

1	bicubic_img = cv2.resize(img,None, fx = 10, fy = 10, interpolation = cv2.INTER_CUBIC)

Output:

Clearly, this produces a sharper image than the above 2 methods. See the white patch on the left side of the apple. This method balances processing time and output quality fairly well.

Next time, when you are resizing an image using any software, wisely use the interpolation method as this can affect your result to a great extent. Hope you enjoy reading.

If you have any doubts/suggestions please feel free to ask and I will do my best to help or improve myself. Good-bye until next time.

TheAILearner

Mastering Artificial Intelligence

Tag Archives: opencv python

Log Transformation

Image Negatives or inverting images using OpenCV

Method 2

Intensity Transformation

Image Processing – Bicubic Interpolation

Steps:

Image Processing – Bilinear Interpolation

Image Processing – Nearest Neighbour Interpolation

Arithmetic Operations for Image Enhancement

Image Averaging

Image Subtraction

Image Multiplication

Understanding Color Models using OpenCV-Python

RGB Trackbar

HSI Trackbar

Object Tracking Using Color Models OpenCV-Python

Steps

Code

Image Interpolation using OpenCV-Python

Nearest Neighbor Interpolation

Bilinear Interpolation

Bicubic Interpolation