def getAverageValues2(self, images): """ get the average values over all the images for every two images, divides the images by 2 then adds them together """ if len(images) == 0: return None if len(images) == 1: return images[0] width = images[0].width height = images[0].height # create image with only 2's # this will be used for division divisionImage = cv.CreateImage((width, height), cv.IPL_DEPTH_8U, 1) cv.Set(divisionImage, 2) image1 = cv.CreateImage((width, height), cv.IPL_DEPTH_8U, 1) image2 = cv.CreateImage((width, height), cv.IPL_DEPTH_8U, 1) avgImage = cv.CloneImage(images[0]) for image in images: # divide images by 2 cv.Div(avgImage, divisionImage, image1) cv.Div(image, divisionImage, image2) # add them to get result cv.Add(image1, image2, avgImage) return avgImage
def get_normalized_rgb_planes(r, g, b): size = cv.GetSize(r) # r,g,b = get_three_planes(img) nr_plane = cv.CreateImage(size, 8, 1) ng_plane = cv.CreateImage(size, 8, 1) nb_plane = cv.CreateImage(size, 8, 1) r32 = cv.CreateImage(size, cv.IPL_DEPTH_32F, 1) g32 = cv.CreateImage(size, cv.IPL_DEPTH_32F, 1) b32 = cv.CreateImage(size, cv.IPL_DEPTH_32F, 1) sum = cv.CreateImage(size, cv.IPL_DEPTH_32F, 1) cv.Zero(sum) cv.Convert(r, r32) cv.Convert(g, g32) cv.Convert(b, b32) cv.Add(r32, g32, sum) cv.Add(b32, sum, sum) tmp = cv.CreateImage(size, cv.IPL_DEPTH_32F, 1) cv.Div(r32, sum, tmp) cv.ConvertScale(tmp, nr_plane, scale=255) cv.Div(g32, sum, tmp) cv.ConvertScale(tmp, ng_plane, scale=255) cv.Div(b32, sum, tmp) cv.ConvertScale(tmp, nb_plane, scale=255) # res = image_empty_clone(img) # cv.Merge(nr_plane,ng_plane,nb_plane,None,res) return nr_plane, ng_plane, nb_plane
def image_callback(data): global running if (running): image = bridge.imgmsg_to_cv(data, "bgr8") #normalize image cv.Split(image, rgb_r, rgb_g, rgb_b, None) red_mean = cv2.mean(np.asarray(rgb_r[:, :])) cv.Div(src2=cv.fromarray(np.ones((480, 640))), src1=rgb_r, dst=scaled_r, scale=128 / red_mean[0]) green_mean = cv2.mean(np.asarray(rgb_g[:, :])) cv.Div(src2=cv.fromarray(np.ones((480, 640))), src1=rgb_g, dst=scaled_g, scale=128 / green_mean[0]) blue_mean = cv2.mean(np.asarray(rgb_b[:, :])) cv.Div(src2=cv.fromarray(np.ones((480, 640))), src1=rgb_b, dst=scaled_b, scale=128 / blue_mean[0]) cv.Merge(scaled_r, scaled_g, scaled_b, None, cv_image) cv.CvtColor(cv_image, hsv, cv.CV_BGR2HSV) # --convert from BGR to HSV cv.CvtColor(cv_image, lab, cv.CV_BGR2Lab) cv.Split(hsv, hsv_h, hsv_s, hsv_v, None) cv.Split(cv_image, rgb_r, rgb_g, rgb_b, None) cv.Split(lab, lab_l, lab_a, lab_b, None) cv.Split(luv, luv_l, luv_u, luv_v, None) cv.Split(hls, hls_h, hls_l, hls_s, None) cv.Split(xyz, xyz_x, xyz_y, xyz_x, None) cv.Split(ycrcb, ycrcb_y, ycrcb_cr, ycrcb_cb, None) cv.Not(lab_a, a_not) cv.Sub(hsv_s, a_not, sa) cv.Sub(luv_u, hls_h, test) cv.Sub(hls_s, hls_h, sminh) threshold_red(sa) cv.ShowImage("red", red_dilated_image) red_contours, _ = cv2.findContours(image=np.asarray( red_dilated_image[:, :]), mode=cv.CV_RETR_EXTERNAL, method=cv.CV_CHAIN_APPROX_SIMPLE) print_lidar_projections(cv_image) circles = extract_circles(red_contours, [1, 0, 0]) for x, y, radius in circles: cv.Circle(cv_image, (x, y), radius, [0, 0, 1], 3) cv.SetMouseCallback("camera feed", mouse_callback, hsv_image) cv.ShowImage("camera feed", cv_image) cv.WaitKey(3)
def main(): root = "/Users/soswow/Documents/Face Detection/test/negative" # root = "/Users/soswow/Documents/Face Detection/test/sets/negative" # root = "/Users/soswow/Documents/Face Detection/test/edge_view/positive" # root = "/Users/soswow/Documents/Face Detection/test/sobel/positive" # root = "/Users/soswow/Documents/Face Detection/test/sets/positive" # root = "/Users/soswow/Documents/Face Detection/test/falses" for folder in os.listdir(root): path = p.join(root, folder) if p.isdir(path): sum = cv.CreateMat(32, 32, cv.CV_32F) cv.Zero(sum) k = 0 for path, _ in directory_files(path): try: img = cv.LoadImage(path, iscolor=False) except IOError: continue mat = cv.CreateMat(32, 32, cv.CV_32F) cv.Zero(mat) cv.Convert(cv.GetMat(img), mat) cv.Add(mat, sum, sum) k += 1 avg = cv.CreateMat(32, 32, cv.CV_32F) cv.Zero(avg) count = cv.CreateMat(32, 32, cv.CV_32F) cv.Zero(count) cv.Set(count, k) cv.Div(sum, count, avg) new_img = cv.CreateImage((32, 32), 8, 0) cv.Zero(new_img) cv.Convert(avg, new_img) cv.SaveImage(p.join(root, "%s-avg.png" % folder), new_img)
def fade_edges(projection_pattern, fade_width): divisor = cv.CreateMat(projection_pattern.height, projection_pattern.width, cv.CV_8UC1) cv.Set(divisor, 1) for i in range(fade_width): cv.Rectangle(divisor, (i, i), (projection_pattern.width - 1 - i, projection_pattern.height - 1 - i), int(((-5.0 / fade_width) * i) + 6)) cv.Div(projection_pattern, divisor, projection_pattern) return projection_pattern
def sub_image(self, imagecurr, imageprev, divid=True): imagesize = (imagecurr.width, imagecurr.height) image = cv.CreateImage(imagesize, cv.IPL_DEPTH_8U, 1) cv.Sub(imagecurr, imageprev, image) # use pyramid/cone to ponderate the weight # ie. moves in corners are more important than in the center if divid: cv.Div(image, self.cone, image) cv.Flip(image, flipMode=1) # for webcam return image
def FormatImage(img, oimg, off, scale, correction): global i01 #print img.height,img.width #print oimg.height,oimg.width cv.Transpose(img,oimg) cv.Flip(oimg,None,0) if(correction): cv.AddS(oimg, off, oimg) cv.Div(oimg, i01, oimg, scale)
def crunch(): size = cv.GetSize(band3) assert size == cv.GetSize(band4) numerator = cv.CreateImage(size, cv.IPL_DEPTH_32F, 1) cv.Sub(band4, band3, numerator) denominator = cv.CreateImage(size, cv.IPL_DEPTH_32F, 1) cv.Add(band4, band3, denominator) ndvi_img = cv.CreateImage(size, cv.IPL_DEPTH_32F, 1) cv.Div(numerator, denominator, ndvi_img) # (NDVI + 1) cv.AddS(ndvi_img, 1, ndvi_img) return ndvi_img
def repeat(): global CAM_CFG, lastframe, diffframe, camframe, camhist, camhist_img frame = cv.GetSubRect(cv.QueryFrame(CAM_CFG['handler']), CAM_CFG['roi']) # This takes 1% CPU: #framearr = cv2array(frame) # This takes 7% CPU: #framearr = framearr.astype(np.float64)*1.0/256 # This takes 3% CPU: cv.ConvertScale(frame, camframe, scale=1.0 / 256) # This takes 2% CPU: #camframearr = cv2array(camframe) # Calculate (cam-dark)/flat. Without mask might be faster sometimes. cv.Sub(camframe, darkframe, camframe, mask=CAM_CFG['mask']) cv.Div(camframe, flatframe, camframe, 1) # # Calculate cam - last cv.Sub(camframe, lastframe, diffframe, mask=CAM_CFG['mask']) # Make histogram of camframe camhist, camhist_img = calc_1dhisto(camframe, nbin=ibins, scale=scale, histh=histh, hist=camhist, histimg=camhist_img) if (LIVE): cv.ShowImage("cam_live", camframe) cv.ShowImage("cam_other", diffframe) cv.ShowImage("cam_histo", camhist_img) c = cv.WaitKey(10) if (c == "n" ): #in "n" key is pressed while the popup window is in focus pass CAM_CFG['buf'][(CAM_CFG['frameidx']) % len(CAM_CFG['buf'])] = camframe CAM_CFG['frameidx'] += 1 lastframe = cv.CloneImage(camframe)
def ray_plane_intersections(rays, planes): rows = rays.height cols = rays.width rays_split = [None] * 3 for i in range(3): rays_split[i] = cv.CreateMat(rows, cols, cv.CV_32FC1) cv.Split(rays, rays_split[0], rays_split[1], rays_split[2], None) planes_split = [None] * 4 for i in range(4): planes_split[i] = cv.CreateMat(rows, cols, cv.CV_32FC1) cv.Split(planes, planes_split[0], planes_split[1], planes_split[2], planes_split[3]) n_dot_v = cv.CreateMat(rows, cols, cv.CV_32FC1) cv.SetZero(n_dot_v) for i in range(3): temp = cv.CreateMat(rows, cols, cv.CV_32FC1) cv.Mul(planes_split[i], rays_split[i], temp) cv.Add(temp, n_dot_v, n_dot_v) depth = cv.CreateMat(rows, cols, cv.CV_32FC1) cv.Div(planes_split[3], n_dot_v, depth) intersection_points_split = [None] * 3 for i in range(3): intersection_points_split[i] = cv.CreateMat(rows, cols, cv.CV_32FC1) for i in range(3): cv.Mul(depth, rays_split[i], intersection_points_split[i]) intersection_points = cv.CreateMat(rows, cols, cv.CV_32FC3) cv.Merge(intersection_points_split[0], intersection_points_split[1], intersection_points_split[2], None, intersection_points) return intersection_points
def DetectaSombra(frame, bg): dbg = 1 if dbg: t1 = time.time() print 'Detectando sombras na imagem...' # gera as imagens de cada canal RGB imgCinza = cv.CreateImage(cv.GetSize(frame), cv.IPL_DEPTH_8U, 1) imgHSV = cv.CloneImage(frame) imgH = cv.CloneImage(imgCinza) imgS = cv.CloneImage(imgCinza) imgV = cv.CloneImage(imgCinza) imgR = cv.CloneImage(imgCinza) imgG = cv.CloneImage(imgCinza) imgB = cv.CloneImage(imgCinza) bgCinza = cv.CreateImage(cv.GetSize(bg), cv.IPL_DEPTH_8U, 1) bgHSV = cv.CloneImage(bg) bgH = cv.CloneImage(bgCinza) bgS = cv.CloneImage(bgCinza) bgV = cv.CloneImage(bgCinza) bgR = cv.CloneImage(bgCinza) bgG = cv.CloneImage(bgCinza) bgB = cv.CloneImage(bgCinza) # gera as imagens de cada frame e backgroun nos canais de HSV e RGB cv.CvtColor(frame, imgHSV, cv.CV_BGR2HSV) cv.Split(imgHSV, imgH, imgS, imgV, None) cv.Split(frame, imgR, imgG, imgB, None) cv.CvtColor(bg, bgHSV, cv.CV_BGR2HSV) cv.Split(bgHSV, bgH, bgS, bgV, None) cv.Split(bg, bgR, bgG, bgB, None) # inicio de calculos para descobrir sombras. ivbv = cv.CreateImage(cv.GetSize(frame), cv.IPL_DEPTH_8U, 1) cv.Div(imgV, bgV, ivbv, 255) isbs = cv.CreateImage(cv.GetSize(frame), cv.IPL_DEPTH_8U, 1) cv.Sub(imgS, bgS, isbs) ihbh = cv.CreateImage(cv.GetSize(frame), cv.IPL_DEPTH_8U, 1) cv.AbsDiff(imgH, bgH, ihbh) # parametros de deteccao de sombra alfa = 190 beta = 210 thrSat = 20 thrHue = 50 alfa = 220 beta = 240 thrSat = 90 thrHue = 90 nErode = 0 nDilate = 0 # trata ivbv imgThr_ivbv = cv.CreateImage(cv.GetSize(frame), cv.IPL_DEPTH_8U, 1) # deixa apenas os menores que beta cv.Threshold(ivbv, imgThr_ivbv, beta, 255, cv.CV_THRESH_TRUNC) # deixa apenas os maiores que alfa cv.Threshold(imgThr_ivbv, imgThr_ivbv, alfa, 255, cv.CV_THRESH_TOZERO) # binariza cv.Threshold(imgThr_ivbv, imgThr_ivbv, alfa, 255, cv.CV_THRESH_BINARY) # trata isbs imgThr_isbs = cv.CreateImage(cv.GetSize(frame), cv.IPL_DEPTH_8U, 1) # deixa apenas os menores que thrSat cv.Threshold(isbs, imgThr_isbs, thrSat, 255, cv.CV_THRESH_BINARY) # trata isbs imgThr_ihbh = cv.CreateImage(cv.GetSize(frame), cv.IPL_DEPTH_8U, 1) # deixa apenas os menores que thrSat cv.Threshold(ihbh, imgThr_ihbh, thrHue, 255, cv.CV_THRESH_BINARY_INV) # onde é preto em todas as imagens, é sombra imgSombra = cv.CreateImage(cv.GetSize(frame), cv.IPL_DEPTH_8U, 1) cv.Not(imgThr_ivbv, imgThr_ivbv) cv.Not(imgThr_isbs, imgThr_isbs) cv.And(imgThr_ivbv, imgThr_isbs, imgSombra) cv.Not(imgThr_ihbh, imgThr_ihbh) cv.And(imgSombra, imgThr_ihbh, imgSombra) for i in range(nErode): cv.Erode(imgSombra, imgSombra) for i in range(nDilate): cv.Dilate(imgSombra, imgSombra) if dbg: print 'Tempo para detectar sombras: %.5f' % (time.time() - t1) #exibe frames de saida #destaca de verde a sombra sobre o frame frameDestacado = cv.CloneImage(frame) cv.Or(imgG, imgSombra, imgG) cv.Merge(imgR, imgG, imgB, None, frameDestacado) ''' cv.ShowImage('frameDestacado',frameDestacado) cv.WaitKey() ''' retorno = {} retorno['sombra'] = imgSombra retorno['sombraDestacada'] = frameDestacado return retorno cv.ShowImage('ivbv', ivbv) cv.ShowImage('isbs', isbs) cv.ShowImage('ihbh', ihbh) cv.ShowImage('imgThr_isbs', imgThr_isbs) cv.ShowImage('imgThr_ivbv', imgThr_ivbv) cv.ShowImage('imgThr_ihbh', imgThr_ihbh) cv.ShowImage('imgSombra', imgSombra) cv.WaitKey() sys.exit() frameMerge = cv.CloneImage(frame) cv.Merge(imgR, imgR, imgR, None, frameMerge) cv.ShowImage('frame', frame) cv.ShowImage('frameMerge', frameMerge) cv.ShowImage('imgR', imgR) cv.ShowImage('imgG', imgG) cv.ShowImage('imgB', imgB) cv.ShowImage('imgH', imgH) cv.ShowImage('imgS', imgS) cv.ShowImage('imgV', imgV) cv.WaitKey() return 0
def doSSIM(frame1, frame2): ''' The equivalent of Zhou Wang's SSIM matlab code using OpenCV. from http://www.cns.nyu.edu/~zwang/files/research/ssim/index.html The measure is described in : "Image quality assessment: From error measurement to structural similarity" C++ code by Rabah Mehdi. http://mehdi.rabah.free.fr/SSIM C++ to Python translation and adaptation by Iñaki Úcar ''' def array2cv(a): dtype2depth = { 'uint8': cv.IPL_DEPTH_8U, 'int8': cv.IPL_DEPTH_8S, 'uint16': cv.IPL_DEPTH_16U, 'int16': cv.IPL_DEPTH_16S, 'int32': cv.IPL_DEPTH_32S, 'float32': cv.IPL_DEPTH_32F, 'float64': cv.IPL_DEPTH_64F, } try: nChannels = a.shape[2] except: nChannels = 1 cv_im = cv.CreateImageHeader((a.shape[1], a.shape[0]), dtype2depth[str(a.dtype)], nChannels) cv.SetData(cv_im, a.tostring(), a.dtype.itemsize * nChannels * a.shape[1]) return cv_im C1 = 6.5025 C2 = 58.5225 img1_temp = array2cv(frame1) img2_temp = array2cv(frame2) nChan = img1_temp.nChannels d = cv.IPL_DEPTH_32F size = img1_temp.width, img1_temp.height img1 = cv.CreateImage(size, d, nChan) img2 = cv.CreateImage(size, d, nChan) cv.Convert(img1_temp, img1) cv.Convert(img2_temp, img2) img1_sq = cv.CreateImage(size, d, nChan) img2_sq = cv.CreateImage(size, d, nChan) img1_img2 = cv.CreateImage(size, d, nChan) cv.Pow(img1, img1_sq, 2) cv.Pow(img2, img2_sq, 2) cv.Mul(img1, img2, img1_img2, 1) mu1 = cv.CreateImage(size, d, nChan) mu2 = cv.CreateImage(size, d, nChan) mu1_sq = cv.CreateImage(size, d, nChan) mu2_sq = cv.CreateImage(size, d, nChan) mu1_mu2 = cv.CreateImage(size, d, nChan) sigma1_sq = cv.CreateImage(size, d, nChan) sigma2_sq = cv.CreateImage(size, d, nChan) sigma12 = cv.CreateImage(size, d, nChan) temp1 = cv.CreateImage(size, d, nChan) temp2 = cv.CreateImage(size, d, nChan) temp3 = cv.CreateImage(size, d, nChan) ssim_map = cv.CreateImage(size, d, nChan) #/*************************** END INITS **********************************/ #// PRELIMINARY COMPUTING cv.Smooth(img1, mu1, cv.CV_GAUSSIAN, 11, 11, 1.5) cv.Smooth(img2, mu2, cv.CV_GAUSSIAN, 11, 11, 1.5) cv.Pow(mu1, mu1_sq, 2) cv.Pow(mu2, mu2_sq, 2) cv.Mul(mu1, mu2, mu1_mu2, 1) cv.Smooth(img1_sq, sigma1_sq, cv.CV_GAUSSIAN, 11, 11, 1.5) cv.AddWeighted(sigma1_sq, 1, mu1_sq, -1, 0, sigma1_sq) cv.Smooth(img2_sq, sigma2_sq, cv.CV_GAUSSIAN, 11, 11, 1.5) cv.AddWeighted(sigma2_sq, 1, mu2_sq, -1, 0, sigma2_sq) cv.Smooth(img1_img2, sigma12, cv.CV_GAUSSIAN, 11, 11, 1.5) cv.AddWeighted(sigma12, 1, mu1_mu2, -1, 0, sigma12) #////////////////////////////////////////////////////////////////////////// #// FORMULA #// (2*mu1_mu2 + C1) cv.Scale(mu1_mu2, temp1, 2) cv.AddS(temp1, C1, temp1) #// (2*sigma12 + C2) cv.Scale(sigma12, temp2, 2) cv.AddS(temp2, C2, temp2) #// ((2*mu1_mu2 + C1).*(2*sigma12 + C2)) cv.Mul(temp1, temp2, temp3, 1) #// (mu1_sq + mu2_sq + C1) cv.Add(mu1_sq, mu2_sq, temp1) cv.AddS(temp1, C1, temp1) #// (sigma1_sq + sigma2_sq + C2) cv.Add(sigma1_sq, sigma2_sq, temp2) cv.AddS(temp2, C2, temp2) #// ((mu1_sq + mu2_sq + C1).*(sigma1_sq + sigma2_sq + C2)) cv.Mul(temp1, temp2, temp1, 1) #// ((2*mu1_mu2 + C1).*(2*sigma12 + C2))./((mu1_sq + mu2_sq + C1).*(sigma1_sq + sigma2_sq + C2)) cv.Div(temp3, temp1, ssim_map, 1) index_scalar = cv.Avg(ssim_map) #// through observation, there is approximately #// 1% error max with the original matlab program return index_scalar[0]
def _div_and_sub(src_dst_image, other_image, threes_image): cv.Div(other_image, threes_image, other_image) cv.Sub(src_dst_image, other_image, src_dst_image)
def image_callback(data): global running, color if (running): #print "running" image = bridge.imgmsg_to_cv(data, "bgr8") #normalize image cv.Split(image, rgb_r, rgb_g, rgb_b, None) red_mean = cv2.mean(numpy.asarray(rgb_r[:, :])) cv.Div(src2=cv.fromarray(numpy.ones((480, 640))), src1=rgb_r, dst=scaled_r, scale=128 / red_mean[0]) green_mean = cv2.mean(numpy.asarray(rgb_g[:, :])) cv.Div(src2=cv.fromarray(numpy.ones((480, 640))), src1=rgb_g, dst=scaled_g, scale=128 / green_mean[0]) blue_mean = cv2.mean(numpy.asarray(rgb_b[:, :])) cv.Div(src2=cv.fromarray(numpy.ones((480, 640))), src1=rgb_b, dst=scaled_b, scale=128 / blue_mean[0]) cv.Merge(scaled_r, scaled_g, scaled_b, None, cv_image) cv.CvtColor(cv_image, hsv, cv.CV_BGR2HSV) cv.CvtColor(cv_image, lab, cv.CV_BGR2Lab) cv.CvtColor(cv_image, luv, cv.CV_BGR2Luv) cv.CvtColor(cv_image, hls, cv.CV_BGR2HLS) cv.CvtColor(cv_image, xyz, cv.CV_BGR2XYZ) cv.CvtColor(cv_image, ycrcb, cv.CV_BGR2YCrCb) cv.Split(hsv, hsv_h, hsv_s, hsv_v, None) cv.Split(cv_image, rgb_r, rgb_g, rgb_b, None) cv.Split(lab, lab_l, lab_a, lab_b, None) cv.Split(luv, luv_l, luv_u, luv_v, None) cv.Split(hls, hls_h, hls_l, hls_s, None) cv.Split(xyz, xyz_x, xyz_y, xyz_x, None) cv.Split(ycrcb, ycrcb_y, ycrcb_cr, ycrcb_cb, None) cv.Not(lab_a, a_not) cv.Sub(hsv_s, a_not, sa) cv.Sub(luv_u, hls_h, test) ''' cv.CvtColor(cv_image,gray,cv.CV_BGR2GRAY) cv.Smooth(gray,blurred_gray,cv.CV_GAUSSIAN,3,3) small = cv2.resize(numpy.asarray(ycrcb_cr[:,:]),(320,240) circles=cv2.HoughCircles(image=numpy.asarray(small[:,:]),method=cv.CV_HOUGH_GRADIENT,dp=1,minDist=1,param1=100,param2=60, minRadius=1,maxRadius=600) if not(circles is None): for i in circles: if (i[0][1] < 200): print "found circles",i,len(i) center = (i[0][0],i[0][1]) radius = i[0][2] cv.Circle(cv_image,center,radius,(1,1,0),2) ''' cv.Mul(test, red_adaptive, final) if (color == 'red'): threshold_red(sa) #threshold_red(ycrcb_cr) red_contours, _ = cv2.findContours( image=numpy.asarray(red_dilated_image[:, :]), mode=cv.CV_RETR_EXTERNAL, method=cv.CV_CHAIN_APPROX_SIMPLE) circles = extract_circles(red_contours, [1, 0, 0]) for x, y, radius in circles: cv.Circle(cv_image, (x, y), radius, [0, 0, 255], 3) elif (color == 'purple'): threshold_purple(lab_a) purple_contours, _ = cv2.findContours( image=numpy.asarray(purple_dilated_image[:, :]), mode=cv.CV_RETR_EXTERNAL, method=cv.CV_CHAIN_APPROX_SIMPLE) circles = extract_circles(purple_contours, [1, 0, 1]) for x, y, radius in circles: cv.Circle(cv_image, (x, y), radius, [255, 0, 255], 3) cv.ShowImage("red", red_adaptive) cv.ShowImage("purple", purple_adaptive) cv.ShowImage("camera feed", cv_image) cv.WaitKey(3)
def cam_getimage(show=False, dfcorr=True, raw=False, showhisto=True, waitkey=25): """ Get image from the camera, convert, scale, dark-flat correct, optionally show this and return as numpy.ndarray. If **raw* is set, return the (scaled/ROI'd) image as CvImage If CAM_CFG['flat'] or CAM_CFG['dark'] are set, use these to dark-flat correct the image. @param [in] show Show image after acquisition @param [in] dfcorr Do dark-flat correction @param [in] raw Return raw IplImage (scaled and ROI'd, w/o DF correction) @param [in] showhisto Show histogram as well (only with **show**) @param [in] waitkey Wait time for cv.WaitKey() If 0, don't call. (only with **show**) @return Image data as numpy.ndarray """ if (not CAM_CFG['handle']): return rawframe = cv.CloneImage(cv.QueryFrame(CAM_CFG['handle'])) # Downscale color images if (rawframe.channels > 1): rawsz = cv.GetSize(rawframe) if (not CAM_CFG.has_key('rawyuv') or not CAM_CFG['rawyuv']): CAM_CFG['rawyuv'] = cv.CreateImage(rawsz, rawframe.depth, 3) CAM_CFG['rawgray'] = cv.CreateImage(rawsz, rawframe.depth, 1) cv.CvtColor(rawframe, CAM_CFG['rawyuv'], cv.CV_BGR2YCrCb) cv.Split(CAM_CFG['rawyuv'], CAM_CFG['rawgray'], None, None, None) rawframe = CAM_CFG['rawgray'] if (CAM_CFG['roi']): rawframe = cv.GetSubRect(rawframe, tuple(CAM_CFG['roi'])) procf = CAM_CFG['frame'] cv.ConvertScale(rawframe, procf, scale=1.0 / 256) if (raw): return cv.CloneImage(procf) if (CAM_CFG.has_key('dark') and dfcorr): cv.Sub(procf, CAM_CFG['dark'], procf) if (CAM_CFG.has_key('flat') and dfcorr): cv.Div(procf, CAM_CFG['flat'], procf) # We *don't* apply the aperture mask here because we might need the data if (show): cv.ShowImage(CAM_CFG['window'], procf) if (showhisto): global camhist, camhistimg camhist, camhistimg = calc_1dhisto(procf, hist=camhist, histimg=camhistimg) cv.ShowImage("cam_histogram", camhistimg) if (waitkey): cv.WaitKey(waitkey) depth2dtype = { cv.IPL_DEPTH_32F: 'float32', cv.IPL_DEPTH_64F: 'float64', } framearr = np.fromstring(procf.tostring(), dtype=depth2dtype[procf.depth], count=procf.width * procf.height * procf.nChannels) framearr.shape = (procf.height, procf.width, procf.nChannels) return framearr[:, :, 0]
def image_callback(data): global running #print "running" if (running): image = bridge.imgmsg_to_cv(data, "bgr8") #normalize image cv.Split(image, rgb_r, rgb_g, rgb_b, None) red_mean = cv2.mean(np.asarray(rgb_r[:, :])) cv.Div(src2=cv.fromarray(np.ones((480, 640))), src1=rgb_r, dst=scaled_r, scale=128 / red_mean[0]) green_mean = cv2.mean(np.asarray(rgb_g[:, :])) cv.Div(src2=cv.fromarray(np.ones((480, 640))), src1=rgb_g, dst=scaled_g, scale=128 / green_mean[0]) blue_mean = cv2.mean(np.asarray(rgb_b[:, :])) cv.Div(src2=cv.fromarray(np.ones((480, 640))), src1=rgb_b, dst=scaled_b, scale=128 / blue_mean[0]) cv.Merge(scaled_r, scaled_g, scaled_b, None, cv_image) cv.CvtColor(cv_image, hsv_image, cv.CV_BGR2HSV) # --convert from BGR to HSV cv.CvtColor(cv_image, lab_image_, cv.CV_BGR2Lab) cv.CvtColor(cv_image, ycrcb, cv.CV_BGR2YCrCb) cv.Smooth(cv_image, blurred_bgr_image, cv.CV_GAUSSIAN, 9, 9) cv.Smooth(hsv_image, blurred_image, cv.CV_GAUSSIAN, 5, 5) cv.Split(blurred_image, h_channel, s_channel, v_channel, None) cv.Split(lab_image_, l_channel, a_channel, b_channel, None) cv.Split(ycrcb, ycrcb_y, ycrcb_cr, ycrcb_cb, None) cv.Sub(s_channel, h_channel, sminh) cv.Sub(s_channel, a_channel, hmina) cv.Sub(ycrcb_cr, hmina, final) #cv.Sub(s_channel,v_channel,sminv) #maybe use for blue threshold_red(final) threshold_green(final) #threshold_yellow(blurred_image) #threshold_blue(h_channel) #cv.ShowImage("test",sminv) cv.ShowImage("red", red_dilated_image) #cv.ShowImage("yellow",yellow_adaptive) #cv.ShowImage("blue",blue_dilated_image) cv.ShowImage("green", green_dilated_image) red_contours, _ = cv2.findContours(image=np.asarray( red_dilated_image[:, :]), mode=cv.CV_RETR_EXTERNAL, method=cv.CV_CHAIN_APPROX_SIMPLE) green_contours, _ = cv2.findContours(image=np.asarray( green_dilated_image[:, :]), mode=cv.CV_RETR_EXTERNAL, method=cv.CV_CHAIN_APPROX_SIMPLE) yellow_contours, _ = cv2.findContours(image=np.asarray( yellow_dilated_image[:, :]), mode=cv.CV_RETR_EXTERNAL, method=cv.CV_CHAIN_APPROX_SIMPLE) blue_contours, _ = cv2.findContours(image=np.asarray( blue_dilated_image[:, :]), mode=cv.CV_RETR_EXTERNAL, method=cv.CV_CHAIN_APPROX_SIMPLE) #cv2.drawContours(np.asarray(cv_image[:,:]),red_contours,-1,(0,0,255),3) print_lidar_projections(cv_image) for i in [ (green_contours, [0, 1, 0]), (red_contours, [1, 0, 0]) ]: #(yellow_contours,[1,1,0]) , ]:# , (blue_contours,[0,0,1])]: circles = extract_circles(i[0], i[1]) rgb = i[1] bgr = (255 * np.array(rgb[::-1])).tolist( ) #invert list and multiply by 255 for cv.Circle color argument for x, y, radius in circles: cv.Circle(cv_image, (x, y), radius, bgr, 3) cv.SetMouseCallback("camera feed", mouse_callback, hsv_image) #cv.ShowImage("l channel",l_channel) #cv.ShowImage("a channel",a_channel) #cv.ShowImage("b channel",b_channel) cv.ShowImage("camera feed", cv_image) cv.WaitKey(3)
def line_line_intersections(P_0, u, Q_0, v): rows = P_0.height cols = P_0.width w_0 = cv.CreateMat(rows, cols, cv.CV_32FC3) cv.Sub(P_0, Q_0, w_0) a = element_wise_dot_product(u, u) b = element_wise_dot_product(u, v) c = element_wise_dot_product(v, v) d = element_wise_dot_product(u, w_0) e = element_wise_dot_product(v, w_0) a_mul_c = cv.CreateMat(rows, cols, cv.CV_32FC1) cv.Mul(a, c, a_mul_c) b_squared = cv.CreateMat(rows, cols, cv.CV_32FC1) cv.Pow(b, b_squared, 2) denominator = cv.CreateMat(rows, cols, cv.CV_32FC1) cv.Sub(a_mul_c, b_squared, denominator) b_mul_e = cv.CreateMat(rows, cols, cv.CV_32FC1) cv.Mul(b, e, b_mul_e) c_mul_d = cv.CreateMat(rows, cols, cv.CV_32FC1) cv.Mul(c, d, c_mul_d) b_mul_d = cv.CreateMat(rows, cols, cv.CV_32FC1) cv.Mul(b, d, b_mul_d) a_mul_e = cv.CreateMat(rows, cols, cv.CV_32FC1) cv.Mul(a, e, a_mul_e) s_c = cv.CreateMat(rows, cols, cv.CV_32FC1) cv.Sub(b_mul_e, c_mul_d, s_c) cv.Div(s_c, denominator, s_c) t_c = cv.CreateMat(rows, cols, cv.CV_32FC1) cv.Sub(a_mul_e, b_mul_d, t_c) cv.Div(t_c, denominator, t_c) u_x = cv.CreateMat(rows, cols, cv.CV_32FC1) u_y = cv.CreateMat(rows, cols, cv.CV_32FC1) u_z = cv.CreateMat(rows, cols, cv.CV_32FC1) cv.Split(u, u_x, u_y, u_z, None) su_x = cv.CreateMat(rows, cols, cv.CV_32FC1) su_y = cv.CreateMat(rows, cols, cv.CV_32FC1) su_z = cv.CreateMat(rows, cols, cv.CV_32FC1) cv.Mul(s_c, u_x, su_x) cv.Mul(s_c, u_y, su_y) cv.Mul(s_c, u_z, su_z) su = cv.CreateMat(rows, cols, cv.CV_32FC3) cv.Merge(su_x, su_y, su_z, None, su) tu_x = cv.CreateMat(rows, cols, cv.CV_32FC1) tu_y = cv.CreateMat(rows, cols, cv.CV_32FC1) tu_z = cv.CreateMat(rows, cols, cv.CV_32FC1) cv.Mul(t_c, u_x, tu_x) cv.Mul(t_c, u_y, tu_y) cv.Mul(t_c, u_z, tu_z) tu = cv.CreateMat(rows, cols, cv.CV_32FC3) cv.Merge(tu_x, tu_y, tu_z, None, tu) closest_point = cv.CreateMat(rows, cols, cv.CV_32FC3) cv.Add(P_0, su, closest_point) return closest_point
def image_callback(data): image = bridge.imgmsg_to_cv(data,"bgr8") #normalize image cv.Split(image,rgb_r,rgb_g,rgb_b,None) red_mean = cv2.mean(numpy.asarray(rgb_r[:,:])) cv.Div(src2 = cv.fromarray(numpy.ones((480,640))),src1 = rgb_r,dst = scaled_r, scale = 128/red_mean[0]) green_mean = cv2.mean(numpy.asarray(rgb_g[:,:])) cv.Div(src2 = cv.fromarray(numpy.ones((480,640))),src1 = rgb_g,dst = scaled_g, scale = 128/green_mean[0]) blue_mean = cv2.mean(numpy.asarray(rgb_b[:,:])) cv.Div(src2 = cv.fromarray(numpy.ones((480,640))),src1 = rgb_b,dst = scaled_b, scale = 128/blue_mean[0]) cv.Merge(scaled_r,scaled_g,scaled_b,None,cv_image) #try all the color spaces cv.CvtColor(cv_image,hsv,cv.CV_BGR2HSV) cv.CvtColor(cv_image,lab,cv.CV_BGR2Lab) cv.CvtColor(cv_image,luv,cv.CV_BGR2Luv) cv.CvtColor(cv_image,hls,cv.CV_BGR2HLS) cv.CvtColor(cv_image,xyz,cv.CV_BGR2XYZ) cv.CvtColor(cv_image,ycrcb,cv.CV_BGR2YCrCb) cv.Split(hsv,hsv_h,hsv_s,hsv_v,None) cv.Split(cv_image,rgb_r,rgb_g,rgb_b,None) cv.Split(lab,lab_l,lab_a,lab_b,None) cv.Split(luv,luv_l,luv_u,luv_v,None) cv.Split(hls,hls_h,hls_l,hls_s,None) cv.Split(xyz,xyz_x,xyz_y,xyz_x,None) cv.Split(ycrcb,ycrcb_y,ycrcb_cr,ycrcb_cb,None) #cv.Not(lab_a,a_not) #cv.Sub(hsv_s,a_not,sa) cv.Not(hsv_s,s_not) cv.Not(hls_h,rock) #cv.Sub(hsv_s,hsv_h,rock) #cv.Sub(rock,hls_h,test) #MAYBE LIZARD #cv.Sub(ycrcb_cr,hsv_h,rock) cv.Sub(luv_u,hls_h,scissors) cv.Sub(luv_v,luv_u,lizard) threshold_scissors(hls_h) #works threshold_lizard(lizard) #finnicky (gets confused with paper) threshold_spock(hls_s) #works (noisy) threshold_paper(ycrcb_cb) threshold_rock(hls_s) #not working cv.ShowImage("paper",paper_dilated) #cv.ShowImage("lizard",lizard_dilated) #cv.ShowImage("scissors",scissors_dilated) #cv.ShowImage("spock",spock_dilated) #cv.ShowImage("rock",rock) #threshold_red(ycrcb_cr) scissors_contours,_ = cv2.findContours(image=numpy.asarray(scissors_dilated[:,:]),mode=cv.CV_RETR_EXTERNAL,method=cv.CV_CHAIN_APPROX_SIMPLE) lizard_contours,_ = cv2.findContours(image=numpy.asarray(lizard_dilated[:,:]),mode=cv.CV_RETR_EXTERNAL,method=cv.CV_CHAIN_APPROX_SIMPLE) spock_contours,_ = cv2.findContours(image=numpy.asarray(spock_dilated[:,:]),mode=cv.CV_RETR_EXTERNAL,method=cv.CV_CHAIN_APPROX_SIMPLE) rock_contours,_ = cv2.findContours(image=numpy.asarray(rock_dilated[:,:]),mode=cv.CV_RETR_EXTERNAL,method=cv.CV_CHAIN_APPROX_SIMPLE) paper_contours,_ = cv2.findContours(image=numpy.asarray(paper[:,:]),mode=cv.CV_RETR_EXTERNAL,method=cv.CV_CHAIN_APPROX_SIMPLE) find_squares(scissors_contours,"scissors") find_squares(lizard_contours,"lizard") find_squares(spock_contours,"spock") find_squares(paper_contours,"paper") ''' cv.ShowImage("HSV_H",hsv_h) cv.ShowImage("HSV_S",hsv_s) cv.ShowImage("HSV_V",hsv_v) cv.ShowImage("LAB_L",lab_l) cv.ShowImage("LAB_A",lab_a) cv.ShowImage("LAB_B",lab_b) cv.ShowImage("RGB_R",scaled_r) cv.ShowImage("RGB_G",scaled_g) cv.ShowImage("RGB_B",scaled_b) cv.ShowImage("LUV_L",luv_l) cv.ShowImage("LUV_U",luv_u) cv.ShowImage("LUV_V",luv_v) cv.ShowImage("HLS_H",hls_h) cv.ShowImage("HLS_L",hls_l) cv.ShowImage("HLS_S",hls_s) cv.ShowImage("YCrCb_Y",ycrcb_y) cv.ShowImage("YCrCb_Cr",ycrcb_cr) cv.ShowImage("YCrCb_Cb",ycrcb_cb) ''' cv.ShowImage("normalized",cv_image) cv.WaitKey(3)
def __SSIM(self, frame1, frame2): """ The equivalent of Zhou Wang's SSIM matlab code using OpenCV. from http://www.cns.nyu.edu/~zwang/files/research/ssim/index.html The measure is described in : "Image quality assessment: From error measurement to structural similarity" C++ code by Rabah Mehdi. http://mehdi.rabah.free.fr/SSIM C++ to Python translation and adaptation by Iñaki Úcar """ C1 = 6.5025 C2 = 58.5225 img1_temp = self.__array2cv(frame1) img2_temp = self.__array2cv(frame2) nChan = img1_temp.nChannels d = cv.IPL_DEPTH_32F size = img1_temp.width, img1_temp.height img1 = cv.CreateImage(size, d, nChan) img2 = cv.CreateImage(size, d, nChan) cv.Convert(img1_temp, img1) cv.Convert(img2_temp, img2) img1_sq = cv.CreateImage(size, d, nChan) img2_sq = cv.CreateImage(size, d, nChan) img1_img2 = cv.CreateImage(size, d, nChan) cv.Pow(img1, img1_sq, 2) cv.Pow(img2, img2_sq, 2) cv.Mul(img1, img2, img1_img2, 1) mu1 = cv.CreateImage(size, d, nChan) mu2 = cv.CreateImage(size, d, nChan) mu1_sq = cv.CreateImage(size, d, nChan) mu2_sq = cv.CreateImage(size, d, nChan) mu1_mu2 = cv.CreateImage(size, d, nChan) sigma1_sq = cv.CreateImage(size, d, nChan) sigma2_sq = cv.CreateImage(size, d, nChan) sigma12 = cv.CreateImage(size, d, nChan) temp1 = cv.CreateImage(size, d, nChan) temp2 = cv.CreateImage(size, d, nChan) temp3 = cv.CreateImage(size, d, nChan) ssim_map = cv.CreateImage(size, d, nChan) #/*************************** END INITS **********************************/ #// PRELIMINARY COMPUTING cv.Smooth(img1, mu1, cv.CV_GAUSSIAN, 11, 11, 1.5) cv.Smooth(img2, mu2, cv.CV_GAUSSIAN, 11, 11, 1.5) cv.Pow(mu1, mu1_sq, 2) cv.Pow(mu2, mu2_sq, 2) cv.Mul(mu1, mu2, mu1_mu2, 1) cv.Smooth(img1_sq, sigma1_sq, cv.CV_GAUSSIAN, 11, 11, 1.5) cv.AddWeighted(sigma1_sq, 1, mu1_sq, -1, 0, sigma1_sq) cv.Smooth(img2_sq, sigma2_sq, cv.CV_GAUSSIAN, 11, 11, 1.5) cv.AddWeighted(sigma2_sq, 1, mu2_sq, -1, 0, sigma2_sq) cv.Smooth(img1_img2, sigma12, cv.CV_GAUSSIAN, 11, 11, 1.5) cv.AddWeighted(sigma12, 1, mu1_mu2, -1, 0, sigma12) #////////////////////////////////////////////////////////////////////////// #// FORMULA #// (2*mu1_mu2 + C1) cv.Scale(mu1_mu2, temp1, 2) cv.AddS(temp1, C1, temp1) #// (2*sigma12 + C2) cv.Scale(sigma12, temp2, 2) cv.AddS(temp2, C2, temp2) #// ((2*mu1_mu2 + C1).*(2*sigma12 + C2)) cv.Mul(temp1, temp2, temp3, 1) #// (mu1_sq + mu2_sq + C1) cv.Add(mu1_sq, mu2_sq, temp1) cv.AddS(temp1, C1, temp1) #// (sigma1_sq + sigma2_sq + C2) cv.Add(sigma1_sq, sigma2_sq, temp2) cv.AddS(temp2, C2, temp2) #// ((mu1_sq + mu2_sq + C1).*(sigma1_sq + sigma2_sq + C2)) cv.Mul(temp1, temp2, temp1, 1) #// ((2*mu1_mu2 + C1).*(2*sigma12 + C2))./((mu1_sq + mu2_sq + C1).*(sigma1_sq + sigma2_sq + C2)) cv.Div(temp3, temp1, ssim_map, 1) index_scalar = cv.Avg(ssim_map) #// through observation, there is approximately #// 1% error max with the original matlab program return index_scalar[0]