def hsvProceed(img): single = cv.CreateImage(cv.GetSize(img), 8, 1) single_c = cv.CreateImage(cv.GetSize(img), 8, 1) width = 0 height = 0 while (1): while (1): if (img[height, width][0] > 70) and (img[height, width][0] < 95) and (img[height, width][1] > 53) and ( img[height, width][1] < 230): #and(img[height,width][2]<200): single[height, width] = 255 single_c[height, width] = 255 else: single[height, width] = 0 single_c[height, width] = 0 height = height + 1 if (height == 480): height = 0 break width = width + 1 if (width == 640): break cv.Erode(single, single) cv.Dilate(single, single) cv.Erode(single_c, single_c) cv.Dilate(single_c, single_c) # cv.ShowImage("rgb",single) # cv.WaitKey() return single, single_c
def detect_no_draw(self, img): # allocate temporary images gray = cv.CreateImage((img.width, img.height), 8, 1) small_img = cv.CreateImage((cv.Round(img.width / self.image_scale), cv.Round(img.height / self.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) if self.cascade: t = cv.GetTickCount() faces = cv.HaarDetectObjects(small_img, self.cascade, cv.CreateMemStorage(0), self.haar_scale, self.min_neighbors, self.haar_flags, self.min_size) t = cv.GetTickCount() - t if faces: return True else: return False
def __init__(self, threshold=1, doRecord=True, showWindows=True): self.writer = None self.font = None self.doRecord = doRecord # Either or not record the moving object self.show = showWindows # Either or not show the 2 windows self.frame = None self.capture = cv.CaptureFromCAM(0) self.frame = cv.QueryFrame( self.capture) # Take a frame to init recorder if doRecord: self.initRecorder() self.gray_frame = cv.CreateImage(cv.GetSize(self.frame), cv.IPL_DEPTH_8U, 1) self.average_frame = cv.CreateImage(cv.GetSize(self.frame), cv.IPL_DEPTH_32F, 3) self.absdiff_frame = None self.previous_frame = None self.surface = self.frame.width * self.frame.height self.currentsurface = 0 self.currentcontours = None self.threshold = threshold self.isRecording = False self.trigger_time = 0 # Hold timestamp of the last detection if showWindows: cv.NamedWindow("Image") cv.CreateTrackbar("Detection treshold: ", "Image", self.threshold, 100, self.onThresholdChange)
def hsvProceed(img, camID): single = cv.CreateImage(cv.GetSize(img), 8, 1) single_c = cv.CreateImage(cv.GetSize(img), 8, 1) if camID == 0: v_min = 120 if camID == 1: v_min = 100 width = 0 height = 0 while (1): while (1): if (img[height, width][0] > 95) and (img[height, width][0] < 140) and (img[height, width][1] > 40) and ( img[height, width][1] < 220) and (img[height, width][2] > v_min): single[height, width] = 255.0 single_c[height, width] = 255.0 else: single[height, width] = 0.0 single_c[height, width] = 0.0 height = height + 1 if (height == 480): height = 0 break width = width + 1 if (width == 640): break cv.Erode(single, single) cv.Dilate(single, single) # cv.Erode(single_c, single_c) # cv.Dilate(single_c, single_c) # cv.ShowImage("rgb",single) # cv.WaitKey() return single, single_c
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 getthresholdedimg(im): imghsv = cv.CreateImage(cv.GetSize(im), 8, 3) # Convert image from RGB to HSV cv.CvtColor(im, imghsv, cv.CV_BGR2HSV) imgthreshold = cv.CreateImage(cv.GetSize(im), 8, 1) cv.InRangeS(imghsv, cv.Scalar(23, 100, 100), cv.Scalar(25, 255, 255), imgthreshold) # catch the orange yellow blob return imgthreshold
def hsvProceed(img, camID): #img为一三通道的HSV图像,camID #初始化 v_min = 0 h_max = 0 h_min = 0 s_max = 0 s_min = 0 width = 0 height = 0 #创建两个单通道图像 single = cv2.CreateImage(cv2.GetSize(img), 8, 1) single_c = cv2.CreateImage(cv2.GetSize(img), 8, 1) #为不同的摄像头分别设置h,s,v的阈值区间 if camID == 0: v_min = 120 h_max = 138 h_min = 95 s_max = 256 s_min = 30 if camID == 1: v_min = 10 h_max = 140 h_min = 95 s_max = 256 s_min = 30 # 提取红色部分到single,组建单通道图像 while (1): while (1): if (img[height, width][0] >= h_min) and (img[height, width][0] < h_max) and ( img[height, width][1] >= s_min) and (img[height, width][1] < s_max) and ( img[height, width][2] >= v_min): #筛选红色部分 single[height, width] = 255.0 single_c[height, width] = 255.0 else: single[height, width] = 0.0 single_c[height, width] = 0.0 height = height + 1 if (height == 480): height = 0 break width = width + 1 if (width == 640): break #形态学处理 cv2.Erode(single, single) cv2.Dilate(single, single) return single, single_c
def run(self): while True: img = self.capture.read() #blur the source image to reduce color noise cv2.blur(img, img, 3) #convert the image to hsv(Hue, Saturation, Value) so its #easier to determine the color to track(hue) hsv_img = cv2.CreateImage(cv2.GetSize(img), 8, 3) cv2.CvtColor(img, hsv_img, cv2.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 greenLower = (20, 190, 165) greenUpper = (30, 225, 220) thresholded_img = cv2.CreateImage(cv2.GetSize(hsv_img), 8, 1) cv2.InRangeS(hsv_img, greenLower, greenUpper, thresholded_img) #determine the objects moments and check that the area is large #enough to be our object moments = cv2.Moments(thresholded_img, 0) area = cv2.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 = cv2.GetSpatialMoment(moments, 1, 0) / area y = cv2.GetSpatialMoment(moments, 0, 1) / area #print 'x: ' + str(x) + ' y: ' + str(y) + ' area: ' + str(area) #create an overlay to mark the center of the tracked object overlay = cv2.CreateImage(cv2.GetSize(img), 8, 3) cv2.Circle(overlay, (x, y), 2, (255, 255, 255), 20) cv2.Add(img, overlay, img) #add the thresholded image back to the img so we can see what was #left after it was applied cv2.Merge(thresholded_img, None, None, None, img) #display the image cv2.ShowImage(color_tracker_window, img) if cv2.WaitKey(10) == 27: break
def __produce_gradient_image(self, i, scale): size = cv.GetSize(i) grey_image = cv.CreateImage(size, 8, 1) size = [s/scale for s in size] grey_image_small = cv.CreateImage(size, 8, 1) cv.CvtColor(i, grey_image, cv.CV_RGB2GRAY) df_dx = cv.CreateImage(cv.GetSize(i), cv.IPL_DEPTH_16S, 1) cv.Sobel( grey_image, df_dx, 1, 1) cv.Convert(df_dx, grey_image) cv.Resize(grey_image, grey_image_small)#, interpolation=cv.CV_INTER_NN) cv.Resize(grey_image_small, grey_image)#, interpolation=cv.CV_INTER_NN) return grey_image
def show_shapes(shapes): """ Function to show all of the shapes which are passed to it """ cv.NamedWindow("Shape Model", cv.CV_WINDOW_AUTOSIZE) # Get size for the window max_x = int(max([pt.x for shape in shapes for pt in shape.pts])) max_y = int(max([pt.y for shape in shapes for pt in shape.pts])) min_x = int(min([pt.x for shape in shapes for pt in shape.pts])) min_y = int(min([pt.y for shape in shapes for pt in shape.pts])) i = cv.CreateImage((max_x-min_x+20, max_y-min_y+20), cv.IPL_DEPTH_8U, 3) cv.Set(i, (0, 0, 0)) for shape in shapes: r = randint(0, 255) g = randint(0, 255) b = randint(0, 255) #r = 0 #g = 0 #b = 0 for pt_num, pt in enumerate(shape.pts): # Draw normals #norm = shape.get_normal_to_point(pt_num) #cv.Line(i,(pt.x-min_x,pt.y-min_y), \ # (norm[0]*10 + pt.x-min_x, norm[1]*10 + pt.y-min_y), (r, g, b)) cv.Circle(i, (int(pt.x-min_x), int(pt.y-min_y)), 2, (r, g, b), -1) cv.ShowImage("Shape Model",i)
def find_leds(thresh_img): """ Given a binary image showing the brightest pixels in an image, returns a result image, displaying found leds in from PIL import Image a rectangle """ contours = cv2.FindContours(thresh_img, cv2.CreateMemStorage(), mode=cv2.CV_RETR_EXTERNAL, method=cv2.CV_CHAIN_APPROX_NONE, offset=(0, 0)) regions = [] while contours: pts = [pt for pt in contours] x, y = zip(*pts) min_x, min_y = min(x), min(y) width, height = max(x) - min_x + 1, max(y) - min_y + 1 regions.append((min_x, min_y, width, height)) contours = contours.h_next() out_img = cv2.CreateImage(cv2.GetSize(grey_img), 8, 3) for x, y, width, height in regions: pt1 = x, y pt2 = x + width, y + height color = (0, 0, 255, 0) cv2.Rectangle(out_img, pt1, pt2, color, 2) return out_img, regions
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] = cv2.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] = cv2.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 = cv2.CreateImage(cv2.GetSize(img), img.depth, 1) cv2.Threshold(grey_img, thresh_img, thresh, 255, cv2.CV_THRESH_BINARY) return thresh_img
def detect_faces(self, image_filename): """ Detects all faces and returns a list with images and corresponding coordinates""" logging.debug( 'Start method "detect_faces" for file %s (face-detector.py)' % image_filename) cascade = cv.Load(parameter.cascadefile) # load face cascade image = cv.LoadImage(image_filename) # loads and converts image # detect and save coordinates of detected faces coordinates = cv.HaarDetectObjects( image, cascade, cv.CreateMemStorage(), parameter.scaleFactor, parameter.minNeighbors, parameter.flags, parameter.min_facesize) # Convert to greyscale - better results when converting AFTER facedetection with viola jones if image.channels == 3: logging.debug( 'Bild %s wird in Graustufenbild umgewandelt (face-detector.py)' % image_filename) grey_face = (cv.CreateImage((image.width, image.height), 8, 1)) # Create grey-scale Image cv.CvtColor(image, grey_face, cv.CV_RGB2GRAY ) # convert Image to Greyscale (necessary for SURF) image = grey_face logging.debug( '%d faces successfully detected in file %s (face-detector.py)' % (len(coordinates), image_filename)) return image, coordinates
def maxValueGarylize(image): grayimg = cv2.CreateImage(cv2.GetSize(image), image.depth, 1) for i in range(image.height): for j in range(image.width): grayimg[i, j] = max(image[i, j][0], image[i, j][1], image[i, j][2]) # cv.ShowImage('srcImage', image) cv2.ShowImage('maxGrayImage', grayimg)
def found_face(self): # global frame_copy if (not self.camera_is_on()) or (not self.find_face_is_on()): return False self.flushCameraBuffer() # this reduces the frame delay frame = cv.QueryFrame(self.capture) if frame is None: self.close_camera() return False if not frame: cv.WaitKey(0) if not self.frame_copy: self.frame_copy = cv.CreateImage((frame.width, frame.height), cv.IPL_DEPTH_8U, frame.nChannels) if frame.origin == cv.IPL_ORIGIN_TL: cv.Copy(frame, self.frame_copy) else: cv.Flip(frame, self.frame_copy, 0) if self.showVideo: result = self.detect_and_draw(self.frame_copy) else: result = self.detect_no_draw(self.frame_copy) cv.WaitKey(10) return result
def getPolar2CartImg(image, rad): imgSize = cv.GetSize(image) c = (float(imgSize[0]/2.0), float(imgSize[1]/2.0)) imgRes = cv.CreateImage((rad*3, int(360)), 8, 3) #cv.LogPolar(image,imgRes,c,50.0, cv.CV_INTER_LINEAR+cv.CV_WARP_FILL_OUTLIERS) cv.LogPolar(image,imgRes,c,60.0, cv.CV_INTER_LINEAR+cv.CV_WARP_FILL_OUTLIERS) return (imgRes)
def scanner_procces(frame, set_zbar): set_width = 100.0 / 100 set_height = 90.0 / 100 coord_x = int(frame.width * (1 - set_width) / 2) coord_y = int(frame.height * (1 - set_height) / 2) width = int(frame.width * set_width) height = int(frame.height * set_height) get_sub = cv.GetSubRect(frame, (coord_x + 1, coord_y + 1, width - 1, height - 1)) cv.Rectangle(frame, (coord_x, coord_y), (coord_x + width, coord_y + height), (255, 0, 0)) cm_im = cv.CreateImage((get_sub.width, get_sub.height), cv.IPL_DEPTH_8U, 1) cv.ConvertImage(get_sub, cm_im) image = zbar.Image(cm_im.width, cm_im.height, 'Y800', cm_im.tostring()) set_zbar.scan(image) for symbol in image: print '\033[1;32mResult : %s symbol "%s" \033[1;m' % (symbol.type, symbol.data) cv.ShowImage("webcame", frame) #cv.ShowImage("webcame2", get_sub) cv.WaitKey(10)
def DetectFace(image, faceCascade): #modified from: http://www.lucaamore.com/?p=638 min_size = (20, 20) image_scale = 1 haar_scale = 1.1 min_neighbors = 3 haar_flags = 0 # Allocate the temporary images smallImage = cv2.CreateImage((cv2.Round( image.width / image_scale), cv2.Round(image.height / image_scale)), 8, 1) # Scale input image for faster processing cv2.Resize(image, smallImage, cv2.CV_INTER_LINEAR) # Equalize the histogram cv2.EqualizeHist(smallImage, smallImage) # Detect the faces faces = cv2.HaarDetectObjects(smallImage, faceCascade, cv2.CreateMemStorage(0), haar_scale, min_neighbors, haar_flags, min_size) # If faces are found 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 = (int(x * image_scale), int(y * image_scale)) pt2 = (int((x + w) * image_scale), int((y + h) * image_scale)) cv2.Rectangle(image, pt1, pt2, cv2.RGB(255, 0, 0), 5, 8, 0) return image
def __init__(self, S1, S2): den = 2 self.width = S1 / den self.height = S2 / den self.sg = cv2.CreateImage((self.width, self.height), 8, 3) self.sgc = cv.CreateImage((self.width, self.height), 8, 3) self.hsv = cv.CreateImage((self.width, self.height), 8, 3) self.dst2 = cv.CreateImage((self.width, self.height), 8, 1) self.d = cv.CreateImage((self.width, self.height), cv.IPL_DEPTH_16S, 1) self.d2 = cv.CreateImage((self.width, self.height), 8, 1) self.b = cv.CreateImage((self.width, self.height), 8, 1) self.lastdetected = 0 self.THR = 70 self.dects = 50 # ideal number of number of lines detections self.hue = cv.CreateImage((self.width, self.height), 8, 1) self.sat = cv.CreateImage((self.width, self.height), 8, 1) self.val = cv.CreateImage((self.width, self.height), 8, 1) # stores the coordinates that make up the face. in order: p,p1,p3,p2 (i.e.) counterclockwise winding self.prevface = [(0, 0), (5, 0), (0, 5)] self.dodetection = True self.onlyBlackCubes = False self.succ = 0 # number of frames in a row that we were successful in finding the outline self.tracking = False self.win_size = 5 self.flags = 0 self.detected = 0 self.grey = cv.CreateImage((self.width, self.height), 8, 1) self.prev_grey = cv.CreateImage((self.width, self.height), 8, 1) self.pyramid = cv.CreateImage((self.width, self.height), 8, 1) self.prev_pyramid = cv.CreateImage((self.width, self.height), 8, 1) self.ff = cv.InitFont(cv.CV_FONT_HERSHEY_PLAIN, 1, 1, shear=0, thickness=1, lineType=8) self.undetectednum = 100 self.extract = False self.selected = 0 self.colors = [[] for i in range(6)] self.center_pixels = [[] for i in range(6)] self.hsvs = [[] for i in range(6)] self.assigned = [[-1 for i in range(9)] for j in range(6)] for i in range(6): self.assigned[i][4] = i self.didassignments = False # Used only for visualization purposes self.mycols = [(0, 127, 255), # orange (20, 240, 20), # green (0, 0, 255), # red (200, 0, 0), # blue (0, 255, 255), # yellow (255, 255, 255)] # white
def _build_image(self, frame): if not self._frame: self._frame = cv2.CreateImage((frame.width, frame.height), cv.IPL_DEPTH_8U, frame.nChannels) if frame.origin == cv2.IPL_ORIGIN_TL: cv2.Copy(frame, self._frame) else: cv2.Flip(frame, self._frame, 0) return IplQImage(self._frame)
def weightedAverageValueGary(image): grayimg = cv2.CreateImage(cv2.GetSize(image), image.depth, 1) for i in range(image.height): for j in range(image.width): grayimg[i, j] = 0.3 * image[i, j][0] + 0.59 * image[ i, j][1] + 0.11 * image[i, j][2] # cv2.ShowImage('srcImage', image) cv2.ShowImage('weightedGrayImage', grayimg)
def averageValueGary(image): grayimg = cv2.CreateImage(cv2.GetSize(image), image.depth, 1) for i in range(image.height): for j in range(image.width): grayimg[i, j] = (image[i, j][0] + image[i, j][1] + image[i, j][2]) / 3 # cv2.ShowImage('srcImage', image) cv2.ShowImage('averageGrayImage', grayimg)
def applyEffect(self, image, width, height): ipl_img = cv2.cv.CreateImageHeader((image.shape[1], image.shape[0]), cv.IPL_DEPTH_8U, 3) cv2.cv.SetData(ipl_img, image.tostring(), image.dtype.itemsize * 3 * image.shape[1]) gray = cv.CreateImage((width, height), 8, 1) # tuple as the first arg dst_img = cv.CreateImage(cv.GetSize(ipl_img), cv.IPL_DEPTH_8U, 3) # _16S => cv2.cv.iplimage if self.effect == 'dilate': cv.Dilate(ipl_img, dst_img, None, 5) elif self.effect == 'laplace': cv.Laplace(ipl_img, dst_img, 3) elif self.effect == 'smooth': cv.Smooth(ipl_img, dst_img, cv.CV_GAUSSIAN) elif self.effect == 'erode': cv.Erode(ipl_img, dst_img, None, 1) cv.Convert(dst_img, ipl_img) return self.ipl2tk_image(dst_img)
def to_gray(img): """ Converts the input in grey levels Returns a one channel image """ grey_img = cv2.CreateImage(cv2.GetSize(img), img.depth, 1) cv2.CvtColor(img, grey_img, cv2.CV_RGB2GRAY) return grey_img
def get_hands(image): """ Returns the hand as white on black. Uses value in HSV to determine hands.""" size = cv2.GetSize(image) hsv = cv2.CreateImage(size, 8, 3) hue = cv2.CreateImage(size, 8, 1) sat = cv2.CreateImage(size, 8, 1) val = cv2.CreateImage(size, 8, 1) hands = cv2.CreateImage(size, 8, 1) cv2.Cv2tColor(image, hsv, cv2.CV2_BGR2HSV) cv2.Split(hsv, hue, sat, val, None) cv2.ShowImage('Live', image) cv2.ShowImage('Hue', hue) cv2.ShowImage('Saturation', sat) cv2.Threshold( hue, hue, 10, 255, cv2.CV2_THRESH_TOZERO) #set to 0 if <= 10, otherwise leave as is cv2.Threshold( hue, hue, 244, 255, cv2.CV2_THRESH_TOZERO_INV) #set to 0 if > 244, otherwise leave as is cv2.Threshold(hue, hue, 0, 255, cv2.CV2_THRESH_BINARY_INV) #set to 255 if = 0, otherwise 0 cv2.Threshold( sat, sat, 64, 255, cv2.CV2_THRESH_TOZERO) #set to 0 if <= 64, otherwise leave as is cv2.EqualizeHist(sat, sat) cv2.Threshold(sat, sat, 64, 255, cv2.CV2_THRESH_BINARY) #set to 0 if <= 64, otherwise 255 cv2.ShowImage('Saturation threshold', sat) cv2.ShowImage('Hue threshold', hue) cv2.Mul(hue, sat, hands) #smooth + threshold to filter noise # cv2.Smooth(hands, hands, smoothtype=cv2.CV2_GAUSSIAN, param1=13, param2=13) # cv2.Threshold(hands, hands, 200, 255, cv2.CV2_THRESH_BINARY) cv2.ShowImage('Hands', hands) return hands
def Restore(mat): w = mat.cols h = mat.rows size = (w,h) iRestore = cv.CreateImage(size,cv.IPL_DEPTH_8U,1) for i in range(h): for j in range(w): num = -1 if (i+j)%2 == 1 else 1 iRestore[i,j] = mat[i,j][0]*num/(w*h) return iRestore
def draw_model_fitter(f): cv.NamedWindow("Model Fitter", cv.CV_WINDOW_AUTOSIZE) # Copy image i = cv.CreateImage(cv.GetSize(f.image), f.image.depth, 3) cv.Copy(f.image, i) for pt_num, pt in enumerate(f.shape.pts): # Draw normals cv.Circle(i, (int(pt.x), int(pt.y)), 2, (0,0,0), -1) cv.ShowImage("Shape Model",i) cv.WaitKey()
def display_rgb(dev, data, timestamp): global keep_running cv.Image = frame_convert.video_cv(data) img = cv.CreateImage(cv.GetSize(cv.Image), cv.IPL_DEPTH_16S, 3) cv.ShowImage('RGB', cv.Image) for x in range(1, 5): name = "img%d" % (x) cv.SaveImage('name.png', cv.Image) time.sleep(1) if cv.WaitKey(10) == 27: keep_running = False
def detect_and_draw(self, img): # allocate temporary images gray = cv.CreateImage((img.width, img.height), 8, 1) small_img = cv.CreateImage((cv.Round(img.width / self.image_scale), cv.Round(img.height / self.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) if self.cascade: t = cv.GetTickCount() faces = cv.HaarDetectObjects(small_img, self.cascade, cv.CreateMemStorage(0), self.haar_scale, self.min_neighbors, self.haar_flags, self.min_size) t = cv.GetTickCount() - t # print "time taken for detection = %gms" % (t/(cv.GetTickFrequency()*1000.)) if faces: face_found = True 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 = (int(x * self.image_scale), int(y * self.image_scale)) pt2 = (int((x + w) * self.image_scale), int((y + h) * self.image_scale)) cv.Rectangle(img, pt1, pt2, cv.RGB(255, 0, 0), 3, 8, 0) else: face_found = False cv.ShowImage("video", img) return face_found
def FImage(mat): w = mat.cols h = mat.rows size = (w,h) # iReal = cv.CreateImage(size,cv.IPL_DEPTH_8U,1) # iIma = cv.CreateImage(size,cv.IPL_DEPTH_8U,1) iAdd = cv.CreateImage(size,cv.IPL_DEPTH_8U,1) for i in range(h): for j in range(w): # iReal[i,j] = mat[i,j][0]/h # iIma[i,j] = mat[i,j][1]/h iAdd[i,j] = mat[i,j][1]/h + mat[i,j][0]/h return iAdd