def get_dirmarker(img, angle, Dist, radius): X, Y = entCenter(robot) Len, _ = entSize(robot) point = (X + (Dist + Len / 2.0) * cos(angle), Y - (Dist + Len / 2.0) * sin(angle)) point = intPoint(point) #For visualisation: # cv.Circle( frame, point, radius, (0,200,200), 1 ) point2 = point[0] - nhood[0], point[1] - nhood[1] out = cv.CloneImage(img) cv.Zero(out) cv.Circle(out, point2, radius, (255, 255, 255), -1) cv.And(out, img2, out) center1 = self.centralMoment(out) count1 = cv.CountNonZero(out) cv.Erode(out, out) center2 = self.centralMoment(out) count2 = cv.CountNonZero(out) if count2 == 0 and count1 > 10: return center1 else: return center2
def is_grayscale(im): if im.nChannels == 1: return True h,s,v = split(rgb2hsv(im)) if cv.CountNonZero(h) == 0 == cv.CountNonZero(s): return True return False
def estimaBG(frames): npixels = cv.GetSize(frames[0])[1] * cv.GetSize(frames[0])[0] gray = cv.CreateImage(cv.GetSize(frames[0]), cv.IPL_DEPTH_8U, 1) frAbsDif = cv.CloneImage(gray) frThrDif = cv.CloneImage(gray) frAnt = cv.CloneImage(gray) # converte cada quadro para cinza cinzas = [] for fr in frames: gray = cv.CreateImage(cv.GetSize(frames[0]), cv.IPL_DEPTH_8U, 1) cv.CvtColor(fr, gray, cv.CV_RGB2GRAY) cinzas.append(gray) iframe = 1 fundos = [] for fr in cinzas[1:]: frAnt = cinzas[iframe - 1] cv.AbsDiff(frAnt, fr, frAbsDif) pixelsDiferentesAbs = cv.CountNonZero(frAbsDif) # limiariza para evitar diferencas muito pequenas. cv.Threshold(frAbsDif, frThrDif, 120, 255, cv.CV_THRESH_TOZERO) # se a direrença for zero, considera a imagem para a mediana dos fundos pixelsDiferentesThr = cv.CountNonZero(frThrDif) print("Pixels diferentes do threeshold: " + str(pixelsDiferentesThr)) if pixelsDiferentesThr < 30: #print 'Imagem adicionada para determinacao do background...' fundos.append((frames[iframe], cv.CloneImage(frThrDif), cv.CloneImage(frThrDif), pixelsDiferentesAbs, pixelsDiferentesThr)) iframe += 1 if not fundos: print 'Não foi possivel determinar o fundo usando os primeiros %d frames da imagem' % len( frames) sys.exit(1) # pega o menor threshold absoluto, ordenando e pegando o primeiro. def porThr(a, b): return cmp(a[3], b[3]) fundos.sort(porThr) # retorna o que apresentou melhor diferença com relação ao anterior return fundos[0][0] return fr
def prepare_negatives(): path = root_folder+"negative_source/new2" negatives_path=root_folder+"negative" for fullpath, name in directory_files(path): try: big_img = cv.LoadImage(fullpath) except IOError: continue print "Getting samples from %s" % name no_suffix_name = name.split(".")[0] negatives_new_path = os.path.join(negatives_path, no_suffix_name) if not os.path.exists(negatives_new_path): os.mkdir(negatives_new_path) sample_gen = samples_generator(big_img,32,32,3,2,bw_from_v_plane=False) k=0 # random_from_generator() for sample, _ in sample_gen: prepared = normalize_plane(sample) if cv.CountNonZero(prepared) > 0: new_name=os.path.join(negatives_new_path, "%d.png" % k) cv.SaveImage(new_name, prepared) k+=1 # if k > 1500: # break print k
def removeBadBackground(seg): threshUp = cv.CreateImage(cv.GetSize(seg), cv.IPL_DEPTH_8U, 1) comparison = cv.CreateImage(cv.GetSize(seg), cv.IPL_DEPTH_8U, 1) visitMask = cv.CreateImage(cv.GetSize(seg), cv.IPL_DEPTH_8U, 1) ffMask = cv.CreateImage((seg.width + 2, seg.height + 2), cv.IPL_DEPTH_8U, 1) cv.Threshold(seg, threshUp, 1, 255, cv.CV_THRESH_BINARY) cv.Zero(visitMask) cv.Zero(ffMask) for x in xrange(seg.width): for y in xrange(seg.height): if seg[y, x] != 96 or visitMask[y, x] == 255: continue comp = cv.FloodFill(threshUp, (x, y), 0, 0, 0, 4 + cv.CV_FLOODFILL_MASK_ONLY + (255 << 8), ffMask) rect = comp[2] cv.SetImageROI(ffMask, cap.shiftRect(rect, 1, 1)) cv.OrS(ffMask, 1, ffMask) cv.SetImageROI(seg, rect) cv.SetImageROI(comparison, rect) cv.Cmp( seg, ffMask, comparison, cv.CV_CMP_EQ) # 'comparison' does not need to be zeroed later intersect = cv.CountNonZero(comparison) cv.SetImageROI(visitMask, rect) cv.Or(visitMask, ffMask, visitMask) cv.ResetImageROI(visitMask) if intersect == 0: cv.Set(seg, 0, ffMask) cv.Zero(ffMask) cv.ResetImageROI(seg) cv.ResetImageROI(ffMask) return seg
def get_contours(frame, approx=True): """Get contours from an image :: iplimage -> CvSeq """ # A workaround for OpenCV 2.0 crash on receiving a (nearly) black image nonzero = cv.CountNonZero(frame) logging.debug("Segmentation got an image with %d nonzero pixels", nonzero) if nonzero < 20 or nonzero > 10000: return [] storage = cv.CreateMemStorage(0) # find the contours contours = cv.FindContours(frame, storage, cv.CV_RETR_LIST, cv.CV_CHAIN_APPROX_SIMPLE) if contours is None: return [] res = [] while contours: if not approx: result = contours else: result = cv.ApproxPoly(contours, storage, cv.CV_POLY_APPROX_DP, cv.ArcLength(contours) * 0.02, 1) res.append(result) contours = contours.h_next() return res
def noise_per_grid(images): size = cv.GetSize(images[0]) total = float(size[0] * size[1]) scores = [] for im in images: scores.append(cv.CountNonZero(im) / total) return scores
def count(img, upper_thresh, lower_thresh): img = cv.LoadImage(img, 0) assert img.depth == cv.IPL_DEPTH_8U cv.Threshold(img, img, upper_thresh, 0, cv.CV_THRESH_TOZERO_INV) cv.Threshold(img, img, lower_thresh, 0, cv.CV_THRESH_TOZERO) return cv.CountNonZero(img)
def count_neighbors(im): size = cv.GetSize(im) mx, my = int(size[0] / 2), int(size[1] / 2) pixel = im[mx, my] if pixel == 0: return 0 c = cv.CountNonZero(im) return c
def auto_edges(im, starting_threshold=50, percentage=0.2): size = cv.GetSize(im) total = size[0] * size[1] * percentage e = edges(im, starting_threshold, starting_threshold*3) while cv.CountNonZero(e) > total: starting_threshold += 10 e = edges(im, starting_threshold, starting_threshold*3) return e
def cutNonBlack(comp, thresh, colthresh=0): image = comp[3] rect = comp[2] newRect = findNonBlackRect(image, thresh, colthresh) if newRect[2] == 0 or newRect[3] == 0: return None region = cvext.getSubImage(image, newRect) newRect = shiftRect(newRect, rect[0], rect[1]) return (cv.CountNonZero(region), 255.0, newRect, region)
def draw(self, im, threshold): new_im = image.new_from(im) edges = image.edges(im, threshold, threshold * 3, 3) cv.SetZero(new_im) cv.Copy(im, new_im, edges) size = cv.GetSize(im) print cv.CountNonZero(image.threshold(edges)) / float( size[0] * size[1]) #cv.Dilate(new_im, new_im) #cv.Erode(new_im, new_im) return new_im
def threshhold_amount(image, image_hsv, lower, upper): """ determine how many pixels of an image are within a HSV threshhold """ # create the placeholder for thresholded image channels = 1 image_threshed = cv.CreateImage(cv.GetSize(image), image.depth, channels) # do the actual thresholding cv.InRangeS(image_hsv, lower, upper, image_threshed) return cv.CountNonZero(image_threshed)
def detect_skin(im, debug=False): hsv = image.rgb2hsv(im) if debug: image.show(hsv, 'hsv') h,s,v = image.split(hsv) if cv.CountNonZero(h) == cv.CountNonZero(s) == 0: white = image.new_from(im) cv.Set(white, 255) return white if debug: image.show(h, "Hue") image.show(s,"sat1") h_rng = 0, 46 s_rng = 48, 178 h = image.threshold(image.gaussian(h, 5), threshold=h_rng[1], type=cv.CV_THRESH_TOZERO_INV) h = image.threshold(h, threshold=h_rng[0], type=cv.CV_THRESH_TOZERO) h = image.threshold(h, threshold=1) s = image.threshold(image.gaussian(s, 5), threshold=s_rng[1], type=cv.CV_THRESH_TOZERO_INV) s = image.threshold(s, threshold=s_rng[0], type=cv.CV_THRESH_TOZERO) if debug: image.show(s,"sat2") s = image.threshold(s, threshold=1) v = image.dilate(image.erode(image.And(s, h))) #im = image.hsv2rgb(image.merge(h,s,v)) if debug: image.show(v, "Human") return image.threshold(v, threshold=1)
def non_zero_in_conv_table(image, x, y): conv_table_length = 3 shift = (conv_table_length - 1) / 2 if x < shift: x_orig = 0 else: x_orig = x - shift if y < shift: y_orig = 0 else: y_orig = y - shift return cv.CountNonZero( cv.GetSubRect(image, (x_orig, y_orig, conv_table_length, conv_table_length)))
def evaluatePolygonLabelRaw(polygons, gtImage, maskImage, foundZeros, image): #splat the results to an image labelImage = getBlankLabelImage(image) visualizePolygons(labelImage, polygons) #get the label image and rescale it to the correct size, if necessary labelImageRescale = cv.CreateImage(cv.GetSize(gtImage), cv.IPL_DEPTH_8U, 1) cv.Resize(labelImage, labelImageRescale) labelImage = labelImageRescale #compute the difference -- this is 0 if correct cv.AbsDiff(labelImage, gtImage, labelImage) w, h = cv.GetSize(gtImage) #mask out unknown values cv.Set(labelImage, 1, maskImage) #return (Total Pixels - incorrect) / (total pixels) nPixValid = w * h - foundZeros return float(w * h - cv.CountNonZero(labelImage)) / nPixValid
def motiondetect(self, img): gray = cv.CreateImage(self.size, 8, 1) cv.CvtColor(img, gray, cv.CV_BGR2GRAY) if not self.oldimg or (time.time() - self.lasttime) > 1: self.oldimg = cv.CreateImage(self.size, 8, 1) cv.Copy(gray, self.oldimg) self.lasttime = time.time() return 0 self.lasttime = time.time() diff = cv.CreateImage(self.size, 8, 1) cv.AbsDiff(gray, self.oldimg, diff) thr = cv.CreateImage(self.size, 8, 1) movement = cv.CreateImage(self.size, 8, 1) cv.SetZero(movement) cv.Threshold(diff, thr, 30, 1, cv.CV_THRESH_BINARY) movecount = cv.CountNonZero(thr) color = cv.CreateImage(self.size, 8, 3) cv.Set(color, (255, 0, 0)) cv.Copy(color, img, thr) cv.Copy(diff, movement, thr) cv.ShowImage("movement" + str(self.channel), movement) writetext( img, 'c' + str(self.channel) + ' a' + str(int(self.core.bucket.value)) + ' m' + str(movecount)) cv.ShowImage("camera" + str(self.channel), img) cv.Copy(gray, self.oldimg) self.lasttime = time.time() return movecount
def find_connected_components(frame): """Find connected components from an image. :: iplimage -> [ dict(box<CvBox2D>, rect<CvRect>) ] Takes as input a grayscale image that should have some blobs in it. Outputs a data structure containing the 'centers' of the blobs and minimal rectangles enclosing them. A maximum of 3 blobs are returned. The input frame is modified in place. """ # A workaround for OpenCV 2.0 crash on receiving a (nearly) black image nonzero = cv.CountNonZero(frame) if nonzero < 20: return [] logging.debug("Segmentation got an image with %d nonzero pixels", nonzero) contours = get_contours(frame) #out = draw_contours(frame, contours) if contours is None: return [] candidates = [] while contours: storage = cv.CreateMemStorage(0) minBox = cv.MinAreaRect2(contours, storage) boundingRect = cv.BoundingRect(contours, 0) candidates.append({ 'box' : minBox, 'rect' : boundingRect }) contours = contours.h_next() candidates = sorted( candidates, key=lambda x:getArea(x['box']), reverse=True ) return candidates
def measure(im, debug=False): gray = image.rgb2gray(im) size = cv.GetSize(im) total = float(size[0] * size[1]) edges = image.auto_edges(im) _, sat, val = image.split(image.rgb2hsv(im)) edges = image.auto_edges(im) l, u, v = tuple(map(image.equalize_hist, image.split(image.rgb2luv(im)))) u, v = tuple(map(image.gaussian, (u, v))) if debug: image.show(l, "1. L") image.show(u, "1. U") image.show(v, "1. V") la, ua, va, uva = tuple(map(image.cv2array, (l, u, v, image.And(l, u, v)))) test = image.new_from(gray) test2 = image.new_from(gray) cv.Xor(u, v, test) #cv.AbsDiff(u,v, test2) if debug: #cv.Threshold(test, test, 32, 255, cv.CV_THRESH_BINARY) image.show(test, "2. U Xor V") #image.show(test2, "TEST 2") #test = image.dilate(test) cv.Set(test, 0, image.dilate(edges)) #cv.Set(test, 0, image.invert(image.threshold(sat, threshold=8))) uv_score = cv.CountNonZero(test) / total if debug: image.show( test, "3. U Xor V - dilate(Edges) - invert(threshold(Saturation))") arr = image.cv2array(test) avg_mean, avg_std = arr.mean(), arr.std() score = uv_score, avg_std return test, score
def getOrientation(self, frame, robot, name, thresh): cv.SetImageROI(frame, robot['rect']) img = thresh(frame) cv.ResetImageROI(frame) thresholded_T = cv.CloneImage(img) offset = 40 c = entCenter(robot) nhood = (max(0, int(round(c[0])) - offset), max(0, int(round(c[1])) - offset), 2 * offset, 2 * offset) cv.SetImageROI(frame, nhood) img2 = self.threshold.dirmarker(frame) cv.ResetImageROI(frame) def mask_end(img, angle): """Mask out one end of the T given an angle of orientation Returns a new image. """ X, Y = entCenter(robot) Len, _ = entSize(robot) Dist = 5 point = (X + (Dist + Len / 2.0) * cos(angle), Y - (Dist + Len / 2.0) * sin(angle)) point = intPoint(point) radius = int(round(Dist + Len / 2.0)) #For visualisation: #cv.Circle( frame, point, radius, (0,0,255), 2 ) rect = entRect(robot) point2 = point[0] - rect[0], point[1] - rect[1] out = cv.CloneImage(img) cv.Circle(out, point2, radius, (0, 0, 0), -1) return out def get_dirmarker(img, angle, Dist, radius): X, Y = entCenter(robot) Len, _ = entSize(robot) point = (X + (Dist + Len / 2.0) * cos(angle), Y - (Dist + Len / 2.0) * sin(angle)) point = intPoint(point) #For visualisation: # cv.Circle( frame, point, radius, (0,200,200), 1 ) point2 = point[0] - nhood[0], point[1] - nhood[1] out = cv.CloneImage(img) cv.Zero(out) cv.Circle(out, point2, radius, (255, 255, 255), -1) cv.And(out, img2, out) center1 = self.centralMoment(out) count1 = cv.CountNonZero(out) cv.Erode(out, out) center2 = self.centralMoment(out) count2 = cv.CountNonZero(out) if count2 == 0 and count1 > 10: return center1 else: return center2 box_direction = None max_count = 0 for angle in entOrientations(robot): masked = mask_end(thresholded_T, angle) count = cv.CountNonZero(masked) if count > max_count: max_count = count box_direction = angle if box_direction is None: return # Not the cleanest way to deal with this angle... robot['orient'] = -box_direction if self.overlay: cv.SetImageROI(frame, robot['rect']) tmp = cv.CloneImage(frame) cv.CvtColor(img, tmp, cv.CV_GRAY2BGR) cv.Add(frame, tmp, frame) cv.ResetImageROI(frame) "Draw the corners of the bounding box" for i in getBoxCorners(robot['box']): col2 = (0, 255, 255) col2 = (255, 0, 0) #cv.Circle( frame, intPoint(i), 3, col2, -1 ) dCenter = get_dirmarker(img2, pi - robot['orient'], 3, 4) if dCenter is None: dCenter = get_dirmarker(img2, pi - robot['orient'], 8, 10) if dCenter is None: dCenter = get_dirmarker(img2, pi - robot['orient'], 10, 4) if dCenter is None: dCenter = get_dirmarker(img2, pi - robot['orient'], 14, 8) if dCenter is None: dCenter = get_dirmarker(img2, pi - robot['orient'], 10, 12) if dCenter is None: return dCenter = intPoint(dCenter + nhood[:2]) if self.overlay: cv.Circle(frame, dCenter, 6, (0, 0, 255), 2) Tcenter = self.centralMoment(img) if Tcenter is not None: Tcenter += entRect(robot)[:2] robot['center'] = Tcenter else: robot['center'] = entCenter(robot) cx, cy = robot['center'] dx, dy = dCenter robot['orient'] = atan2(cy - dy, cx - dx)
def measure(im, debug=False): gray = image.rgb2gray(im) size = cv.GetSize(im) total = float(size[0] * size[1]) l = image.sub(gray, image.gaussian(gray, 5)) l2 = image.sub(gray, image.gaussian(gray, 9)) edges = image.dilate(image.auto_edges(im, percentage=0.2)) if debug: image.show(image.threshold(l, threshold=1), "Before Edge Removal (kernel=5)") image.show(image.threshold(l2, threshold=1), "Before Edge Removal (kernel=9)") cv.Set(l, 0, image.threshold(edges, threshold=1)) cv.Set(l2, 0, image.threshold(edges, threshold=1)) l = image.threshold(l, threshold=1) l2 = image.threshold(l2, threshold=1) if debug: image.show(image.threshold(edges, threshold=1), "Edges") image.show(l, "After Edge Removal (kernel=5)") image.show(l2, "After Edge Removal (kernel=9)") noise2 = image.new_from(gray) cv.EqualizeHist(gray, noise2) cv.AbsDiff(noise2, gray, noise2) cv.Set(noise2, 0, image.threshold(image.sobel(im, xorder=2, yorder=2), threshold=4)) diff = image.cv2array(noise2) if debug: image.show(noise2, "DIFF") print "M", diff.mean(), "S", diff.std() diff_stat = (diff.mean(), diff.std()) percent_noise = cv.CountNonZero(noise2) / total if debug: image.show(noise2, "NOISE2") # magical, I don't understand how this works _, sat, _ = image.split(image.rgb2hsv(im)) edges = image.auto_edges(im) l, u, v = tuple(map(image.equalize_hist, image.split(image.rgb2luv(im)))) u, v = tuple(map(image.gaussian, (u, v))) if debug: image.show(l, "1. L") image.show(u, "1. U") image.show(v, "1. V") la, ua, va, uva = tuple(map(image.cv2array, (l, u, v, image.And(l, u, v)))) test = image.new_from(gray) test2 = image.new_from(gray) cv.Xor(u, v, test) if debug: image.show(test, "2. U Xor V") cv.Set(test, 0, image.dilate(edges)) #cv.Set(test, 0, image.invert(image.threshold(sat, threshold=8))) uv_score = cv.CountNonZero(test) / total if debug: image.show( test, "3. U Xor V - dilate(Edges) - invert(threshold(Saturation))") g = Grid(size) images = map(image.cv2array, g.split_into(test, 6)) arr = image.cv2array(test) avg_mean, avg_std = arr.mean(), arr.std() #ms = [(a.mean(), a.std()) for a in images] #min_mean = min_std = 255 #max_mean = max_std = 0 #for m,s in ms: # min_mean = min(min_mean, m) # min_std = min(min_std, s) # max_mean = max(max_mean, m) # max_std = max(max_std, s) #if debug: # print min_mean, min_std # print avg_mean, avg_std # print max_mean, max_std # #score = uv_score, min_mean, avg_mean, avg_std, max_mean uv_score = uv_score, avg_std score = cv.CountNonZero(l) / total, cv.CountNonZero(l2) / total, \ diff_stat[0], diff_stat[1], uv_score return l, score
def hit_value(resim, hedef): roi = python_opencv_modulu.GetSubRect(resim, hedef.getDimensions()) return python_opencv_modulu.CountNonZero(roi)
def measure(im, debug=False): size = cv.GetSize(im) npixels = size[0] * size[1] #print 'np', npixels focused = get_focus_points(im, debug) points = convert_to_points(focused) if debug: print "\t" + str( len(points)), '/', npixels, '=', len(points) / float(npixels) print "\tlen(points) =", len(points) image.show(focused, "4. Focused Points") saturation_score = 0 if not image.is_grayscale(im): edges = image.auto_edges(im) _, saturation, _ = image.split(image.rgb2hsv(im)) if debug: image.show(saturation, "5. Saturation") #saturation = image.laplace(image.gaussian(saturation, 3)) saturation = image.invert(saturation) mask = image.invert(image.threshold(im, threshold=16)) if debug: image.show(saturation, "5.3. Laplace of Saturation") cv.Set(saturation, 0, mask) cv.Set(saturation, 0, focused) if debug: image.show(mask, "5.6. Mask(focused AND invert(threshold(im, 16)))") image.show(saturation, "6. Set(<5.3>, 0, <5.6>)") saturation_score = cv.Sum(saturation)[0] / float(npixels * 255) print "\tSaturation Score:", saturation_score # light exposure h, s, v = image.split(image.rgb2hsv(im)) if debug: image.show(h, "7. Hue") image.show(s, "7. Saturation") image.show(v, "7. Value") diff = cv.CloneImage(v) cv.Set(diff, 0, image.threshold(s, threshold=16)) diff = image.dilate(diff, iterations=10) if debug: thres_s = image.threshold(s, threshold=16) image.show(thres_s, "8.3. Mask(threshold(<7.Saturation>, 16))") image.show(diff, "8.6. Dilate(Set(<7.Value>, 0, <8.3>), 10)") cdiff = cv.CountNonZero(diff) if cdiff > 0 and cdiff / float(npixels) > 0.01: test = cv.CloneImage(v) cv.Set(test, 0, image.invert(diff)) s = cv.Sum(test)[0] / float(cdiff * 255) if debug: print '\tLight Exposure Score:', s else: s = 0 if image.is_grayscale(im): return focused, (1, 1, 1, saturation_score, s) # we want to short circuit ASAP to avoid doing KMeans 50% of the image's pixels if len(points) > npixels / 2: return focused, (1, 1, 1, saturation_score, s) # we're so blurry we don't have any points! if len(points) < 1: return focused, (0, 0, 0, saturation_score, s) if debug: im2 = cv.CloneImage(im) focused_regions = image.new_from(im) cv.Set(focused_regions, 0) r = lambda x: random.randrange(1, x) groups = form_groups(points, estimated_size=min(max(int(len(points) / 1000), 2), 15)) #groups = form_groups(points, threshold=max(cv.GetSize(im))/16) #print 'groups', len(groups) hulls = draw_groups(groups, focused_regions) focused_regions = image.threshold(focused_regions, threshold=32, type=cv.CV_THRESH_TOZERO) min_area = npixels * 0.0005 densities = [h.points_per_pixel() for h in hulls if h.area() >= min_area] if debug: #image.show(focused, "Focused Points") image.show(focused_regions, "9. Focused Regions from <4>") cv.Sub( im2, image.gray2rgb( image.invert(image.threshold(focused_regions, threshold=1))), im2) image.show(im2, "10. threshold(<9>)") focused_regions = image.rgb2gray(focused_regions) densities = array(densities) c = cv.CountNonZero(focused_regions) c /= float(npixels) score = (c, densities.mean(), densities.std(), saturation_score, s) return focused, score
for x in range(256): for y in range(size[1]): cv.Set2D(u, y, x, x) cv.Set2D(v, 255 - x, min(y, 255), x) image.show(u, "U") image.show(v, "V") rgb = image.luv2rgb(image.merge(l, u, v)) r, g, b = image.split(rgb) #xor = image.threshold(image.Xor(u,v), 0, cv.CV_THRESH_BINARY) xor = image.Xor(u, v) cv.Threshold(xor, xor, 16, 255, cv.CV_THRESH_TOZERO) image.show(rgb, "RGB") image.show(xor, "Xor") #cv.Sub(rgb, image.gray2rgb(image.invert(xor)), rgb) _, sat, _ = image.split(image.rgb2hsv(rgb)) image.show(sat, 'Saturation') #cv.Set(xor, 0, image.invert(image.threshold(sat, threshold=4))) cv.Sub(rgb, image.invert(image.gray2rgb(xor)), rgb) image.show(rgb, "Rgb - Xor") arr = image.cv2array(xor) avg_mean, avg_std = arr.mean(), arr.std() print cv.CountNonZero(xor) / float(size[0] * size[1]), avg_mean, avg_std cv.WaitKey() cv.DestroyAllWindows()
#!/usr/bin/env python2.7 import cv # get orginal image orig = cv.LoadImage('cake.png') # show original cv.ShowImage("orig", orig) # convert to hsv and get just hue hsv = cv.CreateImage(cv.GetSize(orig), 8, 3) hue = cv.CreateImage(cv.GetSize(orig), 8, 1) sat = cv.CreateImage(cv.GetSize(orig), 8, 1) val = cv.CreateImage(cv.GetSize(orig), 8, 1) cv.CvtColor(orig, hsv, cv.CV_RGB2HSV) cv.Split(hsv, hue, sat, val, None) #cv.ShowImage("hue", hue) # loop to find how many different hues are present... query = cv.CreateImage(cv.GetSize(orig), 8, 1) result = cv.CreateImage(cv.GetSize(orig), 8, 1) for i in range(0, 255): cv.Set(query, i) cv.Cmp(query, hue, result, cv.CV_CMP_EQ) # if a number of pixels are equal - show where they are if (cv.CountNonZero(result) > 1000): # <-what is signficant? cv.ShowImage(str(i), result) cv.SaveImage(str(i) + ".png", result) cv.WaitKey(-1)
#print x subparte_largura = regiao_de_interesse.width / 3 subparte_altura = regiao_de_interesse.height / 3 area_subparte = subparte_largura * subparte_altura for i in range(0, 3): for j in range(0, 3): l = i * 3 retangulo = (subparte_largura * i, subparte_altura * j, subparte_largura, subparte_altura) cv.SetImageROI(regiao_de_interesse, retangulo) quadrante.append( cv.CreateImage((subparte_largura, subparte_altura), regiao_de_interesse.depth, regiao_de_interesse.channels)) pixelsbrancos.append(cv.CountNonZero(regiao_de_interesse)) porcentagem.append( float(pixelsbrancos[l + j]) / float(area_subparte)) cv.Copy(regiao_de_interesse, quadrante[l + j]) cv.ResetImageROI(regiao_de_interesse) os.system("clear") #print porcentagem print pixelsbrancos cv.ShowImage("Mascara", mascara) cv.ShowImage("Binario", cinza) cv.ShowImage("Webcam", imagem) cv.ShowImage('Regiao de Interesse', regiao_de_interesse) if cv.WaitKey(7) % 0x100 == 27:
framecnt = 0 stime = ctime # Get original image img = cv.QueryFrame(cam) # Adaptive diff #cv.Smooth(img, col, cv.CV_GAUSSIAN, 3, 0) cv.AddWeighted(img, 1 - ADAPT, avg, ADAPT, 0, avg) cv.AbsDiff(img, avg, col) cv.CvtColor(col, col, cv.CV_RGB2HSV) cv.Split(col, None, None, val, None) cv.CmpS(val, TH, val, cv.CV_CMP_GE) #cv.Dilate(val, val, None, 18) #cv.Erode(val, val, None, 10) dif = cv.CountNonZero(val) # Show image if it's radically new if (dif < PIXCOUNT): if act < 0: act = ACTLOW else: act -= 1 else: if act > 0: act = ACTHIGH else: act += 1 if act > 0: cv.SaveImage('/tmp/tmp.png', img) shutil.move('/tmp/tmp.png', "/shared/%s.png" % (time()))
def main(): os.chdir(sys.argv[1]) try: os.mkdir(OUTPUT_DIR_NAME) except OSError: pass tree = et.parse("project.xml") movie = tree.getroot() file_path = movie.attrib["path"] if DEBUG: cv.NamedWindow("win", cv.CV_WINDOW_AUTOSIZE) cv.MoveWindow("win", 200, 200) cap = cv.CreateFileCapture(file_path) skip_frames(cap, movie) pixel_count = None prev_img = None global_frame_counter = 0 file_counter = 0 w = None h = None output_img = cv.CreateImage((WIDTH, MAX_FRAMES), cv.IPL_DEPTH_8U, 3) f = open("shots.txt", "r") lines = [line for line in f if line] # (start_frame, end_frame, duration) f.close() f_frm = open("motion.txt", "w") f_avg = open("motion_shot-avg.txt", "w") motion = [] t = time.time() for nr, line in enumerate(lines): print(nr + 1), "/", len(lines) duration = int(line.split("\t")[2]) for frame_counter in range(duration): img = cv.QueryFrame(cap) if not img: print "error?" print nr, frame_counter #break return if DEBUG: cv.ShowImage("win", img) global_frame_counter += 1 if nr == 0 and frame_counter == 0: # first shot, first frame w = img.width h = img.height pixel_count = float(img.width * img.height) prev_img = cv.CreateImage(cv.GetSize(img), cv.IPL_DEPTH_8U, 3) cv.Zero(prev_img) diff = cv.CreateImage(cv.GetSize(img), cv.IPL_DEPTH_8U, 3) cv.AbsDiff(img, prev_img, diff) cv.Threshold(diff, diff, 10, 255, cv.CV_THRESH_BINARY) d_color = 0 for i in range(1, 4): cv.SetImageCOI(diff, i) d_color += cv.CountNonZero(diff) / pixel_count d_color = d_color / 3 # 0..1 #print "%.1f" % (d_color*100), "%" motion.append(d_color) cv.Copy(img, prev_img) # WRITE TEXT FILE f_frm.write("%f\n" % (d_color)) if frame_counter == duration - 1: # last frame of current shot motion_value = sum(motion) / len(motion) print "average motion:", motion_value f_avg.write("%f\t%d\n" % (motion_value, duration)) motion = [] # WRITE IMAGE if frame_counter == 0: # ignore each first frame -- the diff after a hard cut is meaningless global_frame_counter -= 1 continue else: for i in range(WIDTH): value = d_color * 255 cv.Set2D(output_img, (global_frame_counter - 1) % MAX_FRAMES, i, cv.RGB(value, value, value)) if global_frame_counter % MAX_FRAMES == 0: cv.SaveImage( os.path.join(OUTPUT_DIR_NAME, "motion_%03d.png" % (file_counter)), output_img) file_counter += 1 if DEBUG: if cv.WaitKey(1) == 27: break if global_frame_counter % MAX_FRAMES != 0: #cv.SetImageROI(output_img, (0, 0, WIDTH-1, (global_frame_counter % MAX_FRAMES)-1)) cv.SetImageROI(output_img, (0, 0, WIDTH - 1, (global_frame_counter - 1) % MAX_FRAMES)) cv.SaveImage( os.path.join(OUTPUT_DIR_NAME, "motion_%03d.png" % (file_counter)), output_img) f_frm.close() f_avg.close() if DEBUG: cv.DestroyWindow("win") print "%.2f min" % ((time.time() - t) / 60) #raw_input("- done -") return
def get_point_cloud(self): # Scan the scene col_associations = self.get_projector_line_associations() # Project white light onto the scene to get the intensities of each pixel (for coloring our point cloud) illumination_projection = cv.CreateMat(self.projector_info.height, self.projector_info.width, cv.CV_8UC1) cv.Set(illumination_projection, 255) intensities_image = self.get_picture_of_projection( illumination_projection) # Turn projector off when done with it off_projection = cv.CreateMat(self.projector_info.height, self.projector_info.width, cv.CV_8UC1) cv.SetZero(off_projection) off_image_message = self.bridge.cv_to_imgmsg(off_projection, encoding="mono8") self.set_projection(off_image_message) camera_model = PinholeCameraModel() camera_model.fromCameraInfo(self.camera_info) valid_points_mask = cv.CreateMat(self.camera_info.height, self.camera_info.width, cv.CV_8UC1) cv.CmpS(col_associations, -1, valid_points_mask, cv.CV_CMP_NE) number_of_valid_points = cv.CountNonZero(valid_points_mask) rectified_camera_coordinates = cv.CreateMat(1, number_of_valid_points, cv.CV_32FC2) scanline_associations = cv.CreateMat(1, number_of_valid_points, cv.CV_32FC1) intensities = cv.CreateMat(1, number_of_valid_points, cv.CV_8UC1) i = 0 for row in range(self.camera_info.height): for col in range(self.camera_info.width): if valid_points_mask[row, col] != 0: rectified_camera_coordinates[0, i] = (col, row) scanline_associations[0, i] = col_associations[row, col] intensities[0, i] = intensities_image[row, col] i += 1 cv.UndistortPoints(rectified_camera_coordinates, rectified_camera_coordinates, camera_model.intrinsicMatrix(), camera_model.distortionCoeffs()) # Convert scanline numbers to plane normal vectors planes = self.scanline_numbers_to_planes(scanline_associations) camera_rays = project_pixels_to_3d_rays(rectified_camera_coordinates, camera_model) intersection_points = ray_plane_intersections(camera_rays, planes) self.point_cloud_msg = sensor_msgs.msg.PointCloud() self.point_cloud_msg.header.stamp = rospy.Time.now() self.point_cloud_msg.header.frame_id = 'base_link' channels = [] channel = sensor_msgs.msg.ChannelFloat32() channel.name = "intensity" points = [] intensities_list = [] for i in range(number_of_valid_points): point = geometry_msgs.msg.Point32() point.x = intersection_points[0, i][0] point.y = intersection_points[0, i][1] point.z = intersection_points[0, i][2] if point.z < 0: print scanline_associations[0, i] print rectified_camera_coordinates[0, i] points.append(point) intensity = intensities[0, i] intensities_list.append(intensity) channel.values = intensities_list channels.append(channel) self.point_cloud_msg.channels = channels self.point_cloud_msg.points = points return self.point_cloud_msg
def main(): BLACK_AND_WHITE = False THRESHOLD = 0.48 BW_THRESHOLD = 0.4 os.chdir(sys.argv[1]) try: os.mkdir(OUTPUT_DIR_NAME) except: pass if len(sys.argv) > 2: if sys.argv[2] == "bw": BLACK_AND_WHITE = True THRESHOLD = BW_THRESHOLD print "##########" print " B/W MODE" print "##########" tree = et.parse("project.xml") movie = tree.getroot() file_path = movie.attrib["path"] cap = cv.CreateFileCapture(file_path) if DEBUG: cv.NamedWindow("win", cv.CV_WINDOW_AUTOSIZE) cv.MoveWindow("win", 200, 200) hist = None prev_hist = None prev_img = None pixel_count = None frame_counter = 0 last_frame_black = False black_frame_start = -1 t = time.time() while 1: img_orig = cv.QueryFrame(cap) if not img_orig: # eof cv.SaveImage(OUTPUT_DIR_NAME + "\\%06d.png" % (frame_counter - 1), prev_img) """movie.set("frames", str(frame_counter)) tree.write("project.xml")""" break img = cv.CreateImage( (int(img_orig.width / 4), int(img_orig.height / 4)), cv.IPL_DEPTH_8U, 3) cv.Resize(img_orig, img, cv.CV_INTER_AREA) if frame_counter == 0: # erster frame cv.SaveImage(OUTPUT_DIR_NAME + "\\%06d.png" % (0), img) pixel_count = img.width * img.height prev_img = cv.CreateImage(cv.GetSize(img), cv.IPL_DEPTH_8U, 3) cv.Zero(prev_img) if DEBUG and frame_counter % 2 == 1: cv.ShowImage("win", img) img_hsv = cv.CreateImage(cv.GetSize(img), cv.IPL_DEPTH_8U, 3) cv.CvtColor(img, img_hsv, cv.CV_BGR2HSV) # ##################### # METHOD #1: find the number of pixels that have (significantly) changed since the last frame diff = cv.CreateImage(cv.GetSize(img), cv.IPL_DEPTH_8U, 3) cv.AbsDiff(img_hsv, prev_img, diff) cv.Threshold(diff, diff, 10, 255, cv.CV_THRESH_BINARY) d_color = 0 for i in range(1, 4): cv.SetImageCOI(diff, i) d_color += float(cv.CountNonZero(diff)) / float(pixel_count) if not BLACK_AND_WHITE: d_color = float(d_color / 3.0) # 0..1 # ##################### # METHOD #2: calculate the amount of change in the histograms h_plane = cv.CreateMat(img.height, img.width, cv.CV_8UC1) s_plane = cv.CreateMat(img.height, img.width, cv.CV_8UC1) v_plane = cv.CreateMat(img.height, img.width, cv.CV_8UC1) cv.Split(img_hsv, h_plane, s_plane, v_plane, None) planes = [h_plane, s_plane, v_plane] hist_size = [50, 50, 50] hist_range = [[0, 360], [0, 255], [0, 255]] if not hist: hist = cv.CreateHist(hist_size, cv.CV_HIST_ARRAY, hist_range, 1) cv.CalcHist([cv.GetImage(i) for i in planes], hist) cv.NormalizeHist(hist, 1.0) if not prev_hist: prev_hist = cv.CreateHist(hist_size, cv.CV_HIST_ARRAY, hist_range, 1) # wieso gibt es kein cv.CopyHist()?! cv.CalcHist([cv.GetImage(i) for i in planes], prev_hist) cv.NormalizeHist(prev_hist, 1.0) continue d_hist = cv.CompareHist(prev_hist, hist, cv.CV_COMP_INTERSECT) # combine both methods to make a decision if ((0.4 * d_color + 0.6 * (1 - d_hist))) >= THRESHOLD: if DEBUG: if frame_counter % 2 == 0: cv.ShowImage("win", img) winsound.PlaySound(soundfile, winsound.SND_FILENAME | winsound.SND_ASYNC) print "%.3f" % ((0.4 * d_color + 0.6 * (1 - d_hist))), "%.3f" % ( d_color), "%.3f" % (1 - d_hist), frame_counter if DEBUG and DEBUG_INTERACTIVE: if win32api.MessageBox(0, "cut?", "", win32con.MB_YESNO) == 6: #yes cv.SaveImage( OUTPUT_DIR_NAME + "\\%06d.png" % (frame_counter), img) else: cv.SaveImage(OUTPUT_DIR_NAME + "\\%06d.png" % (frame_counter), img) cv.CalcHist([cv.GetImage(i) for i in planes], prev_hist) cv.NormalizeHist(prev_hist, 1.0) # ##################### # METHOD #3: detect series of (almost) black frames as an indicator for "fade to black" average = cv.Avg(v_plane)[0] if average <= 0.6: if not last_frame_black: # possible the start print "start", frame_counter black_frame_start = frame_counter last_frame_black = True else: if last_frame_black: # end of a series of black frames cut_at = black_frame_start + int( (frame_counter - black_frame_start) / 2) print "end", frame_counter, "cut at", cut_at img_black = cv.CreateImage( (img_orig.width / 4, img_orig.height / 4), cv.IPL_DEPTH_8U, 3) cv.Set(img_black, cv.RGB(0, 255, 0)) cv.SaveImage(OUTPUT_DIR_NAME + "\\%06d.png" % (cut_at), img_black) last_frame_black = False cv.Copy(img_hsv, prev_img) frame_counter += 1 if DEBUG: if cv.WaitKey(1) == 27: break if DEBUG: cv.DestroyWindow("win") print "%.2f min" % ((time.time() - t) / 60) #raw_input("- done -") return