def detect_moving_target(old_gray, new_gray): # open the camera for warming up cap = cv2.VideoCapture('slow.MOV') # grab the first frame old_frame = get_frame_from(cap) old_gray = cv2.cvtColor(old_frame, cv2.COLOR_BGR2GRAY) # initiate KCF tracker tracker = cv2.TrackerKCF_create() # possible movements ROI # start the tracking while True: # Record FPS timer = cv2.getTickCount() # read the current frame cur_frame = get_frame_from(cap) # covert to gray scale cur_gray = cv2.cvtColor(cur_frame, cv2.COLOR_BGR2GRAY) # Calculate Frames per second (FPS) fps = cv2.getTickFrequency() / (cv2.getTickCount() - timer) # Display FPS on frame cv2.putText(cur_frame, "FPS : " + str(int(fps)), (100, 50), cv2.FONT_HERSHEY_SIMPLEX, 0.75, (50, 170, 50), 2); # display cur frame cv2.imshow('video', cur_frame) # waitkey if cv2.waitKey(1) == ord('q'): break #(major_ver, minor_ver, subminor_ver) = (cv2.__version__).split('.') if __name__ == '__main__': # Set up tracker. # Instead of MIL, you can also use tracker_types = ['BOOSTING', 'MIL', 'KCF', 'TLD', 'MEDIANFLOW', 'GOTURN'] tracker_type = tracker_types[2] if int(minor_ver) < 3: tracker = cv2.Tracker_create(tracker_type) else: if tracker_type == 'BOOSTING': tracker = cv2.TrackerBoosting_create() if tracker_type == 'MIL': tracker = cv2.TrackerMIL_create() if tracker_type == 'KCF': tracker = cv2.TrackerKCF_create() if tracker_type == 'TLD': tracker = cv2.TrackerTLD_create() if tracker_type == 'MEDIANFLOW': tracker = cv2.TrackerMedianFlow_create() if tracker_type == 'GOTURN': tracker = cv2.TrackerGOTURN_create() # Read video video = cv2.VideoCapture('slow.MOV') # Exit if video not opened. if not video.isOpened(): print "Could not open video" sys.exit() # Read first frame. ok, frame = video.read() frame = cv2.resize(frame, dsize=(0, 0), fx=0.5, fy=0.5) if not ok: print 'Cannot read video file' sys.exit() # Define an initial bounding box bbox = (287, 23, 86, 320) # Uncomment the line below to select a different bounding box bbox = cv2.selectROI(frame, False) # Initialize tracker with first frame and bounding box ok = tracker.init(frame, bbox) while True: # Read a new frame ok, frame = video.read() frame = cv2.resize(frame, dsize=(0, 0), fx=0.5, fy=0.5) if not ok: break # Start timer timer = cv2.getTickCount() # Update tracker ok, bbox = tracker.update(frame) # Calculate Frames per second (FPS) fps = cv2.getTickFrequency() / (cv2.getTickCount() - timer) # Draw bounding box if ok: # Tracking success p1 = (int(bbox[0]), int(bbox[1])) p2 = (int(bbox[0] + bbox[2]), int(bbox[1] + bbox[3])) cv2.rectangle(frame, p1, p2, (255, 0, 0), 2, 1) else: # Tracking failure cv2.putText(frame, "Tracking failure detected", (100, 80), cv2.FONT_HERSHEY_SIMPLEX, 0.75, (0, 0, 255), 2) # Display tracker type on frame cv2.putText(frame, tracker_type + " Tracker", (100, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.75, (50, 170, 50), 2); # Display FPS on frame cv2.putText(frame, "FPS : " + str(int(fps)), (100, 50), cv2.FONT_HERSHEY_SIMPLEX, 0.75, (50, 170, 50), 2); # Display result cv2.imshow("Tracking", frame) # Exit if ESC pressed k = cv2.waitKey(1) & 0xff if k == 27: break
# Track FPS fps_global = FPS().start() # Multitracker all_trackers = cv2.MultiTracker_create() # Set up tracker. # Instead of MIL, you can also use tracker_types = ['BOOSTING', 'MIL','KCF', 'TLD', 'MEDIANFLOW', 'GOTURN'] tracker_type = tracker_types[3] trackers = [] ntrackers = 2 if int(minor_ver) < 3: for i in range(ntrackers): trackers.append(cv2.Tracker_create(tracker_type)) else: for i in range(ntrackers): if tracker_type == 'BOOSTING': trackers.append(cv2.TrackerBoosting_create()) if tracker_type == 'MIL': trackers.append(cv2.TrackerMIL_create()) if tracker_type == 'KCF': trackers.append(cv2.TrackerKCF_create()) if tracker_type == 'TLD': trackers.append(cv2.TrackerTLD_create()) if tracker_type == 'MEDIANFLOW': trackers.append(cv2.TrackerMedianFlow_create()) if tracker_type == 'GOTURN': trackers.append(cv2.TrackerGOTURN_create())
def spider(video, algorithm, outSize): (major_ver, minor_ver, subminor_ver) = cv2.__version__.split(".") if int(major_ver) < 3: tracker = cv2.Tracker_create(algorithm) else: if algorithm == 'BOOSTING': tracker = cv2.TrackerBoosting_create() if algorithm == 'MIL': tracker = cv2.TrackerMIL_create() if algorithm == 'KCF': tracker = cv2.TrackerKCF_create() if algorithm == 'TLD': tracker = cv2.TrackerTLD_create() if algorithm == 'CSRT': tracker = cv2.TrackerCSRT_create() #读取视频及确认视频有效 video_cap = cv2.VideoCapture(video) if not video_cap.isOpened(): print("Video is not here :(") sys.exit() ok, frame = video_cap.read() if not ok: print("Something goes wrong with the video :(") sys.exit() #标注初始框 bbox = cv2.selectROI(frame, False) ok = tracker.init(frame, bbox) # 记录原始框信息 prev = bbox current = list(prev) dimensions = frame.shape # 获取窗口大小 size = (int(video_cap.get(cv2.CAP_PROP_FRAME_WIDTH)), int(video_cap.get(cv2.CAP_PROP_FRAME_HEIGHT))) print(size) print(type(outSize)) outSize_write = (int(outSize[0]), int(outSize[1])) # 调用VideoWrite()函数 fps = 30 output = cv2.VideoWriter('MySaveVideo.mp4', cv2.VideoWriter_fourcc('M', 'P', '4', 'V'), fps, outSize_write) # 截取信息初始化 #chopped = frame[current[0]:(current[0]+int(outSize[0])),current[1]:(current[1]+int(outSize[1]))] chopped = frame[current[1]:current[1] + outSize[1], current[0]:current[0] + outSize[0]] #纵列,横列 while True: ok, frame = video_cap.read() if not ok: print("All frames are shown :)") break timer = cv2.getTickCount() ok, bbox = tracker.update(frame) fps = cv2.getTickFrequency() / (cv2.getTickCount() - timer) if ok: #原本检测结果 p1 = (int(bbox[0]), int(bbox[1])) p2 = (int(bbox[0] + bbox[2]), int(bbox[1] + bbox[3])) cv2.rectangle(frame, p1, p2, (255, 0, 0), 1, 1) #加入防抖 for i in range(0, 3): if (abs(bbox[i] - prev[i]) > 5) or (abs(current[i] - bbox[i]) > 6): current[i] = int(prev[i]) p1 = (int(current[0]), int(current[1])) p2 = (int(current[0] + current[2]), int(current[1] + current[3])) cv2.rectangle(frame, p1, p2, (0, 255, 255), 4, 1) #输出视频 up = current[0] left = current[1] down = current[2] right = current[3] # chopped = frame[current[0]:(current[0]+int(outSize[0])),current[1]:(current[1]+int(outSize[1]))] #print("left:",left," right:", right, " up:",up," down:",down) if (current[1] < 0) or ( current[1] + outSize[1] > dimensions[0] ) or (current[0] < 0) or (current[0] + outSize[0] > dimensions[1]): print("ERROR:超出范围,无法录制 :(") else: chopped = frame[current[1]:current[1] + outSize[1], current[0]:current[0] + outSize[0]] #纵列,横列 output.write(chopped) # else: # cv2.putText(frame,"failure detected") prev = bbox cv2.imshow("Tracking", chopped) if cv2.waitKey(1) & 0xFF == ord('q'): break video_cap.release() output.release()
# construct the argument parser and parse the arguments ap = argparse.ArgumentParser() ap.add_argument("-v", "--video", type=str, help="path to input video file") ap.add_argument("-t", "--tracker", type=str, default="kcf", help="OpenCV object tracker type") args = vars(ap.parse_args()) # extract the OpenCV version info (major, minor) = cv2.__version__.split(".")[:2] # if we are using OpenCV 3.2 OR BEFORE, we can use a special factory # function to create our object tracker if int(major) == 3 and int(minor) < 3: tracker = cv2.Tracker_create(args["tracker"].upper()) # otherwise, for OpenCV 3.3 OR NEWER, we need to explicity call the # approrpiate object tracker constructor: else: # initialize a dictionary that maps strings to their corresponding # OpenCV object tracker implementations OPENCV_OBJECT_TRACKERS = { "csrt": cv2.TrackerCSRT_create, "kcf": cv2.TrackerKCF_create, "boosting": cv2.TrackerBoosting_create, "mil": cv2.TrackerMIL_create, "tld": cv2.TrackerTLD_create, "medianflow": cv2.TrackerMedianFlow_create, "mosse": cv2.TrackerMOSSE_create }
# Build box around both panels print(boatD._bluePanelRect, boatD._redPanelRect) panels = np.vstack((boatD._redPanelRect, boatD._bluePanelRect)) box = cv2.minAreaRect(panels) box = cv2.boxPoints(box) x, y = np.min(box, axis=0) w, h = np.max(box, axis=0) w -= x h -= y box = (x, y, w, h) boatTracker = cv2.Tracker_create("MIL") boatTracker.init(img, box) print("Tracker initialized") while (data.more()): img = data.read() boatDetected, box = boatTracker.update(img) if boatDetected: p1 = (int(box[0]), int(box[1])) p2 = (int(box[0] + box[2]), int(box[1] + box[3])) cv2.rectangle(img, p1, p2, (0, 0, 255), 2) cv2.imshow('img', img) k = cv2.waitKey(1) & 0xff
def main(): tracker_types = [ 'BOOSTING', 'MIL', 'KCF', 'TLD', 'MEDIANFLOW', 'GOTURN', 'MOSSE', 'CSRT' ] tracker_type = tracker_types[2] if int(minor_ver) < 3: tracker = cv2.Tracker_create(tracker_type) else: if tracker_type == 'BOOSTING': tracker = cv2.TrackerBoosting_create() if tracker_type == 'MIL': tracker = cv2.TrackerMIL_create() if tracker_type == 'KCF': tracker = cv2.TrackerKCF_create() if tracker_type == 'TLD': tracker = cv2.TrackerTLD_create() if tracker_type == 'MEDIANFLOW': tracker = cv2.TrackerMedianFlow_create() if tracker_type == 'GOTURN': tracker = cv2.TrackerGOTURN_create() if tracker_type == 'MOSSE': tracker = cv2.TrackerMOSSE_create() if tracker_type == "CSRT": tracker = cv2.TrackerCSRT_create() x0 = 200 y0 = 200 w0 = 224 h0 = 224 track_window = (x0, y0, w0, h0) # Reference Distance L0 = 100 S0 = 50176 #224x224 #take#here. # Base Distance LB = 100 # Define an initial bounding box bbox = (x0, y0, w0, h0) #(287, 23, 86, 320) #CX=int(bbox[0]+0.5*bbox[2]+3) #adding #CY=int(bbox[1]+0.5*bbox[3]+3) #adding drone = tellopy.Tello() try: drone.connect() drone.wait_for_connection(60.0) retry = 3 container = None while container is None and 0 < retry: retry -= 1 try: container = av.open(drone.get_video_stream()) except av.AVError as ave: print(ave) print('retry...') drone.takeoff() # skip first 300 frames frame_skip = 300 while True: #------------------------------------------for start for frame in container.decode(video=0): speed = 100 if 0 < frame_skip: frame_skip = frame_skip - 1 continue start_time = time.time() image = cv2.cvtColor(numpy.array(frame.to_image()), cv2.COLOR_RGB2BGR) # Start timer timer = cv2.getTickCount() #cv2.imshow('Canny', cv2.Canny(image, 100, 200)) #cv2.waitKey(1) # Update tracker ok, bbox = tracker.update(image) # Calculate Frames per second (FPS) fps = cv2.getTickFrequency() / (cv2.getTickCount() - timer) # Draw bounding box if ok: #print('Tracking ok') (x, y, w, h) = (int(bbox[0]), int(bbox[1]), int(bbox[2]), int(bbox[3])) CX = int(bbox[0] + 0.5 * bbox[2]) #Center of X CY = int(bbox[1] + 0.5 * bbox[3]) S0 = bbox[2] * bbox[3] print("CX,CY,S0,x,y=", CX, CY, S0, x, y) # Tracking success p1 = (x, y) p2 = (x + w, y + h) cv2.rectangle(image, p1, p2, (255, 0, 0), 2, 1) p10 = (x0, y0) p20 = (x0 + w0, y0 + h0) cv2.rectangle(image, p10, p20, (0, 255, 0), 2, 1) d = round(L0 * m.sqrt(S0 / (w * h))) dx = x + w / 2 - CX0 #no change dx dy = y + h / 2 - CY0 print(d, dx, dy) tracking(drone, d, dx, dy, LB) else: # Tracking failure #print('Tracking failure') cv2.putText(image, "Tracking failure detected", (100, 80), cv2.FONT_HERSHEY_SIMPLEX, 0.75, (0, 0, 255), 2) cv2.imshow('Original', image) key = cv2.waitKey(1) & 0xff if key == ord('q'): print('Q!') break if key == ord('r'): roi_time = time.time() bbox = cv2.selectROI(image, False) print(bbox) (x0, y0, w0, h0) = (int(bbox[0]), int(bbox[1]), int(bbox[2]), int(bbox[3])) CX0 = int(x0 + 0.5 * w0) #Center of X CY0 = int(y0 + 0.5 * h0) # Initialize tracker with first frame and bounding box ok = tracker.init(image, bbox) ''' if frame.time_base < 1.0/60: time_base = 1.0/60 else: time_base = frame.time_base frame_skip2 = int((time.time() - roi_time)/time_base) if 0 < frame_skip2: frame_skip2 = frame_skip2 - 1 continue ''' if frame.time_base < 1.0 / 60: time_base = 1.0 / 60 else: time_base = frame.time_base frame_skip = int((time.time() - start_time) / time_base) #-------------------------------------------------for end break print('stop fly') except Exception as ex: exc_type, exc_value, exc_traceback = sys.exc_info() traceback.print_exception(exc_type, exc_value, exc_traceback) print(ex) finally: drone.quit() drone.land() cv2.destroyAllWindows()
# cvdrone.de # # evaluating different opencv trackers # # [email protected] from pydrone import * import cv2 import imutils import detectors import hud tracker = cv2.Tracker_create("KCF") video = cv2.VideoCapture("/home/user/opencv/videos/correlation-tracking.mp4") #video = cv2.VideoCapture(0) cv2.namedWindow("video") person_found = False frame_idx = 0 pad = 5 def prepare_frame(frame): frame = imutils.resize(frame, width=1024) return frame def get_position(newbox): x1 = int(newbox[0])
def init(self): # construct the argument parser and parse the arguments ap = argparse.ArgumentParser() # use for video file ap.add_argument("-v", "--video", type=str, help="path to input video file") ap.add_argument("-t", "--tracker", type=str, default="kcf", help="OpenCV object tracker type") args = vars(ap.parse_args()) # extract the OpenCV version info (major, minor) = cv2.__version__.split(".")[:2] # if we are using OpenCV 3.2 OR BEFORE, we can use a special factory # function to create our object tracker if int(major) == 3 and int(minor) < 3: tracker = cv2.Tracker_create(args["tracker"].upper()) # otherwise, for OpenCV 3.3 OR NEWER, we need to explicity call the # approrpiate object tracker constructor: else: # initialize a dictionary that maps strings to their corresponding # OpenCV object tracker implementations OPENCV_OBJECT_TRACKERS = { "csrt": cv2.TrackerCSRT_create, "kcf": cv2.TrackerKCF_create, "boosting": cv2.TrackerBoosting_create, "mil": cv2.TrackerMIL_create, "tld": cv2.TrackerTLD_create, "medianflow": cv2.TrackerMedianFlow_create, "mosse": cv2.TrackerMOSSE_create } # grab the appropriate object tracker using our dictionary of # OpenCV object tracker objects self.tracker = OPENCV_OBJECT_TRACKERS[args["tracker"]]() # initialize the bounding box coordinates of the object we are going # to track, and scale object self.initBB = None self.initScale = None # if a video path was not supplied, grab the reference to the web cam if not args.get("video", False): print('\n' + "[INFO] starting video stream...") self.vs = VideoStream(src=0).start() time.sleep(1.0) # otherwise, grab a reference to the video file else: selfvs = cv2.VideoCapture(args["video"]) # initialize the FPS throughput estimator self.fps = None self.com_output = input('Output COM info? <Y/N>')
speed_y_inner = 0 open_1_inner = 0 open_2_inner = 0 open_3_inner = 0 return point_x_inner, point_y_inner, speed_x_inner, speed_y_inner, open_1_inner, open_2_inner, open_3_inner if __name__ == "__main__": # 全局变量 fps = 29 # 获取参数一:帧率(暂时没用) pre_frame = None # 获取参数一:前一帧图像(灰度),判断是否有运动物体 entropy_last = 0 # 获取参数二:前一帧抖动数值 flag = 0 # 是否选择跟踪目标 point_x, point_y = 0, 0 # 获取参数三:初始化运动点 tracker = cv2.Tracker_create( "KCF") # BOOSTING, KCF, TLD, MEDIANFLOW or GOTURN # 视频输入:文件或摄像头 # camera = cv2.VideoCapture("video/sample2_1.mp4") camera = cv2.VideoCapture(0) if camera is None: print('请先连接摄像头或视频') exit() while True: res, cur_frame = camera.read() if res is not True: break # 跳帧参数设置,读取视频用 '''
def main(): tracker_types = ['BOOSTING', 'MIL', 'KCF', 'TLD', 'MEDIANFLOW', 'GOTURN', 'MOSSE', 'CSRT'] tracker_type = tracker_types[2] if int(minor_ver) < 3: tracker = cv2.Tracker_create(tracker_type) else: if tracker_type == 'BOOSTING': tracker = cv2.TrackerBoosting_create() if tracker_type == 'MIL': tracker = cv2.TrackerMIL_create() if tracker_type == 'KCF': tracker = cv2.TrackerKCF_create() if tracker_type == 'TLD': tracker = cv2.TrackerTLD_create() if tracker_type == 'MEDIANFLOW': tracker = cv2.TrackerMedianFlow_create() if tracker_type == 'GOTURN': tracker = cv2.TrackerGOTURN_create() if tracker_type == 'MOSSE': tracker = cv2.TrackerMOSSE_create() if tracker_type == "CSRT": tracker = cv2.TrackerCSRT_create() # 追跡する枠の座標とサイズ x = 200 y = 200 w = 224 h = 224 track_window=(x,y,w,h) # Reference Distance L0 = 100 #S0 = 50176 #224x224 # Base Distance LB = 100 # Define an initial bounding box bbox = (x, y, w, h) #(287, 23, 86, 320) drone = tellopy.Tello() drone.connect() container = av.open(drone.get_video_stream()) drone.takeoff() #drone.is_autopilot="True" drone.is_autopilot="False" while True: for frame in container.decode(video=0): image = cv2.cvtColor(numpy.array(frame.to_image()), cv2.COLOR_RGB2BGR) # Start timer timer = cv2.getTickCount() # Update tracker ok, bbox = tracker.update(image) # Calculate Frames per second (FPS) fps = cv2.getTickFrequency() / (cv2.getTickCount() - timer); # Draw bounding box if ok: (x,y,w,h) = (int(bbox[0]),int(bbox[1]),int(bbox[2]),int(bbox[3])) CX=int(bbox[0]+0.5*bbox[2]) CY=int(bbox[1]+0.5*bbox[3]) S0=bbox[2]*bbox[3] print("CX,CY,S0=",CX,CY,S0) # Tracking success p1 = (x, y) p2 = (x + w, y + h) cv2.rectangle(image, p1, p2, (255,0,0), 2, 1) else : # Tracking failure cv2.putText(image, "Tracking failure detected", (100,80), cv2.FONT_HERSHEY_SIMPLEX, 0.75,(0,0,255),2) # Display tracker type on frame cv2.putText(image, tracker_type + " Tracker", (100,20), cv2.FONT_HERSHEY_SIMPLEX, 0.75, (50,170,50),2) # Display FPS on frame cv2.putText(image, "FPS : " + str(int(fps)), (100,50), cv2.FONT_HERSHEY_SIMPLEX, 0.75, (50,170,50), 2) cv2.imshow('test',image) key = cv2.waitKey(1)&0xff if key == ord('a'): drone.is_autopilot="True" elif key == ord('s'): drone.is_autopilot="False" if drone.is_autopilot=="True": d = round(L0 * m.sqrt(S0 / (w * h))) dx = x + w/2 - CX dy = y + h/2 - CY print(d,dx,dy,drone.is_autopilot,w,h) tracking(drone,d,dx,dy,LB) elif drone.is_autopilot=="False": key_Operation(drone,key) print("key=",key,ord('q')) #key = cv2.waitKey(1)&0xff print("key=",key,ord('q')) if key == ord('q'): cv2.destroyAllWindows() break elif key == ord('r'): bbox = cv2.selectROI(image, False) print(bbox) (x,y,w,h) = (int(bbox[0]),int(bbox[1]),int(bbox[2]),int(bbox[3])) # Initialize tracker with first frame and bounding box ok = tracker.init(image, bbox) break drone.down(50) sleep(5) drone.land() drone.subscribe(drone.EVENT_FLIGHT_DATA, handler) drone.quit()
def track_ecoli(regions): tracker_types = ['BOOSTING', 'MIL', 'KCF', 'TLD', 'MEDIANFLOW', 'GOTURN'] # MIL appears to work best... tracker_type = tracker_types[1] if int(minor_ver) < 3: tracker = cv2.Tracker_create(tracker_type) else: if tracker_type == 'BOOSTING': tracker = cv2.TrackerBoosting_create() if tracker_type == 'MIL': tracker = cv2.TrackerMIL_create() if tracker_type == 'KCF': tracker = cv2.TrackerKCF_create() if tracker_type == 'TLD': tracker = cv2.TrackerTLD_create() if tracker_type == 'MEDIANFLOW': tracker = cv2.TrackerMedianFlow_create() if tracker_type == 'GOTURN': tracker = cv2.TrackerGOTURN_create() root_path = 'C:\\dev\\courses\\2.131 - Advanced Instrumentation\\' img_path = root_path + 'E.coli.tif' pil_img = Image.open(img_path) frame = np.array(pil_img) # frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) fourcc = cv2.VideoWriter_fourcc(*'DIVX') # out = cv2.VideoWriter(root_path + 'ecoli_track1.avi', # fourcc, 5.0,(640,480) ) # Define an initial bounding box bbox = (287, 23, 86, 320) # Uncomment the line below to select a different bounding box bbox = cv2.selectROI(frame, False) # Initialize tracker with first frame and bounding box ok = tracker.init(frame, bbox) csvfile = open(root_path + 'E.coli1.csv', 'w', newline='') bac_writer = csv.writer(csvfile, delimiter=',', quotechar='|', quoting=csv.QUOTE_MINIMAL) bac_writer.writerow(['BacteriaId', 'Time', 'X', 'Y']) for i in range(149): # Read a new frame pil_img.seek(i) frame = np.array(pil_img) # Start timer timer = cv2.getTickCount() # Update tracker ok, bbox = tracker.update(frame) # Calculate Frames per second (FPS) fps = cv2.getTickFrequency() / (cv2.getTickCount() - timer) # Draw bounding box if ok: # Tracking success p1 = (int(bbox[0]), int(bbox[1])) p2 = (int(bbox[0] + bbox[2]), int(bbox[1] + bbox[3])) cv2.rectangle(frame, p1, p2, (255, 0, 0), 2, 1) bac_writer.writerow( [1, i, int(bbox[0] + bbox[2] / 2), int(bbox[1] + bbox[3] / 2)]) else: # Tracking failure cv2.putText(frame, "Tracking failure detected", (100, 80), cv2.FONT_HERSHEY_SIMPLEX, 0.75, (0, 0, 255), 2) # Display tracker type on frame cv2.putText(frame, "2.131 E.Coli Tracker", (100, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.75, (50, 170, 50), 2) # Display FPS on frame cv2.putText(frame, "FPS : " + str(int(fps)), (100, 50), cv2.FONT_HERSHEY_SIMPLEX, 0.75, (50, 170, 50), 2) frame = frame[:480, :640, ...] array_alpha = np.array([1.45]) array_beta = np.array([-150.0]) cv2.add(frame, array_beta, frame) # multiply every pixel value by alpha cv2.multiply(frame, array_alpha, frame) # out.write(frame) # out.write(frame) # Display result cv2.imshow("Tracking", frame) # Exit if ESC pressed k = cv2.waitKey(1) & 0xff if k == 27: break csvfile.close()
import cv2 import sys import time if __name__ == '__main__': # Set up tracker. # Instead of MIL, you can also use # BOOSTING, KCF, TLD, MEDIANFLOW or GOTURN (GOTURN doesn't work) tracker = cv2.Tracker_create("BOOSTING") # Read video video = cv2.VideoCapture("test_video_trimmed.mp4") # Exit if video not opened. if not video.isOpened(): print("Could not open video") sys.exit() # Read first frame. ok, frame = video.read() if not ok: print('Cannot read video file') sys.exit() # Define an initial bounding box bbox = (50, 250, 1150, 100) # Initialize tracker with first frame and bounding box ok = tracker.init(frame, bbox)
frame = cv2.rectangle(frame, (x, y), (x + w, y + h), 255, 2) frame_resized = cv2.resize(frame, (screen_width, screen_height)) cv2.imshow('frame', frame_resized) if cv2.waitKey(1) == ord('q'): break elif cv2.waitKey(1) == ord('p'): print("Frame: " + str(video_capture.get(cv2.CAP_PROP_POS_FRAMES))) plt.imshow(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)) plt.show() elif algorithm == 3 or algorithm == 4: # create tracker if algorithm == 3: tracker = cv2.Tracker_create("MIL") elif algorithm == 4: tracker = cv2.Tracker_create("KCF") # todo second time around it doesn't recreate tracker with new algorithm. I think it needs to be destroyed # initialize tracker bounding box bbox = (int(x), int(y), int(w), int(h)) ok = tracker.init(frame, bbox) p1 = (int(bbox[0]), int(bbox[1])) p2 = (int(bbox[0] + bbox[2]), int(bbox[1] + bbox[3])) cv2.rectangle(frame, p1, p2, (0, 0, 255)) while video_capture.isOpened(): ret, frame = video_capture.read()
def extractFrame(videoPath): videoFrames = [] playerBoxes = [] # if we are using OpenCV 3.2 OR BEFORE, we can use a special factory # function to create our object tracker if args.detector == "tracker": if int(major) == 3 and int(minor) < 3: if args.singleTracker: tracker = cv2.Tracker_create(args.tracker.upper()) # otherwise, for OpenCV 3.3 OR NEWER, we need to explicity call the # appropriate object tracker constructor: else: # initialize a dictionary that maps strings to their corresponding # OpenCV object tracker implementations if args.singleTracker: OPENCV_OBJECT_TRACKERS = { "csrt": cv2.legacy.TrackerCSRT_create(), "kcf": cv2.legacy.TrackerKCF_create(), "mil": cv2.legacy.TrackerMIL_create() } tracker = OPENCV_OBJECT_TRACKERS[args.tracker]() # initialize the bounding box coordinates of the object we are going # to track initBB = None # initialize the FPS throughput estimator fps = None # Set up Neural Net net = cv2.dnn.readNet(args.weights, args.config) cap = cv2.VideoCapture(videoPath) player_threshold = 99999 if not args.singleTracker: # Read first frame success, frame = cap.read() # quit if unable to read the video file if not success: print('Failed to read video') sys.exit(1) ## Select boxes bboxes = [] colors = [] # OpenCV's selectROI function doesn't work for selecting multiple objects in Python # So we will call this function in a loop till we are done selecting all objects while True: # draw bounding boxes over objects # selectROI's default behaviour is to draw box starting from the center # when fromCenter is set to false, you can draw box starting from top left corner bbox = cv2.selectROI('MultiTracker', frame) bboxes.append(bbox) colors.append((randint(0, 255), randint(0, 255), randint(0, 255))) print("Press q to quit selecting boxes and start tracking") print("Press any other key to select next object") k = cv2.waitKey(0) & 0xFF print(k) if (k == 113): # q is pressed break print('Selected bounding boxes {}'.format(bboxes)) createTrackerByName(args.tracker) # Create MultiTracker object trackers = cv2.legacy.MultiTracker_create() # Initialize MultiTracker for bbox in bboxes: trackers.add(createTrackerByName(args.tracker), frame, bbox) frameCount = 0 while (cap.isOpened()): print(frameCount) # Take each frame _, frame = cap.read() if not _: print("Video Ended") break Width = frame.shape[1] Height = frame.shape[0] # Convert BGR to HSV hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) # Hard-Coded Color # court_color = np.uint8([[[188, 218, 236]]]) court_color = np.uint8([[[189, 204, 233]]]) hsv_court_color = cv2.cvtColor(court_color, cv2.COLOR_BGR2HSV) hue = hsv_court_color[0][0][0] # define range of blue color in HSV - Again HARD CODED! :( lower_color = np.array([hue - 5, 10, 10]) upper_color = np.array([hue + 5, 225, 225]) # Threshold the HSV image mask = cv2.inRange(hsv, lower_color, upper_color) # Opening kernel = np.ones((2, 2), np.uint8) opening = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel) # Bitwise-AND mask and original image res = cv2.bitwise_and(frame, frame, mask=opening) cv2.imshow('res', res) if args.draw_line: # Canny Edge Detector gray = cv2.cvtColor(res, cv2.COLOR_BGR2GRAY) high_thresh, thresh_im = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU) low_thresh = 0.5 * high_thresh edges = cv2.Canny(gray, low_thresh, high_thresh, apertureSize=3) cv2.imshow('Canny Edge Detector', edges) # # Hough Lines minLineLength = 200 maxLineGap = 500 lines = cv2.HoughLinesP(edges, 1, np.pi / 180, 100, minLineLength=minLineLength, maxLineGap=maxLineGap) # Green color in BGR LINE_COLOR = (255, 0, 0) if lines is None: continue else: a, b, c = lines.shape for i in range(2): for x1, y1, x2, y2 in lines[i]: # cv2.line(image, start_point, end_point, color, thickness) if args.draw_line: cv2.line(frame, (x1, y1), (x2, y2), LINE_COLOR, 3) # only compare the lower corner of y value player_threshold = min(player_threshold, y1, y2) # Detect People if args.detector == "HOG": # initialize the HOG descriptor/person detector hog = cv2.HOGDescriptor() hog.setSVMDetector(cv2.HOGDescriptor_getDefaultPeopleDetector()) orig = frame.copy() # detect people in the image (rects, weights) = hog.detectMultiScale(frame, winStride=(4, 4), padding=(8, 8), scale=1.05) # draw the original bounding boxes for (x, y, w, h) in rects: cv2.rectangle(orig, (x, y), (x + w, y + h), (0, 0, 255), 2) # apply non-maxima suppression to the bounding boxes using a # fairly large overlap threshold to try to maintain overlapping # boxes that are still people rects = np.array([[x, y, x + w, y + h] for (x, y, w, h) in rects]) pick = non_max_suppression(rects, probs=None, overlapThresh=0.1) # draw the final bounding boxes for (xA, yA, xB, yB) in pick: cv2.rectangle(frame, (xA, yA), (xB, yB), (0, 255, 0), 2) elif args.detector == "yolov3": scale = 0.00392 blob = cv2.dnn.blobFromImage(frame, scale, (416, 416), (0, 0, 0), True, crop=False) net.setInput(blob) outs = net.forward(get_output_layers(net)) class_ids = [] confidences = [] boxes = [] conf_threshold = 0.5 nms_threshold = 0.4 for out in outs: for detection in out: scores = detection[5:] class_id = np.argmax(scores) confidence = scores[class_id] if confidence > 0.5: center_x = int(detection[0] * Width) center_y = int(detection[1] * Height) w = int(detection[2] * Width) h = int(detection[3] * Height) x = center_x - w / 2 y = center_y - h / 2 class_ids.append(class_id) confidences.append(float(confidence)) boxes.append([x, y, w, h]) indices = cv2.dnn.NMSBoxes(boxes, confidences, conf_threshold, nms_threshold) k = 0 for i in indices: i = i[0] box = boxes[i] x = box[0] y = box[1] w = box[2] h = box[3] pad = 5 # print(player_threshold) if (round(y + h) < player_threshold): k += 1 continue else: draw_prediction(frame, class_ids[i], round(x - pad), round(y - pad), round(x + w + pad), round(y + h + pad)) elif args.detector == "tracker": # check to see if we are currently tracking an object if args.singleTracker: if initBB is not None: # grab the new bounding box coordinates of the object (success, box) = tracker.update(frame) # check to see if the tracking was a success if success: (x, y, w, h) = [int(v) for v in box] cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2) # update the FPS counter fps.update() fps.stop() # initialize the set of information we'll be displaying on # the frame info = [ ("Tracker", tracker), ("Success", "Yes" if success else "No"), ("FPS", "{:.2f}".format(fps.fps())), ] # loop over the info tuples and draw them on our frame for (i, (k, v)) in enumerate(info): text = "{}: {}".format(k, v) cv2.putText(frame, text, (10, Height - ((i * 20) + 20)), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 255), 2) else: videoFrames.append(frame) # get updated location of objects in subsequent frames success, boxes = trackers.update(frame) playerBoxes.append(boxes) # draw tracked objects for i, newbox in enumerate(boxes): p1 = (int(newbox[0]), int(newbox[1])) p2 = (int(newbox[0] + newbox[2]), int(newbox[1] + newbox[3])) cv2.rectangle(frame, p1, p2, colors[i], 2, 1) else: continue # show the output frame cv2.imshow("Frame", frame) key = cv2.waitKey(1) & 0xFF # if the 's' key is selected, we are going to "select" a bounding # box to track if key == ord("s"): if args.singleTracker: # select the bounding box of the object we want to track (make # sure you press ENTER or SPACE after selecting the ROI) initBB = cv2.selectROI("Frame", frame, fromCenter=False, showCrosshair=True) # start OpenCV object tracker using the supplied bounding box # coordinates, then start the FPS throughput estimator as well tracker.init(frame, initBB) fps = FPS().start() # if the `q` key was pressed, break from the loop elif key == ord("q"): break frameCount += 1 cap.release() cv2.destroyAllWindows() return videoFrames, playerBoxes, Width, Height, colors
win = "C:/Users/jc306494/Documents/PythonAnalysis/SampleVid/GP010016_fast.mp4" win = "C:/Users/jc306494/Documents/PythonAnalysis/SampleVid/VIRB0009.mp4" mac = "/Users/Cesar/PyCode_MacOSv1/GP010016_fast.mp4" mac2 = '/Users/Cesar/PyCode_MacOSv1/VIRB0006.MP4' resultFile = open("Tracking.csv", "w", newline='\n') wr = csv.writer(resultFile, delimiter=",") wr.writerow(['Coord x', 'Coord y']) position = (0, 0) # Set up tracker. # Instead of MIL, you can also use # BOOSTING, MIL, KCF, TLD, MEDIANFLOW or GOTURN tracker = cv2.Tracker_create(args['method']) # Read video vid = cv2.VideoCapture(args['video']) # Exit if video not opened if not vid.isOpened(): print("Could not open video") sys.exit() # Read first frame ok, frame = vid.read() if not ok: print('Cannot read video file') sys.exit()
def create_trackers(new_item, trackers, frame): trackers.append(cv2.Tracker_create("MIL")) ok = trackers[-1].init(frame, new_item) ok, bb = trackers[-1].update(frame) return trackers, ok
frame_tracker, best_box = 0, None tracker_start, lost_frames = True, 0 while True: ret, frame = cap.read() if frame_tracker < DETECTION_FRAMES: put_text(frame, 'DETECTING', frame_tracker) boxes, scores = detect_hands(frame, sess, d_boxes, d_scores, d_classes, n_detections, i_tensor) best_box = track_boxes(best_box, frame, boxes, scores, width, height) tracker_start, lost_frames = True, 0 else: if best_box is not None and lost_frames < 10: put_text(frame, 'TRACKING', frame_tracker, color=(255, 255, 0)) if tracker_start: tracker = cv.Tracker_create('MEDIANFLOW') ok = tracker.init(frame, best_box) tracker_start = False ok, new_box = tracker.update(frame) best_box = new_box if new_box is not None else best_box if ok: p1, p2 = (int(best_box[0]), int(best_box[1])), (int(best_box[0] + best_box[2]), int(best_box[1] + best_box[3])) cv.rectangle(frame, p1, p2, (200, 0, 0), 2, 1) lost_frames = 0 else: cv.putText(frame, 'Hand Lost', (10, 100), cv.FONT_HERSHEY_SIMPLEX, 1, (0, 100, 200), 3, cv.LINE_AA) lost_frames += 1 else:
def _init_tracker(self, windows, frame): x, y, w, h = windows # KCF tracker = cv2.Tracker_create('KCF') tracker.init(frame, (x, y, w, h)) #初始化一个帧与目标的坐标位置 return tracker
for i in range(0, n_trackers): all_centroids.append([]) rois = [] roi_vertices = {k: () for k in range(0, n_rois)} roi_counts_per_tracker = {k: [] for k in range(0, n_trackers)} for i in range(0, n_trackers): for j in range(0, n_rois): roi_counts_per_tracker[i].append(0) total_count = 0 #set up tracker(s) #tracking algorithms include: BOOSTING, MIL, KCF, TLD, MEDIANFLOW for i in range(0, n_trackers): trackers.append(cv2.Tracker_create("MIL")) #find video for file in os.listdir(path): if file.endswith(".avi"): video = file break #read video cap = cv2.VideoCapture(video) #exit if video didn't open if not cap.isOpened(): print "Video did not open" sys.exit()
def jaccard((x1, y1, w1, h1), (x2, y2, w2, h2)): ix = max(x1, x2) iy = max(y1, y2) iw = max(min(x1 + w1, x2 + w2) - ix, 0) ih = max(min(y1 + h1, y2 + h2) - iy, 0) intersect = iw * ih union = w1 * h1 + w2 * h2 - intersect return intersect / union jaccards = list() # Initialize tracker tracker = cv2.Tracker_create(args.tracker) tracker.init(firstImage, firstROI) score = 0 time = 0 cv2.namedWindow('Tracker') minlen = min(len(images), len(rects)) exframes = args.eframes if args.examples: os.mkdir('./examples/' + args.tracker) if exframes is None: exframes = list(np.linspace(0, minlen, 5)) for i in range(min(len(images), len(rects))): image = cv2.imread(args.dataset + '/img/' + images[i]) tic = clock()
(major_ver, minor_ver, subminor_ver) = (cv2.__version__).split('.') if __name__ == '__main__': # Set up tracker. # Instead of MIL, you can also use tracker_types = [ 'BOOSTING', 'MIL', 'KCF', 'TLD', 'MEDIANFLOW', 'GOTURN', 'MOSSE', 'CSRT' ] tracker_type = tracker_types[7] if int(minor_ver) < 3: tracker = cv2.Tracker_create(tracker_type) else: if tracker_type == 'BOOSTING': tracker = cv2.TrackerBoosting_create() if tracker_type == 'MIL': tracker = cv2.TrackerMIL_create() if tracker_type == 'KCF': tracker = cv2.TrackerKCF_create() if tracker_type == 'TLD': tracker = cv2.TrackerTLD_create() if tracker_type == 'MEDIANFLOW': tracker = cv2.TrackerMedianFlow_create() if tracker_type == 'GOTURN': tracker = cv2.TrackerGOTURN_create() if tracker_type == 'MOSSE': tracker = cv2.TrackerMOSSE_create()
def main(): """ LoadsMulti-Level Otsu masks and tracks the face. Returns a set of ROIs containing only the face. :return: """ tag = 'MLO_' filepath = 'E:\\GitHub\\CovPySourceFile\\MultiLevelOtsu\\' otsu_masks = load_images_from_folder( folder=filepath, name_tag=tag, ) # region MIL Tracking # use binary otsu mask to detect the face (major_ver, minor_ver, subminor_ver) = cv2.__version__.split('.') # Set up tracker tracker_types = [ 'BOOSTING', 'MIL', 'KCF', 'TLD', 'MEDIANFLOW', 'GOTURN', 'MOSSE', 'CSRT' ] tracker_type = tracker_types[4] if int(minor_ver) < 3: tracker = cv2.Tracker_create(tracker_type) else: if tracker_type == 'BOOSTING': tracker = cv2.TrackerBoosting_create() if tracker_type == 'MIL': tracker = cv2.TrackerMIL_create() if tracker_type == 'KCF': tracker = cv2.TrackerKCF_create() if tracker_type == 'TLD': tracker = cv2.TrackerTLD_create() if tracker_type == 'MEDIANFLOW': tracker = cv2.TrackerMedianFlow_create() if tracker_type == 'GOTURN': tracker = cv2.TrackerGOTURN_create() if tracker_type == 'MOSSE': tracker = cv2.TrackerMOSSE_create() if tracker_type == "CSRT": tracker = cv2.TrackerCSRT_create() initial_frame = otsu_masks[0] # Define initial bounding box from roi bbox = cv2.selectROI(initial_frame, showCrosshair=True, fromCenter=False) # Initialize tracker with first frame and bounding box ok = tracker.init(initial_frame, bbox) # roi points points = [] failed_idx = [] for n, mask in enumerate(otsu_masks): # Update tracker ok, bbox = tracker.update(mask) # Draw bounding box if ok: # Tracking success p1 = [int(bbox[0]), int(bbox[1])] p2 = [int(bbox[0] + bbox[2]), int(bbox[1])] p3 = [int(bbox[0] + bbox[2]), int(bbox[1] + bbox[3])] p4 = [int(bbox[0]), int(bbox[1] + bbox[3])] points.append([p1, p2, p3, p4]) cv2.rectangle(mask, tuple(p1), tuple(p3), (255, 0, 0), 2, 1) else: # Tracking failure cv2.putText(mask, "Tracking failure detected", (100, 80), cv2.FONT_HERSHEY_SIMPLEX, 0.75, (0, 0, 255), 2) failed_idx.append(n) # Display result cv2.imshow("Tracking", mask) # Exit if ESC pressed k = cv2.waitKey(1) & 0xff if k == 27: break cv2.destroyAllWindows() # endregion # get rois rois = [] for n, rp in enumerate(points): img = Image.open( r"E:\GitHub\CovPySourceFile\Normalized\NF_{}.png".format(n)) left = rp[0][0] top = rp[0][1] right = rp[2][0] bottom = rp[2][1] cropped = img.crop((left, top, right, bottom)) rois.append(cropped) # plt.imshow(cropped) # plt.show() destination_dir = 'E:\\GitHub\\CovPySourceFile\\FaceROI\\' if not os.path.exists(destination_dir): os.makedirs(destination_dir) for n, r in enumerate(rois): r.save(destination_dir + 'FR_{}.png'.format(n))
def main(): # construct the argument parse and parse the arguments ap = argparse.ArgumentParser() ap.add_argument("-p", "--prototxt", required=True, help="path to Caffe 'deploy' prototxt file") ap.add_argument("-m", "--model", required=True, help="path to Caffe pre-trained model") ap.add_argument("-c", "--confidence", type=float, default=0.5, help="minimum probability to filter weak detections") ap.add_argument("--fps",type=int, default=15, help="frame rate") ap.add_argument("-a", "--min-area", type=int, default=500, help="minimum area size") ap.add_argument("-i","--motion-tracking",type=bool,default=True, help="Enable motion tracking") ap.add_argument("-o", "--object-tracking", type=bool, default=True, help="Enable selectable object tracking") ap.add_argument("-t","--tracker",type=str,default="kcf", help="Tracker type for object tracking") ap.add_argument("-f", "--facial_recog", type=bool, default=True, help="Facial Recognition Tracking") args = vars(ap.parse_args()) print("[INFO] starting video stream...") vs = VideoStream(src=0).start() time.sleep(2.0) if args['facial_recog']: (H, W) = (None, None) # initialize our centroid tracker and frame dimensions ct = CentroidTracker() # load our serialized model from disk print("[INFO] loading model...") net = cv2.dnn.readNetFromCaffe(args["prototxt"], args["model"]) # initialize the video stream and allow the camera sensor to warmup if args['motion_tracking']: firstFrame=None if args["object_tracking"]: initBB = None # extract the OpenCV version info (major, minor) = cv2.__version__.split(".")[:2] # if we are using OpenCV 3.2 OR BEFORE, we can use a special factory # function to create our object tracker if int(major) == 3 and int(minor) < 3: tracker = cv2.Tracker_create(args["tracker"].upper()) # otherwise, for OpenCV 3.3 OR NEWER, we need to explicity call the # approrpiate object tracker constructor: else: OPENCV_OBJECT_TRACKERS = { "csrt": cv2.TrackerCSRT_create, "kcf": cv2.TrackerKCF_create, "boosting": cv2.TrackerBoosting_create, "mil": cv2.TrackerMIL_create, "tld": cv2.TrackerTLD_create, "medianflow": cv2.TrackerMedianFlow_create, "mosse": cv2.TrackerMOSSE_create } tracker = OPENCV_OBJECT_TRACKERS[args["tracker"]]() while True: st=time.time() #read the next frame from the video stream and resize it frame = vs.read() frame = imutils.resize(frame, width=400) if args['motion_tracking']: firstFrame=motionTracker(frame.copy(),firstFrame,args["min_area"]) if args['object_tracking']: initBB=objectTracker(frame.copy(),initBB,tracker) if args['facial_recog']: W,H = facialRecogTracker(frame.copy(),net,ct,W,H,args["confidence"]) sleepTime = (1 / args['fps'])-(time.time()-st) if sleepTime > 0: time.sleep(sleepTime) key = cv2.waitKey(1) & 0xFF # if the `q` key was pressed, break from the loop if key == ord("q"): break # do a bit of cleanup cv2.destroyAllWindows() vs.stop()
def main(): dataset, timestamps = load_thermal_file( _filename='ThermalData_18_06_2020_13_19_36.h5', _folder='E:\\GitHub\\CovPySourceFile') # region Control Variables is_writing = False is_drawing = False # endregion # region Data Pre-Processing # region Timestamps to Sampling Rate # # convert timestamps into datetime objects # dt_obj = [datetime.fromtimestamp(ts / 1000).time() for ts in timestamps] # # convert datetime objects into time strings # time_strings = [dt.strftime("%M:%S:%f") for dt in dt_obj] # # finally convert time strings into seconds # timestamp_in_seconds = [] # for s in time_strings: # date_time = datetime.strptime(s, "%M:%S:%f") # a_timedelta = date_time - datetime(1900, 1, 1) # in_seconds = a_timedelta.total_seconds() # timestamp_in_seconds.append(in_seconds) # # # calculate the mean interval between samples from seconds # ts_mean = np.mean(np.diff(timestamp_in_seconds)) # # finally calculate the mean sampling rate of the signal # fs = int(1 / ts_mean) # endregion # region Get Raw Thermal Data # get data set attributes n_frames, height, width, total_time_ms = [ dataset.attrs[i] for i in list(dataset.attrs) ] # extract thermal frames from the hdf5 dataset thermal_frames = [] # convert raw data into temperature values [deg Celsius] # temp_frames = [] # normalize raw data for further processing steps [0 - 255] norm_frames = [] for n in range(0, n_frames): raw_frame = load_frame_from_dataset(dataset, height, n) thermal_frames.append(raw_frame) # temp_frames.append(raw_frame * 0.1 - 273.15) norm_frames.append( cv2.normalize(raw_frame, None, alpha=0, beta=255, norm_type=cv2.NORM_MINMAX, dtype=cv2.CV_8U)) # get unsharpened img for edge detection later on unsharp_frames = [] # for n, n_frame in enumerate(norm_frames): # u_frame = unsharp_mask(image=n_frame, radius=3, amount=2) # unsharp_frames.append(u_frame) # # if is_writing: # cv2.imwrite('E:\\GitHub\\CovPySourceFile\\UnsharpenedMask\\UM_{}.png'.format(n), u_frame) # # if is_drawing: # fig, ax = plt.subplots(nrows=1, ncols=2, figsize=(10, 3.5)) # # # Plotting the original image. # ax[0].imshow(norm_frames[n]) # ax[0].set_title('Thermal Data - Normalized') # # # ax[1].imshow(temp_frames[n]) # # ax[1].set_title('Temp Frame [C]') # # ax[1].imshow(unsharp_frames[n]) # ax[1].set_title('Unsharpened Image') # # # ax[1].imshow(norm_frames[n]) # # ax[1].set_title('Thermal Data - Normalized [0-255]') # # plt.subplots_adjust() # plt.show() # # if is_drawing: # plt.close('all') # endregion # endregion # region Feature Extraction Algorithm # region Automatic ROI Detection # face segmentation using multi-level Otsu otsu_masks = multi_level_otsu(images=norm_frames, n_regions=4, target_region=3, method=OtsuMethods.BINARY, write=is_writing, draw=is_drawing) # to proceed the masks need to be converted into 3d array empty_array = np.zeros((height, width)) _3d_otsu_masks = [ np.dstack((mask, empty_array, empty_array)) for mask in otsu_masks ] # use binary otsu mask to detect the face (major_ver, minor_ver, subminor_ver) = cv2.__version__.split('.') # Set up tracker tracker_types = [ 'BOOSTING', 'MIL', 'KCF', 'TLD', 'MEDIANFLOW', 'GOTURN', 'MOSSE', 'CSRT' ] tracker_type = tracker_types[4] if int(minor_ver) < 3: tracker = cv2.Tracker_create(tracker_type) else: if tracker_type == 'BOOSTING': tracker = cv2.TrackerBoosting_create() if tracker_type == 'MIL': tracker = cv2.TrackerMIL_create() if tracker_type == 'KCF': tracker = cv2.TrackerKCF_create() if tracker_type == 'TLD': tracker = cv2.TrackerTLD_create() if tracker_type == 'MEDIANFLOW': tracker = cv2.TrackerMedianFlow_create() if tracker_type == 'GOTURN': tracker = cv2.TrackerGOTURN_create() if tracker_type == 'MOSSE': tracker = cv2.TrackerMOSSE_create() if tracker_type == "CSRT": tracker = cv2.TrackerCSRT_create() # video = cv2.VideoCapture('E:\\GitHub\\CovPySourceFile\\Video\\OtsuMask.avi') # # # Exit if video not opened. # if not video.isOpened(): # print("Could not open video file!") # sys.exit() # # # Read first frame # ok, frame = video.read() # if not ok: # print("Could not read video file!") # sys.exit() tracked_frame = _3d_otsu_masks[0] # Define initial bounding box from roi bbox = cv2.selectROI(tracked_frame, showCrosshair=True, fromCenter=False) # Initialize tracker with first frame and bounding box ok = tracker.init(tracked_frame, bbox) # roi points roi_points = [] tracked_frames = [] # while True: # # Read a new frame # ok, frame = video.read() # if not ok: # break for mask in _3d_otsu_masks: tracked_frame = mask # Start timer timer = cv2.getTickCount() # Update tracker ok, bbox = tracker.update(tracked_frame) # Calculate Frames per second (FPS) fps = cv2.getTickFrequency() / (cv2.getTickCount() - timer) # Draw bounding box if ok: # Tracking success p1 = (int(bbox[0]), int(bbox[1])) p2 = (int(bbox[0] + bbox[2])), int(bbox[1]) p3 = (int(bbox[0] + bbox[2]), int(bbox[1] + bbox[3])) p4 = (int(bbox[0]), int(bbox[1] + bbox[3])) cv2.rectangle(tracked_frame, p1, p3, (255, 0, 0), 2, 1) points = [p1, p2, p3, p4] # roi_values = get_values_from_roi(points, t_frame) roi_points.append(points) else: # Tracking failure cv2.putText(tracked_frame, "Tracking failure detected", (100, 80), cv2.FONT_HERSHEY_SIMPLEX, 0.75, (0, 0, 255), 2) roi_points.append([]) # Display tracker type on frame cv2.putText(tracked_frame, tracker_type + " Tracker", (100, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.75, (50, 170, 50), 2) # Display FPS on frame cv2.putText(tracked_frame, "FPS : " + str(int(fps)), (100, 50), cv2.FONT_HERSHEY_SIMPLEX, 0.75, (50, 170, 50), 2) tracked_frames.append(tracked_frame) # Display result cv2.imshow("Tracking", tracked_frame) # Exit if ESC pressed k = cv2.waitKey(1) & 0xff if k == 27: break is_writing = True if is_writing: for n, img in enumerate(tracked_frames): cv2.imwrite( 'E:\\GitHub\\CovPySourceFile\\TrackedFrames\\TF_{}.png'.format( n), img) norm_face_rois = [] for n in range(0, len(roi_points)): # get values inside of roi norm_roi_values = get_values_from_roi(roi_points[n], norm_frames[n]) # my_roi = np.zeros((roi_shapes[n][2], roi_shapes[n][3])) x1 = roi_points[n][0][0] x2 = roi_points[n][2][0] y1 = roi_points[n][0][1] y2 = roi_points[n][2][1] norm_face_roi = norm_roi_values[y1:y2, x1:x2] if is_drawing: cv2.imshow("ROI", norm_face_roi) # Exit if ESC pressed k = cv2.waitKey(1) & 0xff if k == 27: break norm_face_rois.append(norm_face_roi) if is_writing: for n, img in enumerate(tracked_frames): cv2.imwrite( 'E:\\GitHub\\CovPySourceFile\\FaceROI\\TF_{}.png'.format(n), img) # endregion # endregion print('Bye Bye')
def start(self, bbox, frame): # reset the tracker self.cnt_invis = 0 self.tracker = cv2.Tracker_create('KCF') ret = self.tracker.init(frame, bbox) return ret
] data = { "angle": 0, "found": False, "is_ball": False, "num_rot": 0, "ball_center": (-1, -1), "ball_radius": -1, "curr_marker": -1, "count": 0 } (major_ver, minor_ver, subminor_ver) = (cv2.__version__).split('.') tracker = None if int(minor_ver) < 3: tracker = cv2.Tracker_create('KCF') else: tracker = cv2.TrackerKCF_create() state_changed = False curr_state = states[0] car.initialize() # keep looping for frame in camera.capture_continuous(rawCapture, format="bgr", use_video_port=True): # grab the raw NumPy array representing the image, then initialize the timestamp # and occupied/unoccupied text image = frame.array print curr_state
def process_video(groundtruth_path, image_path, out_video): if int(minor_ver) < 3: tracker = cv2.Tracker_create(tracker_type) else: if tracker_type == 'BOOSTING': tracker = cv2.TrackerBoosting_create() if tracker_type == 'MIL': tracker = cv2.TrackerMIL_create() if tracker_type == 'KCF': tracker = cv2.TrackerKCF_create() if tracker_type == 'TLD': tracker = cv2.TrackerTLD_create() if tracker_type == 'MEDIANFLOW': tracker = cv2.TrackerMedianFlow_create() if tracker_type == 'GOTURN': tracker = cv2.TrackerGOTURN_create() if tracker_type == 'MOSSE': tracker = cv2.TrackerMOSSE_create() if tracker_type == "CSRT": tracker = cv2.TrackerCSRT_create() print('processing sequence', out_video) with open(groundtruth_path) as f: groundtruth = f.readlines() groundtruth = [x.rstrip() for x in groundtruth] image_filenames = [y for x in walk(image_path) for y in glob(join(x[0], '*.jpg'))] image_filenames.sort() assert len(image_filenames) == len(groundtruth) image = cv2.imread(image_filenames[0]) height, width = image.shape[:2] writer = cv2.VideoWriter(out_video, cv2.VideoWriter_fourcc('X','V','I','D'), 15, (width , height)) if not writer.isOpened(): print('Failed to open video') return # VOT sequence # polygon_ = parse_region(groundtruth[0]) # cx, cy, w, h = get_axis_aligned_bbox(polygon_) # target_pos, target_sz = np.array([cx, cy]), np.array([w, h]) polygon = [float(x) for x in groundtruth[0].split(',')] ok = tracker.init(image, (polygon[0], polygon[1], polygon[2], polygon[3])) for i in range(len(image_filenames)): image = cv2.imread(image_filenames[i]) polygon = [float(x) for x in groundtruth[i].split(',')] polygon = [int(x) for x in polygon] # VOT sequence # cv2.line(image, (polygon[0], polygon[1]), (polygon[2], polygon[3]), (0, 0, 255), 2) # cv2.line(image, (polygon[2], polygon[3]), (polygon[4], polygon[5]), (0, 0, 255), 2) # cv2.line(image, (polygon[4], polygon[5]), (polygon[6], polygon[7]), (0, 0, 255), 2) # cv2.line(image, (polygon[6], polygon[7]), (polygon[0], polygon[1]), (0, 0, 255), 2) cv2.rectangle(image, (polygon[0], polygon[1]), (polygon[0]+polygon[2], polygon[1]+polygon[3]), (0, 0, 255), 2) # Start timer timer = cv2.getTickCount() # Update tracker ok, bbox = tracker.update(image) # Calculate Frames per second (FPS) fps = cv2.getTickFrequency() / (cv2.getTickCount() - timer) # Draw bounding box if ok: # Tracking success p1 = (int(bbox[0]), int(bbox[1])) p2 = (int(bbox[0] + bbox[2]), int(bbox[1] + bbox[3])) cv2.rectangle(image, p1, p2, (255,0,0), 2, 1) else : # Tracking failure cv2.putText(image, "Tracking failure detected", (50,80), cv2.FONT_HERSHEY_SIMPLEX, 0.75,(0,255,255),2) # Display tracker type on frame cv2.putText(image, tracker_type + " Tracker", (50,20), cv2.FONT_HERSHEY_SIMPLEX, 0.75, (230,170,50),2) # Display FPS on frame cv2.putText(image, "FPS : " + str(int(fps)), (50,50), cv2.FONT_HERSHEY_SIMPLEX, 0.75, (230,170,50), 2) writer.write(image) writer.release()
def tracking_face(vi_path="try.avi", t_type=7): # Set up tracker. # Instead of MIL, you can also use (major_ver, minor_ver, subminor_ver) = (cv2.__version__).split('.') tracker_types = [ 'BOOSTING', 'MIL', 'KCF', 'TLD', 'MEDIANFLOW', 'GOTURN', 'MOSSE', 'CSRT' ] tracker_type = tracker_types[t_type] # if int(minor_ver) < 3: if int(major_ver) < 3: tracker = cv2.Tracker_create(tracker_type) else: if tracker_type == 'BOOSTING': tracker = cv2.TrackerBoosting_create() if tracker_type == 'MIL': tracker = cv2.TrackerMIL_create() if tracker_type == 'KCF': tracker = cv2.TrackerKCF_create() if tracker_type == 'TLD': tracker = cv2.TrackerTLD_create() if tracker_type == 'MEDIANFLOW': tracker = cv2.TrackerMedianFlow_create() if tracker_type == 'GOTURN': tracker = cv2.TrackerGOTURN_create() if tracker_type == 'MOSSE': tracker = cv2.TrackerMOSSE_create() if tracker_type == "CSRT": tracker = cv2.TrackerCSRT_create() # Read video video = cv2.VideoCapture(vi_path) # Exit if video not opened. if not video.isOpened(): print("Could not open video") sys.exit() # Read first frame. ok, frame = video.read() if not ok: print('Cannot read video file') sys.exit() # Define an initial bounding box height, width, layers = frame.shape # box # bbox_transfer() bbox, score = bbox_score(frame) bbox = np.squeeze(bbox)[0] score = np.squeeze(score)[0] while True: if score > 0.7: break ok, frame = video.read() bbox, score = bbox_score(frame) bbox = np.squeeze(bbox)[0] score = np.squeeze(score)[0] bbox = bbox_transfer(bbox, height, width) # bbox = (bbox[1]*width,bbox[0]*height,bbox[2]-bbox[0],bbox[3]-bbox[1]) # bbox = tuple(bbox) # bbox = (265, 48, 70, 82)# x,y, w, h # bbox = (48,151,128,186) # *H ymin, xmin, ymax, xmax # bbox = (85,270,228,332) # *W # bbox = (85,151,228,186) A - 151 85 (228-85) 186-151 # bbox = (48,270,128,332) B # print(bbox.shape,score.shape) # Uncomment the line below to select a different bounding box # bbox = cv2.selectROI(frame, False) # Initialize tracker with first frame and bounding box ok = tracker.init(frame, bbox) # bbox = bbox_transfer(bbox) while True: # Read a new frame ok, frame = video.read( ) # I think this line should be put after tracker.update if not ok: break # Start timer timer = cv2.getTickCount() # Update tracker ok, bbox = tracker.update(frame) # Calculate Frames per second (FPS) fps = cv2.getTickFrequency() / (cv2.getTickCount() - timer) # Draw bounding box if ok: # Tracking success p1 = (int(bbox[0]), int(bbox[1])) p2 = (int(bbox[0] + bbox[2]), int(bbox[1] + bbox[3])) cv2.rectangle(frame, p1, p2, (255, 0, 0), 2, 1) else: # Tracking failure cv2.putText(frame, "Tracking failure detected", (100, 80), cv2.FONT_HERSHEY_SIMPLEX, 0.75, (0, 0, 255), 2) # Display tracker type on frame cv2.putText(frame, tracker_type + " Tracker", (100, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.75, (50, 170, 50), 2) # Display FPS on frame cv2.putText(frame, "FPS : " + str(int(fps)), (100, 50), cv2.FONT_HERSHEY_SIMPLEX, 0.75, (50, 170, 50), 2) # Display result cv2.imshow("Tracking", frame) # Exit if ESC pressed k = cv2.waitKey(1) & 0xff if k == 27: break