def get_filtered_CSF_img(img_in): img_dft = cv2.dft(np.float32(img_in), flags=cv2.DFT_COMPLEX_OUTPUT) dft_shift = np.fft.fftshift(img_dft) height = img_dft.shape[0] weight = img_dft.shape[1] M = weight / 2 N = height / 2 H_matrix = np.zeros((height, weight)) for h_idx in range(height): for w_idx in range(weight): m = -M + w_idx + 0.5 n = -N + h_idx + 0.5 freq, theta = get_freq_dirc(m, n, weight, height) multiVal = freq_trans_func(freq, theta) H_matrix[h_idx][w_idx] = multiVal img_magi = cv2.magnitude(img_dft[:, :, 0], img_dft[:, :, 1]) img_magi *= H_matrix img_phase = cv2.phase(img_dft[:, :, 0], img_dft[:, :, 1]) img_re = img_magi * np.cos(img_phase) img_im = img_magi * (np.sin(img_phase)) img_dft2 = np.dstack((img_re, img_im)) imgback = cv2.idft(img_dft2) imgback = cv2.magnitude(imgback[:, :, 0], imgback[:, :, 1]) return imgback
def doDFT(): # read as gray image. img = cv2.imread('1.jpg', 0) # cv2.imwrite('gray.jpg', img) # t1 = dct(dct(img.T, norm='ortho').T, norm='ortho') dft = cv2.dft(np.float32(img),flags = cv2.DFT_COMPLEX_OUTPUT) dft_shift = np.fft.fftshift(dft) magnitude_spectrum = 20*np.log(cv2.magnitude(dft_shift[:,:,0],dft_shift[:,:,1])) rows, cols = img.shape crow,ccol = rows/2 , cols/2 # create a mask first, center square is 1, remaining all zeros mask = np.zeros((rows,cols,2),np.uint8) mask[crow-5:crow+5, ccol-5:ccol+5] = 1 # apply mask and inverse DFT fshift = dft_shift*mask print fshift[:, :, 0] print fshift[:, :, 0].shape f_ishift = np.fft.ifftshift(fshift) img_back = cv2.idft(f_ishift) img_back = cv2.magnitude(img_back[:,:,0],img_back[:,:,1]) plt.subplot(121),plt.imshow(img, cmap = 'gray') plt.title('Input Image'), plt.xticks([]), plt.yticks([]) plt.subplot(122),plt.imshow(img_back, cmap = 'gray') plt.title('Magnitude Spectrum'), plt.xticks([]), plt.yticks([]) plt.show() return
def cv2_convolution(image, b): dft_m = cv2.getOptimalDFTSize(image.shape[0] + b.shape[0] - 1) dft_n = cv2.getOptimalDFTSize(image.shape[1] + b.shape[1] - 1) d = b.shape[0] c = np.zeros((image.shape[0] + d - 1, image.shape[1] + d - 1), dtype='uint8') # getting gaussian dft dft_b = np.zeros((dft_m, dft_n), dtype='float64') dft_b[:b.shape[0], :b.shape[1]] = b dft_b = cv2.dft(dft_b, flags=cv2.DFT_REAL_OUTPUT) # getting layers dft dfts = [] new_channels = [] channels = cv2.split(image) for i, channel in enumerate(channels): #cv2.imshow('channel %d'%i, channel) a = np.array(channel, dtype='float64') dft_a = np.zeros((dft_m, dft_n), dtype='float64') dft_a[:a.shape[0], :a.shape[1]] = a dft_a = cv2.dft(dft_a, flags=cv2.DFT_REAL_OUTPUT) dft_a = cv2.mulSpectrums(dft_a, dft_b, 0) dft_a = cv2.idft(dft_a, flags= cv2.DFT_SCALE | cv2.DFT_REAL_OUTPUT) tmp = dft_a[d/2:a.shape[0] + d/2, d/2:a.shape[1] + d/2] channel = np.array(tmp, dtype='uint8') #cv2.imshow('new channel %d'%i, channel) new_channels.append(channel) result = cv2.merge(new_channels) return result
def main(): parser = argparse.ArgumentParser( description='Enhance fingerprint image with diferent parameters.') parser.add_argument( "image_path", help="Specify image path location") args = parser.parse_args() pre_processor = preprocessing.PreProcessFingerImage(args.image_path) pre_processor.process_image() image_pre = pre_processor.get_preprocessed_image() #gaussian_3 = cv2.GaussianBlur(image, (9,9), 10.0) #unsharp_image = cv2.addWeighted(image, 1.5, gaussian_3, -0.5, 0, image) dft = cv2.dft(np.float32(image_pre), flags=cv2.DFT_COMPLEX_OUTPUT) dft_shift = np.fft.fftshift(dft) dft_filtered = preprocessing.frequency_filters.blpf(dft_shift, 70, 20) f_ishift = np.fft.ifftshift(dft_filtered) image_pre = cv2.idft( f_ishift, flags=cv2.DFT_SCALE | cv2.DFT_REAL_OUTPUT) for k in np.linspace(0, 2, 5): for window in [20, 25, 35, 40, image_pre.shape[0]]: image_fft = enhance_image(image_pre, window, 2, k) cv2.imshow('FF Enhanced Image with k=' + str(k) + ' window=' + str(window), image_fft) cv2.waitKey() cv2.destroyAllWindows()
def test_dft(self): img = self.get_sample('samples/data/rubberwhale1.png', 0) eps = 0.001 #test direct transform refDft = np.fft.fft2(img) refDftShift = np.fft.fftshift(refDft) refMagnitide = np.log(1.0 + np.abs(refDftShift)) testDft = cv2.dft(np.float32(img),flags = cv2.DFT_COMPLEX_OUTPUT) testDftShift = np.fft.fftshift(testDft) testMagnitude = np.log(1.0 + cv2.magnitude(testDftShift[:,:,0], testDftShift[:,:,1])) refMagnitide = cv2.normalize(refMagnitide, 0.0, 1.0, cv2.NORM_MINMAX) testMagnitude = cv2.normalize(testMagnitude, 0.0, 1.0, cv2.NORM_MINMAX) self.assertLess(cv2.norm(refMagnitide - testMagnitude), eps) #test inverse transform img_back = np.fft.ifft2(refDft) img_back = np.abs(img_back) img_backTest = cv2.idft(testDft) img_backTest = cv2.magnitude(img_backTest[:,:,0], img_backTest[:,:,1]) img_backTest = cv2.normalize(img_backTest, 0.0, 1.0, cv2.NORM_MINMAX) img_back = cv2.normalize(img_back, 0.0, 1.0, cv2.NORM_MINMAX) self.assertLess(cv2.norm(img_back - img_backTest), eps)
def cv2_deconvolution(image, b): dft_m = cv2.getOptimalDFTSize(image.shape[0] + b.shape[0] - 1) dft_n = cv2.getOptimalDFTSize(image.shape[1] + b.shape[1] - 1) c = np.zeros((image.shape[0] + d - 1, image.shape[1] + d - 1), dtype='uint8') # getting gaussian dft dft_b = np.zeros((dft_m, dft_n), dtype='float64') dft_b[:b.shape[0], :b.shape[1]] = b psf = cv2.dft(dft_b, flags=cv2.DFT_COMPLEX_OUTPUT) psf2 = (psf**2).sum(-1) ipsf = psf / (psf2 + 0.7)[..., np.newaxis] # getting layers dft dfts = [] new_channels = [] channels = cv2.split(image) for i, channel in enumerate(channels): #cv2.imshow('channel %d'%i, channel) a = np.array(channel, dtype='float64') dft_a = np.zeros((dft_m, dft_n), dtype='float64') dft_a[:a.shape[0], :a.shape[1]] = a print 'deconv' dft_a = cv2.dft(dft_a, flags=cv2.DFT_COMPLEX_OUTPUT) dft_a = cv2.mulSpectrums(dft_a, ipsf, 0) print dft_a dft_a = cv2.idft(dft_a, flags=cv2.DFT_SCALE | cv2.DFT_REAL_OUTPUT) print dft_a tmp = dft_a[d/2:a.shape[0] + d/2, d/2:a.shape[1] + d/2] channel = np.array(tmp, dtype='uint8') cv2.imshow('new channel %d'%i, channel) new_channels.append(channel) result = cv2.merge(new_channels) return result
def saliency_feature(img): img_orig = img img = cv2.resize(img, (64, 64)) img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) # h = cv2.getOptimalDFTSize(img.shape[0]) # w = cv2.getOptimalDFTSize(img.shape[1]) # print "Resizing (%d, %d) to (%d, %d)" % (img.shape[0], img.shape[1], h, w) # h = (h - img.shape[0])/2.0 # w = (w - img.shape[1])/2.0 # img = cv2.copyMakeBorder(img, int(math.floor(h)), int(math.ceil(h)), int(math.floor(w)), int(math.ceil(w)), cv2.BORDER_CONSTANT, value=0) dft = cv2.dft(np.float32(img), flags=cv2.DFT_COMPLEX_OUTPUT) A, P = cv2.cartToPolar(dft[:,:,0], dft[:,:,1]) L = cv2.log(A) h_n = (1./3**2)*np.ones((3,3)) R = L - cv2.filter2D(L, -1, h_n) S = cv2.GaussianBlur(cv2.idft(np.dstack(cv2.polarToCart(cv2.exp(R), P)), flags=cv2.DFT_REAL_OUTPUT)**2, (0,0), 8) S = cv2.resize(cv2.normalize(S, None, 0, 1, cv2.NORM_MINMAX), (img_orig.shape[1],img_orig.shape[0])) # cv2.namedWindow('tmp1', cv2.WINDOW_NORMAL) # cv2.imshow('tmp1', img_orig) # cv2.namedWindow('tmp', cv2.WINDOW_NORMAL) # cv2.imshow('tmp', S) # cv2.waitKey() return S
def apply_channel_deconvolution (self, img, psfsize=10, snrVal=8): # Based on deconvolution.py in python samples of opencv img = img.astype('double')/255.0 img = self.blur_edge(img) IMG = cv2.dft(img, flags=cv2.DFT_COMPLEX_OUTPUT) if (psfsize==0): return img defocus = True ang = 0 d = psfsize snr = snrVal noise = 10**(-0.1*snr) if defocus: psf = self.defocus_kernel(d) else: psf = self.motion_kernel(ang, d) psf /= psf.sum() psf_pad = np.zeros_like(img) kh, kw = psf.shape psf_pad[:kh, :kw] = psf PSF = cv2.dft(psf_pad, flags=cv2.DFT_COMPLEX_OUTPUT, nonzeroRows = kh) PSF2 = (PSF**2).sum(-1) iPSF = PSF / (PSF2 + noise)[...,np.newaxis] RES = cv2.mulSpectrums(IMG, iPSF, 0) res = cv2.idft(RES, flags=cv2.DFT_SCALE | cv2.DFT_REAL_OUTPUT ) res = np.roll(res, -kh//2, 0) res = np.roll(res, -kw//2, 1) return res
def inverse_fourier_transform(spectral_image): """ Method computes the inverse Fourier transform of a given image """ f_ishift = np.fft.ifftshift(spectral_image) img_back = cv2.idft(f_ishift) return cv2.magnitude(img_back[:, :, 0], img_back[:, :, 1])
def fft(img,x,y,w,h): rows, cols = img.shape crow,ccol = rows/2 , cols/2 dft = cv2.dft(np.float32(img),flags = cv2.DFT_COMPLEX_OUTPUT) dft_shift = np.fft.fftshift(dft) magnitude_spectrum = 20*np.log(cv2.magnitude(dft_shift[:,:,0],dft_shift[:,:,1])) mask = np.zeros((rows,cols,2),np.uint8) mask[crow-x:crow+w, ccol-y:ccol+h] = 1 mag_mask = copy.copy(magnitude_spectrum) mag_mask[crow-x:crow+w, ccol-y:ccol+h] = 0 fshift = dft_shift*mask f_ishift = np.fft.ifftshift(fshift) img_back = cv2.idft(f_ishift) img_back = cv2.magnitude(img_back[:,:,0],img_back[:,:,1]) plt.subplot(121),plt.imshow(img, cmap = 'gray') plt.title('Input Image'), plt.xticks([]), plt.yticks([]) plt.subplot(122),plt.imshow(magnitude_spectrum, cmap = 'gray') plt.title('Magnitude Spectrum'), plt.xticks([]), plt.yticks([]) plt.show() plt.subplot(121),plt.imshow(img_back, cmap = 'gray') plt.title('Output Image'), plt.xticks([]), plt.yticks([]) plt.subplot(122),plt.imshow(mag_mask, cmap = 'gray') plt.title('Cut Magnitude Spectrum'), plt.xticks([]), plt.yticks([]) plt.show()
def state_vis(self): f = cv2.idft(self.H, flags=cv2.DFT_SCALE | cv2.DFT_REAL_OUTPUT ) h, w = f.shape f = np.roll(f, -h//2, 0) f = np.roll(f, -w//2, 1) kernel = np.uint8( (f-f.min()) / f.ptp()*255 ) resp = self.last_resp resp = np.uint8(np.clip(resp/resp.max(), 0, 1)*255) vis = np.hstack([self.last_img, kernel, resp]) return vis
def correlate(self, img): C = cv2.mulSpectrums(cv2.dft(img, flags=cv2.DFT_COMPLEX_OUTPUT), self.H, 0, conjB=True) resp = cv2.idft(C, flags=cv2.DFT_SCALE | cv2.DFT_REAL_OUTPUT) h, w = resp.shape _, mval, _, (mx, my) = cv2.minMaxLoc(resp) side_resp = resp.copy() cv2.rectangle(side_resp, (mx-5, my-5), (mx+5, my+5), 0, -1) smean, sstd = side_resp.mean(), side_resp.std() psr = (mval-smean) / (sstd+eps) return resp, (mx-w//2, my-h//2), psr
def furieTransform(size): dftImage = cv2.dft(np.float32(inImg)) dftShiftImage = np.fft.fftshift(dftImage) rows, cols = inImg.shape centralRow, centralCol = rows / 2, cols / 2 mask = np.ones((rows, cols), np.uint8) mask[centralRow - size:centralRow + size, centralCol - size:centralCol + size] = 0 fshift = dftShiftImage * mask fIShift = np.fft.ifftshift(fshift) imgResult = cv2.idft(fIShift) cv2.imwrite("out_furie.bmp", imgResult)
def filterImg(img,filtro_magnitud): """Filtro para imágenes de un canal""" #como la fase del filtro es 0 la conversión de polar a cartesiano es directa (magnitud->x, fase->y) filtro=np.array([filtro_magnitud,np.zeros(filtro_magnitud.shape)]).swapaxes(0,2).swapaxes(0,1) imgf=cv.dft(np.float32(img), flags=cv.DFT_COMPLEX_OUTPUT) imgf=cv.mulSpectrums(imgf, np.float32(filtro), cv.DFT_ROWS) return cv.idft(imgf, flags=cv.DFT_REAL_OUTPUT | cv.DFT_SCALE)
def correlate(self, img): C = cv2.mulSpectrums(cv2.dft(img, flags=cv2.DFT_COMPLEX_OUTPUT), self.H, 0, conjB=True) resp = cv2.idft(C, flags=cv2.DFT_SCALE | cv2.DFT_REAL_OUTPUT) h, w = resp.shape _, mval, _, (mx, my) = cv2.minMaxLoc(resp) side_resp = resp.copy() cv2.rectangle(side_resp, (mx - 5, my - 5), (mx + 5, my + 5), 0, -1) smean, sstd = side_resp.mean(), side_resp.std() psr = (mval - smean) / (sstd + eps) return resp, (mx - w // 2, my - h // 2), psr
def lowpass(img): radius = 50 dft = cv2.dft(np.float32(img), flags=cv2.DFT_COMPLEX_OUTPUT) dft_shift = np.fft.fftshift(dft) r, c = img.shape cr, cc = r / 2, c / 2 mask = np.zeros((r, c, 2), np.uint8) mask[cr - radius:cr + radius, cc - radius:cc + radius] = 1 fshift = dft_shift * mask f_ishift = np.fft.ifftshift(fshift) nimg = cv2.idft(f_ishift) nimg = cv2.magnitude(nimg[:, :, 0], nimg[:, :, 1]) return nimg
def HPF(self, im_source, im_mask): if len(im_source.shape) == 3: return None im_float32 = np.float32(im_source) dft = cv2.dft(im_float32, flags=cv2.DFT_COMPLEX_OUTPUT) dft_shift = np.fft.fftshift(dft) fshift = dft_shift * im_mask f_ishift = np.fft.ifftshift(fshift) im_back = cv2.idft(f_ishift) im_back = cv2.magnitude(im_back[:, :, 0], im_back[:, :, 1]) Pmax = np.max(im_back) im_pow = im_back / Pmax * 255 return np.uint8(im_pow)
def getFourier(data, HPFsize=60): ''' performs a DFT and high pass filtering data: grayscale 2D image array HPFsize: High Pass Filter size of box to filter out ''' r, c = int(data.shape[0]/2), int(data.shape[1]/2) # data = cv2.fastNlMeansDenoising(data, None, 10, 7, 21) data = np.fft.fftshift(cv2.dft(np.float32(data), flags=cv2.DFT_COMPLEX_OUTPUT)) data[r-HPFsize:r+HPFsize, c-HPFsize:c+HPFsize] = 0 data = cv2.idft(np.fft.ifftshift(data)) data = (data/np.max(data)*255)**2 data[np.where(data>255)] = 255 return (data).astype(np.uint8)
def correlate(self, img): C = cv2.mulSpectrums(cv2.dft(img, flags=cv2.DFT_COMPLEX_OUTPUT), self.H, 0, conjB=True) resp = cv2.idft(C, flags=cv2.DFT_SCALE | cv2.DFT_REAL_OUTPUT) h, w = resp.shape _, mval, _, (mx, my) = cv2.minMaxLoc(resp) fmx = vertex(mx, *resp[my,mx-1:mx+2]) if (1 <= mx <= w-1) else mx fmy = vertex(my, *resp[my-1:my+2,mx]) if (1 <= my <= h-1) else my #print (mx - w//2, my - h//2), (fmx - w//2, fmy - h//2) side_resp = resp.copy() cv2.rectangle(side_resp, (mx-5, my-5), (mx+5, my+5), 0, -1) smean, sstd = side_resp.mean(), side_resp.std() psr = (mval-smean) / (sstd+eps) return resp, (fmx-w//2, fmy-h//2), psr
def HPF(self,im_source,im_mask): if len(im_source.shape) == 3: return None im_float32 = np.float32(im_source) dft = cv2.dft(im_float32, flags = cv2.DFT_COMPLEX_OUTPUT) dft_shift = np.fft.fftshift(dft) fshift = dft_shift*im_mask f_ishift = np.fft.ifftshift(fshift) im_back = cv2.idft(f_ishift) im_back = cv2.magnitude(im_back[:,:,0],im_back[:,:,1]) Pmax = np.max(im_back) im_pow = im_back/Pmax*255 return np.uint8(im_pow)
def apply_mask(mask, img): # apply mask and inverse DFTrum dft = cv2.dft(np.float32(img), flags = cv2.DFT_COMPLEX_OUTPUT) dft_shift = np.fft.fftshift(dft) rows, cols = img.shape crow,ccol = rows/2 , cols/2 # fshift = dft_shift*mask # for low pass filter dft_shift[crow-30:crow+30, ccol-30:ccol+30] = 0 #for high pass filter #f_ishift = np.fft.ifftshift(fshift) #fshift for low pass code f_ishift = np.fft.ifftshift(dft_shift) img_back = cv2.idft(f_ishift) img_back = cv2.magnitude(img_back[:,:,0],img_back[:,:,1]) return img_back
def reconstructframe_ocvU(self, img, i): assert opencv, "No opencv present" mask = cv2.UMat((self.N // 2, self.N // 2), s=1, type=cv2.CV_8U) imU = cv2.UMat(img) diff = cv2.subtract(imU, self._imgstoreU[i]) imf = cv2.multiply(cv2.dft(diff, flags=cv2.DFT_COMPLEX_OUTPUT), self._prefilter_ocvU) cv2.copyTo(src=cv2.UMat(imf, (0, 0, self.N // 2, self.N // 2)), mask=mask, dst=cv2.UMat(self._carray_ocvU, (0, 0, self.N // 2, self.N // 2))) cv2.copyTo( src=cv2.UMat(imf, (0, self.N // 2, self.N // 2, self.N // 2)), mask=mask, dst=cv2.UMat(self._carray_ocvU, (0, 3 * self.N // 2, self.N // 2, self.N // 2))) cv2.copyTo( src=cv2.UMat(imf, (self.N // 2, 0, self.N // 2, self.N // 2)), mask=mask, dst=cv2.UMat(self._carray_ocvU, (3 * self.N // 2, 0, self.N // 2, self.N // 2))) cv2.copyTo( src=cv2.UMat(imf, (self.N // 2, self.N // 2, self.N // 2, self.N // 2)), mask=mask, dst=cv2.UMat( self._carray_ocvU, (3 * self.N // 2, 3 * self.N // 2, self.N // 2, self.N // 2))) img2 = cv2.multiply( cv2.idft(self._carray_ocvU, flags=cv2.DFT_SCALE | cv2.DFT_REAL_OUTPUT), self._reconfactorU[i]) self._imgstoreU[i] = imU self._bigimgstoreU = cv2.add( self._bigimgstoreU, cv2.idft(cv2.multiply(cv2.dft(img2, flags=cv2.DFT_COMPLEX_OUTPUT), self._postfilter_ocvU), flags=cv2.DFT_SCALE | cv2.DFT_REAL_OUTPUT)) return self._bigimgstoreU
def update(_): ang = np.deg2rad(cv2.getTrackbarPos('angle', win)) d = cv2.getTrackbarPos('d', win) noise = 10**(-0.1 * cv2.getTrackbarPos('SNR (db)', win)) if defocus: psf = defocus_kernel(d) else: psf = motion_kernel(ang, d) cv2.imshow('psf', psf) psf /= psf.sum() psf_pad = np.zeros_like(img_r) kh, kw = psf.shape psf_pad[:kh, :kw] = psf PSF = cv2.dft(psf_pad, flags=cv2.DFT_COMPLEX_OUTPUT, nonzeroRows=kh) PSF2 = (PSF**2).sum(-1) iPSF = PSF / (PSF2 + noise)[..., np.newaxis] # RES_BW = cv2.mulSpectrums(IMG_BW, iPSF, 0) RES_R = cv2.mulSpectrums(IMG_R, iPSF, 0) RES_G = cv2.mulSpectrums(IMG_G, iPSF, 0) RES_B = cv2.mulSpectrums(IMG_B, iPSF, 0) # res_bw = cv2.idft(RES_BW, flags=cv2.DFT_SCALE | cv2.DFT_REAL_OUTPUT ) res_r = cv2.idft(RES_R, flags=cv2.DFT_SCALE | cv2.DFT_REAL_OUTPUT) res_g = cv2.idft(RES_G, flags=cv2.DFT_SCALE | cv2.DFT_REAL_OUTPUT) res_b = cv2.idft(RES_B, flags=cv2.DFT_SCALE | cv2.DFT_REAL_OUTPUT) res_rgb = np.zeros_like(img_rgb) res_rgb[..., 0] = res_r res_rgb[..., 1] = res_g res_rgb[..., 2] = res_b # res_bw = np.roll(res_bw, -kh//2, 0) # res_bw = np.roll(res_bw, -kw//2, 1) res_rgb = np.roll(res_rgb, -kh // 2, 0) res_rgb = np.roll(res_rgb, -kw // 2, 1) cv2.imshow(win, res_rgb)
def imageIDFT(frequency_filtered_image): log.debug( "Computing the IDFT (Inverse Discrete Fourier Transform) of the provided image" ) f_ishift = np.fft.ifftshift(frequency_filtered_image) result_image = cv.idft(f_ishift) result_image = cv.magnitude(result_image[:, :, 0], result_image[:, :, 1]) result_image = cv.normalize(result_image, None, 255, 0, cv.NORM_MINMAX, cv.CV_8UC1) log.debug("Finished computing the IDFT of the provided image") return result_image
def high_freq(img): dft = cv2.dft(np.float32(img),flags = cv2.DFT_COMPLEX_OUTPUT) dft_shift = np.fft.fftshift(dft) magnitude_spectrum = 20*np.log(cv2.magnitude(dft_shift[:,:,0],dft_shift[:,:,1])) rows, cols = img.shape crow,ccol = int(rows/2) , int(cols/2) # create a mask first, center square is 1, remaining all zeros mask = np.ones((rows,cols,2),np.uint8) mask[crow-30:crow+30, ccol-30:ccol+30] = 0 # apply mask and inverse DFT fshift = dft_shift*mask f_ishift = np.fft.ifftshift(fshift) img_high = cv2.idft(f_ishift) img_high = cv2.magnitude(img_high[:,:,0],img_high[:,:,1]) mask2 = np.zeros((rows,cols,2),np.uint8) mask2[crow-30:crow+30, ccol-30:ccol+30] = 1 # apply mask and inverse DFT fshift = dft_shift*mask2 f_ishift = np.fft.ifftshift(fshift) img_low = cv2.idft(f_ishift) img_low = cv2.magnitude(img_low[:,:,0],img_low[:,:,1]) # from matplotlib import pyplot as plt # plt.subplot(121),plt.imshow(img_high, cmap = 'gray') # plt.title('Frequency Component'), plt.xticks([]), plt.yticks([]) # plt.subplot(122),plt.imshow(img_low, cmap = 'gray') # plt.title('Base Component'), plt.xticks([]), plt.yticks([]) # plt.show() # img_high = cv2.cvtColor(img_high, cv2.COLOR_GRAY2BGR) return img_high,img_low
def create_Frequency2DFiltering(complexImg, filter): #complexImg = cv.dft(complexImg)#Fourier complexImg = shiftDFT(complexImg) complexImg = cv.mulSpectrums(complexImg, filter, 0) complexImg = shiftDFT(complexImg) #Inverse Fourier m = create_spectrum_magnitude_display(complexImg, True) result = cv.idft(complexImg) (myplanes_0, myplanes_1) = cv.split(result) result = cv.magnitude(myplanes_0, myplanes_1) result = cv.normalize(result, result, 0, 1, cv.NORM_MINMAX) imageRes = result return imageRes, m
def to_image(self,filename,color=True): #convert back into image f_ishift = np.fft.ifftshift(self.unreshape_arr) img_back = cv2.idft(f_ishift) img_back = cv2.magnitude(img_back[:,:,0],img_back[:,:,1]) # plt.subplot(121),plt.imshow(img_back, cmap = 'gray') # plt.title('Image'), plt.xticks([]), plt.yticks([]) # plt.show() #save images with pyplot if color: plt.imsave(filename + "_color.png", img_back) plt.imsave(filename + "_gray.png",img_back,cmap='gray')
def filtering(self): """Performs frequency filtering on an input image returns a filtered image, magnitude of DFT, magnitude of filtered DFT ---------------------------------------------------------- You are allowed to used inbuilt functions to compute fft There are packages available in numpy as well as in opencv Steps: 1. Compute the fft of the image 2. shift the fft to center the low frequencies 3. get the mask (write your code in functions provided above) the functions can be called by self.filter(shape, cutoff, order) 4. filter the image frequency based on the mask (Convolution theorem) 5. compute the inverse shift 6. compute the inverse fourier transform 7. compute the magnitude 8. You will need to do a full contrast stretch on the magnitude and depending on the algorithm you may also need to take negative of the image to be able to view it (use post_process_image to write this code) Note: You do not have to do zero padding as discussed in class, the inbuilt functions takes care of that filtered image, magnitude of DFT, magnitude of filtered DFT: Make sure all images being returned have grey scale full contrast stretch and dtype=uint8 """ #print(self.image.dtype) img_float32 = np.float32(self.image) dft = cv2.dft(img_float32, flags=cv2.DFT_COMPLEX_OUTPUT) dft_shift = np.fft.fftshift(dft) #Magnitude of DFT magnitude = 10 * np.log( cv2.magnitude(dft_shift[:, :, 0], dft_shift[:, :, 1])) magnitude_DFT = np.array(magnitude, dtype=np.uint8) #mask mask = self.filter(self.image.shape, self.cutoff, self.order) # apply mask and inverse DFT fshift = dft_shift * mask f_ishift = np.fft.ifftshift(fshift) i_dft = cv2.idft(f_ishift, flags=cv2.DFT_SCALE | cv2.DFT_REAL_OUTPUT) #print(nmg.dtype) img_back = i_dft.astype(np.uint8) #Magnitude of filtered DFT magnitude_filtered_DFT = np.array(magnitude_DFT * mask[:, :, 1], dtype=np.uint8) # Full scale contrast stretch fc_stretch = self.post_process_image(img_back) return [fc_stretch, magnitude_DFT, magnitude_filtered_DFT]
def _problem1(self, img): angle_img = fft2(img) fft2_img = dft(img, flags=cv.DFT_COMPLEX_OUTPUT) fft2_img_shift = fftshift(fft2_img) mag = cv.magnitude(fft2_img_shift[:,:, 0], fft2_img_shift[:,:, 1]) _min, _max = log(1 + abs(mag.min())), log(1 + abs(mag.max())) new_img = 255 * (log(1 + abs(mag)) - _min) / (_max - _min) idft_img = idft(ifftshift(fft2_img_shift), flags=cv.DFT_SCALE) new_img_ifft = cv.magnitude(idft_img[:,:, 0], idft_img[:,:, 1]) new_img_ifft[new_img_ifft > 255] = 255 new_img_ifft[new_img_ifft < 0] = 0 return new_img, angle(angle_img), new_img_ifft
def filtering(self, grayscale, fft_filter): image_fft2 = self.image_to_fft_center(grayscale) fshift = image_fft2 * fft_filter cv.imshow('fshift',cv.resize(np.uint8(self.get_log_scale(fshift[:,:,0])),(0,0),fx=0.5,fy=0.5)) # cv.wa # cv.waitKey(-1) f_ishift = np.fft.ifftshift(fshift) img_back = cv.idft(f_ishift) result_filter = cv.magnitude(img_back[:,:,0],img_back[:,:,1]) result_filter = result_filter.clip(min=0) result_filter = 255*(result_filter.copy() - result_filter.min()) / (result_filter.max()-result_filter.min()) return np.uint8(result_filter)
def spectralResidual(frame): frame_gray = gray(frame) dft = cv2.dft(np.float32(frame_gray), flags=cv2.DFT_COMPLEX_OUTPUT) A, P = cv2.cartToPolar(dft[:,:,0],dft[:,:,1]) L = np.log(A) kernel = np.ones((3,3),np.float32)/9 new_L = cv2.filter2D(L, -1, kernel) R = new_L - L new_dft = np.empty(dft.shape) new_dft[:,:,0], new_dft[:,:,1] = cv2.polarToCart(R,P) Mr = cv2.idft(new_dft) MrI = cv2.magnitude(Mr[:,:,0],Mr[:,:,1]) return MrI
def high_pass_filter(image, freq_cut): dft = cv2.dft(np.float32(image),flags = cv2.DFT_COMPLEX_OUTPUT) radius = freq_cut H = np.ones_like(dft) for i in range(dft.shape[0]): for j in range(dft.shape[1]): if np.sqrt(i**2 + j**2) <= radius: H[i,j] = 0 fimage = dft * H image_enhanced = cv2.idft(fimage, flags=cv2.DFT_SCALE | cv2.DFT_REAL_OUTPUT) return image_enhanced
def inner(img): img = np.array(img, np.float32) dft = cv2.dft(img, flags=cv2.DFT_COMPLEX_OUTPUT) dft_shift = np.fft.fftshift(dft) mask = pass_filter(img) fshift = dft_shift * mask f_ishift = np.fft.ifftshift(fshift) result_img = cv2.idft(f_ishift, flags=cv2.DFT_SCALE) result_img = cv2.magnitude(result_img[:, :, 0], result_img[:, :, 1]) return result_img
def fourier_back_transfrom(img, dft_shift): rows, cols, dim = img.shape crow,ccol = rows/2 , cols/2 # create a mask first, center square is 1, remaining all zeros mask = np.zeros((rows,cols,2),np.uint8) mask[crow-30:crow+30, ccol-30:ccol+30] = 1 # apply mask and inverse DFT fshift = dft_shift*mask f_ishift = np.fft.ifftshift(fshift) img_back = cv2.idft(f_ishift) img_back = cv2.magnitude(img_back[:,:,0],img_back[:,:,1]) return img_back
def detect_scale(self, image): xsf = self.get_scale_sample(image) # Compute AZ in the paper add_temp = cv2.reduce(complexMultiplication(self.sf_num, xsf), 0, cv2.REDUCE_SUM) # compute the final y scale_response = cv2.idft(complexDivisionReal(add_temp, (self.sf_den + self.scale_lambda)), None, cv2.DFT_REAL_OUTPUT) # Get the max point as the final scaling rate # pv:响应最大值 pi:相应最大点的索引数组 _, pv, _, pi = cv2.minMaxLoc(scale_response) return pi
def process(ip_image): ########################### ## Your Code goes here ########################### id_list = [] f_img = [] frame = ip_image[0:740, 0:1292] frame_con = cv2.addWeighted(frame, 2.2, np.zeros(frame.shape, frame.dtype), 0, -60) frame_con = fna(frame_con) im = split(frame_con) for i in range(0, 3): f_img.append(cv2.dft(np.array(im[i]), flags=cv2.DFT_COMPLEX_OUTPUT)) angle = np.deg2rad(90) psf_length = 19 SNR = 10**(-0.1 * 18) psf_var = PSF(angle, psf_length) psf_var = psf_var / psf_var.sum() i = 0 temp = [] for i in range(0, 3): mask = np.zeros_like(im[i]) h, w = psf_var.shape mask[:h, :w] = psf_var f_psf_var = cv2.dft(mask, flags=cv2.DFT_COMPLEX_OUTPUT, nonzeroRows=h) psf1 = (f_psf_var**2).sum(-1) iff_psf_var = (f_psf_var / (psf1 + SNR)[..., np.newaxis]) f_temp = (cv2.mulSpectrums(f_img[i], iff_psf_var, 0)) temp1 = (cv2.idft(f_temp, flags=cv2.DFT_SCALE)) temp1 = cv2.magnitude(temp1[:, :, 0], temp1[:, :, 1]) temp.append(temp1) bgr = join(temp) bgr = np.multiply(255, bgr) bgr = bgr.astype(np.uint8) bgr = np.clip(bgr, 0, 255) ip_image, id_list = aruco_detector(bgr) ip_image = cv2.fastNlMeansDenoisingColored(ip_image, None, 6, 4, 15, 45) ip_image = cv2.addWeighted(ip_image, 1.5, np.ones(ip_image.shape, ip_image.dtype), 0, -40) ip_image = cv2.copyMakeBorder(ip_image, 0, 100, 0, 308, cv2.BORDER_CONSTANT, value=[255, 255, 255]) ip_image = sharpen(ip_image) cv2.imwrite((generated_folder_path + "/" + "aruco_with_id.png"), ip_image) return (ip_image, id_list)
def ifft(fft_mat): '''傅立叶反变换,返回反变换图像''' # 反换位,低频部分移到四周,高频部分移到中间 f_ishift_mat = np.fft.ifftshift(fft_mat) # 傅立叶反变换 img_back = cv2.idft(f_ishift_mat) # 将复数转换为幅度, sqrt(re^2 + im^2) img_back = cv2.magnitude(*cv2.split(img_back)) # 标准化到0~255之间 cv2.normalize(img_back, img_back, 0, 255, cv2.NORM_MINMAX) return np.uint8(np.around(img_back))
def low_pass_filter(img_in): # Write low pass filter here dft = cv2.dft(np.float32(img_in), flags=cv2.DFT_COMPLEX_OUTPUT) dft_shift = np.fft.fftshift(dft) magnitude_spectrum = 20 * np.log( cv2.magnitude(dft_shift[:, :, 0], dft_shift[:, :, 1])) rows, cols = img_in.shape crow, ccol = rows / 2, cols / 2 mask = np.zeros((rows, cols, 2), np.uint8) mask[int(crow) - 10:int(crow) + 10, int(ccol) - 10:int(ccol) + 10] = 1 fshift = dft_shift * mask f_ishift = np.fft.ifftshift(fshift) img_back = cv2.idft(f_ishift, flags=cv2.DFT_SCALE | cv2.DFT_REAL_OUTPUT) img_out = img_back return img_out
def process(self): start = time() rows, cols, _ = self.dft.shape mask = np.zeros((rows, cols), np.float32) half = np.sqrt(rows**2 + cols**2) / 2 radius = int(half * self.split_spin.value() / 100) mask = cv.circle(mask, (cols // 2, rows // 2), radius, 1, cv.FILLED) kernel = 2 * int(half * self.smooth_spin.value() / 100) + 1 mask = cv.GaussianBlur(mask, (kernel, kernel), 0) mask /= np.max(mask) threshold = int(self.thr_spin.value() / 100 * 255) if threshold > 0: mask[self.magnitude0 < threshold] = 0 zeros = (mask.size - np.count_nonzero(mask)) / mask.size * 100 else: zeros = 0 self.zero_label.setText( self.tr('(zeroed coefficients = {:.2f}%)').format(zeros)) mask2 = np.repeat(mask[:, :, np.newaxis], 2, axis=2) rows0, cols0, _ = self.image.shape low = cv.idft(np.fft.ifftshift(self.dft * mask2), flags=cv.DFT_SCALE) low = norm_mat(cv.magnitude(low[:, :, 0], low[:, :, 1])[:rows0, :cols0], to_bgr=True) self.low_viewer.update_processed(low) high = cv.idft(np.fft.ifftshift(self.dft * (1 - mask2)), flags=cv.DFT_SCALE) high = norm_mat(cv.magnitude(high[:, :, 0], high[:, :, 1]), to_bgr=True) self.high_viewer.update_processed( np.copy(high[:self.image.shape[0], :self.image.shape[1]])) self.magnitude = (self.magnitude0 * mask).astype(np.uint8) self.phase = (self.phase0 * mask).astype(np.uint8) self.postprocess() self.info_message.emit( self.tr('Frequency Split = {}'.format(elapsed_time(start))))
def get_shift(self, imgA, imgB): rv = np.array([0.0, 0.0]) if (imgA is not None) and (imgB is not None) and (imgA.shape==imgB.shape): # Phase correlation. A = cv2.dft(imgA) B = cv2.dft(imgB) AB = cv2.mulSpectrums(A, B, flags=0, conjB=True) normAB = cv2.norm(AB) if (normAB != 0.0): crosspower = AB / normAB shift = cv2.idft(crosspower) shift0 = np.roll(shift, int(shift.shape[0]/2), 0) shift00 = np.roll(shift0, int(shift.shape[1]/2), 1) # Roll the matrix so 0,0 goes to the center of the image. # Get the coordinates of the maximum shift. kShift = np.argmax(shift00) (iShift,jShift) = np.unravel_index(kShift, shift00.shape) # Get weighted centroid of a region around the peak, for sub-pixel accuracy. w = 7 r = int((w-1)/2) i0 = clip(iShift-r, 0, shift00.shape[0]-1) i1 = clip(iShift+r, 0, shift00.shape[0]-1)+1 j0 = clip(jShift-r, 0, shift00.shape[1]-1) j1 = clip(jShift+r, 0, shift00.shape[1]-1)+1 peak = shift00[i0:i1].T[j0:j1].T moments = cv2.moments(peak, binaryImage=False) if (moments['m00'] != 0.0): iShiftSubpixel = moments['m01']/moments['m00'] + float(i0) jShiftSubpixel = moments['m10']/moments['m00'] + float(j0) else: iShiftSubpixel = float(shift.shape[0])/2.0 jShiftSubpixel = float(shift.shape[1])/2.0 # Accomodate the matrix roll we did above. iShiftSubpixel -= float(shift.shape[0])/2.0 jShiftSubpixel -= float(shift.shape[1])/2.0 # Convert unsigned shifts to signed shifts. height = float(shift00.shape[0]) width = float(shift00.shape[1]) iShiftSubpixel = ((iShiftSubpixel+height/2.0) % height) - height/2.0 jShiftSubpixel = ((jShiftSubpixel+width/2.0) % width) - width/2.0 rv = np.array([iShiftSubpixel, jShiftSubpixel]) return rv
def mix(self, imageToBeMixed: 'ImageModel', magnitudeOrRealRatio: float, phaesOrImaginaryRatio: float, mode: 'Modes') -> np.ndarray: """ a function that takes ImageModel object mag ratio, phase ration """ ### # implement this function ### mix = np.zeros((self.imgByte.shape[0], self.imgByte.shape[1], 2), 'float64') if mode.value == "testMagAndPhaseMode": if (self.uniMag and imageToBeMixed.uniPh): real, imaginary = cv.polarToCart( self.uniMagnitude * magnitudeOrRealRatio + imageToBeMixed.magnitude * (1 - magnitudeOrRealRatio), self.phase * (1 - phaesOrImaginaryRatio) + imageToBeMixed.uniPhase * phaesOrImaginaryRatio, angleInDegrees=True) elif (self.uniMag): real, imaginary = cv.polarToCart( self.uniMagnitude * magnitudeOrRealRatio + imageToBeMixed.magnitude * (1 - magnitudeOrRealRatio), self.phase * (1 - phaesOrImaginaryRatio) + imageToBeMixed.phase * phaesOrImaginaryRatio, angleInDegrees=True) elif (imageToBeMixed.uniPh): real, imaginary = cv.polarToCart( self.magnitude * magnitudeOrRealRatio + imageToBeMixed.magnitude * (1 - magnitudeOrRealRatio), self.phase * (1 - phaesOrImaginaryRatio) + imageToBeMixed.uniPhase * phaesOrImaginaryRatio, angleInDegrees=True) else: real, imaginary = cv.polarToCart( self.magnitude * magnitudeOrRealRatio + imageToBeMixed.magnitude * (1 - magnitudeOrRealRatio), self.phase * (1 - phaesOrImaginaryRatio) + imageToBeMixed.phase * phaesOrImaginaryRatio, angleInDegrees=True) elif mode.value == "testRealAndImagMode": real = self.real * magnitudeOrRealRatio + imageToBeMixed.real * ( 1 - magnitudeOrRealRatio) imaginary = self.imaginary * ( 1 - phaesOrImaginaryRatio ) + imageToBeMixed.imaginary * phaesOrImaginaryRatio mix[:, :, 0], mix[:, :, 1] = real, imaginary invImg = cv.idft(mix, flags=cv.DFT_SCALE | cv.DFT_REAL_OUTPUT) invImg *= 255.0 / np.max(invImg) return invImg
def whitened_matched_filter(data, locs, window): """ Function for using whitened matched filter to the original signal for better SNR. Use welch method to approximate the spectral density of the signal. Rescale the signal in frequency domain. After scaling, convolve the signal with peak-triggered-average to make spikes more prominent. Args: data: 1-d array input signal locs: 1-d array spike times window: 1-d array window with size of temporal filter Returns: datafilt: 1-d array signal processed after whitened matched filter """ N = np.ceil(np.log2(len(data))) censor = np.zeros(len(data)) censor[locs] = 1 censor = np.int16( np.convolve(censor.flatten(), np.ones([1, len(window)]).flatten(), 'same')) censor = (censor < 0.5) noise = data[censor] _, pxx = signal.welch(noise, fs=2 * np.pi, window=signal.get_window('hamming', 1000), nfft=2**N, detrend=False, nperseg=1000) Nf2 = np.concatenate([pxx, np.flipud(pxx[1:-1])]) scaling_vector = 1 / np.sqrt(Nf2) cc = np.pad(data.copy(), (0, np.int(2**N - len(data))), 'constant') dd = (cv2.dft(cc, flags=cv2.DFT_SCALE + cv2.DFT_COMPLEX_OUTPUT)[:, 0, :] * scaling_vector[:, np.newaxis])[:, np.newaxis, :] dataScaled = cv2.idft(dd)[:, 0, 0] PTDscaled = dataScaled[(locs[:, np.newaxis] + window)] PTAscaled = np.mean(PTDscaled, 0) datafilt = np.convolve(dataScaled, np.flipud(PTAscaled), 'same') datafilt = datafilt[:len(data)] return datafilt
def apply_inverse_fourier(self, fft_shift, min=0, max=255): # aplicando a inversa da transformada f_ishift = np.fft.ifftshift(fft_shift) img_back = cv2.idft(f_ishift) img_back = np.abs(cv2.magnitude(img_back[:, :, 0], img_back[:, :, 1])) # normalizando a imagem norm_image = cv2.normalize(img_back, None, alpha=min, beta=max, norm_type=cv2.NORM_MINMAX, dtype=cv2.DFT_COMPLEX_OUTPUT).astype( np.uint8) return norm_image
def highpass_1(img): img_float32 = np.float32(img) dft = cv2.dft(img_float32, flags=cv2.DFT_COMPLEX_OUTPUT) dft_shift = np.fft.fftshift(dft) magnitude_spectrum_img = 20 * np.log( cv2.magnitude(dft_shift[:, :, 0], dft_shift[:, :, 1])) mask_hp = highpass_0(img, 5) f_shift_hp = dft_shift * mask_hp f_ishift_hp = np.fft.ifftshift(f_shift_hp) img_back_hp = cv2.idft(f_ishift_hp, flags=cv2.DFT_SCALE | cv2.DFT_REAL_OUTPUT) return img_back_hp
def PHOT(inp): # 2D Discrete Fourier Transform (DFT) is used to find the frequency domain dft = cv2.dft(np.float32(inp), flags=cv2.DFT_COMPLEX_OUTPUT) MAG, PHASE = cv2.cartToPolar(dft[:, :, 0], dft[:, :, 1]) dft[:, :, 0] = dft[:, :, 0] / MAG dft[:, :, 1] = dft[:, :, 1] / MAG img_back = cv2.idft(dft) MAG = img_back[:, :, 0] MAG = cv2.GaussianBlur(MAG, (9, 9), 0) m = np.mean(MAG) MAG = (MAG - m) * (MAG - m) cv2.normalize(MAG, MAG, 0, 1.0, cv2.NORM_MINMAX) return MAG.astype('float32')
def four(): image = cv2.imread(f'{PATH}/first.jpg', 0) mu, sigma = 1, 2 rows, cols = image.shape s = np.random.normal(mu, sigma, (rows, cols, 2)) dft_image = cv2.dft(np.float32(image), flags=cv2.DFT_COMPLEX_OUTPUT) dft_s = dft_image * s image_back = cv2.idft(dft_s) image_back = cv2.magnitude(image_back[:, :, 0], image_back[:, :, 1]) plt.subplot(121), plt.imshow(image, cmap='gray') plt.title('Input Image'), plt.xticks([]), plt.yticks([]) plt.subplot(122), plt.imshow(image_back, cmap='gray') plt.title('After DFT'), plt.xticks([]), plt.yticks([]) plt.show() """
def test(self, frame): (x,y), (w,h) = self.pos, self.size win = cv2.createHanningWindow((w,h), cv2.CV_32F) img1 = self.preprocess(self.last_img, win) F1 = cv2.dft(img1, flags = cv2.DFT_COMPLEX_OUTPUT) G1 = cv2.mulSpectrums(F1, self.H, 0, conjB = True) resp1 = cv2.idft(G1, flags = cv2.DFT_SCALE|cv2.DFT_REAL_OUTPUT) img = cv2.getRectSubPix(frame, (w, h), (x,y)) img2 = self.preprocess(img, win) F2 = cv2.dft(img2, flags = cv2.DFT_COMPLEX_OUTPUT) G2 = cv2.mulSpectrums(F2, self.H, 0, conjB = True) resp2 = cv2.idft(G2, flags = cv2.DFT_SCALE|cv2.DFT_REAL_OUTPUT) merge1 = np.hstack((img1 , resp1)) merge2 = np.hstack((img2, resp2)) merge = np.vstack((merge1, merge2)) name = 'comparison--last vs cur.' cv2.namedWindow(name, cv2.WINDOW_NORMAL) cv2.resizeWindow(name, 600,400) cv2.imshow(name, merge)
def ideal_pass_filter(img_dft_shift, is_low): ipf_shift = np.copy(img_dft_shift) for i in range(M): for j in range(N): calc = math.sqrt((i - M / 2)**2 + (j - N / 2)**2) if (is_low and calc > CUTOFF_FREQ) or\ (not is_low and calc < CUTOFF_FREQ): ipf_shift[i, j] = 0 f_ishift = np.fft.ifftshift(ipf_shift) img_back_ipf = cv.idft(f_ishift, flags=cv.DFT_SCALE | cv.DFT_REAL_OUTPUT) img_back_ipf[img_back_ipf < 0] = 0 img_back_ipf[img_back_ipf > 255] = 255 return img_back_ipf
def phaseCorrelation(img_orig, img_transformed): # Step 3.1 - Initialize complex conjugates for original image and magnitudes orig_conj = np.copy(img_orig) orig_conj[:,:,IM_IDX] = -orig_conj[:,:,IM_IDX] orig_mags = cv2.magnitude(img_orig[:,:,RE_IDX],img_orig[:,:,IM_IDX]) img_trans_mags = cv2.magnitude(img_transformed[:,:,RE_IDX],img_transformed[:,:,IM_IDX]) # Step 3.2 - Do deconvolution # multiplication compex numbers ===> (x + yi) * (u + vi) = (xu - yv) + (xv + yu)i # deconvolution ( H* x G ) / |H x G| realPart = (orig_conj[:,:,RE_IDX] * img_transformed[:,:,RE_IDX] - orig_conj[:,:,IM_IDX] * img_transformed[:,:,IM_IDX]) / (orig_mags * img_trans_mags) imaginaryPart = (orig_conj[:,:,RE_IDX] * img_transformed[:,:,IM_IDX] + orig_conj[:,:,IM_IDX] * img_transformed[:,:,RE_IDX]) / ( orig_mags * img_trans_mags) result = np.dstack((realPart, imaginaryPart)) result_idft = cv2.idft(result) # Step 3.3 - Find Max value (angle and scaling factor) result_mags = cv2.magnitude(result_idft[:,:,RE_IDX],result_idft[:,:,IM_IDX]) return np.unravel_index( np.argmax(result_mags), result_mags.shape)
def apply_filter(img, ftype, flen, ksize=-1, ori=0): """ Apply a particular deblur filter. :param str ftype: Filter type. :param int ksize: Kernel size. :param int flen: Filter length (must be strictly smaller than the kernel size). :param int ori: Optional kernel orientation. Unused for circular kernels. """ if ksize < 0: ksize = flen assert ksize >= flen, "kernel size must not be less than filter length" img = np.array(img, dtype=np.float32) # frequency domain representation of the image img = blur_edge(img, flen) img_gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY) IMG = cv2.dft(img_gray, flags=cv2.DFT_COMPLEX_OUTPUT) print(IMG) # make the PSF for deblurring if ftype == "linear": psf = makeLinearKernel(ksize=ksize, flen=flen, angle=ori) else: psf = makeCircularKernel(ksize=ksize, flen=flen) # perform the deconvolution psf_pad = np.zeros_like(img_gray) kh, kw = psf.shape psf_pad[:kh, :kw] = psf PSF = cv2.dft(psf_pad, flags=cv2.DFT_COMPLEX_OUTPUT, nonzeroRows=kh) PSF2 = (PSF**2).sum(-1) iPSF = PSF / (PSF2 + 10**5)[...,np.newaxis] RES = cv2.mulSpectrums(IMG, iPSF, 0) res = cv2.idft(RES, flags=cv2.DFT_SCALE | cv2.DFT_REAL_OUTPUT) res = np.roll(res, -kh//2, 0) res = np.roll(res, -kw//2, 1)
def update_butterworth_win(self, dummy=None): """ Update Butterworth filter param and the result image. """ sb = cv2.getTrackbarPos("stopband**2", self.ctrl_panel_winname) if sb == 0: sb = 1 print "Stopband should be more than 0. Reset to 1." bw_filter = self.get_butterworth_filter(stopband2=sb, showdft=True) dst_complex = bw_filter * self.dft4img#cv2.multiply(self.dft4img, bw_filter) dst_complex = cv2.idft(np.fft.ifftshift(dst_complex)) dst = np.uint8(cv2.magnitude(dst_complex[:,:,0], dst_complex[:,:,1])) self.tmp = dst self.get_dft(self.tmp, showdft=True) self.hist_lines(dst, showhist=True) cv2.imshow(self.test_winname, dst)
def execute_fft(image): cv2.imshow('image', image) # gettin layers dft dfts = [] channels = cv2.split(image) for channel in channels: #cv2.imshow('channel %d'%i, channel) channel = np.array(channel, dtype='float') dft = cv2.dft(channel, flags=cv2.DFT_SCALE) dfts.append(dft) new_channels = [] for dft in dfts: channel = cv2.idft(dft) channel = np.array(channel, dtype='uint8') #cv2.imshow('new channel %d'%i, channel) new_channels.append(channel) result = cv2.merge(new_channels) cv2.imshow('result', result)
def _get_channel_sal_magn(self, channel): """Returns the log-magnitude of the Fourier spectrum This method calculates the log-magnitude of the Fourier spectrum of a single-channel image. This image could be a regular grayscale image, or a single color channel of an RGB image. :param channel: single-channel input image :returns: log-magnitude of Fourier spectrum """ # do FFT and get log-spectrum if self.use_numpy_fft: img_dft = np.fft.fft2(channel) magnitude, angle = cv2.cartToPolar(np.real(img_dft), np.imag(img_dft)) else: img_dft = cv2.dft(np.float32(channel), flags=cv2.DFT_COMPLEX_OUTPUT) magnitude, angle = cv2.cartToPolar(img_dft[:, :, 0], img_dft[:, :, 1]) # get log amplitude log_ampl = np.log10(magnitude.clip(min=1e-9)) # blur log amplitude with avg filter log_ampl_blur = cv2.blur(log_ampl, (3, 3)) # residual residual = np.exp(log_ampl - log_ampl_blur) # back to cartesian frequency domain if self.use_numpy_fft: real_part, imag_part = cv2.polarToCart(residual, angle) img_combined = np.fft.ifft2(real_part + 1j*imag_part) magnitude, _ = cv2.cartToPolar(np.real(img_combined), np.imag(img_combined)) else: img_dft[:, :, 0], img_dft[:, :, 1] = cv2.polarToCart(residual, angle) img_combined = cv2.idft(img_dft) magnitude, _ = cv2.cartToPolar(img_combined[:, :, 0], img_combined[:, :, 1]) return magnitude
def _fft(self, batch): for i in range(len(batch)): temp = batch[i] temp = temp[ :, :, 0] x = len(temp[0]) dft = cv2.dft(np.float32(temp),flags = cv2.DFT_COMPLEX_OUTPUT) dft_shift = np.fft.fftshift(dft) rows, cols = temp.shape crow,ccol = rows/2 , cols/2 crow = int(crow) ccol = int(ccol) mask = np.zeros((rows,cols,2),np.uint8) mask[crow-30:crow+30, ccol-30:ccol+30] = 1 fshift = dft_shift*mask f_ishift = np.fft.ifftshift(fshift) a = cv2.idft(f_ishift) a = cv2.magnitude(a[:,:,0],a[:,:,1]) batch[i] = a.reshape([x, x, 1]) return batch
def correlate(self, img,size): #print "new size in correlate",size self.H = self.resizeFFT(self.H,size) ## H1 = cv2.resize(self.H[...,0],None,fx=lk_ratio[0], fy=lk_ratio[1], interpolation = cv2.INTER_CUBIC) ## H2 = cv2.resize(self.H[...,1],None,fx=lk_ratio[0], fy=lk_ratio[1], interpolation = cv2.INTER_CUBIC) ## self.H = np.dstack([H1,H2]).copy() FFT_img = cv2.dft(img, flags=cv2.DFT_COMPLEX_OUTPUT) #print "imgF:",FFT_img.shape,"filterF:",self.H.shape C = cv2.mulSpectrums(FFT_img, self.H, 0, conjB=True) resp = cv2.idft(C, flags=cv2.DFT_SCALE | cv2.DFT_REAL_OUTPUT) h, w = resp.shape #print "resp shape:",resp.shape _, mval, _, (mx, my) = cv2.minMaxLoc(resp) side_resp = resp.copy() cv2.rectangle(side_resp, (mx-5, my-5), (mx+5, my+5), 0, -1) smean, sstd = side_resp.mean(), side_resp.std() psr = (mval-smean) / (sstd+eps) return resp, (mx-w//2, my-h//2), psr
def state_vis(self): f = cv2.idft(self.H, flags=cv2.DFT_SCALE | cv2.DFT_REAL_OUTPUT) h, w = f.shape f = np.roll(f, -h // 2, 0) f = np.roll(f, -w // 2, 1) kernel = np.uint8((f - f.min()) / f.ptp() * 255) resp = self.last_resp resp = np.uint8(np.clip(resp / resp.max(), 0, 1) * 255) vis = np.vstack([self.last_img, kernel, resp]) x, y = 5, 10 draw_str(vis, (x, y), "IMAGE") draw_str(vis, (x, y + h), "KERNEL") draw_str(vis, (x, y + 2 * h), "FRESP") return vis
def correlate(self, img): # Multiply the image with the filter (in frequency space) C = cv2.mulSpectrums(cv2.dft(img, flags=cv2.DFT_COMPLEX_OUTPUT), self.H, 0, conjB=True) # Convert back to RGB space resp = cv2.idft(C, flags=cv2.DFT_SCALE | cv2.DFT_REAL_OUTPUT) # Look for peak h, w = resp.shape _, mval, _, (mx, my) = cv2.minMaxLoc(resp) # Get the isolated peak response (should be a Gaussian point) side_resp = resp.copy() cv2.rectangle(side_resp, (mx-5, my-5), (mx+5, my+5), 0, -1) # Calculate the match probability smean, sstd = side_resp.mean(), side_resp.std() psr = (mval-smean) / (sstd+eps) return resp, (mx-w//2, my-h//2), psr