def correlate(self,image_tile): ''' Correlate the image with the left and right filters. ''' self._preprocess(image_tile) cv.DFT(self.image, self.image, cv.CV_DXT_FORWARD) cv.MulSpectrums( self.image, self.left_filter_dft, self.left_corr, cv.CV_DXT_MUL_CONJ ) cv.MulSpectrums( self.image, self.right_filter_dft, self.right_corr, cv.CV_DXT_MUL_CONJ ) cv.DFT(self.left_corr,self.left_corr,cv.CV_DXT_INV_SCALE) cv.DFT(self.right_corr,self.right_corr,cv.CV_DXT_INV_SCALE) return self.left_corr,self.right_corr
def high_freq(img, pct): f = float_version(img) cv.DFT(f, f, cv.CV_DXT_FORWARD) mask = cv.CreateImage( cv.GetSize(img), 8, 1) cv.Set(mask, 0) #cv.Set(mask, 255) w, h = cv.GetSize(img) dw = int(w*pct*0.5) dh = int(h*pct*0.5) #cv.Rectangle(mask, (0,0), (int(w*pct), int(h*pct)), 255, -1) #cv.Rectangle(mask, (int(w*pct), int(h*pct)), (w,h), 255, -1) cv.Rectangle(mask, (w/2-dw,h/2-dh), (w/2+dw,h/2+dh), 255, -1) cv.Set(f,0,mask) return f cv.DFT(f, f, cv.CV_DXT_INVERSE_SCALE) return f
def __init__(self, left_filter, right_filter, left_rect, right_rect): ''' @param left_filter: is in the Fourier domain where the left eye corresponds to the real output and the right eye corresponds to the imaginary output ''' # Check the input to this function r, c = left_filter.rows, left_filter.cols assert left_filter.width == right_filter.width assert left_filter.height == right_filter.height assert left_filter.channels == 1 assert right_filter.channels == 1 # Create the arrays needed for the computation self.left_filter = cv.CreateMat(r, c, cv.CV_32F) self.right_filter = cv.CreateMat(r, c, cv.CV_32F) self.left_filter_dft = cv.CreateMat(r, c, cv.CV_32F) self.right_filter_dft = cv.CreateMat(r, c, cv.CV_32F) self.image = cv.CreateMat(r, c, cv.CV_32F) self.left_corr = cv.CreateMat(r, c, cv.CV_32F) self.right_corr = cv.CreateMat(r, c, cv.CV_32F) # Populate the spatial filters cv.ConvertScale(left_filter, self.left_filter) cv.ConvertScale(right_filter, self.right_filter) # Compute the filters in the Fourier domain cv.DFT(self.left_filter, self.left_filter_dft, cv.CV_DXT_FORWARD) cv.DFT(self.right_filter, self.right_filter_dft, cv.CV_DXT_FORWARD) # Set up correlation region of interest self.left_rect = left_rect self.right_rect = right_rect self.left_roi = cv.GetSubRect(self.left_corr, self.left_rect) self.right_roi = cv.GetSubRect(self.right_corr, self.right_rect) # Create the look up table for the log transform self.lut = cv.CreateMat(256, 1, cv.CV_32F) for i in range(256): self.lut[i, 0] = math.log(i + 1)
def cv_convolution(image, b): #cv.ShowImage('image', cv.fromarray(image)) dft_m = cv.GetOptimalDFTSize(image.shape[0] + b.shape[0] - 1) dft_n = cv.GetOptimalDFTSize(image.shape[1] + b.shape[1] - 1) print dft_m, dft_n # c = cv.CreateMat(image.shape[0] + d - 1, image.shape[1] + d - 1, cv.CV_8U) # getting gaussian dft dft_b = cv.CreateMat(dft_m, dft_n, cv.CV_64F) # tmp = cv.GetSubRect(dft_b, (0, 0, b.shape[1], b.shape[0])) cv.Copy(cv.fromarray(b), tmp) tmp = cv.GetSubRect(dft_b, (b.shape[1], 0, dft_b.cols - b.shape[1], b.shape[0])) cv.Zero(tmp) # cv.DFT(dft_b, dft_b, cv.CV_DXT_FORWARD, b.shape[0]) # 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='float') dft_a = cv.CreateMat(dft_m, dft_n, cv.CV_64F) # tmp = cv.GetSubRect(dft_a, (0, 0, a.shape[1], a.shape[0])) cv.Copy(cv.fromarray(a), tmp) tmp = cv.GetSubRect( dft_a, (a.shape[1], 0, dft_a.cols - a.shape[1], a.shape[0])) cv.Zero(tmp) # cv.DFT(dft_a, dft_a, cv.CV_DXT_FORWARD, a.shape[0]) cv.MulSpectrums(dft_a, dft_b, dft_a, 0) cv.DFT(dft_a, dft_a, cv.CV_DXT_INV_SCALE, c.rows) tmp = cv.GetSubRect(dft_a, (0, 0, c.cols, c.rows)) #cv.Copy(tmp, c) channel = np.array(tmp, dtype='uint8') cv.ShowImage('new channel %d' % i, cv.fromarray(channel)) new_channels.append(channel) result = cv2.merge(new_channels) return result
def getSpectra(imgList): """ Calculates the fourier transforms (against time) of all pixels in imgList. imgList is a list of tuples (datetime,image). Creates a 2 dimensional array, where one dimension is the pixel values in the image, and the other is time, then calculates the fourier transform. To give the frequency contributions of the values in each pixel. """ (width, height) = cv.GetSize(imgList[0][1]) nPixels = width * height print "Image Size = (%d x %d) - %d pixels. Number of Images = %d" \ % (width,height,nPixels,len(imgList)) # Create a matrix with pixel values in the y direction, and time (frame no) # in the x direction. This means we can do an FFT on each row to get # frequency components of each pixel. dataMat = cv.CreateMat(nPixels, len(imgList), cv.CV_32FC1) for frameNo in range(len(imgList)): for y in range(height - 1): for x in range(width - 1): pixelNo = y * width + x pixelVal = float(imgList[frameNo][1][y, x] / 255.0) dataMat[pixelNo, frameNo] = pixelVal cv.ShowImage(window3, dataMat) fftMat = cv.CreateMat(nPixels, len(imgList), cv.CV_32FC1) (a, fftMax, b, c) = cv.MinMaxLoc(fftMat) #print "fftMax=%f" % (fftMax) fftMat_int = cv.CreateMat(nPixels, len(imgList), cv.CV_8UC1) cv.DFT(dataMat, fftMat, cv.CV_DXT_ROWS) #cv.Split(fftMat,complexParts) #cv.magnitude(complexParts[0],complexParts[1],complexParts[0]) #fftMat = complexParts[0] cv.ConvertScale(fftMat, fftMat_int, 1000) cv.ShowImage(window4, fftMat_int) # Apply frequency filter to FFT data for x in range(0, FFT_CHAN_MIN): for y in range(0, nPixels): fftMat[y, x] = 0.0 for x in range(FFT_CHAN_MAX, len(imgList) - 1): for y in range(0, nPixels): fftMat[y, x] = 0.0 (a, fftMax, b, c) = cv.MinMaxLoc(fftMat) print "fftMax=%f (filtered region)" % (fftMax)
def FFT(image, flag=0): w = image.width h = image.height iTmp = cv.CreateImage((w, h), cv.IPL_DEPTH_32F, 1) cv.Convert(image, iTmp) iMat = cv.CreateMat(h, w, cv.CV_32FC2) mFFT = cv.CreateMat(h, w, cv.CV_32FC2) for i in range(h): for j in range(w): if flag == 0: num = -1 if (i + j) % 2 == 1 else 1 else: num = 1 iMat[i, j] = (iTmp[i, j] * num, 0) cv.DFT(iMat, mFFT, cv.CV_DXT_FORWARD) return mFFT
def IFFT(mat): mIFFt = cv.CreateMat(mat.rows, mat.cols, cv.CV_32FC2) cv.DFT(mat, mIFFt, cv.CV_DXT_INVERSE) return mIFFt
dft_A = cv.CreateMat(dft_M, dft_N, cv.CV_64FC2) image_Re = cv.CreateImage((dft_N, dft_M), cv.IPL_DEPTH_64F, 1) image_Im = cv.CreateImage((dft_N, dft_M), cv.IPL_DEPTH_64F, 1) # copy A to dft_A and pad dft_A with zeros tmp = cv.GetSubRect(dft_A, (0, 0, im.width, im.height)) cv.Copy(complexInput, tmp, None) if (dft_A.width > im.width): tmp = cv.GetSubRect(dft_A, (im.width, 0, dft_N - im.width, im.height)) cv.Zero(tmp) # no need to pad bottom part of dft_A with zeros because of # use nonzero_rows parameter in cv.FT() call below cv.DFT(dft_A, dft_A, cv.CV_DXT_FORWARD, complexInput.height) cv.NamedWindow("win", 0) cv.NamedWindow("magnitude", 0) cv.ShowImage("win", im) # Split Fourier in real and imaginary parts cv.Split(dft_A, image_Re, image_Im, None, None) # Compute the magnitude of the spectrum Mag = sqrt(Re^2 + Im^2) cv.Pow(image_Re, image_Re, 2.0) cv.Pow(image_Im, image_Im, 2.0) cv.Add(image_Re, image_Im, image_Re, None) cv.Pow(image_Re, image_Re, 0.5) # Compute log(1 + Mag)
def atualiza_foto(self): real = cv.CreateImage(cv.GetSize(imagem), cv.IPL_DEPTH_64F, 1) imaginario = cv.CreateImage(cv.GetSize(imagem), cv.IPL_DEPTH_64F, 1) complexo = cv.CreateImage(cv.GetSize(imagem), cv.IPL_DEPTH_64F, 2) cv.Scale(imagem_cinza, real, 1.0, 0.0) cv.Zero(imaginario) cv.Merge(real, imaginario, None, None, complexo) Altura_M = cv.GetOptimalDFTSize(imagem.height - 1) Largura_N = cv.GetOptimalDFTSize(imagem.width - 1) Vetor_dft = cv.CreateMat(Altura_M, Largura_N, cv.CV_64FC2) imagem_Real = cv.CreateImage((Largura_N, Altura_M), cv.IPL_DEPTH_64F, 1) imagem_Imaginaria = cv.CreateImage((Largura_N, Altura_M), cv.IPL_DEPTH_64F, 1) temporario = cv.GetSubRect(Vetor_dft, (0, 0, imagem.width, imagem.height)) cv.Copy(complexo, temporario, None) if (Vetor_dft.width > imagem.width): temporario = cv.GetSubRect( Vetor_dft, (imagem.width, 0, Largura_N - imagem.width, imagem.height)) cv.Zero(temporario) # APLICANDO FOURIER cv.DFT(Vetor_dft, Vetor_dft, cv.CV_DXT_FORWARD, complexo.height) cv.Split(Vetor_dft, imagem_Real, imagem_Imaginaria, None, None) cv.Pow(imagem_Real, imagem_Real, 2.0) cv.Pow(imagem_Imaginaria, imagem_Imaginaria, 2.0) cv.Add(imagem_Real, imagem_Imaginaria, imagem_Real, None) cv.Pow(imagem_Real, imagem_Real, 0.5) cv.AddS(imagem_Real, cv.ScalarAll(1.0), imagem_Real, None) cv.Log(imagem_Real, imagem_Real) cvShiftDFT(imagem_Real, imagem_Real) min, max, pt1, pt2 = cv.MinMaxLoc(imagem_Real) cv.Scale(imagem_Real, imagem_Real, 1.0 / (max - min), 1.0 * (-min) / (max - min)) #APLICANDO FILTRO passa-baixa circular cv.Circle(Vetor_dft, (0, 0), self.raio, [0, 0, 0], -1, 1, 0) cv.Circle(Vetor_dft, (Vetor_dft.cols, 0), self.raio, [0, 0, 0], -1, 1, 0) cv.Circle(Vetor_dft, (0, Vetor_dft.rows), self.raio, [0, 0, 0], -1, 1, 0) cv.Circle(Vetor_dft, (Vetor_dft.cols, Vetor_dft.rows), self.raio, [0, 0, 0], -1, 1, 0) cv.Split(Vetor_dft, imagem_Real, imagem_Imaginaria, None, None) cv.Pow(imagem_Real, imagem_Real, 2.0) cv.Pow(imagem_Imaginaria, imagem_Imaginaria, 2.0) cv.Add(imagem_Real, imagem_Imaginaria, imagem_Real, None) cv.Pow(imagem_Real, imagem_Real, 0.5) cv.AddS(imagem_Real, cv.ScalarAll(1.0), imagem_Real, None) cv.Log(imagem_Real, imagem_Real) cvShiftDFT(imagem_Real, imagem_Real) min, max, pt1, pt2 = cv.MinMaxLoc(imagem_Real) cv.Scale(imagem_Real, imagem_Real, 1.0 / (max - min), 1.0 * (-min) / (max - min)) cv.ShowImage("Transformada de Fourier", imagem_Real) # APLICANDO A INVERSA de Fourier cv.DFT(Vetor_dft, Vetor_dft, cv.CV_DXT_INVERSE_SCALE, Largura_N) cv.Split(Vetor_dft, imagem_Real, imagem_Imaginaria, None, None) min, max, pt1, pt2 = cv.MinMaxLoc(imagem_Real) if ((pt1 < 0) or (pt2 > 255)): cv.Scale(imagem_Real, imagem_Real, 1.0 / (max - min), 1.0 * (-min) / (max - min)) else: cv.Scale(imagem_Real, imagem_Real, 1.0 / 255, 0) cv.ShowImage("Inversa da Fourier", imagem_Real)
def opencvSaliency(self, scaledImageGray): cvImageGray = cv.CreateMat(scaledImageGray.height, scaledImageGray.width, cv.CV_32FC1) cv.Convert(scaledImageGray, cvImageGray) src = cvImageGray dftWidth = cv.GetOptimalDFTSize(src.width - 1) dftHeight = cv.GetOptimalDFTSize(src.height - 1) real = cv.CreateMat(dftHeight, dftWidth, cv.CV_32FC1) imaginary = cv.CreateMat(dftHeight, dftWidth, cv.CV_32FC1) dft = cv.CreateMat(dftHeight, dftWidth, cv.CV_32FC2) tmp = cv.GetSubRect(real, (0, 0, src.width, src.height)) cv.Copy(src, tmp) cv.Zero(imaginary) cv.Merge(real, imaginary, None, None, dft) # do the fft cv.DFT(dft, dft, cv.CV_DXT_FORWARD, src.height) cv.Split(dft, real, imaginary, None, None) cv.CartToPolar(real, imaginary, real, imaginary, 0) cv.Log(real, real) filtered = cv.CreateMat(dftHeight, dftWidth, cv.CV_32FC1) cv.Copy(real, filtered) cv.Smooth(filtered, filtered, cv.CV_BLUR) cv.Sub(real, filtered, real, None) cv.Exp(real, real) cv.PolarToCart(real, imaginary, real, imaginary, 0) #cv.PolarToCart( np.ones( shape=(dftHeight,dftWidth), dtype=np.float32 ), imaginary, real, imaginary,0 ) # do inverse fourier transform cv.Merge(real, imaginary, None, None, dft) cv.DFT(dft, dft, cv.CV_DXT_INV_SCALE, src.height) cv.Split(dft, real, imaginary, None, None) # get magnitude cv.CartToPolar(real, imaginary, real, None, 0) cv.Pow(real, real, 2.0) FILTER_RAD = 3 IPL_BORDER_CONSTANT = 0 sfiltered = cv.CreateMat(real.height + FILTER_RAD * 2, real.width + FILTER_RAD * 2, cv.CV_32FC1) cv.CopyMakeBorder(real, sfiltered, (FILTER_RAD, FILTER_RAD), IPL_BORDER_CONSTANT) cv.Smooth(sfiltered, sfiltered, cv.CV_GAUSSIAN, 2 * FILTER_RAD + 1) (min, max, minLoc, maxLoc) = cv.MinMaxLoc(sfiltered) cv.ConvertScale(sfiltered, sfiltered, 1 / (max - min), -min / (max - min)) # copy result to output image tmp = cv.GetSubRect(sfiltered, (FILTER_RAD, FILTER_RAD, src.width, src.height)) cv.Copy(tmp, cvImageGray) #cvReleaseMat(&sfiltered); #cvReleaseMat(&real); #cvReleaseMat(&filtered); #cvReleaseMat(&imaginary); #cvReleaseMat(&dft); saliencyMap = np.array(255.0 * np.array(cvImageGray), dtype=np.uint8) return saliencyMap