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()