CODEWITHSUNDEEP
image-processingfilter
user366312
user366312

Reputation: 16894

How can I create a custom band-pass filter?

In this research paper, in the Section 4.1(Preprocessing), an equation of a Bandpass filter is given:

enter image description here

Where,

enter image description here

Now, I have implemented this like the following:

https://dotnetfiddle.net/ZhucE2

But, this code produces nothing.

Upvotes: 10

Views: 2267

Answers (2)

user1196549
user1196549

Reputation:

There is no real need to store the filter in an array. You can just perform a double loop on the u, v components for the values at which the FFT was evaluated, compute the filter response H(u, v) for every couple and multiply that to the corresponding array element. After reverse transformation of the modifed array, you'll get the filtered image.

Upvotes: 3

taarraas
taarraas

Reputation: 1483

You need to create image of your kernel, then to convolve it with your image. fft is used for optimization of convolution for large images. You can use filter2D function to make opencv do everything for you.

Kernel image:
enter image description here
Source image:
Source image
Convolution applied:
enter image description here
Trhesholding:
enter image description here

Please see code below:

import cv2
import math
import numpy as np

class Kernel(object):
    def H_Function(self, Dh, Dv, u, v, centerX, centerY, theta, n):
        return 1 / (1 + 0.414 * math.sqrt(math.pow(self.U_Star(u, centerX, centerY, theta) / Dh + self.V_Star(v, centerX, centerY, theta) / Dv, 2 * n)))

    def U_Star(self, u, centerX, centerY, theta):
        return math.cos(theta) * (u + self.Tx(centerX, theta)) + math.sin(theta) * (u + self.Ty(centerY, theta))

    def V_Star(self, u, centerX, centerY, theta):
        return (-math.sin(theta)) * (u + self.Tx(centerX, theta)) + math.cos(theta) * (u + self.Ty(centerY, theta))

    def Tx(self, center, theta):
        return center * math.cos(theta)

    def Ty(self, center, theta):
        return center * math.sin(theta)

K = Kernel()

size = 40, 40
kernel = np.zeros(size, dtype=np.float)
Dh=2
Dv=2
centerX = -size[0] / 2
centerY = -size[1] / 2
theta=0.9
n=4

for u in range(0, size[0]):
    for v in range(0, size[1]):
        kernel[u][v] = K.H_Function(Dh, Dv, u, v, centerX, centerY, theta, n) 
kernelNorm = np.copy(kernel)
cv2.normalize(kernel, kernel, 1.0, 0, cv2.NORM_L1)
cv2.normalize(kernelNorm, kernelNorm, 0, 255, cv2.NORM_MINMAX)
cv2.imwrite("kernel.jpg", kernelNorm)

imgSrc = cv2.imread('src.jpg',0)

convolved = cv2.filter2D(imgSrc,-1,kernel)
cv2.normalize(convolved, convolved, 0, 255, cv2.NORM_MINMAX)
cv2.imwrite("conv.jpg", convolved)
th, thresholded = cv2.threshold(convolved, 100, 255, cv2.THRESH_BINARY)
cv2.imwrite("thresh.jpg", thresholded)

Upvotes: 8

Related Questions