# Setup the termination criteria, either 10 iteration or move by atleast 1 pt term_crit = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1) roiBox = None # Main loop while (1): ret, frame = cap.read() if roiBox is not None: # Making the frame into HSV and backproject the HSV frame hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) dst = cv2.calcBackProject([hsv], [0], roi_hist, [0, 180], 1) # Apply meanshift to get the new location ret, roiBox = cv2.CamShift(dst, roiBox, term_crit) # Draw it on image pts = cv2.boxPoints(ret) pts = np.intp(pts) cv2.polylines(frame, [pts], True, 255, 2) # Draw the center cx = (pts[0][0] + pts[1][0]) // 2 cy = (pts[0][1] + pts[2][1]) // 2 cv2.circle(frame, (cx, cy), 4, (0, 255, 0), 2) # cv2.imshow('img2',frame) # handle if the 'i' key is pressed, then go into ROI # selection mode cv2.imshow("image", frame)
vis = copy hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) # convert to HSV mask = cv2.inRange(hsv, np.array( (0., 60., 32.)), np.array( (180., 255., 255.))) # eliminate low and high saturation and value values # The next line shows which pixels are being used to make the histogram. # it sets to black all the ones that are masked away for being too over or under-saturated if showHistMask: vis[mask == 0] = 0 prob = cv2.calcBackProject([hsv], [0], hist, [0, 180], 1) prob &= mask term_crit = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1) track_box, track_window = cv2.CamShift(prob, track_window, term_crit) print("Track box:", track_box) # Extract track_box[1]. track_box[1] contains the minor and major axes of the detected object (In my case, it is a tennis ball.) tuple = track_box[1] # tuple[1] seems to be the major axis. I wrote a boolean statement to see if the major axis is smaller than 100. # If I put the tennis ball at the distance about 0.5 meters from the camera, the major axis of one tennis ball will be within 100. # However, the major axis of two tennis ball will exceed 100. # Therefore, I want to use this method to solve the problem that two tennis balls are circled together even if they are separated. flag = tuple[1] < 100 # I print out the result. print(tuple[1]) print(flag) # However, I found that even if flag is False, the "if statement" still works and draw an ellipse. I don't know why this happens. if showBackProj and flag:
def cam_shift(frame): hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) dst = cv2.calcBackProject([hsv], [0], roi_hist, [0, 180], 1) ret, track_window = cv2.CamShift(dst, track_window, termination)
def run(self, frame): global Update global MorphOps global Channel global Realtime y = None if True: self.frame = frame.copy() vis = self.frame.copy() hsv = cv2.cvtColor(self.frame, cv2.COLOR_BGR2HSV) mask = cv2.inRange(hsv, np.array((0., 60., 32.)), np.array((180., 255., 255.))) mask = cv2.inRange(hsv, np.array((0., 0., 0.)), np.array((180., 255., 255.))) if self.selection: x0, y0, x1, y1 = self.selection self.track_window = (x0, y0, x1 - x0, y1 - y0) hsv_roi = hsv[y0:y1, x0:x1] mask_roi = mask[y0:y1, x0:x1] if Channel: hist = cv2.calcHist([hsv_roi], [0, 1], mask_roi, [16, 5], [0, 180, 0, 256]) else: hist = cv2.calcHist([hsv_roi], [0], mask_roi, [16], [0, 180]) cv2.normalize(hist, hist, 0, 255, cv2.NORM_MINMAX) self.hist = hist.reshape(-1) self.show_hist() vis_roi = vis[y0:y1, x0:x1] cv2.bitwise_not(vis_roi, vis_roi) vis[mask == 0] = 0 if self.tracking_state == 2: if Channel: prob = cv2.calcBackProject([hsv], [0, 1], self.hist, [0, 180, 0, 256], 1) else: prob = cv2.calcBackProject([hsv], [0], self.hist, [0, 180], 1) prob &= mask term_crit = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1) self.previous_window = self.track_window kernel = np.ones((5, 5), np.uint8) if MorphOps: prob = cv2.morphologyEx(prob, cv2.MORPH_OPEN, kernel) prob = cv2.morphologyEx(prob, cv2.MORPH_CLOSE, kernel) prob = cv2.GaussianBlur(prob, (5, 5), 0) track_box, self.track_window = cv2.CamShift( prob, self.track_window, term_crit) if get_window_size(self.track_window) <= size_treshold: self.track_window = get_increased_window( self.previous_window) self.tracking_state = 2 else: self.tracking_state = 1 font = cv2.FONT_HERSHEY_SIMPLEX # print "Target Missing." cv2.putText(vis, 'Target Missing', (10, 400), font, 1, (255, 255, 255), 2, 1) if self.tracking_state == 1: self.selection = None if Channel: prob = cv2.calcBackProject([hsv], [0, 1], self.hist, [0, 180, 0, 256], 1) else: prob = cv2.calcBackProject([hsv], [0], self.hist, [0, 180], 1) prob &= mask term_crit = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1) self.previous_window = self.track_window kernel = np.ones((5, 5), np.uint8) if MorphOps: prob = cv2.morphologyEx(prob, cv2.MORPH_OPEN, kernel) prob = cv2.morphologyEx(prob, cv2.MORPH_CLOSE, kernel) prob = cv2.GaussianBlur(prob, (5, 5), 0) track_box, self.track_window = cv2.CamShift( prob, self.track_window, term_crit) if get_window_size(self.track_window) <= size_treshold: self.track_window = get_increased_window( self.previous_window) self.tracking_state = 2 if self.show_backproj: vis[:] = prob[..., np.newaxis] xx0, yy0, xx1, yy1 = self.track_window img_roi = self.frame[yy0:yy0 + yy1, xx0:xx0 + xx1] cv2.imshow("Tracking Window", img_roi) if get_window_size( self.track_window) >= size_treshold and Update: self.bkp = self.hist font = cv2.FONT_HERSHEY_SIMPLEX cv2.putText(vis, 'Updating...', (10, 200), font, 1, (255, 255, 255), 2, 1) xx0, yy0, xx1, yy1 = self.track_window xx1 /= 3 yy1 /= 3 xx0 += xx1 yy0 += yy1 if xx1 > 0 and yy1 > 0: # print self.track_window hsv_roi = hsv[yy0:yy0 + yy1, xx0:xx0 + xx1] mask_roi = mask[yy0:yy0 + yy1, xx0:xx0 + xx1] cv2.imshow("Tracking Window", hsv_roi) hist = cv2.calcHist([hsv_roi], [0], mask_roi, [16], [0, 180]) cv2.normalize(hist, hist, 0, 255, cv2.NORM_MINMAX) # print cv2.compareHist(hist.reshape(-1), self.bkp, 0) self.hist = hist.reshape(-1) self.show_hist() if not Realtime: Update = not Update font = cv2.FONT_HERSHEY_SIMPLEX cv2.putText(vis, str(track_box[0]), (10, 400), font, 1, (255, 255, 255), 2, 1) y = track_box[0] mark.draw_machine_mark(60, track_box[0], vis) if flag: height, width, _ = vis.shape if y: for i in range(1, 5): draw_rect(vis, depth=i, angle=(y[0] - width / 2) / 10) cv2.imshow('camshift', vis) ch = 0xFF & cv2.waitKey(50) if ch == 27: return if ch == ord('b'): self.show_backproj = not self.show_backproj if ch == ord('m'): MorphOps = not MorphOps if ch == ord('c'): Channel = not Channel if ch == ord('u'): Update = not Update if ch == ord('r'): Realtime = not Realtime return y
def camshift(cap, rec, initial_left, initial_top, initial_width, initial_height): ret, frame = cap.read() track_window = (initial_left, initial_top, initial_width, initial_height) # set up the ROI for tracking roi = frame[initial_top:initial_top + initial_height, initial_left:initial_left + initial_width] hsv_roi = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV) # 60, 32 #255 mask = cv2.inRange(hsv_roi, np.array((0., 60., 32.)), np.array((180., 255., 255.))) roi_hist = cv2.calcHist([hsv_roi], [0], mask, [20], [0, 180]) cv2.normalize(roi_hist, roi_hist, 0, 255, cv2.NORM_MINMAX) # Setup the termination criteria, either 10 iteration or move by atleast 1 pt term_crit = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1) # thresholds search_range_th = 15 rec_size_th = 140 dist_th = 30 scale_th = 1.8 target_center = (0, 0) past_target_center = (0, 0) color = (49, 78, 234) start_flag = False end_flag = False while (True): ret, frame = cap.read() if ret == True: hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) dst = cv2.calcBackProject([hsv], [0], roi_hist, [0, 180], 1) # apply camshift to get the new location ret, track_window = cv2.CamShift(dst, track_window, term_crit) x, y, w, h = track_window target_center = (x + int(w / 2), y + int(h / 2)) height, width = frame.shape[:2] # threshold process # size threshold if w > rec_size_th or h > rec_size_th: # print("over size") break # frame range threshold elif target_center[0] < search_range_th or target_center[1] < search_range_th or \ target_center[0] > width-search_range_th or \ target_center[1] > height-search_range_th: # print("over range") break # cener distance and rectangle scale threshold elif start_flag is True: dist = np.linalg.norm( np.asarray(past_target_center) - np.asarray(target_center)) w_scale = w / past_w h_scale = h / past_h # print(w_scale) # print(h_scale) # print() if dist > dist_th: # print("over dist") break elif w_scale > scale_th and h_scale > scale_th: # print("over scale") break # Draw it on image tracking_result = cv2.rectangle(frame, (x, y), (x + w, y + h), color, 2) cv2.circle(tracking_result, target_center, 2, (0, 215, 253), 2) cv2.putText(tracking_result, 'Tracking with Camshift ...', (10, 18), cv2.FONT_HERSHEY_SIMPLEX, 0.7, color, 2) cv2.putText(tracking_result, 'TARGET', (x, y + h + 25), cv2.FONT_HERSHEY_SIMPLEX, 0.6, color, 2) # pts = cv2.boxPoints(ret) # pts = np.int0(pts) # img2 = cv2.polylines(frame,[pts],True, (0,255,0),2) cv2.imshow('video', tracking_result) k = cv2.waitKey(60) & 0xff if k == 27: end_flag = True past_target_center = target_center past_w = w past_h = h start_flag = True if not rec == False: rec.write(tracking_result) else: break return end_flag
def run(self): while True: self.frame = get_video() self.depth = get_depth() vis = self.frame.copy() vis1 = self.depth.copy() hsv = cv2.cvtColor(self.frame, cv2.COLOR_BGR2HSV) mask = cv2.inRange(hsv, np.array((0., 60., 32.)), np.array((180., 255., 255.))) if self.selection: x0, y0, x1, y1 = self.selection self.track_window = (x0, y0, x1 - x0, y1 - y0) hsv_roi = hsv[y0:y1, x0:x1] mask_roi = mask[y0:y1, x0:x1] hist = cv2.calcHist([hsv_roi], [0], mask_roi, [16], [0, 180]) cv2.normalize(hist, hist, 0, 255, cv2.NORM_MINMAX) self.hist = hist.reshape(-1) self.show_hist() vis_roi = vis[y0:y1, x0:x1] cv2.bitwise_not(vis_roi, vis_roi) vis[mask == 0] = 0 if self.tracking_state == 1: self.selection = None prob = cv2.calcBackProject([hsv], [0], self.hist, [0, 180], 1) prob &= mask term_crit = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1) track_box, self.track_window = cv2.CamShift( prob, self.track_window, term_crit) xPos = track_box[0][0] yPos = track_box[0][1] #w = int(track_box[1][0]) #h = int(track_box[1][1]) xp = int(xPos) yp = int(yPos) kernel = np.ones((5, 5), np.uint8) vis1 = cv2.dilate(vis1, kernel, iterations=4) vis1 = cv2.erode(vis1, kernel, iterations=2) #vis1 = cv2.morphologyEx(vis1, cv2.MORPH_CLOSE, kernel) zPos = vis1[yp, xp] #data = str(xPos) +','+str(yPos) data = str(xPos) + ',' + str(yPos) + ',' + str(zPos) print "position - X:", str(xPos) print "position - Y:", str(yPos) print "position - Z:", str(zPos) #print "position - Z:", str(track_box) sock.sendto(str(data), (UDP_IP, UDP_PORT)) if self.show_backproj: vis[:] = prob[..., np.newaxis] try: cv2.ellipse(vis, track_box, (0, 0, 255), 2) except: print track_box cv2.imshow('camshift', vis) cv2.imshow('depth', vis1) ch = 0xFF & cv2.waitKey(5) if ch == 27: break if ch == ord('b'): self.show_backproj = not self.show_backproj cv2.destroyAllWindows()
def main(args): #Clean previous image clean_images() #Training phase model = training() vidcap = cv2.VideoCapture(args.file_name) fps = vidcap.get(cv2.CAP_PROP_FPS) width = vidcap.get(3) # float height = vidcap.get(4) # float # Define the codec and create VideoWriter object fourcc = cv2.VideoWriter_fourcc(*'XVID') out = cv2.VideoWriter('output.avi', fourcc, fps, (640, 480)) # initialize the termination criteria for cam shift, indicating # a maximum of ten iterations or movement by a least one pixel # along with the bounding box of the ROI termination = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1) roiBox = None roiHist = None success = True similitary_contour_with_circle = 0.65 # parameter count = 0 current_sign = None current_text = "" current_size = 0 sign_count = 0 coordinates = [] position = [] file = open("Output.txt", "w") while True: success, frame = vidcap.read() if not success: print("FINISHED") break width = frame.shape[1] height = frame.shape[0] #frame = cv2.resize(frame, (640,int(height/(width/640)))) frame = cv2.resize(frame, (640, 480)) print("Frame:{}".format(count)) #image = cv2.cvtColor(image, cv2.COLOR_BGR2HSV) coordinate, image, sign_type, text = localization( frame, args.min_size_components, args.similitary_contour_with_circle, model, count, current_sign) if coordinate is not None: cv2.rectangle(image, coordinate[0], coordinate[1], (255, 255, 255), 1) print("Sign:{}".format(sign_type)) if sign_type > 0 and (not current_sign or sign_type != current_sign): current_sign = sign_type current_text = text top = int(coordinate[0][1] * 1.05) left = int(coordinate[0][0] * 1.05) bottom = int(coordinate[1][1] * 0.95) right = int(coordinate[1][0] * 0.95) position = [ count, sign_type if sign_type <= 8 else 8, coordinate[0][0], coordinate[0][1], coordinate[1][0], coordinate[1][1] ] cv2.rectangle(image, coordinate[0], coordinate[1], (0, 255, 0), 1) font = cv2.FONT_HERSHEY_PLAIN cv2.putText(image, text, (coordinate[0][0], coordinate[0][1] - 15), font, 1, (0, 0, 255), 2, cv2.LINE_4) tl = [left, top] br = [right, bottom] print(tl, br) current_size = math.sqrt( math.pow((tl[0] - br[0]), 2) + math.pow((tl[1] - br[1]), 2)) # grab the ROI for the bounding box and convert it # to the HSV color space roi = frame[tl[1]:br[1], tl[0]:br[0]] roi = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV) #roi = cv2.cvtColor(roi, cv2.COLOR_BGR2LAB) # compute a HSV histogram for the ROI and store the # bounding box roiHist = cv2.calcHist([roi], [0], None, [16], [0, 180]) roiHist = cv2.normalize(roiHist, roiHist, 0, 255, cv2.NORM_MINMAX) roiBox = (tl[0], tl[1], br[0], br[1]) elif current_sign: hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) backProj = cv2.calcBackProject([hsv], [0], roiHist, [0, 180], 1) # apply cam shift to the back projection, convert the # points to a bounding box, and then draw them (r, roiBox) = cv2.CamShift(backProj, roiBox, termination) pts = np.int0(cv2.boxPoints(r)) s = pts.sum(axis=1) tl = pts[np.argmin(s)] br = pts[np.argmax(s)] size = math.sqrt(pow((tl[0] - br[0]), 2) + pow((tl[1] - br[1]), 2)) print(size) if current_size < 1 or size < 1 or size / current_size > 30 or math.fabs( (tl[0] - br[0]) / (tl[1] - br[1])) > 2 or math.fabs( (tl[0] - br[0]) / (tl[1] - br[1])) < 0.5: current_sign = None print("Stop tracking") else: current_size = size if sign_type > 0: top = int(coordinate[0][1]) left = int(coordinate[0][0]) bottom = int(coordinate[1][1]) right = int(coordinate[1][0]) position = [ count, sign_type if sign_type <= 8 else 8, left, top, right, bottom ] cv2.rectangle(image, coordinate[0], coordinate[1], (0, 255, 0), 1) font = cv2.FONT_HERSHEY_PLAIN cv2.putText(image, text, (coordinate[0][0], coordinate[0][1] - 15), font, 1, (0, 0, 255), 2, cv2.LINE_4) elif current_sign: position = [ count, sign_type if sign_type <= 8 else 8, tl[0], tl[1], br[0], br[1] ] cv2.rectangle(image, (tl[0], tl[1]), (br[0], br[1]), (0, 255, 0), 1) font = cv2.FONT_HERSHEY_PLAIN cv2.putText(image, current_text, (tl[0], tl[1] - 15), font, 1, (0, 0, 255), 2, cv2.LINE_4) if current_sign: sign_count += 1 coordinates.append(position) cv2.imshow('Result', image) count = count + 1 #Write to video out.write(image) if cv2.waitKey(1) & 0xFF == ord('q'): break file.write("{}".format(sign_count)) for pos in coordinates: file.write("\n{} {} {} {} {} {}".format(pos[0], pos[1], pos[2], pos[3], pos[4], pos[5])) print("Finish {} frames".format(count)) file.close() return
def run(self): while True: _ret, self.frame = self.cam.read() vis = self.frame.copy() hsv = cv2.cvtColor(self.frame, cv2.COLOR_BGR2HSV) mask = cv2.inRange(hsv, np.array((0., 60., 32.)), np.array((180., 255., 255.))) if self.selection: x0, y0, x1, y1 = self.selection hsv_roi = hsv[y0:y1, x0:x1] mask_roi = mask[y0:y1, x0:x1] hist = cv2.calcHist([hsv_roi], [0], mask_roi, [16], [0, 180]) cv2.normalize(hist, hist, 0, 255, cv2.NORM_MINMAX) self.hist = hist.reshape(-1) self.show_hist() vis_roi = vis[y0:y1, x0:x1] cv2.bitwise_not(vis_roi, vis_roi) vis[mask == 0] = 0 if self.track_window and self.track_window[ 2] > 0 and self.track_window[3] > 0: self.selection = None prob = cv2.calcBackProject([hsv], [0], self.hist, [0, 180], 1) prob &= mask term_crit = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1) track_box, self.track_window = cv2.CamShift( prob, self.track_window, term_crit) if self.show_backproj: vis[:] = prob[..., np.newaxis] try: # Magica cv2.ellipse(vis, track_box, (0, 0, 255), 2) #Envio e impressão dos dados do rastreamento X = Alema1map( track_box[0][0], 0, 640, 0, 255) #X convertido pra int variando de 0 a 640px Y = Alema1map( track_box[0][1], 0, 480, 0, 255) #Y convertido pra int variando de 0 a 480px comport.write([3, X]) #envia no serial a coordenada X comport.write([4, Y]) #envia no serial a coordenada Y print(X) print(Y) time.sleep(0.05) #comport.write(track_box [0][1])#coordenada Y #print("Coordenada X") #print(track_box [0][0])#coordenada X #a= comport.Read() #print('batatinha') #print("Coordenada Y") #print(track_box [0][1])#coordenada Y except: print('ih rapaz') cv2.imshow('SPEAR Eye', vis) ch = cv2.waitKey(5) if ch == 27: break if ch == ord('b'): self.show_backproj = not self.show_backproj cv2.destroyAllWindows()
def cmShift_tracker(v, file_name): # Open output file output_name = sys.argv[3] + file_name output = open(output_name,"w") frameCounter = 0 # read first frame ret ,frame = v.read() #debug # cv2.imshow('frame',frame) # cv2.waitKey(0) # print(type(frame),frame) if ret == False: return # detect face in first frame c,r,w,h = detect_one_face(frame) # Write track point for first frame pt_x, pt_y=c + w/2.0,r + h/2.0 #channged output.write("%d,%d,%d\n" % (frameCounter,pt_x,pt_y)) # Write as 0,pt_x,pt_y frameCounter = frameCounter + 1 # set the initial tracking window track_window = (c,r,w,h) # calculate the HSV histogram in the window # NOTE: you do not need this in the Kalman, Particle or OF trackers roi_hist = hsv_histogram_for_window(frame, (c,r,w,h)) # this is provided for you # initialize the tracker # e.g. kf = cv2.KalmanFilter(4,2,0) # or: particles = np.ones((n_particles, 2), int) * initial_pos while(1): ret ,frame = v.read() # read another frame if ret == False: break # perform the tracking # e.g. cv2.meanShift, cv2.CamShift, or kalman.predict(), kalman.correct() # use the tracking result to get the tracking point (pt): # if you track a rect (e.g. face detector) take the mid point, # if you track particles - take the weighted average # the Kalman filter already has the tracking point in the state vector hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) prob = cv2.calcBackProject([hsv], [0], roi_hist, [0, 180], 1) retval,track_window=cv2.CamShift(prob,track_window,term_crit) # Draw it on image # print(retval) pts = cv2.boxPoints(retval) pts = np.int0(pts) img2 = cv2.polylines(frame,[pts],True, 255,2) cv2.imshow('img2',img2) k = cv2.waitKey(60) & 0xff c,r,w,h=track_window # write the result to the output file output.write("%d,%d,%d\n" % (frameCounter,c + w/2.0,r + h/2.0)) # Write as frame_index,pt_x,pt_y frameCounter = frameCounter + 1 output.close()
# 1) separamos los canales y calculamos la posición de sus # valores en el histograma b, g, r = (frame // (256 // bins)).transpose(2, 0, 1) # 2) obtenemos el valor del histograma en toda la imagen # aprovechando características de numpy L = H[b, g, r] # las imágenes de float se muestran en la escala 0:negro 1:blanco cv.imshow('likelihood', L / L.max()) if True: # tracking mediante camshift de opencv term_crit = (cv.TERM_CRITERIA_EPS | cv.TERM_CRITERIA_COUNT, 10, 1) elipse, track_window = cv.CamShift(L, track_window, term_crit) cv.ellipse(frame, elipse, (0, 128, 255), 2) (c, r, w, h) = track_window cv.rectangle(frame, (c, r), (c + w, r + h), (0, 128, 255), 1) # implementación propia de mean shift # mostramos la posición anterior cv.rectangle(frame, (cm - szx, rm - szy), (cm + szx, rm + szy), (255, 128, 255), 2) # preparamos una máscara de tamaño doble para calcular la media # en un entorno del objeto mask = np.zeros_like(L, np.uint8) s = 2 # thickness = -1 rellena el rectángulo
def find_object_by_color(color=172, pctErr=.1): aoLocList = [(0, 0)] #average object location list #for each image for file_num in [str(x) for x in range(0, 7)]: #cap = cv.VideoCapture(0) #while(1): #_wtf, frame = cap.read() print "File:" + file_num + ".jpg" frame = cv.imread(file_num + '.jpg', cv.IMREAD_COLOR) print "frame.shape=", frame.shape frame_y, frame_x = frame.shape[:2] #set the default first average object location to the middle of the screen aoLocList[0] = (frame_x / 2, frame_y / 2) hsv = cv.cvtColor( frame, cv.COLOR_BGR2HSV) #Convert the captured frame from BGR to HSV # Threshold the HSV image to get only red colors #lower_red = np.array([165,100,100]) #RGB #upper_red = np.array([180,255,255]) # Threshold the HSV image to be within 10% of the requested lower_red = np.array([color * (1 - pctErr), 100, 100]) #RGB upper_red = np.array([color * (1 + pctErr), 255, 255]) mask = cv.inRange(hsv, lower_red, upper_red) kernel = np.ones((5, 5), np.uint8) eroded_mask = cv.dilate(mask, kernel, iterations=3) #DEBUG#cv.imshow('eroded_mask', eroded_mask) # Set tracking to start with the full frame track_window = (0, 0, frame_x, frame_y) print track_window # Bitwise-AND mask and original image #res = cv.bitwise_and(img,img, mask= mask) #cv.imshow('res',res) # Setup the termination criteria, either 10 iteration or move by atleast 1 pt term_crit = (cv.TERM_CRITERIA_EPS | cv.TERM_CRITERIA_COUNT, 10, 1) sys.stdout.flush() #Run camshift x times and draw the box # apply meanshift to get the new location # camshift returns tw[0]=y, tw[1]=x, tw[2]=h, tw[3]=w ret, track_window = cv.CamShift(mask, track_window, term_crit) tw = track_window # for averages we want x1+x2/2, = tw[1]+tw[1]+tw[3]/2 = 2*tw[1]+tw[3]/2 = tw1+tw3, #print "track_window (x,w,y,h) = ", track_window #DEBUG# # Draw it on image pts = cv.boxPoints(ret) pts = np.int0(pts) img = cv.polylines(frame, [pts], True, 255, 2) #cv.imshow('track', track_window) #calculate vector for each frame after camshift #aoLocList.append ((tw[1]+tw[3]/2, tw[0]+tw[2]/2)) aoLocList.append((tw[0] + tw[2] / 2, tw[1] + tw[3] / 2)) #object_vector = (aoLocList[-2][0] - aoLocList[-1][0], aoLocList[-2][1] - aoLocList[-1][1]) object_loc = aoLocList[-1] prev_object_loc = aoLocList[-2] object_vector = [ object_loc[i] - prev_object_loc[i] for i in range(len(object_loc)) ] print "aoLocList", aoLocList print "object_vector", object_vector print frame_x, frame_y #draw_arrow not working vector line #draw arrow from middle representing magnitude and direction f.draw_arrow( img, (frame_x / 2, frame_y / 2), (object_vector[0] - frame_x / 2, object_vector[1] - frame_y / 2)) #draw line from previous center to current center cv.line(img, (prev_object_loc), (object_loc), (200, 10, 40), 3) print "draw line at:", (frame_x / 2, frame_y / 2), object_vector #img = cv.line(img, (x/2, y/2), object_vector, (60,20,200)) #cv.imshow('frame', frame[tw[1]:tw[1]+tw[3], tw[0]:tw[0]+tw[2]]) cv.imwrite( os.path.join('image_results', "t_camShift" + file_num + ".jpg"), img) cv.imwrite(os.path.join('image_results', "t_mask" + file_num + ".jpg"), eroded_mask) #I would love to learn more about this method and what I'm doing wrong #roi_hist = cv.calcHist([hsv],[0],eroded_mask,[180],[10,160]) #cv.normalize(roi_hist, roi_hist, 0, 255, cv.NORM_MINMAX) #dst = cv.calcBackProject([hsv], [0], roi_hist, [20,180], 1) #cv.imwrite(os.path.join('image_results',"t_BackProp" + file_num + ".jpg"), dst) print "image saved test_" + file_num + ".jpg" sys.stdout.flush() #pause #k = cv.waitKey() #if k == 27: # wait for ESC key to exit any other key continues operation # break cv.destroyAllWindows()
def run(self): roi = self.roi self.start() while True: # for frame in self.cam.capture_continuous(self.rCa, format='bgr', use_video_port=True): #读取视频帧 ret, self.frame = self.cam.read() # self.frame = frame.array vis = self.frame.copy() # vis = copy.deepcopy(self.frame) #把图像从rgb转换为hsv颜色空间,色调 饱和度 亮度 hsv = cv2.cvtColor(self.frame, cv2.COLOR_BGR2HSV) #函数去除阈值,去除背景部分 mask = cv2.inRange(hsv, np.array((0., 60., 32.)), np.array((255., 255., 255.))) # self.selection = 1 if self.selection: # x0, y0, x1, y1 = 220, 110, 358, 245 x0, y0, x1, y1 = self.selection self.track_window = (x0, y0, x1 - x0, y1 - y0) # hsv_roi = hsv[y0:y1, x0:x1] # mask_roi = mask[y0:y1, x0:x1] hsv_roi = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV) mask_roi = cv2.inRange(hsv_roi, np.array((0., 0., 0.)), np.array((255., 255., 255.))) #一维直方图 hist = cv2.calcHist([hsv_roi], [0], mask_roi, [32], [0, 180]) #二维直方图 #hist = cv2.calcHist( [hsv_roi], [0,2],None, [180,256], [0, 180,0 , 255] ) #hist = cv2.calcHist( [hsv_roi], [0, 2],None, [180,256], [0, 180, 0, 255] ) #将绘制出来的直方图归一化,设定显示范围 cv2.normalize(hist, hist, 0, 255, cv2.NORM_MINMAX) self.hist = hist.reshape(-1) #二维直方图显示 # plt.imshow(hist,interpolation = 'nearest') # plt.show() # plt.imshow(hist,interpolation = 'nearest') # plt.show() self.show_hist() vis_roi = vis[y0:y1, x0:x1] #bitwise_not是对二进制数据进行“非”操作,即对图像(灰度图像或彩色图像均可)每个像素值进行二进制“非”操作,~1=0,~0=1 cv2.bitwise_not(vis_roi, vis_roi) vis[mask == 0] = 0 if self.tracking_state == 1: self.selection = None #反向投影 #BackProjection中存储的数值代表了测试图像中该像素属于红色、蓝色区域的概率 #这里是图像函数,channel,掩模图像,像素值范围,(可选输出反向投影的比例因子) 像素是否均匀分布 prob = cv2.calcBackProject([hsv], [0], self.hist, [0, 180], 1) prob &= mask #设置迭代的终止标准,最多十次迭代 term_crit = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1) track_box, self.track_window = cv2.CamShift( prob, self.track_window, term_crit) # if track_box[0][1] <= 240: # self.ser.write(str(int(track_box[0][0])-320) + " " + str(int(track_box[0][1])-240)) # print str(int(track_box[0][0])-320) + " " + str(int(track_box[0][1])-240) if track_box[1][1] <= 1: self.tracking_state = 0 self.start() print(track_box) print( "===================================================") else: if self.show_backproj: vis[:] = prob[..., np.newaxis] try: cv2.ellipse(vis, track_box, (0, 0, 255), 2) # print track_box # 中心的x,y坐标;宽,高;角度 a = str(track_box[0][0])+" "+str(track_box[0][1])+" "+str(round(track_box[1][0],2))\ +" "+str(round(track_box[1][1],2))+" "+str(round(track_box[2],2))+"\r\n" print(a) # self.ser.write(a) except: print(track_box) cv2.imshow('camshift', vis) ch = 0xFF & cv2.waitKey(5) if ch == 27: break if ch == ord('b'): self.show_backproj = not self.show_backproj if ch == ord('r'): self.tracking_state = 0 self.start() cv2.destroyAllWindows()
def update(self): flag = False track_window = (250, 90, 400, 125) term_crit = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1) cascade = cv2.CascadeClassifier('rpalm.xml') #setting of letters display width = cv2.VideoCapture.get(self.capture, cv2.CAP_PROP_FRAME_WIDTH) height = cv2.VideoCapture.get(self.capture, cv2.CAP_PROP_FRAME_HEIGHT) font = cv2.FONT_HERSHEY_SIMPLEX fontScale = 0.9 fontColor = (255, 255, 255) lineType = 2 bottomLeftCornerOfText = (0, int(height * 0.95)) while True: if self.capture.isOpened(): # Read frame (self.status, self.frame) = self.capture.read() self.frame = cv2.flip(self.frame, 1) key = cv2.waitKey(2) # Close program with keyboard 'q' if key == ord('q'): cv2.destroyAllWindows() exit() # Crop and display cropped image if flag: hsv = cv2.cvtColor(self.frame, cv2.COLOR_BGR2HSV) dst = cv2.calcBackProject([hsv], [0], self.roi_hist, [0, 180], 1) edges = cv2.Canny(dst, 0, 100) #cv2.imshow('canny edges',edges) rect_kernel = cv2.getStructuringElement( cv2.MORPH_ELLIPSE, (20, 20)) edges = cv2.morphologyEx(edges, cv2.MORPH_CLOSE, rect_kernel) #cv2.imshow('img after closing the edges',edges) cv2.imshow('img dst', dst) ret, thresh = cv2.threshold(dst, 100, 255, 0) contours, hierarchy = cv2.findContours( edges, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) contour_sizes = [(cv2.contourArea(contour), contour) for contour in contours] contours_poly = [None] * len(contours) boundRect = [None] * len(contours) centers = [None] * len(contours) radius = [None] * len(contours) for i, c in enumerate(contours): contours_poly[i] = cv2.approxPolyDP(c, 3, True) boundRect[i] = cv2.boundingRect(contours_poly[i]) drawing = np.zeros(thresh.shape, np.uint8) for i in range(len(contours)): color = (rng.randint(0, 256), rng.randint(0, 256), rng.randint(0, 256)) cv2.drawContours(drawing, contours_poly, i, color) #cv2.imshow('Contours', drawing) if len(contour_sizes) > 0: mask = np.zeros(thresh.shape, np.uint8) biggest_contour = max(contour_sizes, key=lambda x: x[0])[1] bRect = cv2.boundingRect( cv2.approxPolyDP(biggest_contour, 3, True)) cv2.drawContours(drawing, contours_poly, i, color) cv2.rectangle(self.frame, (int(bRect[0]), int(bRect[1])), (int(bRect[0] + bRect[2]), int(bRect[1] + bRect[3])), color, 2) cropp_img = self.frame[int(bRect[1]):int(bRect[1] + bRect[3]), int(bRect[0]):int(bRect[0] + bRect[2])] cv2.imshow("cropped", cropp_img) cv2.drawContours(mask, contours, -1, 255, -1) #cv2.imshow('mask', mask) ret, track_window = cv2.CamShift( mask, track_window, term_crit) pts = cv2.boxPoints(ret) pts = np.int0(pts) if self.translator != None: # TRANSLATION OF CROPED IMAGE l1, p1, l2, p2, l3, p3 = self.translator.translate( cropp_img) s = str(l1) + ': ' + str(round( p1, 3)) + str(' ') + str(l2) + ': ' + str( round(p2, 3)) + str(' ') + str( l3) + ': ' + str(round(p3, 3)) cv2.putText(self.frame, s, bottomLeftCornerOfText, font, fontScale, fontColor, lineType) else: while flag == False: (self.status, self.frame) = self.capture.read() key = cv2.waitKey(2) clone = self.frame.copy() flag = self.crop_ROI(cascade) if flag: self.setup_ROI_tracking() cv2.imshow('image', self.frame) cv2.imshow('image', self.frame) else: pass
hsv_roi = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV) mask = cv2.inRange(hsv_roi, np.array((0., 60., 32.)), np.array((180., 255., 255.))) roi_hist = cv2.calcHist([hsv_roi], [0], mask, [180], [0, 180]) cv2.normalize(roi_hist, roi_hist, 0, 255, cv2.NORM_MINMAX) print(roi_hist.shape) # setup the termination criteria, either 10 iteration or move by at least 1 pt term_crit = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1) cv2.imshow('roi', roi) while 1: ret, frame = cap.read() if ret: hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) dst = cv2.calcBackProject([hsv], [0], roi_hist, [0, 180], 1) ret, track_window = cv2.CamShift(dst, track_window, term_crit) # ret has value x, y, w, h, rot pts = cv2.boxPoints(ret) pts = np.int0(pts) final_img = cv2.polylines(frame, [pts], True, (255, 255, 9), 2) cv2.imshow('dst', dst) cv2.imshow('final', final_img) cv2.imshow('frame', frame) k = cv2.waitKey(1) if k == 27: break else: break cap.release() cv2.destroyAllWindows()
def main(): ap = argparse.ArgumentParser() ap.add_argument("-v", "--video", help="path to the (optional) video file") args = vars(ap.parse_args()) global frame, roiPts, inputMode, roiBoxWidth, roiBoxHeight centerX = 0 centerY = 0 if not args.get("video", False): camera = cv2.VideoCapture(0) else: camera = cv2.VideoCapture(args["video"]) cv2.namedWindow("frame") cv2.setMouseCallback("frame", selectROI) termination = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1) roiBox = None while True: (grabbed, frame) = camera.read() if not grabbed: break if roiBox is not None: hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) backProj = cv2.calcBackProject([hsv], [0], roiHist, [0, 180], 1) if roiBoxWidth > 0 and roiBoxHeight > 0: (r, roiBox) = cv2.CamShift(backProj, roiBox, termination) roiBoxWidth = roiBox[2] roiBoxHeight = roiBox[3] else: print "roiBox init !!!!!!!!!!!!!" tl[0] = 1 tl[1] = 1 br[0] = Width - 1 br[1] = Height - 1 roiBox = (tl[0], tl[1], br[0], br[1]) (r, roiBox) = cv2.CamShift(backProj, roiBox, termination) roiBoxWidth = roiBox[2] roiBoxHeight = roiBox[3] pts = np.int0(cv2.cv.BoxPoints(r)) cv2.polylines(frame, [pts], True, (0, 255, 0), 2) centerX = (pts[0][0] + pts[2][0]) / 2 centerY = (pts[0][1] + pts[2][1]) / 2 cv2.imshow("frame", frame) key = cv2.waitKey(1) & 0xFF if key == ord("i") and len(roiPts) < 4: inputMode = True orig = frame.copy() while len(roiPts) < 4: cv2.imshow("frame", frame) cv2.waitKey(0) roiPts = np.array(roiPts) s = roiPts.sum(axis=1) tl = roiPts[np.argmin(s)] br = roiPts[np.argmax(s)] roi = orig[tl[1]:br[1], tl[0]:br[0]] roi = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV) roiHist = cv2.calcHist([roi], [0], None, [16], [0, 180]) roiHist = cv2.normalize(roiHist, roiHist, 0, 255, cv2.NORM_MINMAX) roiBox = (tl[0], tl[1], br[0], br[1]) roiBoxWidth = roiBox[2] roiBoxHeight = roiBox[3] elif key == ord("q"): break camera.release() cv2.destroyAllWindows()
def main(): # construct the argument parse and parse the arguments ap = argparse.ArgumentParser() ap.add_argument("-v", "--video", help="Input a video") args = vars(ap.parse_args()) # grab the reference to the current frame, list of ROI # points and whether or not it is ROI selection mode global frame, roiPts, inputMode detector = dlib.get_frontal_face_detector() predictor = dlib.shape_predictor("shape_predictor_68_face_landmarks.dat") # if the video path was not supplied, grab the reference to the # camera if not args.get("video", False): camera = cv2.VideoCapture(0) # otherwise, load the video else: camera = cv2.VideoCapture(args["video"]) # setup the mouse callback cv2.namedWindow("frame") # cv2.setMouseCallback("frame", selectROI) # initialize the termination criteria for cam shift, indicating # a maximum of ten iterations or movement by a least one pixel # along with the bounding box of the ROI termination = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1) # initialize Variables frame, nextgray, prevgray, currROI1, currROI2, currROI3, normalizedrectangle1, normalizedrectangle2, normalizedrectangle3, nextframe, previousFrame, threshold, listtocheck, roiBox, tao = None, None, None, None, None, None, None, None, None, None, None, None, None, None, None meanlist, listoftimes, roiPts, HistoryList, prevlistforehead, prevlistfleftface, prevlistrightface, prevallpoints = [], [], [], [], [], [], [], [] a11, a22, c11, b11, b22, c22, prevframecounter, listcounter, firstframe, initframecounter, firsttimecount, cutlow, frameno, fcount = 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 inputMode, resetloop, writetext, HRready = False, False, True, False enterif, notmoving, first, thritysecs = True, True, True, True detectioncount1, detectioncount2 = 0, 0 countdowntime = 1 result = [] topleft, bottomleft, topright, bottomright = (0, 0), (0, 0), (0, 0), (0, 0) cuthigh = 10 currentcount = 5 ptsss = [(0, 0) for i in range(15)] ctd = "Calibrating" # reading the next frame frame and starting time nextframe = camera.read() start_time = time.time() # creating a file for writing textFilee = open( 'test.txt', 'w' ) #this textfile records all heart rate values until the end of video or 'q' is pressed # saving the frames as .mp4 video # fourcc = cv2.VideoWriter_fourcc(*'MP4V') # out = cv2.VideoWriter('original_vid.mp4', fourcc, 25.0, (480, 640)) # keep looping over the frames while True: # setting face not detected to begin with foundlandmark = False # resetting all the variable to initialed value when resetloop is envoked if resetloop == True: listtocheck = None firstframe = 1 initframecounter = 0 firsttimecount = 0 countdowntime = 1 resetloop = False enterif = True notmoving = True first = True # grab the current frame (grabbed, frame) = camera.read() # resizing the frame frame = cv2.resize(frame, (640, 480)) # copying the frame HSVframe = copy.copy(frame) # setting precious frame and next frame prevframe = copy.copy(nextframe) nextframe = copy.copy(frame) # check to see if we have reached the end of the # video if not grabbed: break # if the see if the ROI has been computed if roiBox is not None: # convert the current frame to the HSV color space # and perform mean shift hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) backProj = cv2.calcBackProject([hsv], [0, 1], roiHist, [0, 180, 0, 256], 1) # Now convolute with circular disc disc = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5)) cv2.filter2D(backProj, -1, disc, backProj) # threshold and binary AND ret, thresh = cv2.threshold(backProj, 50, 255, 0) thresh = cv2.merge((thresh, thresh, thresh)) skinMask = cv2.erode(thresh, disc, iterations=2) skinMask = cv2.dilate(thresh, disc, iterations=2) # blur the mask to help remove noise, then apply the # mask to the frame skinMask = cv2.GaussianBlur(thresh, (3, 3), 0) res = cv2.bitwise_and(frame, skinMask) fcount = fcount + 1 # draw a box on the indentified density (r, roiBox) = cv2.CamShift(backProj, roiBox, termination) pts = np.int0(cv2.boxPoints(r)) cv2.polylines(frame, [pts], True, (0, 255, 0), 2) # converting frame to grayscale gray = cv2.cvtColor(res, cv2.COLOR_BGR2GRAY) rects = detector(gray, 0) # declaring variables ixc, iyc, a1x, a1y, a2x, a2y, a3x, a3y, a4x, a4y, a5lx, a5y, b1x, b1y, b2x, b2y, b3x, b3y, b4x, b4y, b5y, b5x, c1x, c1y, c2x, c2y, c3x, c3y, c4x, c4y, c5x, c5y, d1x, d1y, e1x, e1y = 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 for rect in rects: # determine the facial landmarks for the face region, then # convert the facial landmark (x, y)-coordinates to a NumPy # array shape = predictor(gray, rect) shape = face_utils.shape_to_np(shape) counter = 0 # loop over the (x, y)-coordinates for the facial landmarks # and draw them on the image for (x, y) in shape: cv2.circle(frame, (x, y), 4, (0, 0, 255), -1) cv2.putText(frame, str(counter), (x, y), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (255, 255, 255), 1) # setting face as found foundlandmark = True # saving particular face landmarks for the ROI box if counter == 21: a1x = x a1y = y / 1.3 if counter == 22: a2x = x a2y = y if counter == 27: a3x = x a3y = y if counter == 8: a4x = x a4y = y if counter == 23: a5x = x a5y = y if counter == 17: b1x = x b1y = y * 1.2 if counter == 31: b2x = x b2y = y if counter == 28: b3x = x b3y = y if counter == 39: b4x = x b4y = y ixc = (a1x + a2x) / 2.2 iyc = (a4y + a3y) if counter == 26: c1x = x c1y = y / 1.2 if counter == 35: c2x = x c2y = y if counter == 28: c3x = x c3y = y if counter == 42: c4x = x c4y = y if counter == 16: d1x = x * 1.1 d1y = y if counter == 0: e1x = x / 1.15 e1y = y counter = counter + 1 firstframe = 0 initframecounter = initframecounter + 1 # co-ordinates for the rectangle listforehead = [int(a1x), int(a1y), a2x, a2y] listleftface = [int(b1x), int(b3y), b4x, b2y] listrightface = [int(c1x), int(c3y), c4x, c2y] cv2.rectangle(frame, (listforehead[0], listforehead[1]), (listforehead[2], listforehead[3]), (255, 0, 0), 2) cv2.rectangle(frame, (listleftface[0], listleftface[1]), (listleftface[2], listleftface[3]), (255, 0, 0), 2) cv2.rectangle(frame, (listrightface[0], listrightface[1]), (listrightface[2], listrightface[3]), (255, 0, 0), 2) # converting the frame to HSV HSVframe = CoverttoHSV(HSVframe) # checkig if this is the first frame if firstframe == 0: if first == True: listtocheck = listforehead firstframe = 1 first = False # setting up intital frames to measure the Bluriness value # setting up the blurriness threshold from the frist 6 seconds # checking the following frames and comparing it to the bluriness value # sharpen the frames if needed depending on the blurriness mean if (initframecounter / 2) < 6: if enterif == True: if countdowntime == 0: HistoryList.append(gray) notmoving = checkpixeldiff(listtocheck, listforehead) if notmoving == False: text = "You Moved. Starting countdown again" resetloop = True HistoryList = [] continue else: if enterif == True: initframecounter = 0 if countdowntime == 0: notmoving = checkpixeldiff(listtocheck, listforehead) if notmoving == True: enterif = False continue else: resetloop = True HistoryList = [] continue countdowntime = countdowntime - 1 if enterif == False: threshold = findvarmean(HistoryList) if cv2.Laplacian(gray, cv2.CV_64F).var() < threshold: HSVframe = cv2.bilateralFilter(HSVframe, 9, 75, 75) gaussian = cv2.GaussianBlur(HSVframe, (9, 9), 10.0) HSVframe = cv2.addWeighted(HSVframe, 1.5, gaussian, -0.5, 0, HSVframe) else: HistoryList.pop(listcounter) HistoryList.append(gray) threshold = findvarmean(HistoryList) listcounter = listcounter + 1 if listcounter == len(HistoryList): listcounter = 0 if enterif == True: currentcount = countdowntime if foundlandmark == False: ctd = "Searching For Face" else: ctd = "Calibrating" ctd2 = ctd cv2.putText(frame, ctd, (30, 30), cv2.FONT_HERSHEY_PLAIN, 1.5, (0, 0, 255)) # setting the previous ROI to cerrent ROI prevROI1 = currROI1 prevROI2 = currROI2 prevROI3 = currROI3 # setting the current ROI to next ROI currROI1 = gray[listforehead[1]:listforehead[1] + 10, listforehead[0]:listforehead[0] + 10] currROI2 = gray[listleftface[1]:listleftface[1] + 10, listleftface[0]:listleftface[0] + 10] currROI3 = gray[listrightface[1]:listrightface[1] + 10, listrightface[0]:listrightface[0] + 10] pointsListRoi1, pointsListRoi2, pointsListRoi3, avelist1, avearray2, Normalizedlist = [], [], [], [], [], [ 8] # finding the middle points of the region of interest for Kalman Filter Calculation for x1 in range(1): a1 = int((listforehead[0] + listforehead[2]) / 2) + x1 b1 = int((listleftface[0] + listleftface[2]) / 2) + x1 c1 = int((listrightface[0] + listrightface[2]) / 2) + x1 for y1 in range(5): a2 = int((listforehead[1] + listforehead[3]) / 2) + y1 b2 = int((listleftface[1] + listleftface[3]) / 2) + y1 c2 = int((listrightface[1] + listrightface[3]) / 2) + y1 tup1 = (a1, a2) tup2 = (b1, b2) tup3 = (c1, c2) pointsListRoi1.append(tup1) pointsListRoi2.append(tup2) pointsListRoi3.append(tup3) allPoints = pointsListRoi1 + pointsListRoi2 + pointsListRoi3 d = 0 # if face is found if foundlandmark == True: # seeting the previous to current prevlistforehead = listforehead prevlistleftface = listleftface prevlistrightface = listrightface prevallpoints = allPoints topright = (pts[0][0], pts[0][1]) bottomright = (pts[1][0], pts[1][1]) topleft = (pts[3][0], pts[3][1]) bottomleft = (pts[2][0], pts[2][1]) # Passing the points to the Kalman filter ptsss = kalman_filter(topleft, bottomleft, topright, bottomright, allPoints, foundlandmark) # finding the length of the ROI a11 = int(abs(listforehead[0] - listforehead[2]) / 4) b11 = int(abs(listleftface[0] - listleftface[2]) / 4) c11 = int(abs(listrightface[0] - listrightface[2]) / 4) a22 = int(abs(listforehead[1] - listforehead[3]) / 4) b22 = int(abs(listleftface[1] - listleftface[3]) / 4) c22 = int(abs(listrightface[1] - listrightface[3]) / 4) ptsss2 = [ptsss[0], ptsss[5], ptsss[10]] # Finding the HSV value of the points of the ROI and storing it for xaxis in range(ptsss[0][0] - a11, ptsss[0][0] + a11): for yaxis in range(ptsss[0][1] - a22, ptsss[0][1] + a22): Normalizedlist.append(HSVframe[yaxis][xaxis][0]) cv2.circle(frame, (ptsss[0][0], ptsss[0][1]), 8, (0, 0, 255), -1) for xaxis in range(ptsss[5][0] - b11, ptsss[5][0] + b11): for yaxis in range(ptsss[5][1] - b22, ptsss[5][1] + b22): Normalizedlist.append(HSVframe[yaxis][xaxis][0]) cv2.circle(frame, (ptsss[5][0], ptsss[5][1]), 8, (0, 0, 255), -1) for xaxis in range(ptsss[10][0] - c11, ptsss[10][0] + c11): for yaxis in range(ptsss[5][1] - c22, ptsss[5][1] + c22): Normalizedlist.append(HSVframe[yaxis][xaxis][0]) cv2.circle(frame, (ptsss[10][0], ptsss[10][1]), 8, (0, 0, 255), -1) avearray2 = np.asarray(Normalizedlist) # taking the mean of the ROi totalmean = int(np.mean(avearray2)) else: # When face not found work with previous values # Passing the points to the Kalman filter ptsss = kalman_filter(topleft, bottomleft, topright, bottomright, ptsss, foundlandmark) ptsss2 = [ptsss[0], ptsss[5], ptsss[10]] # Finding the HSV value of the points of the ROI and storing it for xaxis in range(ptsss[0][0] - a11, ptsss[0][0] + a11): for yaxis in range(ptsss[0][1] - a22, ptsss[0][1] + a22): Normalizedlist.append(HSVframe[yaxis][xaxis][0]) # cv2.circle(frame, (ptsss[0][0], ptsss[0][1]), 8, (0, 0, 255), -1) for xaxis in range(ptsss[5][0] - b11, ptsss[5][0] + b11): for yaxis in range(ptsss[5][1] - b22, ptsss[5][1] + b22): Normalizedlist.append(HSVframe[yaxis][xaxis][0]) # cv2.circle(frame, (ptsss[5][0], ptsss[5][1]), 8, (0, 0, 255), -1) for xaxis in range(ptsss[10][0] - c11, ptsss[10][0] + c11): for yaxis in range(ptsss[5][1] - c22, ptsss[5][1] + c22): Normalizedlist.append(HSVframe[yaxis][xaxis][0]) # cv2.circle(frame, (ptsss[10][0], ptsss[10][1]), 8, (0, 0, 255), -1) avearray2 = np.asarray(Normalizedlist) # Taking the mean of the ROI totalmean = int(np.mean(avearray2)) # upldating frame number and storing the mean frameno = frameno + 1 end_time = time.time() #record end time of program meanlist.append(totalmean) listoftimes.append(frameno) # converting to numpy array alll = np.asarray(meanlist) nptime = np.asarray(listoftimes) loop = False if foundlandmark == False: detectioncount1 = detectioncount1 + 1 else: detectioncount1 = 0 if detectioncount1 == 20: loop = True detectioncount1 = 0 if foundlandmark == False and loop == True: roiPts = [] roiBox = None # checking if enough samples are collected # Following is all the signal processing steps if len( alll ) >= 125 + cutlow: # fps = 30 frames/second, 300frames = 10 second window (30frames *10seconds) HRready = True global hr FPS = 25.00 WINDOW_TIME_SEC = 5 WINDOW_SIZE = int(np.ceil(WINDOW_TIME_SEC * FPS)) windowStart = len(alll) - WINDOW_SIZE window = alll[windowStart:windowStart + WINDOW_SIZE] window = np.asarray(window) # ica = FastICA(whiten=False) window = (window - np.mean(window, axis=0)) / np.std( window, axis=0) # signal normalization window = np.reshape(window, (125, 1)) # S = ica.fit_transform(window) # ICA Part fs = FPS lowcut = 0.75 highcut = 2.5 detrend = scipy.signal.detrend(window) y = butter_bandpass_filter(detrend, lowcut, highcut, fs, order=5) powerSpec = np.abs(np.fft.fft(y, axis=0))**2 freqs = np.fft.fftfreq(window.shape[0], 1.0 / fs) MIN_HR_BPM = 45.0 MAX_HR_BMP = 150.0 MAX_HR_CHANGE = 2.0 SEC_PER_MIN = 60 maxPwrSrc = np.max(powerSpec, axis=1) validIdx = np.where((freqs >= MIN_HR_BPM / SEC_PER_MIN) & (freqs <= MAX_HR_BMP / SEC_PER_MIN)) validPwr = maxPwrSrc[validIdx] validFreqs = freqs[validIdx] maxPwrIdx = np.argmax(validPwr) hr = validFreqs[maxPwrIdx] cutlow = cutlow + FPS out6 = hr * 60 result.append(out6) ave = np.asarray(result) out6 = int(np.mean(ave)) global previous previous = out6 # lock2.acquire() # uncomment this if graph is required textFile = open( 'bpmTemp.txt', 'w' ) #this textfile updates the graph if graph option is uncommented textFile.write(str(out6)) textFile.close() # lock2.release() # uncomment this if graph is required tao = str('%.2f' % (out6)) ce = 'BPM: ' + tao if enterif == False: cv2.putText(frame, ce, (30, 30), cv2.FONT_HERSHEY_PLAIN, 1.5, (0, 0, 255)) if writetext == True: textFilee.write( tao + '\n' ) #this textfile records all heart rate values until the end of video or 'q' is pressed else: if enterif == False: if HRready == False: if foundlandmark == False: ctd = "Searching For Face" else: ctd = "Calibrating" cv2.putText(frame, ctd, (30, 30), cv2.FONT_HERSHEY_PLAIN, 1.5, (0, 0, 255)) else: t = str('%.2f' % out6) fe = 'BPM: ' + t cv2.putText(frame, fe, (30, 30), cv2.FONT_HERSHEY_PLAIN, 1.5, (0, 0, 255)) cv2.imshow("frame", frame) cv2.imwrite("frame.jpg", frame) # out.write(frame) #comment out if saving video output key = cv2.waitKey(1) & 0xFF # handle if the 'i' key is pressed, then go into ROI # selection mode if len(roiPts) < 4: #if len(roiPts) < 4: # indicate that we are in input mode and clone the # frame inputMode = True orig = frame.copy() # keep looping until 4 reference ROI points have # been selected; press any key to exit ROI selction # mode once 4 points have been selected while len(roiPts) < 4: foundface = False face_cascade = cv2.CascadeClassifier( 'haarcascade_frontalface_default.xml') gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) faces = face_cascade.detectMultiScale(gray, 1.3, 5) top1 = (0, 0) top2 = (0, 0) bottom1 = (0, 0) bottom2 = (0, 0) for (x, y, w, h) in faces: foundface = True cv2.rectangle(frame, (int(x + 0.2 * w), y), (int(x + 0.8 * w), int(y + 0.78 * h)), (255, 0, 0), 2) top1 = (int(x + 0.2 * w), y) top2 = (int(x + 0.8 * w), y) bottom1 = (int(x + 0.2 * w), int(y + 0.78 * h)) bottom2 = (int(x + 0.8 * w), int(y + 0.78 * h)) cv2.imshow("frame", frame) # cv2.waitKey(0) if foundface == True: roiPts.append(top1) roiPts.append(top2) roiPts.append(bottom1) roiPts.append(bottom2) # determine the top-left and bottom-right points roiPts = np.array(roiPts) s = roiPts.sum(axis=1) tl = roiPts[np.argmin(s)] br = roiPts[np.argmax(s)] # grab the ROI for the bounding box and convert it # to the HSV color space roi = orig[tl[1]:br[1], tl[0]:br[0]] roi = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV) # roi = cv2.cvtColor(roi, cv2.COLOR_BGR2LAB) # compute a HSV histogram for the ROI and store the # bounding box roiHist = cv2.calcHist([roi], [0, 1], None, [180, 256], [0, 180, 0, 256]) roiHist = cv2.normalize(roiHist, roiHist, 0, 255, cv2.NORM_MINMAX) roiBox = (tl[0], tl[1], br[0], br[1]) # if the 'q' key is pressed, stop the loop elif key == ord("q"): break # Press T for text file writing elif key == ord("t"): writetext = True # textFile.close() textFilee.close() # cleanup the camera and close any open windows camera.release() # out.release() #comment out if saving video output cv2.destroyAllWindows()
def main(): global frame_histogram global track_window global capture # Capture camera device 0 (webcam) capture = cv2.VideoCapture(0) # Capture first frame success, frame = capture.read() if (not success): print "[Tracking] Error in video first capture process." # Init server server_instance = server.server() # Init algo frame, term_criteria, track_window, frame_histogram = init(frame) while (True): # Link mouse event to handleUserInteraction() cv2.setMouseCallback('Make Baby Groot dance', handleUserInteraction) # Capture frame-by-frame success, frame = capture.read() if (not success): print "[Tracking] Error in video capture process." break # Transform image from BGR to HSV hsv_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) back_projection = cv2.calcBackProject([hsv_frame], [0], frame_histogram, [0, 180], 1) # Apply meanshift to get the new location ret, track_window = cv2.CamShift(back_projection, track_window, term_criteria) x, y, width, height = track_window[0], track_window[1], track_window[ 2], track_window[3] if (width * height > 1e-14): frame = drawROI(frame, x, y, width, height) # Call to server ratio_x = float((x + width / 2)) / float(numpy.size(frame, 0)) server_instance.sendPosition(str(ratio_x)) else: #print "[Tracking] Nothing tracked. Reset track window." x, y, width, height = 250, 400, 125, 90 track_window = (x, y, width, height) key = cv2.waitKey(1) # Returns -1 if no key pressed if (key == ord('q')) or (key == 27): # Break if "q" or "esc" pressed break # Display the resulting frame cv2.imshow('Make Baby Groot dance', frame) cv2.imshow('Tracking', back_projection) #cv2.imshow('HSV',hsv_frame) # When everything done, release the capture capture.release() cv2.destroyAllWindows() return
print( "암호가 맞습니다." ) cv2.waitKey( 0 ) quit() else: cv2.imwrite( 'Result.jpg', frame ) print( '암호가 새로 저장되었습니다. 다시 암호를 풀어주세요' ) start = False # 이 while 문 종료하고, 다시 C를 누를 때까지 체크 # 검사 # Q를 누를 때까지 암호 만들기 while trackWindow is not None: _, frame = cam.read() HSV = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) dst = cv2.calcBackProject( [HSV], [0], roi_hist, [0, 180], 1 ) termination = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1) getData, trackWindow = cv2.CamShift( dst, trackWindow, termination ) pts = cv2.boxPoints( getData ) pts = np.int0( pts ) Show_frame = cv2.polylines( frame, [pts], True, (0, 255, 0), 2 ) cv2.imshow('Showing', Show_frame) except: pass cv2.destroyAllWindows() quit()
def testCamshiftSelectROI(self): # from ComputerVisionOnline # http://www.computervisiononline.com/blog/tutorial-using-camshift-track-objects-video #ap = argparse.ArgumentParser() #ap.add_argument("-v", "--video", # help = "path to the (optional) video file") #args = vars(ap.parse_args()) # grab the reference to the current frame, list of ROI # points and whether or not it is ROI selection mode #global frame, roiPts, inputMode # if the video path was not supplied, grab the reference to the # camera #if not args.get("video", False): camera = cv2.VideoCapture(0) # otherwise, load the video #else: # camera = cv2.VideoCapture(args["video"]) # setup the mouse callback cv2.namedWindow("frame") cv2.setMouseCallback("frame", self.utilSelectROI) # initialize the termination criteria for cam shift, indicating # a maximum of ten iterations or movement by a least one pixel # along with the bounding box of the ROI termination = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1) roiBox = None # keep looping over the frames while True: # grab the current frame (grabbed, self.frame) = camera.read() self.frame = self.utilResizeImgIsoScale(self.frame) # check to see if we have reached the end of the # video if not grabbed: break # if the see if the ROI has been computed if roiBox is not None: # convert the current frame to the HSV color space # and perform mean shift hsv = cv2.cvtColor(self.frame, cv2.COLOR_BGR2HSV) backProj = cv2.calcBackProject([hsv], [0], roiHist, [0, 180], 1) cv2.imshow("backProj", backProj) # apply cam shift to the back projection, convert the # points to a bounding box, and then draw them (r, roiBox) = cv2.CamShift(backProj, roiBox, termination) pts = np.int0(cv2.cv.BoxPoints(r)) cv2.polylines(self.frame, [pts], True, (0, 255, 0), 2) # show the frame and record if the user presses a key cv2.imshow("frame", self.frame) key = cv2.waitKey(1) & 0xFF # handle if the 'i' key is pressed, then go into ROI # selection mode if key == ord("i") and len(self.roiPts) < 4: # indicate that we are in input mode and clone the # frame self.inputMode = True orig = self.frame.copy() # keep looping until 4 reference ROI points have # been selected; press any key to exit ROI selction # mode once 4 points have been selected while len(self.roiPts) < 4: cv2.imshow("frame", self.frame) cv2.waitKey(0) # determine the top-left and bottom-right points self.roiPts = np.array(self.roiPts) s = self.roiPts.sum(axis=1) tl = self.roiPts[np.argmin(s)] br = self.roiPts[np.argmax(s)] # grab the ROI for the bounding box and convert it # to the HSV color space roi = orig[tl[1]:br[1], tl[0]:br[0]] roi = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV) #roi = cv2.cvtColor(roi, cv2.COLOR_BGR2LAB) # compute a HSV histogram for the ROI and store the # bounding box roiHist = cv2.calcHist([roi], [0], None, [16], [0, 180]) roiHist = cv2.normalize(roiHist, roiHist, 0, 255, cv2.NORM_MINMAX) roiBox = (tl[0], tl[1], br[0], br[1]) # if the 'q' key is pressed, stop the loop elif key == ord("q"): break # cleanup the camera and close any open windows camera.release() cv2.destroyAllWindows()
def color_tracking(drone_vision:DroneVisionGUI, bebop:Bebop): def show_hist(hist): """Takes in the histogram, and displays it in the hist window.""" bin_count = hist.shape[0] bin_w = 24 img = np.zeros((256, bin_count * bin_w, 3), np.uint8) for i in range(bin_count): h = int(hist[i]) cv2.rectangle(img, (i * bin_w + 2, 255), ((i + 1) * bin_w - 2, 255 - h), (int(180.0 * i / bin_count), 255, 255), -1) img = cv2.cvtColor(img, cv2.COLOR_HSV2BGR) cv2.imshow('hist', img) showBackProj = False showHistMask = False frame = drone_vision.get_latest_valid_picture() if frame is not None: (hgt, wid, dep) = frame.shape cv2.namedWindow('camshift') cv2.namedWindow('hist') cv2.moveWindow('hist', 700, 100) # Move to reduce overlap # Initialize the track window to be the whole frame track_window = (0, 0, wid, hgt) # # Initialize the histogram from the stored image # Here I am faking a stored image with just a couple of blue colors in an array # you would want to read the image in from the file instead histImage = np.array([[[110, 70, 50]], [[111, 128, 128]], [[115, 100, 100]], [[117, 64, 50]], [[117, 200, 200]], [[118, 76, 100]], [[120, 101, 210]], [[121, 85, 70]], [[125, 129, 199]], [[128, 81, 78]], [[130, 183, 111]]], np.uint8) histImage = cv2.imread('orange.jpg') histImage = cv2.cvtColor(histImage,cv2.COLOR_BGR2HSV) maskedHistIm = cv2.inRange(histImage, np.array((0., 60., 32.)), np.array((180., 255., 255.))) cv2.imshow("masked",maskedHistIm) cv2.imshow("histim",histImage) hist = cv2.calcHist([histImage], [0], maskedHistIm, [16], [0, 180]) cv2.normalize(hist, hist, 0, 255, cv2.NORM_MINMAX) hist = hist.reshape(-1) show_hist(hist) # start processing frames while cv2.getWindowProperty('camshift', 0) >= 0: frame = drone_vision.get_latest_valid_picture() vis = frame.copy() hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) # convert to HSV mask = cv2.inRange(hsv, np.array((0., 60., 32.)), np.array((180., 255., 255.))) # eliminate low and high saturation and value values # The next line shows which pixels are being used to make the histogram. # it sets to black all the ones that are masked away for being too over or under-saturated if showHistMask: vis[mask == 0] = 0 prob = cv2.calcBackProject([hsv], [0], hist, [0, 180], 1) prob &= mask term_crit = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1) track_box, track_window = cv2.CamShift(prob, track_window, term_crit) print(track_box[1][0]*track_box[1][1]) if showBackProj: vis[:] = prob[..., np.newaxis] try: cv2.ellipse(vis, track_box, (0, 0, 255), 2) area = track_box[1][0]*track_box[1][1] if area > 7000: print("GOING BACK") bebop.fly_direct(roll=0,pitch=-20,yaw=0,vertical_movement=0,duration=0.5) #bebop.smart_sleep(1) elif area < 4000: print("GOING FORWARD") bebop.fly_direct(roll=0,pitch=20,yaw=0,vertical_movement=0,duration=0.5) #bebop.smart_sleep(1) except: pass # print("Track box:", track_box) cv2.imshow('camshift', vis) ch = chr(0xFF & cv2.waitKey(5)) if ch == 'q': break elif ch == 'b': showBackProj = not showBackProj elif ch == 'v': showHistMask = not showHistMask bebop.safe_land(10) cv2.destroyAllWindows()
y = 252 width = 455 - x height = 395 - y hsv_roi = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV) roi_hist = cv2.calcHist([hsv_roi], [0], None, [180], [0, 180]) cap = cv2.VideoCapture(0) term_criteria = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1) while True: _, frame = cap.read() hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) mask = cv2.calcBackProject([hsv], [0], roi_hist, [0, 180], 1) ret, track_window = cv2.CamShift(mask, (x, y, width, height), term_criteria) pts = cv2.boxPoints(ret) pts = np.int0(pts) cv2.polylines(frame, [pts], True, (255, 0, 0), 2) cv2.imshow("mask", mask) cv2.imshow("Frame", frame) key = cv2.waitKey(1) if key == 27: break cap.release() cv2.destroyAllWindows()
if not params.locked: # Calculate average color params.hsv = cv2.mean(reigon1.getROI(hsv)) # params.hsv2 = cv2.mean(reigon2.getROI(hsv)) # params.hsv3 = cv2.mean(reigon3.getROI(hsv)) mask = getMask(hsv, params.hsv) # mask = mask + getMask(hsv,params.hsv2) # mask = mask + getMask(hsv,params.hsv3) disc = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (7, 7)) cv2.filter2D(mask, -1, disc, mask) # apply meanshift to get the new location ret, track_window = cv2.CamShift(mask, track_window, term_crit) reigon2 = ROI(track_window) cv2.imshow('mask1', cv2.flip(mask, 1)) # cv2.imshow('mask2',mask2) # cv2.imshow('mask3',mask3) reigon1.drawBoundary(frame) if reigon2 is not None: reigon2.drawBoundary(frame) # reigon2.drawBoundary(frame) # reigon3.drawBoundary(frame) # cv2.imshow('original',frame)
def color_recognition(): video1 = cv2.VideoCapture(0) video2 = cv2.VideoCapture(1) _, frame1 = video1.read() _, frame2 = video2.read() h, w, _ = frame1.shape print(h, w) x1 = w/2 y1 = h/2 x2 = w/2 y2 = h/2 roi1 = cv2.imread("frame2_tubleron.jpg", 1) roi2 = cv2.imread("frame2_tubleron.jpg", 1) width1 = 300 height1 = 120 width2 = 300 height2 = 120 hsv_roi1 = cv2.cvtColor(roi1, cv2.COLOR_BGR2HSV) roi_hist1 = cv2.calcHist([hsv_roi1], [0], None, [180], [0, 180]) roi_hist1[0] = 0 roi_hist1 = cv2.normalize(roi_hist1, roi_hist1, 0, 255, cv2.NORM_MINMAX) hsv_roi2 = cv2.cvtColor(roi2, cv2.COLOR_BGR2HSV) roi_hist2 = cv2.calcHist([hsv_roi2], [0], None, [180], [0, 180]) roi_hist2[0] = 0 roi_hist2 = cv2.normalize(roi_hist2, roi_hist2, 0, 255, cv2.NORM_MINMAX) term_criteria = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1) medstack1 = [] medstack2 = [] counter1 = 1 counter2 = 1 counter3 = 1 num = 10 text_file_out = open("Output.txt", "w") text_file_out.close() text_file_out = open("location.txt", "a") text_file_location = open("location.txt", "w") text_file_location.close() text_file_location = open("location.txt", "a") x_axis = 0 y_axis = 0 z_axis = 0 while True: _, frame1 = video1.read() _, frame2 = video2.read() hsv1 = cv2.cvtColor(frame1, cv2.COLOR_BGR2HSV) mask1 = cv2.calcBackProject([hsv1], [0], roi_hist1, [0, 180], 1) # mask = cv2.dilate(mask, cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3)), iterations=3) # mask = cv2.erode(mask, cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3)), iterations=1) # smask = cv2.dilate(mask, cv2.getStructuringElement(cv2.MORPH_RECT, (20, 20)), iterations=2) satNmask1 = cv2.bitwise_and(hsv1[:, :, 1], mask1) satNmask1 = cv2.dilate(satNmask1, cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3)), iterations=3) satNmask1 = cv2.erode(satNmask1, cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3)), iterations=1) threshold_indices1 = satNmask1 < 40 satNmask1[threshold_indices1] = 0 # satNmask = cv2.dilate(satNmask, cv2.getStructuringElement(cv2.MORPH_RECT, (5, 5)), iterations=2) hsv2 = cv2.cvtColor(frame2, cv2.COLOR_BGR2HSV) mask2 = cv2.calcBackProject([hsv2], [0], roi_hist2, [0, 180], 1) # mask = cv2.dilate(mask, cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3)), iterations=3) # mask = cv2.erode(mask, cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3)), iterations=1) # smask = cv2.dilate(mask, cv2.getStructuringElement(cv2.MORPH_RECT, (20, 20)), iterations=2) satNmask2 = cv2.bitwise_and(hsv2[:, :, 1], mask2) satNmask2 = cv2.dilate(satNmask2, cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3)), iterations=3) satNmask2 = cv2.erode(satNmask2, cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3)), iterations=1) threshold_indices2 = satNmask2 < 85 satNmask2[threshold_indices2] = 0 # satNmask = cv2.dilate(satNmask, cv2.getStructuringElement(cv2.MORPH_RECT, (5, 5)), iterations=2) if counter1 < num: counter1 += 1 medstack1.append(satNmask1) median_1 = np.median(medstack1, axis=0) else: _ = medstack1.pop(0) medstack1.append(satNmask1) median_1 = np.median(medstack1, axis=0) if counter2 < num: counter2 += 1 medstack2.append(satNmask2) median_2 = np.median(medstack2, axis=0) else: _ = medstack2.pop(0) medstack2.append(satNmask2) median_2 = np.median(medstack2, axis=0) ret1, track_window1 = cv2.CamShift(median_1, (x1, y1, width1, height1), term_criteria) x1, y1, w1, h1 = track_window1 pts1 = cv2.boxPoints(ret1) # add cv. after cv2 pts1 = np.intp(pts1) cv2.polylines(frame1,[pts1],True, 255,2) cv2.circle(frame1, (x1 + int(round(0.5 * w1)), y1 + int(round(0.5 * h1))), 5, (0, 0, 255), -1) font = cv2.FONT_HERSHEY_SIMPLEX ret2, track_window2 = cv2.CamShift(median_2, (x2, y2, width2, height2), term_criteria) x2, y2, w2, h2 = track_window2 pts2 = cv2.boxPoints(ret2) # add cv. after cv2. pts2 = np.intp(pts2) cv2.polylines(frame2, [pts2], True, 255, 2) cv2.circle(frame2, (x2 + int(round(0.5 * w2)), y2 + int(round(0.5 * h2))), 5, (0, 0, 255), -1) distance = abs(x1 - x2) new_dist = 0 if distance != 0: new_dist = 5000/distance else: new_dist = new_dist cv2.putText(frame1, str(distance), ((x1 + int(round(0.5 * w1))), y1 + 4 + int(round(0.5 * h1))), font, 1, (0, 0, 255), 2) cv2.putText(frame2, str(distance), ((x2 + int(round(0.5 * w2))), y2 + 4 + int(round(0.5 * h2))), font, 1, (0, 0, 255), 2) phi = (min(x1,x2) + 0.5*abs(x1-x2) - 320) * 0.109375 theta = (min(y1,y2) + 0.5*abs(y1-y2) ) * 0.113 + 62.86 x_axis_temp = new_dist * math.sin(math.radians(theta)) * math.cos(math.radians(phi)) y_axis_temp = new_dist * math.sin(math.radians(theta)) * math.sin(math.radians(phi)) z_axis_temp = new_dist * math.cos(math.radians(theta)) if (x_axis+ y_axis+ z_axis == 0) or (abs(x_axis - x_axis_temp) <50 and abs(y_axis - y_axis_temp) <50 and abs(z_axis - z_axis_temp) <50): x_axis = x_axis_temp y_axis = y_axis_temp z_axis = z_axis_temp cv2.imshow('frame1', frame1) cv2.imshow('frame2', frame2) cv2.imshow('median_1', median_1) cv2.imshow('median_2', median_2) if counter3 == 1: #text_file_out.write("theta =%d, phi =%d, distance = %f x =%f,y =%f,z =%f \n" % (theta,phi, new_dist, x_axis, y_axis, z_axis)) text_file_location.write("%f\t%f\t%f\n" % (x_axis, y_axis, z_axis)) counter3 = 1 else: counter3 += 1 # cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2) #cv2.imshow("Mask1", mask1) #cv2.imshow("sat1",hsv1[:,:,1]) #cv2.imshow("satNmask1", satNmask1) # cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2) # cv2.imshow("Mask2", mask2) # cv2.imshow("sat2",hsv2[:,:,1]) #cv2.imshow("satNmask2", satNmask2) # cv2.imshow("average satNmask2",satNmask2_temp) key = cv2.waitKey(1) if key == 27: break video1.release() video2.release() cv2.destroyAllWindows()
def run(self): print "Step6: run" roi = self.roi self.start() imCount = 0 while True: print "Step10: run while" # for frame in self.cam.capture_continuous(self.rCa, format='bgr', use_video_port=True): ret, self.frame = self.cam.read() # self.frame = frame.array vis = self.frame.copy() # vis = copy.deepcopy(self.frame) hsv = cv2.cvtColor(self.frame, cv2.COLOR_BGR2HSV) mask = cv2.inRange(hsv, np.array((0., 60., 32.)), np.array((180., 255., 255.))) #创建一个遮罩mask # self.selection = 1 if self.selection: print "Step10: run while if selection" # x0, y0, x1, y1 = 220, 110, 358, 245 x0, y0, x1, y1 = self.selection self.track_window = (x0, y0, x1 - x0, y1 - y0) # hsv_roi = hsv[y0:y1, x0:x1] # mask_roi = mask[y0:y1, x0:x1] hsv_roi = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV) mask_roi = cv2.inRange(hsv_roi, np.array((0., 60., 32.)), np.array((180., 255., 255.))) #一维直方图 hist = cv2.calcHist([hsv_roi], [0], mask_roi, [16], [0, 180]) #二维直方图 # hist = cv2.calcHist( [hsv_roi], [0,2],None, [180,256], [0, 180,0 , 255] ) cv2.normalize(hist, hist, 0, 255, cv2.NORM_MINMAX) self.hist = hist.reshape(-1) #二维直方图显示 # plt.imshow(hist,interpolation = 'nearest') # plt.show() # self.show_hist() vis_roi = vis[y0:y1, x0:x1] cv2.bitwise_not(vis_roi, vis_roi) vis[mask == 0] = 0 if self.tracking_state == 1: print "Step11: run while if tracking_state" self.selection = None prob = cv2.calcBackProject([hsv], [0], self.hist, [0, 180], 1) prob &= mask term_crit = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1) track_box, self.track_window = cv2.CamShift( prob, self.track_window, term_crit) # if track_box[0][1] <= 240: # self.ser.write(str(int(track_box[0][0])-320) + " " + str(int(track_box[0][1])-240)) # print str(int(track_box[0][0])-320) + " " + str(int(track_box[0][1])-240) if track_box[1][1] <= 1: print "Step12: run while if tracking_state if" self.tracking_state = 0 self.start() motor.walk(0, 0) else: print "Step13: run while if tracking_state else" if self.show_backproj: vis[:] = prob[..., np.newaxis] try: print "Step14: run while if tracking_state try" cv2.ellipse(vis, track_box, (0, 0, 255), 2) # print track_box imageX = track_box[0][0] imageY = track_box[0][1] imageR = (track_box[1][0] + track_box[1][1]) / 4 visCut = vis[int(imageY - imageR):int(imageY + imageR), int(imageX - imageR):int(imageX + imageR)] imageSize = (int(100), int(100)) visResize = cv2.resize(visCut, imageSize, interpolation=cv2.INTER_AREA) visResize = cv2.medianBlur(visResize, 5) visResizeHSV = cv2.cvtColor(visResize, cv2.COLOR_BGR2HSV) #hsvWidth = visResizeHSV.width #hsvHeight = visResizeHSV.height #for i in range(0, hsvWidth): # for j in range(0, hsvHeight): #hsvTmp = cv2.cvGet2D(visResizeHSV, i, j) # hsvTmp = visResizeHSV[i, j] #hsvPoint = NULL #if not (hsvTmp[0] > 90 and hsvTmp[0] < 120): #hsvPoint.val[0] = 0 #hsvPoint.val[1] = 0 #hsvPoint.val[2] = 0 #cv2.cvSet2D(visResizeHSV, i, j, hsvPoint) # hsvTmp[0] = 0 # hsvTmp[1] = 0 # hsvTmp[2] = 0 # visResizeHSV[i, j] = hsvTmp print "visCut before" #visCut = vis[0:100, 0:100] cv2.imshow('imageCut', visCut) cv2.imshow('imageResize', visResize) #cv2.imshow('imageResize', visResizeHSV) print "visCut after" imCount = imCount + 1 imName = "./right/" + str(imCount) + ".jpg" #print "imPath = " + imPath #cv2.imwrite("imPath", visResize) cv2.imwrite(imName, visResize) a = str(track_box[0][0])+" "+str(track_box[0][1])+" "+str(round(track_box[1][0],2))\ +" "+str(round(track_box[1][1],2))+" "+str(round(track_box[2],2))+"\r\n" print a ActualCenterX = track_box[0][0] print "try1" TargetCentorX = 160 print "try2" SetX = self.PID_Center(ActualCenterX, TargetCentorX) ActualForward = (track_box[1][0] + track_box[1][1]) / 2 TargetForward = 80 if ActualForward < 80: ActualForward = 1.732 * ActualForward - 58.56 SetF = self.PID_Forward(ActualForward, TargetForward) #imageX = track_box[0][0] #imageY = track_box[0][1] #imageR = (track_box[1][0] + track[1][1]) / 2 #visCut = vis[imageX:imageY, imageR:imageR] #visCut = vis[50:50, 100:100] #cv2.imshow('imageCut', visCut) cv2.ellipse(vis, track_box, (0, 0, 255), 2) print "try3" #motor.walk(-SetX+SetF, SetX+SetF, 5) #motor.walk(SetF, SetF) print "try4" #b = "AcutualX = "+str(ActualCenterX)+" TargetX = "+str(TargetCentorX)+" SetX = "+str(SetX) #print b #print SetX # self.ser.write(a) except: traceback.print_exc() #print "Error" #print track_box cv2.imshow('camshift', vis) # cv2.imshow('imageCut', visCut) ch = 0xFF & cv2.waitKey(5) if ch == 27: break if ch == ord('b'): self.show_backproj = not self.show_backproj if ch == ord('r'): self.tracking_state = 0 self.start() cv2.destroyAllWindows()
def main(): global frame, roiPts, inputMode camera = cv2.VideoCapture(0) cv2.namedWindow("frame") cv2.setMouseCallback("frame", selectROI) termination = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1) roiBox = None while True: (grabbed, frame) = camera.read() if roiBox is not None: hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) backProj = cv2.calcBackProject([hsv], [0], roiHist, [0, 180], 1) (r, roiBox) = cv2.CamShift(backProj, roiBox, termination) pts = np.int0(cv2.cv.BoxPoints(r)) #coordinates contain the coordinates of the tracked object coordinates = r[0] # x, y contains the coordinates x = int(coordinates[0]) y = int(coordinates[1]) #print ('x = '+ str(x)) #print ('y = '+ str(y)) #move(x,y) #mouse controlling actions py.moveTo(int(x * 2.5), int(y * 2)) #draws a circle around the center from x,y cv2.circle(frame, (int(x), int(y)), 4, (0, 0, 255), 2) #draws a colored frame around the object cv2.polylines(frame, [pts], True, (0, 255, 0), 2) cv2.imshow("frame", frame) key = cv2.waitKey(1) & 0xFF # handle if the 'i' key is pressed, then go into ROI if key == ord("i") and len(roiPts) < 4: inputMode = True orig = frame.copy() while len(roiPts) < 4: cv2.imshow("frame", frame) cv2.waitKey(0) roiPts = np.array(roiPts) s = roiPts.sum(axis=1) tl = roiPts[np.argmin(s)] br = roiPts[np.argmax(s)] roi = orig[tl[1]:br[1], tl[0]:br[0]] roi = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV) roiHist = cv2.calcHist([roi], [0], None, [16], [0, 180]) roiHist = cv2.normalize(roiHist, roiHist, 0, 255, cv2.NORM_MINMAX) roiBox = (tl[0], tl[1], br[0], br[1]) # if the 'q' key is pressed, stop the loop elif key == ord("q"): break camera.release() cv2.destroyAllWindows()
def cam_tracker(v, file_name): # Open output file output_name = sys.argv[3] + file_name output = open(output_name, "w") frameCounter = 0 # read first frame ret, frame = v.read() if ret == False: return # detect face in first frame c, r, w, h = detect_one_face(frame) pt = (frameCounter, (c + w / 2), (r + h / 2)) # Write track point for first frame output.write("%d,%d,%d\n" % pt) # Write as 0,pt_x,pt_y frameCounter = frameCounter + 1 # set the initial tracking window track_window = (c, r, w, h) # calculate the HSV histogram in the window # NOTE: you do not need this in the Kalman, Particle or OF trackers roi_hist = hsv_histogram_for_window(frame, (c, r, w, h)) # this is provided for you # initialize the tracker # e.g. kf = cv2.KalmanFilter(4,2,0) # or: particles = np.ones((n_particles, 2), int) * initial_pos term_crit = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1) while (1): ret, frame = v.read() # read another frame if ret == False: break hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) dst = cv2.calcBackProject([hsv], [0], roi_hist, [0, 180], 1) ret, track_window = cv2.CamShift(dst, track_window, term_crit) (c, r, w, h) = track_window pt = (frameCounter, (c + w / 2), (r + h / 2)) pts = cv2.boxPoints(ret) pts = np.int0(pts) img2 = cv2.polylines(frame, [pts], True, 255, 2) #cv2.imshow('img2',img2) #cv2.waitKey(40) # e.g. cv2.meanShift, cv2.CamShift, or kalman.predict(), kalman.correct() # use the tracking result to get the tracking point (pt): # if you track a rect (e.g. face detector) take the mid point, # if you track particles - take the weighted average # the Kalman filter already has the tracking point in the state vector # write the result to the output file output.write("%d,%d,%d\n" % pt) # Write as frame_index,pt_x,pt_y frameCounter = frameCounter + 1 output.close()
mask = cv2.inRange(hsv_roi, np.array((150., 150., 50.)), np.array((190., 255., 255.))) roi_hist = cv2.calcHist([hsv_roi], [0], mask, [180], [0, 180]) cv2.normalize(roi_hist, roi_hist, 0, 255, cv2.NORM_MINMAX) term_crit = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1) hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) dst = cv2.calcBackProject([hsv], [0], roi_hist, [0, 180], 1) cv2.imshow('back',dst) ret, track_window = cv2.CamShift(dst, track_window, term_crit) # Draw it on image pts = cv2.boxPoints(ret) pts = np.int0(pts) img = cv2.polylines(frame, [pts], True, 255, 2) cv2.circle(img, (int(c+w/2),int(r+h/2)),3, [0,255,0]) #x, y, w, h = track_window # img2 = cv2.rectangle(frame, (x, y), (x + w, y + h), 255, 2) cv2.imshow('img',img)
def run(self): try: while True: self.frame = cv2.cvtColor(self.drone.get_image(), cv2.COLOR_BGR2RGB) vis = self.frame.copy() hsv = cv2.cvtColor(self.frame, cv2.COLOR_RGB2HSV) mask = cv2.inRange(hsv, np.array((0., 60., 32.)), np.array((180., 255., 255.))) if self.selection: x0, y0, x1, y1 = self.selection self.track_window = (x0, y0, x1-x0, y1-y0) hsv_roi = hsv[y0:y1, x0:x1] mask_roi = mask[y0:y1, x0:x1] hist = cv2.calcHist( [hsv_roi], [0], mask_roi, [16], [0, 180] ) cv2.normalize(hist, hist, 0, 255, cv2.NORM_MINMAX); self.hist = hist.reshape(-1) self.show_hist() vis_roi = vis[y0:y1, x0:x1] cv2.bitwise_not(vis_roi, vis_roi) vis[mask == 0] = 0 if self.tracking_state == 1: try: self.selection = None prob = cv2.calcBackProject([hsv], [0], self.hist, [0, 180], 1) prob &= mask term_crit = ( cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1 ) track_box, self.track_window = cv2.CamShift(prob, self.track_window, term_crit) if self.show_backproj: vis[:] = prob[...,np.newaxis] try: cv2.ellipse(vis, track_box, (0, 0, 255), 2) except: print track_box x_distance = 2*(track_box[0][0] / hsv.shape[1]) - 1 x_speed = 0.5 * x_distance y_distance = 2*(track_box[0][1] / hsv.shape[0]) - 1 y_speed = -0.2 * y_distance z_distance = np.min([(track_box[1][0] / hsv.shape[0]), (track_box[1][1] / hsv.shape[0])]) - 0.4 # Both sizes relative to y of image z_speed = -0.3 * z_distance #print (x_speed, y_speed, z_speed) #print track_box x_speed = x_speed * self.speed_multiplier y_speed = y_speed * self.speed_multiplier z_speed = z_speed * self.speed_multiplier if self.ai_control: self.drone.at(libardrone.at_pcmd, True, 0, -z_speed, y_speed, x_speed) except: print 'Tracking failed' self.ai_control = False self.drone.hover() cv2.imshow('camshift', vis) #ch = 0xFF & cv2.waitKey(5) ch = cv2.waitKey(5) if ch == 27: self.drone.emergency() if ch == ord('q'): break if ch == ord('b'): self.show_backproj = not self.show_backproj if ch == ord('\r'): self.drone.takeoff() if ch == ord(' '): self.drone.land() if ch == ord('a'): self.drone.move_left() self.ai_control = False if ch == ord('d'): self.drone.move_right() self.ai_control = False if ch == ord('w'): self.drone.move_forward() self.ai_control = False if ch == ord('s'): self.drone.move_backward() self.ai_control = False if ch == ord('9'): self.speed_multiplier = self.speed_multiplier * 1.1 if ch == ord('8'): self.speed_multiplier = self.speed_multiplier * 0.9 if ch == 63234: self.drone.turn_left(mult=2.5) self.ai_control = False if ch == 63235: self.drone.turn_right(mult=2.5) self.ai_control = False if ch == 63232: self.drone.move_up() self.ai_control = False if ch == 63233: self.drone.move_down() self.ai_control = False if (ch == ord('z')) or (ch == ord('x')) or (ch == ord('c')) or (ch == ord('v')): # i.e. can mash keyboard self.drone.hover() self.ai_control = False if ch == ord('y'): self.drone.trim() if ch == ord('p'): self.drone.reset() if ch == ord('t'): self.ai_control = not self.ai_control if self.ai_control: print 'AI in control' else: self.drone.hover() print 'No AI control' finally: cv2.destroyAllWindows() self.drone.emergency() self.drone.reset() self.drone.halt()
# 获取ROI直方图 roi = frame[y:y + h, x:x + w] hsv_roi = cv.cvtColor(roi, cv.COLOR_BGR2HSV) mask = cv.inRange(hsv_roi, (26, 43, 46), (34, 255, 255)) roi_hist = cv.calcHist([hsv_roi], [0], mask, [180], [0, 180]) cv.normalize(roi_hist, roi_hist, 0, 255, cv.NORM_MINMAX) # 设置搜索跟踪分析 term_crit = (cv.TERM_CRITERIA_EPS | cv.TERM_CRITERIA_COUNT, 10, 1) while True: ret, frame = cap.read() if ret is False: break hsv = cv.cvtColor(frame, cv.COLOR_BGR2HSV) dst = cv.calcBackProject([hsv], [0], roi_hist, [0, 180], 1) # ,搜索更新roi区域 track_box = cv.CamShift(dst, track_window, term_crit) track_window = track_box[1] print(track_box) # 绘制窗口CAM cv.ellipse(frame, track_box[0], (0, 0, 255), 3, 8) cv.imshow('CAM Demo', frame) k = cv.waitKey(50) & 0xff if k == 27: break else: cv.imwrite(chr(k) + ".jpg", frame) cv.destroyAllWindows() cap.release()
def main(): # construct the argument parse and parse the arguments ap = argparse.ArgumentParser() ap.add_argument("-v", "--video", help="path to the (optional) video file") args = vars(ap.parse_args()) # grab the reference to the current frame, list of ROI # points and whether or not it is ROI selection mode global frame, roiPts, inputMode # if the video path was not supplied, grab the reference to the # camera if not args.get("video", False): camera = cv2.VideoCapture(0) # otherwise, load the video else: camera = cv2.VideoCapture(args["video"]) # setup the mouse callback to grab the clicks to define ROI cv2.namedWindow("frame") cv2.setMouseCallback("frame", selectROI) # initialize the termination criteria for cam shift, indicating # a maximum of ten iterations or movement by a least one pixel # along with the bounding box of the ROI termination = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1) roiBox = None # keep looping over the frames while True: # grab the current frame (grabbed, frame) = camera.read() # resize frame frame = imutils.resize(frame, width=800) # check to see if we have reached the end of the video if not grabbed: break # if the see if the ROI has been computed if roiBox is not None: # convert the current frame to the HSV color space # and perform mean shift hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) # optional sharpening of the image: blur with minimal kernel then # weighted subtract from image # image = cv2.GaussianBlur(hsv, (0, 0), 3) # hsv = cv2.addWeighted(hsv, 1.5, image, -0.5, 0, image) # 2D histogram back-projection (Hue + Saturation) backProj = cv2.calcBackProject([hsv], [0, 1], roiHist, [0, 179, 0, 255], 1) # Show back-projection image result # cv2.imshow("backProjection", backProj) # apply cam shift to the back projection, convert the # points to a bounding box, and then draw them (r, roiBox) = cv2.CamShift(backProj, roiBox, termination) pts = np.int0(cv2.boxPoints(r)) cv2.polylines(frame, [pts], True, (0, 255, 0), 2) # show the frame and record if the user presses a key cv2.imshow("frame", frame) key = cv2.waitKey(1) & 0xFF # handle if the 'i' key is pressed, then go into ROI # selection mode if key == ord("i") and len(roiPts) < 4: # indicate that we are in input mode and clone the # frame (to keep original since we later write on it.) inputMode = True orig = frame.copy() # keep looping until 4 reference ROI points have # been selected; press any key to exit ROI selction # mode once 4 points have been selected while len(roiPts) < 4: cv2.imshow("frame", frame) cv2.waitKey(0) # determine the top-left and bottom-right points # Top Left is the minimum if the sum, Bottom Right is the max # (this is true for a somewhat rectangular shape) roiPts = np.array(roiPts) s = roiPts.sum(axis=1) tl = roiPts[np.argmin(s)] br = roiPts[np.argmax(s)] # store bounding box roiBox = (tl[0], tl[1], br[0], br[1] ) # grab the ROI for the bounding box and convert it # crop image and convert to the HSV color space (Hue-Saturation-Value) roi = orig[tl[1]:br[1], tl[0]:br[0]] roi = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV) # optional blurring to smooth the histogram roi = cv2.GaussianBlur(roi, (21, 21), 0) # show histogram # cv2.imshow("histogram", roi) # compute a HSV histogram for the ROI # 2D histogram calculation, with channel 0 (H-Hue) and 1 (S-Saturation) # in range 0-180 degrees for Hue and 0-255 for Saturation roiHist = cv2.calcHist([roi], [0, 1], None, [6, 8], [0, 180, 0, 255]) # normalize histogram to 0-255 uint8 space roiHist = cv2.normalize(roiHist, roiHist, 0, 255, cv2.NORM_MINMAX) # if the 'q' key is pressed, stop the loop elif key == ord("q"): break # cleanup the camera and close any open windows camera.release() cv2.destroyAllWindows()