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
