def hsv_orange_red_threshold(input_image): blur_image = cv.CreateMat(input_image.rows, input_image.cols, cv.CV_8UC3) cv.Smooth(input_image, blur_image, cv.CV_BLUR, 10, 10) proc_image = cv.CreateMat(input_image.rows, input_image.cols, cv.CV_8UC3) cv.CvtColor(blur_image, proc_image, cv.CV_BGR2HSV) split_image = [ cv.CreateMat(input_image.rows, input_image.cols, cv.CV_8UC1), cv.CreateMat(input_image.rows, input_image.cols, cv.CV_8UC1), cv.CreateMat(input_image.rows, input_image.cols, cv.CV_8UC1) ] cv.Split(proc_image, split_image[0], split_image[1], split_image[2], None) thresh_0 = cv.CreateMat(input_image.rows, input_image.cols, cv.CV_8UC1) thresh_1 = cv.CreateMat(input_image.rows, input_image.cols, cv.CV_8UC1) thresh_2 = cv.CreateMat(input_image.rows, input_image.cols, cv.CV_8UC1) red_orange = cv.CreateMat(input_image.rows, input_image.cols, cv.CV_8UC1) cv.Threshold(split_image[1], thresh_0, 128, 255, cv.CV_THRESH_BINARY) # > 50% saturation cv.Threshold(split_image[0], thresh_1, 220, 255, cv.CV_THRESH_BINARY) # > Purple cv.Threshold(split_image[0], thresh_2, 10, 255, cv.CV_THRESH_BINARY_INV) # < Yellow-Orange cv.Add(thresh_1, thresh_2, red_orange) cv.And(red_orange, thresh_0, red_orange) return red_orange
def main(args): if args.output_directory: directory = args.output_directory else: directory = os.path.dirname(args.input_image) print "No output directory specified. Defaulting to %s" % directory if not os.path.exists(directory): os.makedirs(directory) if args.output_prefix: prefix = args.output_prefix extension = os.path.splitext(os.path.basename(args.input_image))[1] else: prefix, extension = os.path.splitext(os.path.basename( args.input_image)) print "No output prefix selected. Defaulting to %s" % prefix output_file = "%s/%s%s" % (directory, prefix, extension) image = cv.LoadImage(args.input_image) input_image = cv.LoadImage(args.input_image) mask = cv.CreateImage(cv.GetSize(input_image), 8, 1) image_hue = cv.CreateImage(cv.GetSize(input_image), 8, 1) image_hsv = cv.CreateImage(cv.GetSize(input_image), 8, 3) cv.CvtColor(input_image, image_hsv, cv.CV_BGR2HSV) cv.Split(image_hsv, image_hue, None, None, None) upper_thresh = cv.CreateImage(cv.GetSize(input_image), 8, 1) lower_thresh = cv.CreateImage(cv.GetSize(input_image), 8, 1) cv.Threshold(image_hue, upper_thresh, args.hue_max, 255, cv.CV_THRESH_BINARY) cv.Threshold(image_hue, lower_thresh, args.hue_min, 255, cv.CV_THRESH_BINARY_INV) cv.Or(upper_thresh, lower_thresh, mask) cv.SaveImage(output_file, mask)
def createMask(image, thresh): b, g, r = doSplit(image) cv.Threshold(b, b, thresh, 255, cv.CV_THRESH_BINARY) cv.Threshold(g, g, thresh, 255, cv.CV_THRESH_BINARY) cv.Threshold(r, r, thresh, 255, cv.CV_THRESH_BINARY) cv.And(b, g, b, None) cv.And(b, r, b, None) return b
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 removeLightColors(image): b = cv.CreateImage(cv.GetSize(image), image.depth, 1) g = cv.CreateImage(cv.GetSize(image), image.depth, 1) r = cv.CreateImage(cv.GetSize(image), image.depth, 1) cv.Split(image, b, g, r, None) cv.Threshold(b, b, 154, 255, cv.CV_THRESH_BINARY) cv.Threshold(g, g, 154, 255, cv.CV_THRESH_BINARY) cv.Threshold(r, r, 154, 255, cv.CV_THRESH_BINARY) cv.Or(b, g, b) cv.Or(b, r, b) cv.Set(image, cv.ScalarAll(255), b) return image
def get_diff(old, new): """ Returns the difference between two BGR images. """ size = cv.GetSize(old) diff = cv.CreateImage(size, 8, 1) old_grayscale = cv.CreateImage(size, 8, 1) new_grayscale = cv.CreateImage(size, 8, 1) cv.CvtColor(old, old_grayscale, cv.CV_BGR2GRAY) cv.CvtColor(new, new_grayscale, cv.CV_BGR2GRAY) cv.AbsDiff(old_grayscale, new_grayscale, diff) cv.Smooth(diff, diff, smoothtype=cv.CV_GAUSSIAN, param1=3, param2=3) cv.Threshold(diff, diff, 16, 255, cv.CV_THRESH_BINARY) cv.Smooth(diff, diff, smoothtype=cv.CV_GAUSSIAN, param1=13, param2=13) cv.Threshold(diff, diff, 200, 255, cv.CV_THRESH_BINARY) return diff
def showThresholdedImage(src, dst, Threshold, show=True, method=cv.CV_THRESH_BINARY): n = src.nChannels m = Threshold if (n > 1): src2 = cv.CreateImage((src.width, src.height), src.depth, 1) cv.ConvertImage(src, src2, cv.CV_BGR2GRAY) else: src2 = src cv.Threshold(src2, dst, m, 255, method) i = 0 if (show): cv.NamedWindow("Original", 1) cv.NamedWindow("Thresholded", 1) while (i < 6000): cv.ShowImage("Original", src2) cv.ShowImage("Thresholded", dst) cv.WaitKey(300) i = i + 1 return
def clearNoise(image, tLetter=64, rBright=30): if tLetter <= 0: raise ValueError("tLetter = " + str(tLetter)) if rBright <= 0: raise ValueError("rBright = " + str(rBright)) def doThis(): result = cv.CloneImage(image) for x in xrange(result.width): for y in xrange(result.height): if result[y, x] == 0: continue if result[y, x] < tLetter: cv.FloodFill(result, (x, y), 0, rBright, rBright, 8, None) if result[0, 0] != image[0, 0] or \ result[result.height - 1, 0] != image[image.height - 1, 0] or \ result[0, result.width - 1] != image[0, image.width - 1] or \ result[result.height - 1, result.width - 1] != image[image.height - 1, image.width - 1]: return None return result result = doThis() while result is None: rBright -= 1 result = doThis() cv.Threshold(result, result, 1, 255, cv.CV_THRESH_BINARY_INV) return result
def update_mhi(img, dst, diff_threshold): global last global mhi global mask timestamp = time.clock() / CLOCKS_PER_SEC # get current time in seconds size = cv.GetSize(img) # get current frame size idx1 = last if not mhi or cv.GetSize(mhi) != size: for i in range(N): buf[i] = cv.CreateImage(size, cv.IPL_DEPTH_8U, 1) cv.Zero(buf[i]) mhi = cv.CreateImage(size, cv.IPL_DEPTH_32F, 1) cv.Zero(mhi) # clear MHI at the beginning mask = cv.CreateImage(size, cv.IPL_DEPTH_8U, 1) cv.CvtColor(img, buf[last], cv.CV_BGR2GRAY) # convert frame to grayscale idx2 = (last + 1) % N # index of (last - (N-1))th frame last = idx2 silh = buf[idx2] cv.AbsDiff(buf[idx1], buf[idx2], silh) # get difference between frames cv.Threshold(silh, silh, diff_threshold, 1, cv.CV_THRESH_BINARY) # and threshold it cv.UpdateMotionHistory(silh, mhi, timestamp, MHI_DURATION) # update MHI cv.CvtScale(mhi, mask, 255. / MHI_DURATION, (MHI_DURATION - timestamp) * 255. / MHI_DURATION) cv.Zero(dst) cv.Merge(mask, None, None, None, dst)
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 change_threshold(value): '''change displayed threshold''' global img_thresh, imgf, threshold threshold = value cv.Threshold(imgf, img_thresh, value / 65536.0, 0, cv.CV_THRESH_TOZERO) cv.ShowImage('Threshold', img_thresh) return img_thresh
def first_bigger_then_second(a, b): sub = image_empty_clone(a) cv.Sub(a, b, sub) #Thouse with R < G will become 0 binary = image_empty_clone(a) #Make binary image cv.Threshold(sub, binary, 1, 255, cv.CV_THRESH_BINARY) return binary
def extract_bright(grey_img, histogram=False): """ Extracts brightest part of the image. Expected to be the LEDs (provided that there is a dark background) Returns a Thresholded image histgram defines if we use the hist calculation to find the best margin """ ## Searches for image maximum (brightest pixel) # We expect the LEDs to be brighter than the rest of the image [minVal, maxVal, minLoc, maxLoc] = cv.MinMaxLoc(grey_img) print "Brightest pixel val is %d" % (maxVal) #We retrieve only the brightest part of the image # Here is use a fixed margin (80%), but you can use hist to enhance this one if 0: ## Histogram may be used to wisely define the margin # We expect a huge spike corresponding to the mean of the background # and another smaller spike of bright values (the LEDs) hist = grey_histogram(img, nBins=64) [hminValue, hmaxValue, hminIdx, hmaxIdx] = cv.GetMinMaxHistValue(hist) margin = 0 # statistics to be calculated using hist data else: margin = 0.8 thresh = int(maxVal * margin) # in pix value to be extracted print "Threshold is defined as %d" % (thresh) thresh_img = cv.CreateImage(cv.GetSize(img), img.depth, 1) cv.Threshold(grey_img, thresh_img, thresh, 255, cv.CV_THRESH_BINARY) return thresh_img
def get_motion_mask(self, img, diff_threshold=30): self.timestamp = time.clock( ) / self.CLOCKS_PER_SEC # get current time in seconds size = cv.GetSize(img) # get current frame size idx1 = self.last if not self.mhi or cv.GetSize(self.mhi) != size: for i in range(self.N): self.buf[i] = cv.CreateImage(size, cv.IPL_DEPTH_8U, 1) cv.Zero(self.buf[i]) self.mhi = cv.CreateImage(size, cv.IPL_DEPTH_32F, 1) cv.Zero(self.mhi) # clear MHI at the beginning self.orient = cv.CreateImage(size, cv.IPL_DEPTH_32F, 1) self.segmask = cv.CreateImage(size, cv.IPL_DEPTH_32F, 1) self.mask = cv.CreateImage(size, 8, 1) self.test = cv.CreateImage(size, 8, 3) cv.CvtColor(img, self.buf[self.last], cv.CV_BGR2GRAY) # convert frame to grayscale #self.buf[self.last] = cv.CloneImage(img) idx2 = (self.last + 1) % self.N # index of (last - (N-1))th frame self.last = idx2 self.silh = self.buf[idx2] cv.AbsDiff(self.buf[idx1], self.buf[idx2], self.silh) # get difference between frames cv.Threshold(self.silh, self.silh, diff_threshold, 1, cv.CV_THRESH_BINARY) # and threshold it cv.UpdateMotionHistory(self.silh, self.mhi, self.timestamp, self.MHI_DURATION) # update MHI cv.CvtScale(self.mhi, self.mask, 255. / self.MHI_DURATION, (self.MHI_DURATION - self.timestamp) * 255. / self.MHI_DURATION) #cv.ShowImage("motion mask", self.mask) max_rect = self.segment_motion() return self.mask
def edge_threshold(image, roi=None, debug=0): thresholded = cv.CloneImage(image) horizontal = cv.CreateImage(cv.GetSize(image), cv.IPL_DEPTH_16S, 1) magnitude32f = cv.CreateImage(cv.GetSize(image), cv.IPL_DEPTH_32F, 1) vertical = cv.CloneImage(horizontal) v_edge = cv.CloneImage(image) magnitude = cv.CloneImage(horizontal) storage = cv.CreateMemStorage(0) mag = cv.CloneImage(image) cv.Sobel(image, horizontal, 0, 1, 1) cv.Sobel(image, vertical, 1, 0, 1) cv.Pow(horizontal, horizontal, 2) cv.Pow(vertical, vertical, 2) cv.Add(vertical, horizontal, magnitude) cv.Convert(magnitude, magnitude32f) cv.Pow(magnitude32f, magnitude32f, 0.5) cv.Convert(magnitude32f, mag) if roi: cv.And(mag, roi, mag) cv.Normalize(mag, mag, 0, 255, cv.CV_MINMAX, None) cv.Threshold(mag, mag, 122, 255, cv.CV_THRESH_BINARY) draw_image = cv.CloneImage(image) and_image = cv.CloneImage(image) results = [] threshold_start = 17 for window_size in range(threshold_start, threshold_start + 1, 1): r = 20 for threshold in range(0, r): cv.AdaptiveThreshold(image, thresholded, 255, \ cv.CV_ADAPTIVE_THRESH_MEAN_C, cv.CV_THRESH_BINARY_INV, window_size, threshold) contour_image = cv.CloneImage(thresholded) contours = cv.FindContours(contour_image, storage, cv.CV_RETR_LIST) cv.Zero(draw_image) cv.DrawContours(draw_image, contours, (255, 255, 255), (255, 255, 255), 1, 1) if roi: cv.And(draw_image, roi, draw_image) cv.And(draw_image, mag, and_image) m1 = np.asarray(cv.GetMat(draw_image)) m2 = np.asarray(cv.GetMat(mag)) total = mag.width * mag.height #cv.Sum(draw_image)[0] coverage = cv.Sum(and_image)[0] / (mag.width * mag.height) if debug: print threshold, coverage cv.ShowImage("main", draw_image) cv.ShowImage("main2", thresholded) cv.WaitKey(0) results.append((coverage, threshold, window_size)) results.sort(lambda x, y: cmp(y, x)) _, threshold, window_size = results[0] cv.AdaptiveThreshold(image, thresholded, 255, cv.CV_ADAPTIVE_THRESH_MEAN_C, \ cv.CV_THRESH_BINARY, window_size, threshold) return thresholded
def main(): """main method""" print "Start" # open video file filepath = "ocup.avi" data = openfile(filepath) # DEBUG: just to skip some frames # for f in xrange(300): # frame = cv.QueryFrame(data["video"]) # TODO: last image is empty? for f in xrange(data["fcount"] - 1): # for f in xrange(1): # query next frame from video frame = cv.QueryFrame(data["video"]) # create images to store... well... images... framebw = cv.CreateImage((frame.width, frame.height), cv.IPL_DEPTH_8U, 1) framebin = cv.CreateImage((frame.width, frame.height), cv.IPL_DEPTH_8U, 1) frameedges = cv.CreateImage((frame.width, frame.height), cv.IPL_DEPTH_8U, 1) frameout = cv.CreateImage((frame.width, frame.height), cv.IPL_DEPTH_8U, 1) frameoutcol = cv.CreateImage((frame.width, frame.height), cv.IPL_DEPTH_8U, 3) # rgb to grayscale cv.CvtColor(frame, framebw, cv.CV_BGR2GRAY) # grayscale to binary cv.Threshold(framebw, framebin, 150, 255, cv.CV_THRESH_BINARY) # detect edges with canny... # cv.Canny(framebin,frameedges,150,300,3) # cv.Canny(framebin,frameedges,150,100,3) cv.Copy(framebin, frameout) cv.CvtColor(frameout, frameoutcol, cv.CV_GRAY2RGB) # check the image and get result if street is straight or curved result = checkimage(framebin, frameoutcol) # TODO: implement state machine or something if result == 0: print "straight" if result == -1: print "left" if result == 1: print "right" cv.ShowImage("window", frameoutcol) cv.WaitKey(50000) # delete used ressources deleteRessources(data) print "Done"
def update_mhi(img, dst, diff_threshold): global last global mhi global storage global mask global orient global segmask timestamp = time.clock() / CLOCKS_PER_SEC # get current time in seconds size = cv.GetSize(img) # get current frame size idx1 = last if not mhi or cv.GetSize(mhi) != size: for i in range(N): buf[i] = cv.CreateImage(size, cv.IPL_DEPTH_8U, 1) cv.Zero(buf[i]) mhi = cv.CreateImage(size,cv. IPL_DEPTH_32F, 1) cv.Zero(mhi) # clear MHI at the beginning orient = cv.CreateImage(size,cv. IPL_DEPTH_32F, 1) segmask = cv.CreateImage(size,cv. IPL_DEPTH_32F, 1) mask = cv.CreateImage(size,cv. IPL_DEPTH_8U, 1) cv.CvtColor(img, buf[last], cv.CV_BGR2GRAY) # convert frame to grayscale idx2 = (last + 1) % N # index of (last - (N-1))th frame last = idx2 silh = buf[idx2] cv.AbsDiff(buf[idx1], buf[idx2], silh) # get difference between frames cv.Threshold(silh, silh, diff_threshold, 1, cv.CV_THRESH_BINARY) # and threshold it cv.UpdateMotionHistory(silh, mhi, timestamp, MHI_DURATION) # update MHI cv.CvtScale(mhi, mask, 255./MHI_DURATION, (MHI_DURATION - timestamp)*255./MHI_DURATION) cv.Zero(dst) cv.Merge(mask, None, None, None, dst) cv.CalcMotionGradient(mhi, mask, orient, MAX_TIME_DELTA, MIN_TIME_DELTA, 3) if not storage: storage = cv.CreateMemStorage(0) seq = cv.SegmentMotion(mhi, segmask, storage, timestamp, MAX_TIME_DELTA) for (area, value, comp_rect) in seq: if comp_rect[2] + comp_rect[3] > 100: # reject very small components color = cv.CV_RGB(255, 0,0) silh_roi = cv.GetSubRect(silh, comp_rect) mhi_roi = cv.GetSubRect(mhi, comp_rect) orient_roi = cv.GetSubRect(orient, comp_rect) mask_roi = cv.GetSubRect(mask, comp_rect) angle = 360 - cv.CalcGlobalOrientation(orient_roi, mask_roi, mhi_roi, timestamp, MHI_DURATION) count = cv.Norm(silh_roi, None, cv.CV_L1, None) # calculate number of points within silhouette ROI if count < (comp_rect[2] * comp_rect[3] * 0.05): continue magnitude = 30. center = ((comp_rect[0] + comp_rect[2] / 2), (comp_rect[1] + comp_rect[3] / 2)) cv.Circle(dst, center, cv.Round(magnitude*1.2), color, 3, cv.CV_AA, 0) cv.Line(dst, center, (cv.Round(center[0] + magnitude * cos(angle * cv.CV_PI / 180)), cv.Round(center[1] - magnitude * sin(angle * cv.CV_PI / 180))), color, 3, cv.CV_AA, 0)
def przygotuj_zdjecie(self, src, ROI, white_level, dark_level): img = cv.LoadImageM(src, cv.CV_LOAD_IMAGE_COLOR) size = cv.GetSize(img) print size gray = cv.CreateImage(size, 8, 1) cv.CvtColor(img, gray, cv.CV_RGB2GRAY) print ROI if ROI != [-1, -1, -1, -1]: cv.SetImageROI(gray, (ROI[0], ROI[1], ROI[2], ROI[3])) cv.Threshold(gray, gray, white_level, 255, cv.CV_THRESH_BINARY) cv.Smooth(gray, gray, cv.CV_BLUR, 9, 9) cv.Threshold(gray, gray, white_level * 0.8, 255, cv.CV_THRESH_BINARY) cv.Smooth(gray, gray, cv.CV_BLUR, 5, 5) #cv.Dilate(gray,gray) #cv.Canny( gray, gray, 1.0, 1.0, 3) size = cv.GetSize(gray) return gray, size
def clearNoise(self, image): for x in range(image.width): for y in range(image.height): if image[y, x] == 0: continue if image[y, x] < self.tLetter: cv.FloodFill(image, (x, y), 0, self.rBright, self.rBright, 8, None) cv.Threshold(image, image, 1, 255, cv.CV_THRESH_BINARY_INV)
def threshold(self): for x in range(0, self.size[0], 30): for y in range(0, self.size[1], 30): cv.SetImageROI(self.gray_img, (x, y, 30, 30)) cv.SetImageROI(self.bw_img, (x, y, 30, 30)) cv.Threshold( self.gray_img, self.bw_img, 127, 255, cv.CV_THRESH_OTSU) cv.ResetImageROI(self.gray_img) cv.ResetImageROI(self.bw_img)
def FrameMask(old_frame, frame): if MovingHead(): return None mask = cv.CloneImage(old_frame) cv.AbsDiff(old_frame, frame, mask) cv.Threshold(mask,mask, 15, 255, cv.CV_THRESH_BINARY) return mask
def subtract(self, thres_chan): cv.RunningAvg(thres_chan, self.accumulator, self.adaptation_rate) cv.CvtScale(thres_chan, self.green32_img) cv.Sub(self.green32_img, self.accumulator, self.difference_img) cv.Threshold(self.difference_img, self.thresholded_img, self.threshold, 1, cv.CV_THRESH_BINARY) cv.Dilate(self.thresholded_img, self.thresholded_img, iterations=1) blob.remove_large_blobs(self.thresholded_img, max_area=self.max_area) return self.thresholded_img
def dothreshold(I): # bins := [ 9358 83 67 119 991 2183 153 64 141 12377] # binsizes: [ 0. 25.5 51. 76.5 102. 127.5 153. 178.5 204. 229.5 255. ] newI = cv.CreateImage(cv.GetSize(I), I.depth, I.channels) #I_mat = iplimage2cvmat(I) #I_np = np.asarray(I_mat) #bins, binsizes = np.histogram(I_np) cv.Threshold(I, newI, 35, 255.0, cv.CV_THRESH_BINARY) return newI
def get_hands(image): """ Returns the hand as white on black. Uses value in HSV to determine hands.""" size = cv.GetSize(image) hsv = cv.CreateImage(size, 8, 3) hue = cv.CreateImage(size, 8, 1) sat = cv.CreateImage(size, 8, 1) val = cv.CreateImage(size, 8, 1) hands = cv.CreateImage(size, 8, 1) cv.CvtColor(image, hsv, cv.CV_BGR2HSV) cv.Split(hsv, hue, sat, val, None) cv.ShowImage('Live', image) cv.ShowImage('Hue', hue) cv.ShowImage('Saturation', sat) cv.Threshold( hue, hue, 10, 255, cv.CV_THRESH_TOZERO) #set to 0 if <= 10, otherwise leave as is cv.Threshold( hue, hue, 244, 255, cv.CV_THRESH_TOZERO_INV) #set to 0 if > 244, otherwise leave as is cv.Threshold(hue, hue, 0, 255, cv.CV_THRESH_BINARY_INV) #set to 255 if = 0, otherwise 0 cv.Threshold( sat, sat, 64, 255, cv.CV_THRESH_TOZERO) #set to 0 if <= 64, otherwise leave as is cv.EqualizeHist(sat, sat) cv.Threshold(sat, sat, 64, 255, cv.CV_THRESH_BINARY) #set to 0 if <= 64, otherwise 255 cv.ShowImage('Saturation threshold', sat) cv.ShowImage('Hue threshold', hue) cv.Mul(hue, sat, hands) #smooth + threshold to filter noise # cv.Smooth(hands, hands, smoothtype=cv.CV_GAUSSIAN, param1=13, param2=13) # cv.Threshold(hands, hands, 200, 255, cv.CV_THRESH_BINARY) cv.ShowImage('Hands', hands) return hands
def processFrame(self): startTime = time.time() logging.debug("Frame %d at %s", self.N, self.formatTime(startTime)) self.N += 1 logging.debug("Capturing a frame") frame = self.capture.getFrame() logging.debug("Entering preprocessing") standard = self.pre.get_standard_form(frame) bgsub_vals, bgsub_mask = self.pre.bgsub(standard) logging.debug("Entering feature extraction") hist_props_bgsub = self.histogram.calcHistogram(standard) hist_props_abs = self.histogram.calcHistogram(bgsub_vals) self.threshold.updateBGSubThresholds(hist_props_bgsub) #self.threshold.updateAbsThresholds(hist_props_abs) ents = self.featureEx.features(bgsub_vals, self.threshold) logging.debug("Detected entities:", ents) logging.debug("Entering interpreter") self.interpreter.interpret(ents) logging.debug("Entering World") self.world.update(startTime, ents) logging.debug("Updating GUI") if not self.headless: try: bgsub = self.pre.remove_background(standard) self.gui.updateWindow('raw', frame) self.gui.updateWindow('mask', bgsub_mask) self.gui.updateWindow('foreground', bgsub_vals) self.gui.updateWindow('bgsub', bgsub) self.gui.updateWindow('standard', standard) canny = cv.CreateImage(self.pre.cropSize, 8, 1) # adaptive = cv.CreateImage(self.pre.cropSize, 32,3) # tmp = cv.CreateImage(self.pre.cropSize, 8,3) # cv.Convert(standard, adaptive) cv.CvtColor(bgsub, canny, cv.CV_BGR2GRAY) cv.Threshold(canny, canny, 150, 255, cv.CV_THRESH_OTSU) # cv.Threshold(canny, canny, 100, 255, cv.CV_ADAPTIVE_THRESH_GAUSSIAN_C) # cv.Sobel(adaptive, adaptive, 1,1,1) # cv.Convert(adaptive, tmp) # cv.ConvertScale(tmp, tmp, 10) # cv.CvtColor(tmp, canny, cv.CV_BGR2GRAY) # cv.Threshold(canny,canny, 50, 255, cv.CV_THRESH_BINARY) #cv.Canny(canny,canny, 100, 180,3) cv.CvtColor(canny, bgsub, cv.CV_GRAY2BGR) new = self.featureEx.detectCircles(bgsub) self.gui.updateWindow('adaptive', canny) self.gui.updateWindow('new', new) self.gui.draw(ents, startTime) except Exception, e: logging.error("GUI failed: %s", e) if self.debug: raise
def processMotion(self): """ Take a raw input image frame from the camera and perform motion detection using the current frame plus considering several previous frames and return the CV image that should be given to the Region network. """ #find motion image, then find feature corners from that if self._prevIplImage: cv.AbsDiff(self._inputImage, self._prevIplImage, self._diffImage) else: cv.Copy(self._inputImage, self._diffImage) cv.Copy(self._inputImage, self._prevIplImage) #save as t-1 image for next frame #(src, dest, threshold, maxVal, type) cv.Threshold(self._diffImage, self._threshImage, 16.0, 255.0, cv.CV_THRESH_BINARY) #For now, disable segmentMotion and return all motion in frame... if self._threshImage!=None: return (0,0, self._threshImage.width, self._threshImage.height) ###Experimental: segment motion to return only the most 'interesting' area tsec = clock() #(silhouette, mhi, timestamp, duration) cv.UpdateMotionHistory(self._threshImage, self._historyImage, tsec, 0.3) #(mhi, segMask, storage, timestamp, segThresh) #return: [tuple(area, value, rect)], (float, CvScalar, CvRect) seqs = cv.SegmentMotion(self._historyImage, self._segMaskImage, \ self._memStorage, tsec, 1.0) #cv.Copy(self._threshImage, self._inputImage) #cv.Threshold(self._segMaskImage, self._threshImage, 0.0, 250.0, CV_THRESH_BINARY) rects = [] for seq in seqs: seqRect = seq[2] #CvRect = tuple (x, y, width, height) if(seqRect[2] > 4 and seqRect[3] > 4): rects.append(seqRect) #find the 3rd largest area and only keep those rects if len(rects) > 0: areas = [x[2]*x[3] for x in rects] areas.sort() minArea = areas[0] if len(areas) > 1: minArea = areas[len(areas)-1] rectsOk = [x for x in rects if x[2]*x[3] >= minArea] rect = rectsOk[0] #center the largest rect cRect = (rect[0]+(rect[2]/2), rect[1]+(rect[3]/2)) return rect return None #none means no motion bounding box detected
def loop(self, lock): print('starting thread - ProcessContours') self.active = True self.loops = 0 while self.active: self.loops += 1 print('.....contours thread... locking, convert scale...') lock.acquire() #lock.release() # bug was here cv.CvtColor(self.depth8, self.DEPTH640, cv.CV_GRAY2RGB) cv.Resize(self.DEPTH640, self.DEPTH240, False) lock.release() # fixed Dec 6th 2011 print('.....contours thread ok.....') # blur helps? #cv.Smooth( self.depth8, self.depth8, cv.CV_BLUR, 16, 16, 0.1, 0.1 ) #cv.Smooth( self.depth8, self.depth8, cv.CV_GAUSSIAN, 13, 13, 0.1, 0.1 ) thresh = Kinect.sweep_begin index = 0 #for img in self.sweep_thresh: for i in range(int(Kinect.sweeps)): if thresh >= 255: break img = self.sweep_images[i] cv.ClearMemStorage(self.storage) cv.Threshold(self.depth8, img, thresh, 255, cv.CV_THRESH_BINARY_INV) #cv.Canny( img, img, 0, 255, 3 ) # too slow seq = cv.CvSeq() contours = ctypes.pointer(seq.POINTER) cv.FindContours(img, self.storage, contours, ctypes.sizeof(cv.Contour.CSTRUCT), cv.CV_RETR_EXTERNAL, cv.CV_CHAIN_APPROX_SIMPLE, (0, 0)) #print( contours.contents.contents.total ) _total = 0 try: _total = contours.contents.contents.total except ValueError: #ValueError: NULL pointer access thresh += int(Kinect.sweep_step) continue P = ReducedPolygon(contours.contents, index, thresh) lock.acquire() Kinect.BUFFER.append(P) lock.release() index += 1 thresh += int(Kinect.sweep_step) print('==========proc shapes.iterate============') self.proc_shapes.iterate(lock) time.sleep(0.01) print('thread exit - ProcessContours', self.loops)
def threshold_lines(self,lines): all_lines=sum(lines,[]) tmp=cv.CreateImage((len(all_lines),1), 8, 1) for i,p in enumerate(all_lines): tmp[0,i]=p cv.Threshold(tmp, tmp, 0, 1, cv.CV_THRESH_OTSU) j=0 for l in lines: for i in range(len(l)): l[i]=tmp[0,j] j+=1
def sat_threshold(image, min_sat): image_hsv = cv.CloneImage(image) cv.CvtColor(image, image_hsv, cv.CV_RGB2HSV) image_sat = cv.CreateImage(cv.GetSize(image_hsv), 8, 1) cv.Split(image_hsv, None, image_sat, None, None) sat_thresh = cv.CloneImage(image_sat) cv.Threshold(image_sat, sat_thresh, min_sat, 255, cv.CV_THRESH_BINARY) image_out = cv.CloneImage(image) cv.Zero(image_out) cv.Copy(image, image_out, sat_thresh) return image_out
def track(bgr_image, threshold=100): '''Accepts BGR image and optional object threshold between 0 and 255 (default = 100). Returns: (x,y) coordinates of centroid if found (-1,-1) if no centroid was found None if user hit ESC ''' # Extract bytes, width, and height bgr_bytes = bgr_image.tostring() width = bgr_image.width height = bgr_image.height # Create separate red, green, and blue image matrices from bytes r_image = _create_grayscale_mat(bgr_bytes, width, height, 2) b_image = _create_grayscale_mat(bgr_bytes, width, height, 0) g_image = _create_grayscale_mat(bgr_bytes, width, height, 1) # Remove 1/3 of red and blue components from green threes_image = cv.CreateImage((width,height), cv.IPL_DEPTH_8U, 1) cv.Set(threes_image, 3) _div_and_sub(g_image, r_image, threes_image) _div_and_sub(g_image, b_image, threes_image) # Threshold and erode green image cv.Threshold(g_image, g_image, threshold, 255, cv.CV_THRESH_BINARY) cv.Erode(g_image, g_image) # Find centroid of eroded image moments = cv.Moments(cv.GetMat(g_image), 1) # binary flag centroid_x = _centroid(moments, 1, 0) centroid_y = _centroid(moments, 0, 1) # Assume no centroid ctr = (width/2,height/2) err = ctr # Use centroid if it exists if centroid_x != None and centroid_y != None: ctr = (centroid_x, centroid_y) # Put black circle in at centroid in image cv.Circle(bgr_image, ctr, 4, (0,0,0)) # Display full-color image cv.NamedWindow(WINDOW_NAME) cv.ShowImage(WINDOW_NAME, bgr_image) # Force image display, setting centroid to None on ESC key input if cv.WaitKey(5) == 27: ctr = None # Return coordinates of centroid return ctr if ctr != err else None