def EMD(saliency_map1, saliency_map2, sub_sample=1 / 32.0):
map2 = np.array(saliency_map2, copy=True)
# Reduce image size for efficiency of calculation
map2 = resize(map2,
np.round(np.array(map2.shape) * sub_sample),
order=3,
mode='nearest')
map1 = resize(saliency_map1, map2.shape, order=3, mode='nearest')
# Histogram match the images so they have the same mass
map1 = match_hist(map1, *exposure.cumulative_distribution(map2))
# Normalize the two maps to sum up to 1,
# so that the score is independent of the starting amount of mass / spread of fixations of the fixation map
map1 = normalize(map1, method='sum')
map2 = normalize(map2, method='sum')
# Compute EMD with OpenCV
# - http://docs.opencv.org/modules/imgproc/doc/histograms.html#emd
# - http://stackoverflow.com/questions/5101004/python-code-for-earth-movers-distance
# - http://stackoverflow.com/questions/12535715/set-type-for-fromarray-in-opencv-for-python
r, c = map2.shape
x, y = np.meshgrid(range(c), range(r))
signature1 = cv.CreateMat(r * c, 3, cv.CV_32FC1)
signature2 = cv.CreateMat(r * c, 3, cv.CV_32FC1)
cv.Convert(cv.fromarray(np.c_[map1.ravel(),
x.ravel(),
y.ravel()]), signature1)
cv.Convert(cv.fromarray(np.c_[map2.ravel(),
x.ravel(),
y.ravel()]), signature2)
return cv.CalcEMD2(signature2, signature1, cv.CV_DIST_L2)
def processImage(self, curframe):
cv.Smooth(curframe, curframe) #Remove false positives
if not self.absdiff_frame: #For the first time put values in difference, temp and moving_average
self.absdiff_frame = cv.CloneImage(curframe)
self.previous_frame = cv.CloneImage(curframe)
cv.Convert(
curframe, self.average_frame
) #Should convert because after runningavg take 32F pictures
else:
cv.RunningAvg(curframe, self.average_frame,
0.05) #Compute the average
cv.Convert(self.average_frame,
self.previous_frame) #Convert back to 8U frame
cv.AbsDiff(curframe, self.previous_frame,
self.absdiff_frame) # moving_average - curframe
cv.CvtColor(
self.absdiff_frame, self.gray_frame,
cv.CV_RGB2GRAY) #Convert to gray otherwise can't do threshold
cv.Threshold(self.gray_frame, self.gray_frame, 50, 255,
cv.CV_THRESH_BINARY)
cv.Dilate(self.gray_frame, self.gray_frame, None,
15) #to get object blobs
cv.Erode(self.gray_frame, self.gray_frame, None, 10)
def EMD(saliency_map1, saliency_map2, sub_sample=1/32.0):
'''
Earth Mover's Distance measures the distance between two probability distributions
by how much transformation one distribution would need to undergo to match another
(EMD=0 for identical distributions).
Parameters
----------
saliency_map1 : real-valued matrix
If the two maps are different in shape, saliency_map1 will be resized to match saliency_map2.
saliency_map2 : real-valued matrix
Returns
-------
EMD : float, positive
'''
map2 = np.array(saliency_map2, copy=False)
# Reduce image size for efficiency of calculation
map2 = resize(map2, np.round(np.array(map2.shape)*sub_sample), order=3, mode='nearest')
map1 = resize(saliency_map1, map2.shape, order=3, mode='nearest')
# Histogram match the images so they have the same mass
map1 = match_hist(map1, *exposure.cumulative_distribution(map2))
# Normalize the two maps to sum up to 1,
# so that the score is independent of the starting amount of mass / spread of fixations of the fixation map
map1 = normalize(map1, method='sum')
map2 = normalize(map2, method='sum')
# Compute EMD with OpenCV
# - http://docs.opencv.org/modules/imgproc/doc/histograms.html#emd
# - http://stackoverflow.com/questions/5101004/python-code-for-earth-movers-distance
# - http://stackoverflow.com/questions/12535715/set-type-for-fromarray-in-opencv-for-python
r, c = map2.shape
x, y = np.meshgrid(range(c), range(r))
signature1 = cv.CreateMat(r*c, 3, cv.CV_32FC1)
signature2 = cv.CreateMat(r*c, 3, cv.CV_32FC1)
cv.Convert(cv.fromarray(np.c_[map1.ravel(), x.ravel(), y.ravel()]), signature1)
cv.Convert(cv.fromarray(np.c_[map2.ravel(), x.ravel(), y.ravel()]), signature2)
return cv.CalcEMD2(signature2, signature1, cv.CV_DIST_L2)
def Magnitude(self, dx, dy, Mask=None, precise=True, method="cv"):
'''Calculates the magnitude of the gradient using precise and fast approach'''
dxconv = cv.CreateImage(cv.GetSize(dx), cv.IPL_DEPTH_32F, dx.channels)
dyconv = cv.CreateImage(cv.GetSize(dx), cv.IPL_DEPTH_32F, dx.channels)
dxdest = cv.CreateImage(cv.GetSize(dx), cv.IPL_DEPTH_32F, dx.channels)
dydest = cv.CreateImage(cv.GetSize(dx), cv.IPL_DEPTH_32F, dx.channels)
magdest = cv.CreateImage(cv.GetSize(dx), cv.IPL_DEPTH_32F, dx.channels)
magnitude = cv.CreateImage(cv.GetSize(dx), cv.IPL_DEPTH_32F,
dx.channels)
magnitudetemp = cv.CreateImage(cv.GetSize(dx), cv.IPL_DEPTH_32F,
dx.channels)
zero = cv.CreateImage(cv.GetSize(dx), cv.IPL_DEPTH_32F, dx.channels)
cv.Convert(dx, dxconv)
cv.Convert(dy, dyconv)
if precise:
cv.Pow(dxconv, dxdest, 2)
cv.Pow(dyconv, dydest, 2)
cv.Add(dxdest, dydest, magdest)
cv.Pow(magdest, magnitude, 1. / 2)
else:
#Add the |dx| + |dy|
return None
if method == "slow":
size = cv.GetSize(magnitude)
for x in range(size[0]):
for y in range(size[1]):
if Mask == None:
pass
elif Mask[y, x] > 0:
pass
else:
magnitude[y, x] = 0
final = cv.CreateImage(cv.GetSize(dx), cv.IPL_DEPTH_8U,
dx.channels)
cv.ConvertScaleAbs(magnitude, final)
else:
cv.Add(zero, magnitude, magnitudetemp, Mask)
final = cv.CreateImage(cv.GetSize(dx), cv.IPL_DEPTH_8U,
dx.channels)
cv.ConvertScaleAbs(magnitudetemp, final)
if self.visualize:
magnitude2 = cv.CreateImage(cv.GetSize(dy), cv.IPL_DEPTH_8U, 1)
cv.EqualizeHist(final, magnitude2)
while True:
cv.NamedWindow("Magnitude")
cv.ShowImage("Magnitude", magnitude2)
c = cv.WaitKey(5)
if c > 0:
break
cv.DestroyAllWindows()
return final
def __init__(self):
"""
O construtor obtem a referencia da webcam e cria uma janela para exibir as imagens.
"""
# Variavel que vai definir o estado do monitoramento.
self.estado = True
# Obtendo a referencia da captura da webCam.
self.webCam = cv.CaptureFromCAM(0)
# Obtendo a imagem atual da webCam.
self.imagem_atual = cv.QueryFrame(self.webCam)
if self.imagem_atual is None:
stderr.write('A Web Cam esta desligada. Por favor ligue-a\n')
exit()
else:
# Cria uma nova imagem que sera utilizada para descobrir os contornos na imagem_atual.
self.imagem_cinza = cv.CreateImage(cv.GetSize(self.imagem_atual), cv.IPL_DEPTH_8U, 1)
# Cria uma nova imagem que sera utilizada para converter a imagem atual em 32F.
self.imagem_auxiliar = cv.CreateImage(cv.GetSize(self.imagem_atual), cv.IPL_DEPTH_32F, 3)
# Imagem sera utilizada para guardar a diferenca entre a imagem atual e anterior.
self.imagem_diferenca = None
# Obtendo a area total da imagem da webCam.
self.area = self.imagem_atual.width * self.imagem_atual.height
self.area_corrente = 0
self.imagem_diferenca = cv.CloneImage(self.imagem_atual)
self.imagem_anterior = cv.CloneImage(self.imagem_atual)
# Tenho que converter a imagem_atual em 32F para poder calcular a media em "RuningAvg".
cv.Convert(self.imagem_atual, self.imagem_auxiliar)
def get_image(camera, filename=None):
im = cv.QueryFrame(camera)
# take greyscale and compute RMS value
im2 = cv.CreateImage(cv.GetSize(im), cv.IPL_DEPTH_32F, 3)
cv.Convert(im, im2)
gray = cv.CreateImage(cv.GetSize(im), cv.IPL_DEPTH_32F, 1)
cv.CvtColor(im2, gray, cv.CV_RGB2GRAY)
gray_mat = cv.GetMat(gray)
img = numpy.asarray(gray_mat)
power = numpy.sqrt(numpy.mean(img**2))
#save file
if filename:
font = cv.InitFont(cv.CV_FONT_HERSHEY_SIMPLEX, 0.8, 0.8, 0, 2,
cv.CV_AA)
cv.PutText(im, filename, (DATE_X, DATE_Y), font, cv.RGB(255, 255, 0))
filename = os.path.join(DIR_PREFIX, filename + '.jpg')
print filename
cv.SaveImage(filename, im)
del font
else:
filename = ''
#del(camera)
del im, im2, gray, img, gray_mat
return (power, filename)
def applyEffect(self, image, width, height):
ipl_img = cv2.cv.CreateImageHeader((image.shape[1], image.shape[0]),
cv.IPL_DEPTH_8U, 3)
cv2.cv.SetData(ipl_img, image.tostring(),
image.dtype.itemsize * 3 * image.shape[1])
gray = cv.CreateImage((width, height), 8, 1) #tuple as the first arg
dst_img = cv.CreateImage(cv.GetSize(ipl_img), cv.IPL_DEPTH_8U,
3) #_16S => cv2.cv.iplimage
if self.effect == 'dilate':
cv.Dilate(ipl_img, dst_img, None, 5)
elif self.effect == 'laplace':
cv.Laplace(ipl_img, dst_img, 3)
elif self.effect == 'smooth':
cv.Smooth(ipl_img, dst_img, cv.CV_GAUSSIAN)
elif self.effect == 'erode':
cv.Erode(ipl_img, dst_img, None, 1)
cv.Convert(dst_img, ipl_img)
return self.ipl2tk_image(dst_img)
def processaImagem(self):
"""
Crio uma imagem cinza a partir da atual para o programa ficar mais rapido, crio uma imagem com a
diferenca da imagem anterior e a imagem atual, e binarizo a imagem cinza para filtrar pixels pequenos.
"""
# Remove os falsos positivos.
cv.Smooth(self.imagem_atual, self.imagem_atual)
# Aqui eu coloco um tempo de execucao entre as imagens.
cv.RunningAvg(self.imagem_atual, self.imagem_auxiliar, 0.05)
# Covertendo de volta a imagem para poder trabalhar.
cv.Convert(self.imagem_auxiliar, self.imagem_anterior)
# Cria uma nova imagem com a diferenca entre a imagem anterior e a atual.
cv.AbsDiff(self.imagem_atual, self.imagem_anterior, self.imagem_diferenca)
# Converte a imagem atual em escala de cinza.
cv.CvtColor(self.imagem_diferenca, self.imagem_cinza, cv.CV_RGB2GRAY)
# Binariza a imagem. Para poder filtrar pixels pequenos.
cv.Threshold(self.imagem_cinza, self.imagem_cinza, 50, 255, cv.CV_THRESH_BINARY)
dilated = cv.CloneImage(dst_32f)
cv.Dilate(
dst_32f, dilated
) # By this way we are sure that pixel with local max value will not be changed, and all the others will
localMax = cv.CreateMat(dst_32f.height, dst_32f.width, cv.CV_8U)
cv.Cmp(
dst_32f, dilated, localMax, cv.CV_CMP_EQ
) #compare allow to keep only non modified pixel which are local maximum values which are corners.
threshold = 0.01 * maxv
cv.Threshold(dst_32f, dst_32f, threshold, 255, cv.CV_THRESH_BINARY)
cornerMap = cv.CreateMat(dst_32f.height, dst_32f.width, cv.CV_8U)
cv.Convert(dst_32f, cornerMap) #Convert to make the and
cv.And(cornerMap, localMax, cornerMap) #Delete all modified pixels
radius = 3
thickness = 2
l = []
for x in range(
cornerMap.height
): #Create the list of point take all pixel that are not 0 (so not black)
for y in range(cornerMap.width):
if cornerMap[x, y]:
l.append((y, x))
for center in l:
cv.Circle(im, center, radius, (255, 255, 255), thickness)
def convertCV32(stacked):
hist64 = cv.fromarray(stacked)
hist32 = cv.CreateMat(hist64.rows, hist64.cols, cv.CV_32FC1)
cv.Convert(hist64, hist32)
return hist32
backImage = cv.CreateImage((width, height), cv.IPL_DEPTH_8U, 1)
foreground = cv.CreateImage((width, height), cv.IPL_DEPTH_8U, 1)
output = cv.CreateImage((width, height), 8, 1)
begin = True
threshold = 10
for f in xrange(nbFrames):
frame = cv.QueryFrame(capture)
out_foreground.write(np.uint8(frame))
cv.CvtColor(frame, gray, cv.CV_BGR2GRAY)
if begin:
cv.Convert(gray, background) #Convert gray into background format
begin = False
cv.Convert(background,
backImage) #convert existing background to backImage
cv.AbsDiff(backImage, gray, foreground) #Absdiff to get differences
cv.Threshold(foreground, output, threshold, 255, cv.CV_THRESH_BINARY_INV)
cv.Acc(foreground, background, output) #Accumulate to background
cv.ShowImage("Output", output)
cv.ShowImage("Gray", gray)
c = cv.WaitKey(wait)
if c == 27: #Break if user enters 'Esc'.
import cv2.cv as cv
import cv2
import numpy as np
im = cv.LoadImage('WechatIMG92.jpeg', cv.CV_LOAD_IMAGE_COLOR)
# Laplace on a gray scale picture
gray = cv.CreateImage(cv.GetSize(im), 8, 1)
cv.CvtColor(im, gray, cv.CV_BGR2GRAY)
aperture = 3
dst = cv.CreateImage(cv.GetSize(gray), cv.IPL_DEPTH_32F, 1)
cv.Laplace(gray, dst, aperture)
cv.Convert(dst, gray)
thresholded = cv.CloneImage(im)
cv.Threshold(im, thresholded, 50, 255, cv.CV_THRESH_BINARY_INV)
cv.ShowImage('Laplaced grayscale', gray)
cv2.imwrite('~/Users/horace/Documents/TensorFlow/linedetection.jpg', gray)
cv.WaitKey(0)
#------------------------------------
# Laplace on color
planes = [cv.CreateImage(cv.GetSize(im), 8, 1) for i in range(3)]
laplace = cv.CreateImage(cv.GetSize(im), cv.IPL_DEPTH_16S, 1)
colorlaplace = cv.CreateImage(cv.GetSize(im), 8, 3)
cv.Split(im, planes[0], planes[1], planes[2],
import cv2.cv as cv
im = cv.LoadImage('ri.jpg', cv.CV_LOAD_IMAGE_COLOR)
res = cv.CreateImage(cv.GetSize(im), cv.CV_8UC2, 3)
cv.Convert(im, res), cv.ShowImage("Converted", res)
res2 = cv.CreateImage(cv.GetSize(im), cv.CV_8UC2, 3)
cv.CvtColor(im, res2, cv.CV_RGB2BGR)
cv.ShowImage('CvtColor', res2)
cv.WaitKey(0)
def cannyTangent(self,
image,
smooth=True,
T1=20,
T2=250,
eq=False,
method="cv",
method2="fast"):
'''Gets the thresholded edge from opencv canny, and use the locations to take out the magnitude and gradient
from manually calculated gradient using sobel mask'''
gsimage = cv.CreateImage(cv.GetSize(image), cv.IPL_DEPTH_8U, 1)
smoothed = cv.CreateImage(cv.GetSize(image), cv.IPL_DEPTH_8U, 1)
final = cv.CreateImage(cv.GetSize(image), cv.IPL_DEPTH_8U, 1)
if image.channels > 1:
temp = cv.CreateImage(cv.GetSize(image), cv.IPL_DEPTH_8U, 1)
cv.CvtColor(image, temp, cv.CV_BGR2GRAY)
else:
temp = image
if eq:
cv.EqualizeHist(temp, gsimage)
else:
cv.Copy(temp, gsimage)
if smooth:
cv.Smooth(gsimage, smoothed)
final = smoothed
else:
cv.Copy(gsimage, final)
tempo = self.visualize
self.visualize = False
#a = time.time()
gradient = self.cannyGradient(final, t1=T1, t2=T2)
#print "single canny time:", time.time() - a
#a = time.time()
(dx, dy) = self.sobelGradient(final)
#print "single sobel time:", time.time() - a
#a = time.time()
tangent = self.tangent(dx, dy, gradient, method=method)
#print "single tangent time:", time.time() - a
#a = time.time()
magnitude = self.Magnitude(dx, dy, gradient, method=method2)
#print "single magnitude time:", time.time() - a
self.visualize = tempo
if self.visualize:
jinjer = 0
while True:
tan = cv.CreateImage(cv.GetSize(tangent), cv.IPL_DEPTH_8U, 1)
timp = cv.CreateImage(cv.GetSize(tangent), cv.IPL_DEPTH_8U, 1)
cv.Convert(tangent, tan)
cv.EqualizeHist(tan, timp)
cv.NamedWindow("Original")
cv.MoveWindow("Original", 0, 0)
cv.ShowImage("Original", final)
#cv.NamedWindow("TangentCanny")
#cv.ShowImage("TangentCanny", timp)
cv.NamedWindow("magnitude")
cv.MoveWindow("magnitude", 640, 0)
cv.ShowImage("magnitude", magnitude)
c = cv.WaitKey(5)
jinjer += 1
if c > 0 or jinjer > 1000000:
break
cv.DestroyAllWindows()
return (tangent, magnitude)
import cv2.cv as cv
im = cv.LoadImage('../img/fruits.jpg', cv.CV_LOAD_IMAGE_COLOR)
res = cv.CreateImage(cv.GetSize(im), cv.CV_8UC2,
3) #cv.CV_32F, cv.IPL_DEPTH_16S, ...
cv.Convert(im, res)
cv.ShowImage("Converted", res)
res2 = cv.CreateImage(cv.GetSize(im), cv.CV_8UC2, 3)
cv.CvtColor(im, res2, cv.CV_RGB2BGR) # HLS, HSV, YCrCb, ....
cv.ShowImage("CvtColor", res2)
cv.WaitKey(0)
cv.Threshold(morphed, morphed, 30, 255, cv.CV_THRESH_BINARY_INV)
cv.ShowImage("Morphed green edge", morphed)
cv.SaveImage("green edge Morphed.png", dst)
cv.WaitKey(0)
enter = raw_input("Mostrar Laplace")
#laplace
#imagen en gris
gray = cv.CreateImage(cv.GetSize(im), 8, 1)
cv.CvtColor(im, gray, cv.CV_BGR2GRAY)
aperture = 3 #cambiar el aperture
dst = cv.CreateImage(cv.GetSize(gray), cv.IPL_DEPTH_32F, 1)
cv.Laplace(gray, dst, aperture)
cv.Convert(dst, gray)
thresholded = cv.CloneImage(im)
cv.Threshold(orig, thresholded, 100, 255, cv.CV_THRESH_BINARY_INV)
cv.ShowImage('Grayscale edge Laplace', gray)
cv.SaveImage("Grayscale edge Laplace.png", dst)
cv.WaitKey(0)
#azul
blue = cv.CreateImage(cv.GetSize(imblue), 8, 1)
cv.CvtColor(im, blue, cv.CV_BGR2GRAY)
aperture = 3 #cambiar el aperture
dst = cv.CreateImage(cv.GetSize(blue), cv.IPL_DEPTH_32F, 1)
cv.Laplace(blue, dst, aperture)
cv.Convert(dst, blue)
thresholded = cv.CloneImage(im)
cv.Threshold(orig, thresholded, 100, 255, cv.CV_THRESH_BINARY_INV)
import cv2.cv as cv
img = cv.LoadImage('img/blueRose.jpeg', cv.CV_LOAD_IMAGE_COLOR)
rose = cv.CreateImage(cv.GetSize(img), cv.CV_8UC2, 3)
cv.Convert(img, rose)
cv.ShowImage('converting - press key \'space\' to invoke convert', rose)
k = cv.WaitKey(0)
#assert k == 32 # space
rose2 = cv.CreateImage(cv.GetSize(img), cv.CV_8UC2, 3)
cv.CvtColor(img, rose2, cv.CV_RGB2BGR)
cv.ShowImage('CvtColor', rose2)
k = cv.WaitKey(0)
if k == 27:
cv.DestroyAllWindows()
