def get_hand(img): global h_lower, h_upper, s_lower, s_upper storage = cv.CreateMemStorage(0) contours, hull, max_contours, max_hull = (0, 0, 0, 0) max_rect = (1, 1, 100, 100) dst = cv.CreateImage((img.width, img.height), 8, 3) hsv = cv.CreateImage((img.width, img.height), 8, 3) frame = cv.CreateImage((img.width, img.height), 8, 1) con = cv.CreateImage((img.width, img.height), 8, 1) cv.Zero(con) cv.Smooth(img, dst, cv.CV_GAUSSIAN, 5, 5) for i in range(3): cv.Smooth(dst, dst, cv.CV_GAUSSIAN, 5, 5) cv.CvtColor(dst, hsv, cv.CV_RGB2HSV) cv.InRangeS(hsv, (h_lower, s_lower, 0), (h_upper, s_upper, 256), frame) kernel = cv.CreateStructuringElementEx(3, 3, 0, 0, cv.CV_SHAPE_RECT) #cv.MorphologyEx(frame, frame, None, kernel, cv.CV_MOP_CLOSE , 7) # cv.MorphologyEx(frame, frame, None, kernel, cv.CV_MOP_OPEN , 3) #contours = im.find_contours(frame) #hull = im.find_convex_hull(contours) print contours #max_hull_area, max_contour_area = (0, 0) #print "xxxxxxxx" #contour = contours.h_next() #print "........" #while (contour != 0): # hull = cv.ConvexHull2(contour, storage, cv.CV_CLOCKWISE, 1); # maxv = cv.ContourArea(hull) # contour = contour.h_next() #cv.DrawContours(con, contours, red, blue, 1, 3, 8) cv.ShowImage("result", con)
def detectSkin(self, bgrimg): img_temp = cv.CreateImage(im.size(bgrimg), 8, 3) cv.Smooth(bgrimg, img_temp, cv.CV_GAUSSIAN, 5, 5) for i in range(3): cv.Smooth(img_temp, img_temp, cv.CV_GAUSSIAN, 5, 5) #cv.ShowImage("Capture from camera", img_temp) skin = self._detectSkin(img_temp) return skin
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 read_image_canny(filename): img = cv.LoadImage(filename, 1) gray = cv.CreateImage((img.width, img.height), 8, 1) edge = cv.CreateImage((img.width, img.height), 8, 1) cv.CvtColor(img, gray, cv.CV_BGR2GRAY) cv.Smooth(gray, edge, cv.CV_BLUR, 3, 3, 0) #cv.Not(gray, edge) # run the edge dector on gray scale cv.Canny(gray, edge, 80, 160, 3) cv.Not(edge, edge) cv.Smooth(edge, edge, cv.CV_GAUSSIAN, 3, 3, 0) a_img = cv2array(edge) return a_img.flatten(1)
def run(im, headInfo): (cam, head) = headInfo # convert the image im = convertImage(im) #cv.SaveImage('a.jpg', im) # filter the image im = filterImage(im) #cv.SaveImage('b.jpg', im) # blur the image cv.Smooth(im, im, cv.CV_BLUR, 5, 5) #cv.SaveImage('c.jpg', im) # find the max value in the image (minVal, maxValue, minLoc, maxLocation) = cv.MinMaxLoc(im) #print maxValue/256.0 # if the maxValue isn't hight enough return 'None' if maxValue / 256.0 < 0.4: return None # calculate the angles to the ball #(xAngle, yAngle) = calcAngles((xcoord, ycoord ), cam) # calculate the position of the ball position = calcPosition(maxLocation, cam) (xPos, yPos, xAngle, yAngle) = position #print position #track(position) return (xPos, yPos)
def findRectPoints(self, oldRectPoints): hueRange = self.hueRange satRange = self.satRange valRange = self.valRange clone = cv.CloneImage(self.frame) hsv = cv.CloneImage(self.channels3) threshold = cv.CloneImage(self.channels1) threshold2 = cv.CloneImage(self.channels1) cv.Smooth(clone, clone, cv.CV_GAUSSIAN, 7, 7) cv.CvtColor(clone, hsv, cv.CV_BGR2HSV) cv.InRangeS(hsv, (hueRange[0], satRange[0], valRange[0]), (hueRange[1], satRange[1], satRange[1]), threshold) cv.InRangeS(hsv, (hueRange[2], satRange[0], satRange[0]), (hueRange[3], satRange[1], valRange[1]), threshold2) cv.Add(threshold, threshold2, threshold) cv.Erode(threshold, threshold, iterations=5) cv.Dilate(threshold, threshold, iterations=5) # cv.ShowImage(self.color, threshold) memory = cv.CreateMemStorage(0) clone2 = cv.CloneImage(threshold) contours = cv.FindContours(clone2, memory, cv.CV_RETR_LIST, cv.CV_CHAIN_APPROX_SIMPLE, (0, 0)) if not contours: rectPoints = oldRectPoints else: rectPoints = cv.BoundingRect(list(contours)) return rectPoints
def sobel(im, xorder=1, yorder=0, aperture_size=3, sigma=None): ''' void cv.Sobel(src, dst, xorder, yorder, apertureSize = 3) @param im: Input image @param xorder: The order of the x derivative (see cv.Sobel openCV docs) @param yorder: The order of the y derivative (see cv.Sobel openCV docs) @param aperture_size: How large a convolution window to use @param sigma: Optional smoothing parameter to be applied prior to detecting edges ''' gray = im.asOpenCVBW() edges = cv.CreateImage(cv.GetSize(gray), 8, 1) if sigma != None: cv.Smooth(gray, gray, cv.CV_GAUSSIAN, int(sigma) * 4 + 1, int(sigma) * 4 + 1, sigma, sigma) #sobel requires a destination image with larger bit depth... #...so we have to convert it back to 8 bit for the pv Image... dst32f = cv.CreateImage(cv.GetSize(gray), cv.IPL_DEPTH_32F, 1) cv.Sobel(gray, dst32f, xorder, yorder, aperture_size) cv.Convert(dst32f, edges) edges = pv.Image(edges) return edges
def CountPinkPixels(self,cv_img): cv.Smooth(cv_img, cv_img, cv.CV_BLUR, 3); hsv_img = cv.CreateImage(cv.GetSize(cv_img), 8, 3) cv.CvtColor(cv_img, hsv_img, cv.CV_BGR2HSV) #limit all pixels that don't match our criteria, in this case we are #looking for purple but if you want you can adjust the first value in #both turples which is the hue range(120,140). OpenCV uses 0-180 as #a hue range for the HSV color model thresholded_img = cv.CreateImage(cv.GetSize(hsv_img), 8, 1) cv.InRangeS(hsv_img, (120, 80, 80), (180, 255, 255), thresholded_img) #print type(thresholded_img) mat = cv.GetMat(thresholded_img) #mat = hsv_img.getNumpy() (width,height) = cv.GetSize(thresholded_img) aveW = 0 aveH = 0 count = 0 for j in range(0,height): for i in range(0,width): if (mat[j,i] == 255.0): count += 1 aveH += j aveW += i print i,j, mat[j,i] aveH = aveH/count aveW = aveW/count overlay = cv.CreateImage(cv.GetSize(cv_img),8,3) cv.Circle(overlay, (int(aveW), int(aveH)), 2, (255,255,255),20) cv.Add(cv_img,overlay,cv_img) return cv_img
def getHsvRange(self): self.x_co = 0 self.y_co = 0 cv.NamedWindow('camera feed', cv.CV_WINDOW_AUTOSIZE) capture = cv.CaptureFromCAM(1) font = cv.InitFont(cv.CV_FONT_HERSHEY_SIMPLEX, 0.5, 1, 0, 2, 8) while True: src = cv.QueryFrame(capture) # src = cv.LoadImage('2012_automata.jpg') cv.Smooth(src, src, cv.CV_BLUR, 3) hsv = cv.CreateImage(cv.GetSize(src), src.depth, 3) cv.CvtColor(src, hsv, cv.CV_BGR2HSV) cv.SetMouseCallback("camera feed", self.on_mouse, 0) s = cv.Get2D(hsv, self.y_co, self.x_co) # print "H:", s[0], " S:", s[1], " V:", s[2] cv.PutText(src, str(s[0]) + "," + str(s[1]) + "," + str(s[2]), (self.x_co, self.y_co), font, (55, 25, 255)) cv.ShowImage("camera feed", src) if cv.WaitKey(10) == 27: return (s[0], s[1], s[2]) break
def getIris(frame): iris = [] copyImg = cv.CloneImage(frame) resImg = cv.CloneImage(frame) grayImg = cv.CreateImage(cv.GetSize(frame), 8, 1) mask = cv.CreateImage(cv.GetSize(frame), 8, 1) storage = cv.CreateMat(frame.width, 1, cv.CV_32FC3) cv.CvtColor(frame, grayImg, cv.CV_BGR2GRAY) cv.Canny(grayImg, grayImg, 5, 70, 3) cv.Smooth(grayImg, grayImg, cv.CV_GAUSSIAN, 7, 7) circles = getCircles(grayImg) iris.append(resImg) for circle in circles: rad = int(circle[0][2]) global radius radius = rad cv.Circle(mask, centroid, rad, cv.CV_RGB(255, 255, 255), cv.CV_FILLED) cv.Not(mask, mask) cv.Sub(frame, copyImg, resImg, mask) x = int(centroid[0] - rad) y = int(centroid[1] - rad) w = int(rad * 2) h = w cv.SetImageROI(resImg, (x, y, w, h)) cropImg = cv.CreateImage((w, h), 8, 3) cv.Copy(resImg, cropImg) cv.ResetImageROI(resImg) return (cropImg) return (resImg)
def captureReferenceImage(self): frame = self.getFrame() self.frameSize = cv.GetSize(frame) self.referencedImage = cv.CloneImage(frame) cv.Smooth(self.referencedImage, self.referencedImage, cv.CV_GAUSSIAN, 9, 0) self.lastReferenceCaptureTime = TimeUtil.getCurrentTime()
def process(self): def seq_to_iter(seq): while seq: yield seq seq = seq.h_next() def score_rect(r,p): x,y,w,h = r return w * h cv.Resize(self.frame, self.resized_frame) cv.CvtColor(self.resized_frame, self.hsv_frame, cv.CV_RGB2HSV) cv.Smooth(self.hsv_frame, self.smooth_frame, cv.CV_GAUSSIAN, 31) for p in self.pompon: if p.calibration_done: self.in_range(p, self.smooth_frame, self.bin_frame) cv.Erode(self.bin_frame, self.mask, None, self.dilatation); if self.show_binary: self.mask2 = cv.CloneImage(self.mask) # for miniature contour = seq_to_iter(cv.FindContours(self.mask, cv.CreateMemStorage(), cv.CV_RETR_EXTERNAL, cv.CV_CHAIN_APPROX_SIMPLE)); rects = map((lambda c: cv.BoundingRect(c, 0)), contour) if rects: x,y,w,h = max(rects, key=lambda r: score_rect(r,p)) p.pos = self.proc2sym(x+w/2,y+h/2)
def threshold(self, frame, record, op=cv.And, magic=False): """Threshold a frame using a record of min/max thresholds Output is a new image. """ colorspace, min, max = record tmp = cv.CloneImage(frame) if magic: cv.Smooth(tmp, tmp, cv.CV_GAUSSIAN, 11) # Work in the correct colorspace self.colorspaceConv[colorspace](tmp) num_chans = len(min) size = cv.GetSize(frame) chan = [ cv.CreateImage(size, cv.IPL_DEPTH_8U, 1) for _ in range(num_chans) ] cv.Split(tmp, chan[0], chan[1], chan[2], None) minS = map(cv.Scalar, min) maxS = map(cv.Scalar, max) for i in range(num_chans): cv.InRangeS(chan[i], minS[i], maxS[i], chan[i]) out = cv.CreateImage(size, cv.IPL_DEPTH_8U, 1) op(chan[0], chan[1], out) op(out, chan[2], out) return out
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 find_matches(imgpaths, patch, C=0.8): """ Runs template matching to find PATCH in each IMGPATHS. Input: list imgpaths: [imgpath_i, ...] IplImage patch: float C: Output: list matches, [[imgpath_i, (x,y), score_i], ...] """ matches = {} # maps {str imgpath: [(x,y,score_i), ...]} for imgpath in imgpaths: img = cv.LoadImage(imgpath, cv.CV_LOAD_IMAGE_GRAYSCALE) img_smooth = cv.CreateImage((img.width, img.height), img.depth, img.channels) cv.Smooth(img, img_smooth, cv.CV_GAUSSIAN, param1=17, param2=17) M = cv.CreateMat(img.height - patch.height + 1, img.width - patch.width + 1, cv.CV_32F) cv.MatchTemplate(img_smooth, patch, M, cv.CV_TM_CCOEFF_NORMED) M_np = np.array(M) score = np.inf while score > C: M_idx = np.argmax(M_np) i = int(M_idx / M.cols) j = M_idx % M.cols score = M_np[i, j] if score < C: break matches.setdefault(imgpath, []).append((j, i, score)) # Suppression M_np[i - (patch.height / 3):i + (patch.height / 3), j - (patch.width / 3):j + (patch.width / 3)] = -1.0 return matches
def findFirstColorPattern(img, pattern): """ try to test if one pixel is in our pattern """ channels = [None, None, None] channels[0] = cv.CreateImage(cv.GetSize(img), 8, 1) #blue channels[1] = cv.CreateImage(cv.GetSize(img), 8, 1) #green channels[2] = cv.CreateImage(cv.GetSize(img), 8, 1) #red ch0 = cv.CreateImage(cv.GetSize(img), 8, 1) #blue ch1 = cv.CreateImage(cv.GetSize(img), 8, 1) #green ch2 = cv.CreateImage(cv.GetSize(img), 8, 1) #red cv.Split(img, ch0, ch1, ch2, None) dest0 = cv.CreateImage(cv.GetSize(img), 8, 1) dest1 = cv.CreateImage(cv.GetSize(img), 8, 1) dest2 = cv.CreateImage(cv.GetSize(img), 8, 1) dest3 = cv.CreateImage(cv.GetSize(img), 8, 1) cv.Smooth(ch0, channels[0], cv.CV_GAUSSIAN, 3, 3, 0) cv.Smooth(ch1, channels[1], cv.CV_GAUSSIAN, 3, 3, 0) cv.Smooth(ch2, channels[2], cv.CV_GAUSSIAN, 3, 3, 0) result = [] for i in range(3): lower = pattern[i][2] - 25 upper = pattern[i][2] + 25 cv.InRangeS(channels[0], lower, upper, dest0) lower = pattern[i][1] - 25 upper = pattern[i][1] + 25 cv.InRangeS(channels[1], lower, upper, dest1) lower = pattern[i][0] - 25 upper = pattern[i][0] + 25 cv.InRangeS(channels[2], lower, upper, dest2) cv.And(dest0, dest1, dest3) temp = cv.CreateImage(cv.GetSize(img), 8, 1) cv.And(dest2, dest3, temp) result.append(temp) cv.ShowImage("result0", result[0]) cv.WaitKey(0) cv.ShowImage("result1", result[1]) cv.WaitKey(0) cv.ShowImage("result2", result[2]) cv.WaitKey(0) cv.Or(result[0], result[1], dest0) cv.Or(dest0, result[2], dest3) cv.NamedWindow("result", cv.CV_WINDOW_AUTOSIZE) cv.ShowImage("result", dest3) cv.WaitKey(0) return dest3
def glyphRec(image): storage = cv.CreateMemStorage(0) contrast = cv.CreateImage(cv.GetSize(image), 8, 3) grey = cv.CreateImage(cv.GetSize(image), 8, 1) canny = cv.CreateImage(cv.GetSize(grey), cv.IPL_DEPTH_8U, 1) #increase contrast avg = cv.Avg(image) cv.AddS(image, cv.Scalar(-.5 * avg[0], -.5 * avg[1], -.5 * avg[2]), contrast) cv.Scale(contrast, contrast, 3) #make grayscale cv.CvtColor(contrast, grey, cv.CV_BGR2GRAY) #smooth cv.Smooth(grey, grey, cv.CV_GAUSSIAN, 3, 3) #edge detect cv.Canny(grey, canny, 20, 200, 3) #smooth again cv.Smooth(canny, canny, cv.CV_GAUSSIAN, 3, 3) #find lines lines = cv.HoughLines2(canny, storage, cv.CV_HOUGH_PROBABILISTIC, 3, math.pi / 180, 50, 150, 40) #find corners corners = getCorners(lines) #find quadrilaterals quad = findGlpyh(contrast, corners) if quad == None: return None drawQuad(image, quad) grid = readGlyph(image, quad) printGrid(grid) print '' toCoords(grid) return grid
def process_image(self, image, texture_type): spare = image #return image # get the size of the current image size = (image.width, image.height) cv.Smooth(spare, spare, cv.CV_GAUSSIAN, BLUR_SIZE, BLUR_SIZE) #out = cv.CreateImage( size, 8, 1) cannyB = cv.CreateImage(size, 8, 1) cannyR = cv.CreateImage(size, 8, 1) sobel = cv.CreateImage(size, 8, 1) yuv = cv.CreateImage(size, 8, 3) dest_canny = cv.CreateImage(size, 8, 3) gray = cv.CreateImage(size, 8, 1) cv.CvtColor(spare, yuv, cv.CV_BGR2YCrCb) cv.Split(yuv, gray, None, None, None) cv.Canny(gray, cannyB, 5, 50, 3) cv.Canny(gray, cannyR, 5, 150, 3) cv.Sobel(gray, sobel, 1, 0, 3) #cv.ConvertScale(sobel, sobel, -1, 255 ) #cv.ConvertScale(cannyR, cannyR, -1, 155 ) #cv.ConvertScale(gray, gray, -1, 255 ) #cv.ConvertScale(cannyB, cannyB, -1, 255 ) cv.Smooth(cannyR, cannyR, cv.CV_GAUSSIAN, 3, 3) cv.Smooth(cannyB, cannyB, cv.CV_GAUSSIAN, 3, 3) #cv.CvtColor( canny, canny, cv.CV_YCrCb2BGR ) #cv.Merge(sobel, gray, sobel, None, dest) cv.Merge(cannyR, cannyB, gray, None, dest_canny) #cv.Merge(sobel, sobel, sobel, None, dest_sobel) #cv.Smooth( dest, dest, cv.CV_GAUSSIAN, BLUR_SIZE, BLUR_SIZE ) #cv.ShowImage( 'canny', dest) #cv.Merge #cv.Smooth( dest_canny, dest_canny, cv.CV_GAUSSIAN, BLUR_SIZE, BLUR_SIZE ) #success = True self.prevImage = image options = {'normal': dest_canny, 'post': dest_canny} #return yuv return options[texture_type]
def processFrames(self): self.vidcap = cv2.VideoCapture(self.path) count = 0 success, image = self.vidcap.read() print success self.createWindows() while True: success, image = self.vidcap.read() if not success: return spare = cv.fromarray(image) size = (spare.width / 2, spare.height / 2) cv.Smooth(spare, spare, cv.CV_GAUSSIAN, BLUR_SIZE, BLUR_SIZE) out = cv.CreateImage(size, 8, 3) cv.PyrDown(spare, out) yuv = cv.CreateImage(size, 8, 3) gray = cv.CreateImage(size, 8, 1) canny = cv.CreateImage(size, 8, 1) sobel = cv.CreateImage(size, 8, 1) harris = cv.CreateImage(size, cv.IPL_DEPTH_32F, 1) cv.CvtColor(out, yuv, cv.CV_BGR2YCrCb) cv.Split(yuv, gray, None, None, None) cv.Canny(gray, canny, 50, 200, 3) cv.CornerHarris(gray, harris, 3) cv.Sobel(gray, sobel, 1, 0, 3) cv.ConvertScale(canny, canny, -1, 255) cv.ConvertScale(sobel, sobel, -1, 255) for y in range(0, out.height): for x in range(0, out.width): harr = cv.Get2D(sobel, y, x) if harr[0] < 10e-06: cv.Circle(out, (x, y), 2, cv.RGB(155, 0, 25)) #cv2.imwrite("frame%d.jpg" % count, np.asarray(canny[:,:])) cv.ShowImage('canny', canny) #cv.ShowImage( 'harris' , harris ) cv.ShowImage('sobel', sobel) cv.ShowImage('output', out) if cv2.waitKey(1) == 27: break count += 1 return
def detect_and_draw(img): t1 = time.time() # allocate temporary images gray = cv.CreateImage((img.width, img.height), 8, 1) small_img = cv.CreateImage((cv.Round( img.width / image_scale), cv.Round(img.height / image_scale)), 8, 1) # blur the source image to reduce color noise cv.Smooth(img, img, cv.CV_BLUR, 3) hsv_img = cv.CreateImage(cv.GetSize(img), 8, 3) cv.CvtColor(img, hsv_img, cv.CV_BGR2HSV) thresholded_img = cv.CreateImage(cv.GetSize(hsv_img), 8, 1) #cv.InRangeS(hsv_img, (120, 80, 80), (140, 255, 255), thresholded_img) # White sensitivity = 15 cv.InRangeS(hsv_img, (0, 0, 255 - sensitivity), (255, sensitivity, 255), thresholded_img) # Red #cv.InRangeS(hsv_img, (0, 150, 0), (5, 255, 255), thresholded_img) # Blue #cv.InRangeS(hsv_img, (100, 50, 50), (140, 255, 255), thresholded_img) # Green #cv.InRangeS(hsv_img, (40, 50, 50), (80, 255, 255), thresholded_img) mat = cv.GetMat(thresholded_img) moments = cv.Moments(mat, 0) area = cv.GetCentralMoment(moments, 0, 0) # scale input image for faster processing cv.Resize(gray, small_img, cv.CV_INTER_LINEAR) cv.EqualizeHist(small_img, small_img) if (area > 5000): #determine the x and y coordinates of the center of the object #we are tracking by dividing the 1, 0 and 0, 1 moments by the area x = cv.GetSpatialMoment(moments, 1, 0) / area y = cv.GetSpatialMoment(moments, 0, 1) / area x = int(round(x)) y = int(round(y)) #create an overlay to mark the center of the tracked object overlay = cv.CreateImage(cv.GetSize(img), 8, 3) cv.Circle(overlay, (x, y), 2, (0, 0, 0), 20) cv.Add(img, overlay, img) #add the thresholded image back to the img so we can see what was #left after it was applied #cv.Merge(thresholded_img, None, None, None, img) t2 = time.time() message = "Color tracked!" print "detection time = %gs x=%d,y=%d" % (round(t2 - t1, 3), x, y) cv.ShowImage("Color detection", img)
def main(): """Parse the command line and set off processing.""" # parse command line opts,args = getopt(sys.argv[1:], "i") if len(args) != 1: syntax() return 1 # grab options invert = False for n,v in opts: if n == '-i': invert = True # load image grey = prepare_image(args[0], invert) size = cv.GetSize(grey) # a bit of smoothing to reduce noise smoothed = cv.CreateImage(size, cv.IPL_DEPTH_8U, 1) cv.Smooth(grey, smoothed, cv.CV_GAUSSIAN, 5, 5) # adaptive thresholding finds the letters against the numberplate # background thresholded = cv.CloneImage(grey) cv.AdaptiveThreshold(smoothed, thresholded, 255, cv.CV_ADAPTIVE_THRESH_GAUSSIAN_C, cv.CV_THRESH_BINARY_INV, 19, 9) # use a hough transform to find straight edges in the image and then # remove them - removes number plate edges to ensure that characters # don't join with the edges of the plate storage = cv.CreateMemStorage() #lines = cv.HoughLines2(thresholded, storage, cv.CV_HOUGH_PROBABILISTIC, # 1, math.pi/180, 50, 50, 2) #for line in lines: # cv.Line(thresholded, line[0], line[1], 0, 3, 4) # grab the contours from the image cont = cv.FindContours(thresholded, storage, cv.CV_RETR_CCOMP, cv.CV_CHAIN_APPROX_NONE) # grab 'good' contours col = 128 validated = [] while cont: v = validate_contour(cont,grey) if v is not None: validated.append(v) cont = cont.h_next() # overlay bounding boxes of 'good' contours on the original image result = cv.LoadImage(args[0]) clusters = cluster_fuck(set(validated)) for cluster in clusters: cv.Rectangle(result, (int(min([c.x1 for c in cluster])), int(min([c.y1 for c in cluster]))), (int(max([c.x2 for c in cluster])), int(max([c.y2 for c in cluster]))), (0,0,255)) for bbox in cluster: cv.Rectangle(result, (int(bbox.x1),int(bbox.y1)), (int(bbox.x2), int(bbox.y2)), (255,0,0)) quick_show(result)
def yellow(img): global yx global yy global bx global by #blur the source image to reduce color noise cv.Smooth(img, img, cv.CV_BLUR, 3) #convert the image to hsv(Hue, Saturation, Value) so its #easier to determine the color to track(hue) hsv_img = cv.CreateImage(cv.GetSize(img), 8, 3) cv.CvtColor(img, hsv_img, cv.CV_BGR2HSV) #limit all pixels that don't match our criteria, in this case we are #looking for purple but if you want you can adjust the first value in #both turples which is the hue range(120,140). OpenCV uses 0-180 as #a hue range for the HSV color model thresholded_img = cv.CreateImage(cv.GetSize(hsv_img), 8, 1) cv.InRangeS(hsv_img, (20, 100, 100), (30, 255, 255), thresholded_img) #yellow #determine the objects moments and check that the area is large #enough to be our object mat = cv.GetMat(thresholded_img) moments = cv.Moments(mat, 0) area = cv.GetCentralMoment(moments, 0, 0) #there can be noise in the video so ignore objects with small areas if (area > 100000): #determine the x and y coordinates of the center of the object #we are tracking by dividing the 1, 0 and 0, 1 moments by the area x = cv.GetSpatialMoment(moments, 1, 0) / area y = cv.GetSpatialMoment(moments, 0, 1) / area x = int(x) y = int(y) yx = x yy = y cv.Circle(img, (x, y), 5, (0, 0, 0), -1) cv.InRangeS(hsv_img, (100, 80, 80), (120, 255, 255), thresholded_img) #pink #determine the objects moments and check that the area is large #enough to be our object mat = cv.GetMat(thresholded_img) moments = cv.Moments(mat, 0) area = cv.GetCentralMoment(moments, 0, 0) #there can be noise in the video so ignore objects with small areas if (area > 100): x = cv.GetSpatialMoment(moments, 1, 0) / area y = cv.GetSpatialMoment(moments, 0, 1) / area x = int(x) y = int(y) bx = x by = y cv.Circle(img, (x, y), 5, (0, 0, 255), -1)
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 gaussianFilter(im, sigma): ''' Smooth an image using a Gaussian filter. ''' cvim = cv.CreateImage(im.size, cv.IPL_DEPTH_8U, im.channels) cv.Smooth(im.asOpenCV(), cvim, cv.CV_GAUSSIAN, 0, 0, sigma) return pv.Image(cvim)
def template_match(img, refimg, confidence=0.6, xwin=19, ywin=19): """ Return all matches of refimg inside img, using Template Matching. (Gratefully) borrowed from: http://stackoverflow.com/questions/7670112/finding-a-subimage-inside-a-numpy-image/9253805#9253805 Input: obj img: A numpy array representing an image obj refimg: A numpy array representing the reference image float confidence: threshold value (from [0,1]) for template matching Output: A tuple of (x,y) coodinates, w.r.t the coordinate system of img. """ # OpenCV requires either uint8, or float, but with floats it got # buggy and failed badly (I think it had to do with it not # correctly handling when 'img' had no decimals, but 'refimg' # had decimal expansions, which I suppose means that internally # OpenCV.matchTemplate does exact integer comparisons. img = img.astype('uint8') refimg = refimg.astype('uint8') I = cv.fromarray(img) ref = cv.fromarray(refimg) #I = cv.fromarray(np.copy(img)) #ref = cv.fromarray(np.copy(refimg)) I_s = cv.CreateMat(I.rows, I.cols, I.type) cv.Smooth(I, I_s, cv.CV_GAUSSIAN, param1=xwin, param2=ywin) ref_s = cv.CreateMat(ref.rows, ref.cols, ref.type) cv.Smooth(ref, ref_s, cv.CV_GAUSSIAN, param1=xwin, param2=ywin) #img = np.array(img, dtype='uint8') #refimg = np.array(refimg, dtype='uint8') result = cv.CreateMat(I_s.rows - ref_s.rows + 1, I_s.cols - ref_s.cols + 1, cv.CV_32F) cv.MatchTemplate(I_s, ref_s, result, cv.CV_TM_CCOEFF_NORMED) #result = cv2.matchTemplate(img, refimg, cv2.TM_CCOEFF_NORMED) # result is a 'similarity' matrix, with values from -1.0 (?) to 1.0, # where 1.0 is most similar to the template image. result_np = np.asarray(result) match_flatidxs = np.arange( result_np.size)[(result_np > confidence).flatten()] return [ flatidx_to_pixelidx(flatidx, result_np.shape) for flatidx in match_flatidxs ]
def main(): s = scratch.Scratch() capture = cv.CaptureFromCAM(0) cv.NamedWindow("Track", 1) while True: #capture frame frame_o = cv.QueryFrame(capture) frame = cv.CreateImage((frame_o.width * 3 / 8, frame_o.height * 3 / 8), frame_o.depth, frame_o.nChannels) cv.Resize(frame_o, frame) cv.Smooth(frame, frame, cv.CV_GAUSSIAN, 3, 3) #Convert to HSV imgHSV = cv.CreateImage(cv.GetSize(frame), 8, 3) cv.CvtColor(frame, imgHSV, cv.CV_BGR2HSV) #Thresh imgThreshed = cv.CreateImage(cv.GetSize(frame), 8, 1) cv.InRangeS(imgHSV, cv.Scalar(0, 124, 221), cv.Scalar(10, 255, 256), imgThreshed) cv.Smooth(imgThreshed, imgThreshed, cv.CV_GAUSSIAN, 3, 3) mat = cv.GetMat(imgThreshed) moments = cv.Moments(mat) moment10 = cv.GetSpatialMoment(moments, 1, 0) moment01 = cv.GetSpatialMoment(moments, 0, 1) area = cv.GetCentralMoment(moments, 0, 0) if area > 1000: posX = int(moment10 / area) posY = int(moment01 / area) if posX >= 0 and posY >= 0: print("X: " + str(posX) + ", Y: " + str(posY)) cv.Rectangle(frame, (posX - 10, posY - 10), (posX + 10, posY + 10), cv.RGB(0, 255, 0)) s.sensorupdate({'X': posX}) s.sensorupdate({'Y': posY}) cv.ShowImage("Track", frame) k = cv.WaitKey(70) if k % 0x100 == 27: break
def detect_and_draw(img, cascade): # allocate temporary images gray = cv.CreateImage((img.width, img.height), 8, 1) small_img = cv.CreateImage((cv.Round( img.width / image_scale), cv.Round(img.height / image_scale)), 8, 1) # convert color input image to grayscale cv.CvtColor(img, gray, cv.CV_BGR2GRAY) # scale input image for faster processing cv.Resize(gray, small_img, cv.CV_INTER_LINEAR) cv.EqualizeHist(small_img, small_img) window = cv.CreateImage((cv.Round(img.width), cv.Round(img.height)), 8, 3) if (cascade): t = cv.GetTickCount() faces = local_haar_detect(small_img, cascade, cv.CreateMemStorage(0), haar_scale, min_neighbors, haar_flags, min_size) t = cv.GetTickCount() - t print "detection time = %gms" % (t / (cv.GetTickFrequency() * 1000.)) channels = None if faces: for ((x, y, w, h), n) in faces: # the input to cv.HaarDetectObjects was resized, so scale the # bounding box of each face and convert it to two CvPoints pt1 = (cv.Round( (x + w * .2) * image_scale), cv.Round(y * image_scale)) pt2 = (cv.Round( (x + w * .8) * image_scale), cv.Round( (y + h) * image_scale)) window = cv.CreateImage((cv.Round(w * .6) * image_scale, cv.Round(h) * image_scale), 8, 3) cv.Smooth(window, window, cv.CV_GAUSSIAN) channels = [ cv.CreateImage((cv.Round(w * .6) * image_scale, cv.Round(h) * image_scale), 8, 1), cv.CreateImage((cv.Round(w * .6) * image_scale, cv.Round(h) * image_scale), 8, 1), cv.CreateImage((cv.Round(w * .6) * image_scale, cv.Round(h) * image_scale), 8, 1) ] cv.GetRectSubPix(img, window, (cv.Round( (pt1[0] + pt2[0]) / 2.0), cv.Round( (pt1[1] + pt2[1]) / 2.0))) cv.Rectangle(img, pt1, pt2, cv.RGB(255, 0, 0), 3, 8, 0) cv.Split(window, channels[0], channels[1], channels[2], None) result.append([ cv.Avg(channels[0])[0], cv.Avg(channels[1])[0], cv.Avg(channels[2])[0] ]) cv.ShowImage("result", img)
def edge_trackbar(position): #cv.Smooth(threshold_img,edge_img,cv.CV_BLUR,3,3,0) cv.Smooth(src, edge_img, cv.CV_BLUR, 3, 3, 0) #cv.Not(src,edge_img) #run the edge detector on threshold scale cv.Canny(src, edge_img, position, position * 3, 3) #show the image cv.ShowImage(window_edge, edge_img)
def main(): pr_window = "imagen" capture = cv.CaptureFromCAM(-1) cv.NamedWindow(pr_window, 1) # seteo tamanio de la ventana |-| comentar cuando no se necesite mostrar ventana cv.SetCaptureProperty(capture, cv.CV_CAP_PROP_FRAME_WIDTH, config.ancho) cv.SetCaptureProperty(capture, cv.CV_CAP_PROP_FRAME_HEIGHT, config.alto) delay = 0 while True: if (not (delay == 20)): delay += 1 img = cv.QueryFrame(capture) #cv.ReleaseCapture( img ) else: delay = 0 frame = cv.QueryFrame(capture) maskN = cv.CreateImage(cv.GetSize(frame), 8, 1) hsvN = cv.CloneImage(frame) cv.Smooth(frame, frame, cv.CV_BLUR, 3) cv.CvtColor(frame, hsvN, cv.CV_BGR2HSV) cv.InRangeS(hsvN, config.min_range, config.max_range, maskN) moment = cv.Moments(cv.GetMat(maskN), 0) a = cv.GetCentralMoment(moment, 0, 0) if a > config.min_area: X = int(cv.GetSpatialMoment(moment, 1, 0) / a) print "X: " + str(X) print "min: " + str(config.min_x) print "max: " + str(config.max_x) #Y = int(cv.GetSpatialMoment (moment, 0, 1) / a) if X > config.max_x: print "derecha" elif X < config.min_x: print "izquierda" else: print "centrado" else: print "objeto no detectado o muy pequeno" cv.ShowImage(pr_window, maskN) # descomentar para debug # X = int(cv.GetSpatialMoment (moment, 1, 0) / a) # print 'x: ' + str (X) + ' area: ' + str (a) # Con esto corto y salgo # if cv.WaitKey (100) != -1: # break return
def getCannyMask(image, threshold): """convert image to gray scale run the edge dector returns mask """ res = cv.GetSize(image) gray = cv.CreateImage (res, 8, 1) mask = cv.CreateImage (res, 8, 1) cv.CvtColor(image, gray, cv.CV_BGR2GRAY) cv.Smooth (gray, mask, cv.CV_BLUR, 3, 3, 0) cv.Not(gray, mask) cv.Canny(gray, mask, threshold, threshold * 3, 3) return mask