k = cv2.waitKey(1) & 0xFF if k == 27: ##ser.close() cap.release() cv2.destroyAllWindows() sys.exit() print("Obj Detected") # End of Obj Detection #------------------------------------------------------------------------------------------- # Start of Trackers KCF and MEDIANFLOW ser = serial.Serial("COM3", 9600) tracker_KCF = cv2.TrackerKCF_create() tracker_MEDIANFLOW = cv2.TrackerMedianFlow_create() bbox = np.array(bbox) bbox[0] = dst[0, 0, 0] bbox[1] = dst[0, 0, 1] bbox[2] = dst[2, 0, 0] - bbox[0] bbox[3] = dst[2, 0, 1] - bbox[1] bbox = tuple(bbox) # Initialize tracker with first frame and bounding box ok = tracker_KCF.init(frame_copy, bbox) and tracker_MEDIANFLOW.init( frame_copy, bbox) print("Start Tracking") while (True): ok, frame = cap.read() if not ok:
out = cv2.VideoWriter('output.mp4', fourcc, 20.0, (width, height)) except Exception as e: print(e) return cap, out if __name__ == '__main__': tracker_switcher = { 'BOOSTING': cv2.TrackerBoosting_create(), 'MIL': cv2.TrackerMIL_create(), 'KCF': cv2.TrackerKCF_create(), 'TLD': cv2.TrackerTLD_create(), 'MEDIANFLOW': cv2.TrackerMedianFlow_create(), 'CSRT': cv2.TrackerCSRT_create(), 'MOSSE': cv2.TrackerMOSSE_create() } # Initialize the tracker with the configured type tracker = tracker_switcher[settings.TRACKER_TYPE] # Capture frame-by-frame cap, out = get_cam_frames() ok, frame = cap.read() # Define an initial bounding box bbox = (287, 23, 86, 320) # Uncomment the line below to select a different bounding box
def create_tracker(self, img, bbox): self.tracker = cv2.TrackerMedianFlow_create() self.tracker.init(img, bbox)
def tracking_MEDIANFLOW(videofile, fps, save = False): # trackerのしくみを決める tracker_type = 'MEDIANFLOW' tracker = cv2.TrackerMedianFlow_create() # Read Video(sizeは512x512を推奨) video = cv2.VideoCapture(videofile) now = datetime.datetime.now() timestamp = '{0:%Y%m%d_%H%M%S}'.format(now) # Output setting fourcc = cv2.VideoWriter_fourcc(*'DIVX') if save == True: out = cv2.VideoWriter('tracking_output_%s.mp4'%timestamp, fourcc , fps, (512,512)) # 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 the video file") sys.exit() # Define an initial bouding box bbox = (144, 295, 60, 40) # Initialize tracker with first frame and bounding box ok = tracker.init(frame, bbox) while True: # read a new frame ok, frame = video.read() if not ok: time.sleep(2) 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 bouding 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) # Save result as movie file if save == True: out.write(frame) #Exit if ESC pressed k = cv2.waitKey(1) & 0xff if k == 27: break # When everything done, release the capture video.release() if save == True: out.release() cv2.destroyAllWindows()
def detect(self): cap = cv2.VideoCapture(0) if not cap.isOpened(): print("Камера не в 0 порту") sys.exit() tracker = cv2.TrackerMedianFlow_create() ok, frame = cap.read() if not ok: print('Ошибка чтения видео') sys.exit() bbox = (287, 23, 86, 320) bbox = cv2.selectROI(frame, False) ok = tracker.init(frame, bbox) while True: # Читаем новый фрейм ok, frame = cap.read() if not ok: break # Запуск таймера timer = cv2.getTickCount() # Обновляем трекер ok, bbox = tracker.update(frame) # Вычисляем fps 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), 2, 1) else: # Объект не найден cv2.putText(frame, "Cant find any", (100, 80), cv2.FONT_HERSHEY_SIMPLEX, 0.75, (0, 0, 255), 2) # HUD трекера( какой трекер используется) cv2.putText(frame, "MedianFlowTracker", (100, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.75, (50, 170, 50), 2) # HUD fps cv2.putText(frame, "FPS : " + str(int(fps)), (100, 50), cv2.FONT_HERSHEY_SIMPLEX, 0.75, (50, 170, 50), 2) face_cascade = cv2.CascadeClassifier( 'haarcascades/haarcascade_frontalface_default.xml') eye_cascade = cv2.CascadeClassifier( 'haarcascades/haarcascade_eye.xml') image = frame.copy() gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) faces = face_cascade.detectMultiScale(gray, 1.3, 5) for (x, y, w, h) in faces: cv2.rectangle(image, (x, y), (x + w, y + h), (255, 0, 0), 2) # roi_gray = gray[y:y + h, x:x + w] # roi_color = img[y:y + h, x:x + w] for_eyes = gray[y:y + h, x:x + w] eyes = eye_cascade.detectMultiScale(for_eyes) for (ex, ey, ew, eh) in eyes: cv2.rectangle(image, (ex + x, ey + y), (x + ex + ew, y + ey + eh), (0, 255, 0), 2) # Вывод #cv2.imshow("Tracking", frame) cv2.imshow("Faces", image) # Выход по клавише esc k = cv2.waitKey(1) & 0xff if k == 27: break
def 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[2] tracker_type = 'MOSSE' if tracker_type == 'BOOSTING': tracker = cv.TrackerBoosting_create() if tracker_type == 'MIL': tracker = cv.TrackerMIL_create() if tracker_type == 'KCF': tracker = cv.TrackerKCF_create() if tracker_type == 'TLD': tracker = cv.TrackerTLD_create() if tracker_type == 'MEDIANFLOW': tracker = cv.TrackerMedianFlow_create() if tracker_type == 'GOTURN': tracker = cv.TrackerGOTURN_create() if tracker_type == 'MOSSE': tracker = cv.TrackerMOSSE_create() if tracker_type == "CSRT": tracker = cv.TrackerCSRT_create() # Read video video = cv.VideoCapture(0) # 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 = (287, 23, 86, 320) # Uncomment the line below to select a different bounding box bbox = cv.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() if not ok: break # Start timer timer = cv.getTickCount() # Update tracker ok, bbox = tracker.update(frame) # Calculate Frames per second (FPS) fps = cv.getTickFrequency() / (cv.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])) cv.rectangle(frame, p1, p2, (255, 0, 0), 2, 1) else: # Tracking failure cv.putText(frame, "Tracking failure detected", (100, 80), cv.FONT_HERSHEY_SIMPLEX, 0.75, (0, 0, 255), 2) # Display tracker type on frame cv.putText(frame, tracker_type + " Tracker", (100, 20), cv.FONT_HERSHEY_SIMPLEX, 0.75, (50, 170, 50), 2) # Display FPS on frame cv.putText(frame, "FPS : " + str(int(fps)), (100, 50), cv.FONT_HERSHEY_SIMPLEX, 0.75, (50, 170, 50), 2) # Display result cv.imshow("Tracking", frame) # Exit if ESC pressed if cv.waitKey(1) == ord('q'): print('release') break
def _display_camera(self): failed_frames_counter = 0 while self.playing: if not self.paused: frame_start = time.time() ret, raw_frame = self.camera.read() if ret: failed_frames_counter = 0 raw_frame = cv2.flip(raw_frame, 1) frame = np.copy(raw_frame) if len(frame.shape) != 3: frame = cv2.merge((frame, frame, frame)) if self.measure_pulse: if self.tracker == None: print('Tracking initialized') #self.tracker = cv2.TrackerCSRT_create() self.tracker = cv2.TrackerMedianFlow_create() self.tracker.init(frame, self.roi.to_tuple()) # analyze max 5 seconds self.pulse_processor.buffer_size = math.ceil( MAX_FPS * 5) # round(1 / average(self.frame_times))*5 # open output files means_file = open('mean.csv', 'w') means_file.write('frame,x,y,w,h,g_mean\n') fft_file = open('fft.csv', 'w') fft_file.write( 'start_frame,end_frame,amp_bmp_48,amp_bmp_60,amp_bmp_72,amp_bmp_84,amp_bmp_96,amp_bmp_108,amp_bmp_120,amp_bmp_132,amp_bmp_144\n' ) bpm_file = open('bpm.csv', 'w') bpm_file.write('frame,bpm\n') else: ok, tracked = self.tracker.update(frame) self.roi.set_roi(*tracked) if ok: x, y, w, h = self.roi.to_tuple() pulse_visualized = self.pulse_processor.run( frame[y:y + h, x:x + w, :]) frame[y:y + h, x:x + w, :] = pulse_visualized means_file.write('{},{},{},{},{},{}\n'.format( self.camera.get_frame_position(), x, y, w, h, self.pulse_processor.data_buffer[-1])) means_file.flush() if (len(self.pulse_processor.data_buffer) == self.pulse_processor.buffer_size): fft_file.write( '{},{},{},{},{},{},{},{},{},{},{}\n'. format( self.camera.get_frame_position() - MAX_FPS * 5 - 1, self.camera.get_frame_position(), *self.pulse_processor.fft)) fft_file.flush() bpm_file.write('{},{}\n'.format( self.camera.get_frame_position(), self.pulse_processor.bpm)) bpm_file.flush() else: print('Tracking failed...') if self.recording: self._record_frame(frame) if self.overlay_active: self.add_overlay_to_frame(frame) # frame[:, :, 0] = 0#blue # frame[:, :, 1] = 0#green # frame[:, :, 2] = 0#red cv2.imshow(self.window_name, frame) # cv2.waitKey(1) # cap fps to MAX_FPS diff = 1 / MAX_FPS - (time.time() - frame_start) time.sleep(0 if diff < 0 else diff) self.frame_times.append((time.time() - frame_start)) else: failed_frames_counter += 1 if failed_frames_counter > 100: self.camera_defect = True break #playback is paused else: frame = np.copy(raw_frame) if self.overlay_active: self.add_overlay_to_frame(frame) cv2.imshow(self.window_name, frame)
def start_tracking(self): tracker_types = [ 'BOOSTING', 'MIL', 'KCF', 'TLD', 'MEDIANFLOW', 'CSRT', 'MOSSE' ] tracker_type = tracker_types[6] 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 == 'CSRT': tracker = cv2.TrackerCSRT_create() if tracker_type == 'MOSSE': tracker = cv2.TrackerMOSSE_create() # Initialize tracker with first frame and bounding box while (self.frame == None): try: print("Waiting for image ...") rospy.spin() except Exception: break print("Got image...") cv2.imshow("Tracking", self.frame) print("Got bottle...") self.update_bbox() ok = tracker.init(self.frame, self.bbox) while True: # Start timer timer = cv2.getTickCount() # Update tracker ok, self.bbox = tracker.update(self.frame) # Calculate Frames per second (FPS) fps = cv2.getTickFrequency() / (cv2.getTickCount() - timer) # Draw bounding box if ok: # Tracking success p1 = (int(self.bbox[0]), int(self.bbox[1])) p2 = (int(self.bbox[0] + self.bbox[2]), int(self.bbox[1] + self.bbox[3])) cv2.rectangle(self.frame, p1, p2, (255, 0, 0), 2, 1) else: # Tracking failure cv2.putText(self.frame, "Tracking failure detected", (100, 80), cv2.FONT_HERSHEY_SIMPLEX, 0.75, (0, 0, 255), 2) # Display tracker type on frame cv2.putText(self.frame, tracker_type + " Tracker", (100, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.75, (50, 170, 50), 2) # Display FPS on frame cv2.putText(self.frame, "FPS : " + str(int(fps)), (100, 50), cv2.FONT_HERSHEY_SIMPLEX, 0.75, (50, 170, 50), 2) # Display result cv2.imshow("Tracking", self.frame) rospy.spin()
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
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(): 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')
import cv2 tracker = None CORRELATION_TRACKER = 'csrt' # OPENCV_OBJECT_TRACKERS or dlib 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() } def init_tracker(frame): global tracker if CORRELATION_TRACKER == 'dlib': tracker = dlib.correlation_tracker() roi = cv2.selectROI("Frame", frame, fromCenter=False, showCrosshair=False) roi = dlib.rectangle(roi[0], roi[1], roi[0] + roi[2], roi[1] + roi[3]) tracker.start_track(frame, roi) else: tracker = OPENCV_OBJECT_TRACKERS[CORRELATION_TRACKER] roi = cv2.selectROI("Frame", frame, fromCenter=False,
def run_concurrent(self, args, sign_progress): annotation_id = args[0] bbox = tuple(args[1]) movie_path = args[2] fps = args[5] start_frame = ms_to_frames(args[3], fps) end_frame = ms_to_frames(args[4], fps) method = args[6] resolution = args[7] keys = [] # TRACKING if method == 'BOOSTING': tracker = cv2.TrackerBoosting_create() elif method == 'MIL': tracker = cv2.TrackerMIL_create() elif method == 'KCF': tracker = cv2.TrackerKCF_create() elif method == 'TLD': tracker = cv2.TrackerTLD_create() elif method == 'MEDIANFLOW': tracker = cv2.TrackerMedianFlow_create() elif method == 'GOTURN': tracker = cv2.TrackerGOTURN_create() else: raise Exception("Tracking Method not identifiable. " + str(method)) # Read video capture = cv2.VideoCapture(movie_path) # Exit if video not opened. if not capture.isOpened(): raise RuntimeError("Tracking: Could not open video.") # Read first frame. capture.set(cv2.CAP_PROP_POS_FRAMES, start_frame) ok, frame = capture.read() if not ok: raise RuntimeError("Tracking: Could not read Frame.") # Initialize tracker with first frame and bounding box ok = tracker.init(frame, bbox) for i in range(start_frame, end_frame, 1): sign_progress( round(float(i - start_frame) / (end_frame - start_frame), 2)) # Read a new frame ok, frame = capture.read() if not ok: break # Update tracker ok, bbox = tracker.update(frame) # Draw bounding box if ok: # Tracking success if i % resolution == 0: time = frame2ms(i, fps) pos = [bbox[0], bbox[1]] keys.append([time, pos]) 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) # cv2.imshow("Returned", frame) # cv2.waitKey(30) return [annotation_id, keys]
def initialize_track(self, image, boxes): # return boxes self.tracker = cv2.MultiTracker_create() for box in boxes: self.tracker.add(cv2.TrackerMedianFlow_create(), image, box)
def main(): args = build_argparser().parse_args() log.basicConfig( format="[ %(levelname)s ] %(asctime)-15s %(message)s", level=log.INFO, stream=sys.stdout, ) log.debug(str(args)) log.info("Reading input data from '%s'" % (args.input)) stream = args.input try: stream = int(args.input) except ValueError: pass cap = cv2.VideoCapture(stream) frame_size = ( int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)), int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)), ) input_crop = None if args.crop_width and args.crop_height: input_crop = np.array((args.crop_width, args.crop_height)) crop_size = (args.crop_width, args.crop_height) frame_size = tuple(np.minimum(frame_size, crop_size)) frame_timeout = 0 if args.timelapse else 1 if args.tracker == "BOOSTING": tracker = cv2.TrackerBoosting_create() elif args.tracker == "MIL": tracker = cv2.TrackerMIL_create() elif args.tracker == "KCF": tracker = cv2.TrackerKCF_create() elif args.tracker == "TLD": tracker = cv2.TrackerTLD_create() elif args.tracker == "MEDIANFLOW": tracker = cv2.TrackerMedianFlow_create() elif args.tracker == "GOTURN": tracker = cv2.TrackerGOTURN_create() elif args.tracker == "CSRT": tracker = cv2.TrackerCSRT_create() tracker = tracker_initial(args.tracker) traceStart = 0 traceWarning = True while True: (grabbed, frame) = cap.read() if not grabbed: log.error("no inputs") break if args.log: start = time.time() if input_crop is not None: frame = center_crop(frame, input_crop) if traceStart: ok, bbox = tracker.update(frame) 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, (0, 255, 0), 3) if not traceWarning: traceWarning = True else: if traceWarning: log.warning("Tracking lost") traceWarning = False if args.log: end = time.time() log.info("Tracking took {:.6f} seconds".format(end - start)) cv2.imshow("Tracking", frame) getKey = cv2.waitKey(frame_timeout) & 0xFF if getKey in BREAK_KEYS: break elif getKey in TRACKING_KEYS: bbox = cv2.selectROI(frame, False) ok = tracker.init(frame, bbox) traceStart = 1 cv2.destroyAllWindows() elif getKey in CAPTURE_KEYS: log.info("Screen captured") save_result(frame, "tracking") elif getKey in TRACKING_STOP_KEYS: tracker.clear() tracker = tracker_initial(args.tracker) traceStart = 0 cap.release() cv2.destroyAllWindows()
# Pass blob to model model.setInput(blob) # Execute forward pass outputs = model.forward(outputNames) bboxes, probs, class_ids = where_is_it(frame, outputs) if len(bboxes) > 0: # Init multitracker mtracker = cv2.MultiTracker_create() # Apply non-max suppression and pass boxes to the multitracker idxs = cv2.dnn.NMSBoxes(bboxes, probs, P_THRESH, NMS_THRESH) for i in idxs: bbox = [int(v) for v in bboxes[i[0]]] x, y, w, h = bbox # Use median flow mtracker.add(cv2.TrackerMedianFlow_create(), frame, (x, y, w, h)) # Increase counter count += 1 else: # declare failure cv2.putText(frame, 'Detection failed', (20, 80), cv2.FONT_HERSHEY_SIMPLEX, 0.75, (0, 0, 255), 2) else: # perform tracking is_tracking, bboxes = mtracker.update(frame) if is_tracking: for i, bbox in enumerate(bboxes): x, y, w, h = [int(val) for val in bbox] class_id = classes[class_ids[idxs[i][0]]] col = [int(c) for c in colors[class_ids[idxs[i][0]], :]] # Mark tracking frame with corresponding color, write class name on top cv2.rectangle(frame, (x, y), (x + w, y + h), col, 2)
def main_thread(self): self.cap = cv2.VideoCapture(self.data_bridge.selected_video_file_path) num = 0 number=0 while self.data_bridge.start_process_manager: if self.data_bridge.start_process_manager and (number==0 or number>99): if number>99: number=0 ret, frame = self.cap.read() frame = cv2.resize(frame, (720, 480)) if num < self.skip_frames: num += 1 cv2.imshow('Camera', frame) cv2.waitKey(10) continue result = self.detect(frame) # print(np.shape(result), "result shape", result[:][0]) self.draw_result(frame, result) number+=1 cv2.imshow('Camera', frame) cv2.waitKey(1) num += 1 self.gui_root.update() if (self.data_bridge.start_process_manager and (number<100)): a = int(len(result)) tracker_types = ['BOOSTING', 'MIL', 'KCF', 'TLD', 'MEDIANFLOW', ] tracker_type = self.data_bridge.methode_chosen_for_tracking print(tracker_type) if True: if tracker_type == 'BOOSTING': tracker = [] i = 0 while i < a: tracker.append(cv2.TrackerBoosting_create()) i = i + 1 if tracker_type == 'MIL': tracker = [] i = 0 while i < a: tracker.append(cv2.TrackerMIL_create()) i = i + 1 if tracker_type == 'KCF': tracker = [] i = 0 while i < a: tracker.append(cv2.TrackerKCF_create()) i = i + 1 if tracker_type == 'TLD': tracker = [] i = 0 while i < a: tracker.append(cv2.TrackerTLD_create()) i = i + 1 if tracker_type == 'MEDIANFLOW': tracker = [] i = 0 while i < a: tracker.append(cv2.TrackerMedianFlow_create()) i = i + 1 bbox = [] i = 0 while i < a: x = int(result[i][1]) y = int(result[i][2]) w = int(result[i][3] / 2) h = int(result[i][4] / 2) res=(x-w,y-h,2*w,2*h) bbox.append(res) #print(bbox[i]) tracker[i].init(frame, bbox[i]) i = i+1 while (number<100)and(self.data_bridge.start_process_manager): ret, frame = self.cap.read() frame = cv2.resize(frame, (720, 480)) timer = cv2.getTickCount() i = 0 while i < a: ret, bbox[i] = tracker[i].update(frame) i = i + 1 fps = cv2.getTickFrequency() / (cv2.getTickCount() - timer); if ret: i = 0 while i < a: p1 = (int(bbox[i][0]), int(bbox[i][1])) p2 = (int(bbox[i][0] + bbox[i][2]), int(bbox[i][1] + bbox[i][3])) cv2.rectangle(frame, p1, p2, (255, 255, 255), 2, 1) i = i + 1 else: cv2.putText(frame, "Tracking failure detected", (100, 80), cv2.FONT_HERSHEY_SIMPLEX, 0.75,(0, 0, 255),2) cv2.putText(frame, str(i)+ " Object detected", (400, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.75, (50, 170, 50), 2); cv2.putText(frame, tracker_type + " Tracker", (100, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.75, (50, 170, 50),2); cv2.putText(frame, "FPS : " + str(int(fps)), (100, 50), cv2.FONT_HERSHEY_SIMPLEX, 0.75, (50, 170, 50),2); cv2.imshow("Camera", frame) k = cv2.waitKey(1) self.gui_root.update() number+=1 print("number",number) cv2.destroyAllWindows() self.cap.release()
import cv2 import sys import find as f import numpy as np import neural_network as nn import os.path import matplotlib.pyplot as plt tracker = cv2.TrackerMedianFlow_create() counter = 0 colors = [] limit = 4 kernel = np.ones((3, 3), np.uint8) rectangle_distance_limit = 2 suma = 0 last_blue_roi_shape = (0, 0) last_blue_predicted_number = 0 last_green_roi_shape = (0, 0) last_green_predicted_number = 0 DIR = 'D:\\Boban\Fakultet\Soft\Projekti\softPredef' file = open(DIR + '\\out.txt', 'w') file.write('RA 89/2014 Boban Poznanovic\nfile sum\n') DIR = DIR + '\\videos' video_names = [] for name in os.listdir(DIR): if os.path.isfile(os.path.join(DIR, name)): video_names.append(os.path.join(DIR, name))
IMG_NAME = "img_%d.jpeg" % index PATH_TO_IMAGE = os.path.join(CWD_PATH, FILE_NAME, 'Figures/', IMG_NAME) image = cv2.imread(PATH_TO_IMAGE) tstart = time.time() if not trackEnable or not TRACK_FLAG: count += 1 image_expanded = np.expand_dims(image, axis=0) (boxes_ml, scores_ml, classes_ml, num) = sess.run( [detection_boxes, detection_scores, detection_classes, num_detections], feed_dict={image_tensor: image_expanded}) boxes_ml = boxes_ml.reshape(-1, 4) if threshold is not False: boxes_ml = boxes_ml[(scores_ml > threshold).reshape(-1), ] boxes_ml = pdf.tfcv_convertor(boxes_ml, image.shape[0:2], source='tf') for bbox in boxes_ml: multitracker.add(cv2.TrackerMedianFlow_create(), image, bbox) boxes_ml = pdf.tfcv_convertor(boxes_ml, image.shape[0:2], source='cv') if boxes_ml.shape[0] <= 1: TRACK_FLAG = False multitracker = cv2.MultiTracker_create() else: TRACK_FLAG = True else: success, boxes_ml = multitracker.update(image) boxes_ml = pdf.tfcv_convertor(boxes_ml, image.shape[0:2], source='cv') if boxes_ml.shape[0] <= 1: TRACK_FLAG = False multitracker = cv2.MultiTracker_create() count += 1 else:
def main(_argv): th = threading.Thread(target=arduino_read) th.start() physical_devices = tf.config.experimental.list_physical_devices('GPU') for physical_device in physical_devices: tf.config.experimental.set_memory_growth(physical_device, True) if FLAGS.tiny: yolo = YoloV3Tiny(classes=FLAGS.num_classes) else: yolo = YoloV3(classes=FLAGS.num_classes) yolo.load_weights(FLAGS.weights) logging.info('weights loaded') class_names = [c.strip() for c in open(FLAGS.classes).readlines()] logging.info('classes loaded') CUDA = torch.cuda.is_available() times = [] inp_dim = int('416') assert inp_dim % 32 == 0 assert inp_dim > 32 try: vid = cv2.VideoCapture(1) #cam number - usb=1 vid = cap except: vid = cv2.VideoCapture(FLAGS.video) # vid = cv2.VideoCapture(0) out = None if FLAGS.output: # by default VideoCapture returns float instead of int width = int(vid.get(cv2.CAP_PROP_FRAME_WIDTH)) height = int(vid.get(cv2.CAP_PROP_FRAME_HEIGHT)) fps = int(vid.get(cv2.CAP_PROP_FPS)) codec = cv2.VideoWriter_fourcc(*FLAGS.output_format) out = cv2.VideoWriter(FLAGS.output, codec, fps, (width, height)) tracker = cv2.TrackerKCF_create() fps = None initBB = None # initBB = True redetect = False failCnt = 0 global start check_start = None while True: ret, frame = vid.read() #img = frame # if frmae is None: # logging.warning("Empty Frame") # time.sleep(0.1) # continue # frame = imutils.resize(frame, width = 500) (H, W) = frame.shape[:2] img_in = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) img_in = tf.expand_dims(img_in, 0) img_in = transform_images(img_in, FLAGS.size) boxes, scores, classes, nums = yolo.predict(img_in) # t1 = time.time() # boxes, scores, classes, nums = yolo.predict(img_in) # t2 = time.time() # times.append(t2-t1) # times = times[] # print('initBB = ', initBB) if initBB is not None: (success, box) = tracker.update(frame) if start == 'q': initBB = None tracker = cv2.TrackerMedianFlow_create() ardu_stop() elif success: failCnt = 0 (x, y, w, h) = [int(v) for v in box] cv2.rectangle(frame, (x+30, y), (x + w-30, y + h), (0, 255, 0), 2) ardu(box) # frame = draw_outputs(frame, (boxes, scores, classes, nums), class_names) else: failCnt += 1 ardu_detect() if failCnt > 50: redetect = True initBB = None tracker = cv2.TrackerKCF_create() # fps.update() # fps.stop() # info = [ # ('Tracker', 'kcf'), # ('Success', 'yes' if success else 'No'), # ('FPS', '{:.2f}'.format(fps.fps())), # ] # # for (i, (k, v)) in enumerate(info): # text = '{}:{}'.format(k, v) # cv2.putText(frame, text, (10, H-((i*20)+20)), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 255, 2)) # if redetect: # ret, frame = vid.read() # gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) # template = cv2.imread('./user_faces/user.jpg', 0) # w, h = template.shape[::-1] # # res = cv2.matchTemplate(gray, template, cv2.TM_SQDIFF) # min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(res) # top_left = min_loc # bottom_right = (top_left[0] + w, top_left[1] + h) # cv2.rectangle(frame, top_left, bottom_right, (0, 255, 0), 1) """ imgray = cv2.cvtColor(frame, cv2.COLOR_RGB2GRAY) w, h = imgray.shape[::-1] templ = cv2.imread('./user.jpg', cv2.IMREAD_GRAYSCALE) templ_h, templ_w = templ.shape[::-1] res = cv2.matchTemplate(imgray, templ, cv2.TM_CCOEFF_NORMED) loc = np.where(res >= 0.6) for pt in zip(*loc[::-1]): cv2.rectangle(frame, pt, (pt[0] + w, pt[1] + h), (0, 255, 0), 1) """ key = cv2.waitKey(1) & 0xFF if key == ord('s') or start == 's': check_start = start_tracker(frame, (boxes, scores, classes, nums), class_names) if check_start is not None: start = 'a' initBB = tuple(check_start) tracker.init(frame, initBB) x, y, w, h = check_start frame_user = frame[y:y+h,x+20:x+w-20] cv2.imwrite('./user_faces/user.jpg', frame_user) # fps = FPS().start() # img, orig_im, dim = prep_image(frame, inp_dim) # img = prep_image(frame, inp_dim) # cv2.imshow('img', frame) # if CUDA: # # im_dim = im_dim.cuda() # img = img.cuda() # # with torch.no_grad(): # output = model(Variable(img),CUDA) # output = write_results(output, confidence, num_classes, nms = True, nms_conf = nms_thesh) # try: # if output[0][0].tolist() == 0: # #tensor[0][0] mean the category of predicted class and 0 is person in coco.names # initBB = np.array([int(i) for i in output[0][1:5].tolist]) # x, y, w, h = initBB # initBB = (x, y, w, h) # frame_user = frame[x-10:w+10, y-10:h+10] # cv2.imwrite('./user_faces/user.jpg', frame_user) # tracker.init(frame, initBB) # fps = FPS().start() # except: # print("다시해주세요") #print(initBB) cv2.imshow('img', frame) if key == ord('q'): ardu_stop() break vid.release() cv2.destroyAllWindows()
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()) go_live = True if go_live: # start video stream thread, allow buffer to fill print("[INFO] starting threaded video stream...") stream = WebcamVideoStream(src=0).start() # default camera time.sleep(1.0) # first frame frame = stream.read() else: # Read video video = cv2.VideoCapture("chaplin.mp4") # Exit if video not opened.
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() ''' # populates trackers dict with all types of trackers trackers = {} trackers["BOOSTING"] = cv2.TrackerBoosting_create() trackers["MIL"] = cv2.TrackerMIL_create() trackers["KCF"] = cv2.TrackerKCF_create() trackers["TLD"] = cv2.TrackerTLD_create() trackers["MEDIANFLOW"] = cv2.TrackerMedianFlow_create() trackers["MOSSE"] = cv2.TrackerMOSSE_create() trackers["CSRT"] = cv2.TrackerCSRT_create() #trackers = cv2.TrackerGOTURN_create() tracker = cv2.TrackerBoosting_create() # Read video video = cv2.VideoCapture(infilename) # Write video fourcc = cv2.VideoWriter_fourcc('D', 'I', 'V', 'X') out = cv2.VideoWriter(outfilename, fourcc, video_fps, (int(video.get(3)), int(video.get(4))), True) # Exit if video not opened.
def tracker(): red = (0, 0, 255) blue = (255, 0, 0) green = (0, 255, 0) frameCounter = 0 currentCarID = 0 # dictionary for locations previous_location = {} current_location = {} # dictionary for trackers carTracker = {} # dictionary for corners corners1 = {} corners2 = {} corners_update = {} corners_center = {} old_corners_center = {} width1 = {} width2 = {} speed = {} time1 = {} time2 = {} while True: # read frame and check it, if it is not frame break rc, image = video.read() if type(image) == type(None): break # start time of iteration # crop frame # copy cropped frame # add 1 to frame counter # start = time.time() image = image[150:600, 150:950] resultImage = image.copy() frameCounter = frameCounter + 1 # create empty list for trackers you need to delete carIDtoDelete = [] # iterate trough dictionary of created trackers and if object leave frame delete tracker for carID in carTracker.keys(): # get position of bounding box trackedPosition = carTracker[carID].update(image) t_x, t_y, t_w, t_h = trackedPosition[1] t_x = int(t_x) t_y = int(t_y) t_w = int(t_w) t_h = int(t_h) # x_center = t_x + 0.5 * t_w # y_center = t_y + 0.5 * t_h # if object leave frame add tracker to delete list if t_x + t_w >= 750: carIDtoDelete.append(carID) elif t_y >= 570 or t_y <= 0: carIDtoDelete.append(carID) elif t_x <= 0: carIDtoDelete.append(carID) # delete all trackers in delete list for carID in carIDtoDelete: # print 'Tracker deleted: ' + str(carID) + '.' # print 'Current location deleted: ' + str(carID) + '.' # print 'Previous location deleted: ' + str(carID) + '.' # print 'Corners 1 deleted: ' + str(carID) + '.' # print 'Corners 2 deleted: ' + str(carID) + '.' # print 'Width 1 deleted: ' + str(carID) + '.' # print 'Width 2 deleted: ' + str(carID) + '.' # print '\n' carTracker.pop(carID, None) current_location.pop(carID, None) previous_location.pop(carID, None) corners1.pop(carID, None) corners2.pop(carID, None) width1.pop(carID, None) width2.pop(carID, None) time1.pop(carID, None) time2.pop(carID, None) corners_center.pop(carID, None) old_corners_center.pop(carID, None) # try to detect new object in frame in every 10 frames if not (frameCounter % 10): # convert frame to grayscale # try to detect new object in frame gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) cars = carCascade.detectMultiScale(gray, 1.15, 15) # if object is detected, save it location and calculate center point of bounding box for (_x, _y, _w, _h) in cars: x = int(_x) + 7 y = int(_y) + 7 w = int(_w) - 5 h = int(_h) - 5 x_bar = x + 0.5 * w y_bar = y + 0.5 * h matchCarID = None # iterate trough tracked objects for carID in carTracker.keys(): # get object location and calculate center point of tracked object trackedPosition = carTracker[carID].update(image) t_x, t_y, t_w, t_h = trackedPosition[1] t_x = int(t_x) t_y = int(t_y) t_w = int(t_w) t_h = int(t_h) t_x_bar = t_x + 0.5 * t_w t_y_bar = t_y + 0.5 * t_h # if condition is true, detected object already have tracker if ((t_x <= x_bar <= (t_x + t_w)) and (t_y <= y_bar <= (t_y + t_h)) and (x <= t_x_bar <= (x + w)) and (y <= t_y_bar <= (y + h))): matchCarID = carID # if detected object don't have tracker yet, create new tracker and add it to tracker dictionary # save object location for speed estimation if matchCarID is None: bbox = (x, y, w, h) if bbox[0] + bbox[2] < 400 and bbox[1] < 100 and bbox[ 0] > 70: tracker = cv2.TrackerMedianFlow_create() tracker.init(image, bbox) carTracker[currentCarID] = tracker previous_location[currentCarID] = bbox ROI = gray[y:y + h, x:x + h] corners1[currentCarID] = cv2.goodFeaturesToTrack( ROI, 10, 0.25, 5) corners1[currentCarID][:, 0, 0] += x corners1[currentCarID][:, 0, 1] += y for i in corners1[currentCarID]: x, y = i.ravel() cv2.circle(resultImage, (x, y), 5, green, thickness=-1) #-- width1[currentCarID] = bbox[2] old_corners_center[currentCarID] = find_center( corners1[currentCarID]) #-- time1[currentCarID] = time.time() currentCarID = currentCarID + 1 # in every frame iterate trough trackers for carID in carTracker.keys(): # get position of object trackedPosition = carTracker[carID].update(image) t_x, t_y, t_w, t_h = trackedPosition[1] t_x = int(t_x) t_y = int(t_y) t_w = int(t_w) t_h = int(t_h) t_x_bar = t_x + 0.5 * t_w t_y_bar = t_y + 0.5 * t_h bbox = (t_x, t_y, t_w, t_h) width2[carID] = bbox[2] if len(corners1[carID]): ret, frame = video.read() if type(frame) == type(None): break frame = frame[150:600, 150:950] gray2 = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) corners2[carID], st, err = cv2.calcOpticalFlowPyrLK( gray, gray2, corners1[carID], None, **lk_params) corners_center[carID] = find_center(corners2[carID]) # print(corners_center[carID]) cv2.circle(resultImage, corners_center[carID], 5, blue, thickness=-1) for corner in corners2[carID]: cv2.circle(resultImage, (corner[0][0], corner[0][1]), 5, green, -1) corners1[carID] = corners2[carID].copy() time2[carID] = time.time() gray = gray2.copy() # save location for speed estimation # draw new rectangle in frame current_location[carID] = bbox cv2.rectangle(resultImage, (t_x, t_y), (t_x + t_w, t_y + t_h), red, 2) #-- # iterate trough locations for i in corners_center.keys(): sec = time2[i] - time1[i] if old_corners_center[i] != corners_center[ i] and sec >= 0.01 and sec < 0.1: v = estimate_speed(old_corners_center[i], corners_center[i], sec, width1[i], width2[i], i) print v d = distance(width1[i], width2[i]) cv2.putText(resultImage, 'Distance: ' + str(int(d)) + ' m.', (20, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.75, (0, 0, 255), 3) cv2.putText(resultImage, 'TTC: ' + str(int(timeToCollision(v, d))) + ' s.', (20, 40), cv2.FONT_HERSHEY_SIMPLEX, 0.75, (0, 0, 255), 3) old_corners_center[i] = corners_center[i] time1[i] = time2[i] # if len(width1): width1[i] = width2[i] #-- # show results # wait for esc to terminate if cv2.waitKey(33) == 27: break cv2.imshow('image', resultImage) # close all open cv2.destroyAllWindows()
def medianFlowTracker(video): tracker = cv2.TrackerMedianFlow_create() excute(video, tracker)
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 objTrack(self): self.makeDirs() videoLocation = self.tcVars.filePaths cap = cv2.VideoCapture(videoLocation[0]) vidNum = 0 init = 1 initScale = 1 posCount = 0 negCount = 0 posList = [] negList = [] self.tcVars.statusBox.AppendText('Space -- to Pause/Play video\n') self.tcVars.statusBox.AppendText('w -- to select object to train on\n') self.tcVars.statusBox.AppendText( 's -- to stop obj tracking (if it starts tracking something weird)\n' ) self.tcVars.statusBox.AppendText('a -- rewind 3 seconds\n') self.tcVars.statusBox.AppendText('d -- fast foward 3 seconds\n') self.tcVars.statusBox.AppendText( 'n -- to move on to next video in list\n') self.tcVars.statusBox.AppendText('q or Esc -- to quit\n\n') class Found(Exception): pass try: while True: success, frame = cap.read() if not success: self.tcVars.statusBox.AppendText('didnt find video\n') break refFrame = frame.copy() refFrame2 = frame.copy() key = cv2.waitKey(50) & 0xFF # Pause the Video if key == 32: while True: key2 = cv2.waitKey(1) or 0xFF # Start obj tracking if key2 == ord('w'): if initScale: yRatio = 1 box = areaSelector(frame, yRatio, initScale) ratioInit = mask2Rect(box) h = ratioInit[1][1] - ratioInit[0][1] w = ratioInit[1][0] - ratioInit[0][0] yRatio = round(h / w, 2) initScale = 0 objFrame = refFrame[box] w = objFrame.shape[1] h = objFrame.shape[0] else: box = areaSelector(frame, yRatio, initScale) objFrame = refFrame[box] objFrame = cv2.resize(objFrame, (w, h)) init = 2 tracker = cv2.TrackerMedianFlow_create() tracker.init(frame, mask2Box(box)) posCount += 1 posPath = os.path.abspath('data/pos') cv2.imwrite(f'{posPath}\\pos{posCount}.jpg', objFrame) posList.append( f'pos/pos{posCount}.jpg 1 0 0 {w} {h}\n') temp = mask2Rect(box) refFrame = cv2.rectangle(refFrame, temp[0], temp[1], (0, 0, 0), cv2.FILLED) negCount += 1 negPath = os.path.abspath('data/neg') cv2.imwrite(f'{negPath}\\neg{negCount}.jpg', refFrame) negList.append(f'neg/neg{negCount}.jpg\n') break cv2.imshow('Video', frame) # Play the Video if key2 == 32: break if key2 == ord('s'): init = 1 break if key2 == ord('n'): vidNum += 1 if len(videoLocation) > 1 and vidNum < len( videoLocation): cap.release() cap = cv2.VideoCapture(videoLocation[vidNum]) break else: if len(videoLocation) == 1: self.statusBox.AppendText( 'Only one video loaded\n') else: self.statusBox.AppendText( 'Last video in list\n') if key2 == 27 or key2 == 113: raise Found if success and init == 2: trackSuccess, box = tracker.update(frame) if trackSuccess: rectPts = box2Rect(box) objFrame = refFrame2[box2Mask(box)] cv2.rectangle(frame, rectPts[0], rectPts[1], (255, 0, 0), 2, 1) posCount += 1 resizedModImg = cv2.resize(objFrame, (w, h)) cv2.imwrite(f'{posPath}\\pos{posCount}.jpg', resizedModImg) posList.append( f'pos/pos{posCount}.jpg 1 0 0 {w} {h}\n') refFrame = cv2.rectangle(refFrame, rectPts[0], rectPts[1], (0, 0, 0), cv2.FILLED) negCount += 1 cv2.imwrite(f'{negPath}\\neg{negCount}.jpg', refFrame) negList.append(f'neg/neg{negCount}.jpg\n') else: init = 1 if key == ord('s'): init = 1 # Skip forward 3 seconds if key == ord('d'): skip = cap.get(cv2.CAP_PROP_POS_MSEC) + 3000 cap.set(cv2.CAP_PROP_POS_MSEC, skip) success, frame = cap.read() # Skip Back 3 seconds if key == ord('a'): skip = cap.get(cv2.CAP_PROP_POS_MSEC) - 3000 cap.set(cv2.CAP_PROP_POS_MSEC, skip) success, frame = cap.read() if key == ord('n'): vidNum += 1 if len(videoLocation) > 1 and vidNum < len(videoLocation): cap.release() cap = cv2.VideoCapture(videoLocation[vidNum]) else: if len(videoLocation) == 1: self.tcVars.statusBox.AppendText( 'Only one video loaded\n') else: self.tcVars.statusBox.AppendText( 'Last video in list\n') # Quit Video Playback by pressing 'q' or ESC if key == 113 or key == 27: break if success: cv2.imshow('Video', frame) except Found: self.tcVars.statusBox.AppendText( 'Finished making Pictures. Now review positives and delete false positives\n' ) def reviewPics(posCount): self.tcVars.statusBox.AppendText( 'a -- to go to previous picture\n') self.tcVars.statusBox.AppendText('d -- to go to next picture\n') self.tcVars.statusBox.AppendText( 'x -- to delete picture from training arena\n') self.tcVars.statusBox.AppendText('q or Esc -- to skip review\n\n') count = posCount i = 1 self.tcVars.statusBox.AppendText('image: ' + str(i) + '/' + str(count) + '\n') while i <= count: frame = cv2.imread(f'data/pos/pos{i}.jpg') while True: key = cv2.waitKey(1) or 0xFF cv2.imshow('Video', frame) if key == ord('a'): try: if i > 1: i -= 1 frame = cv2.imread(f'data/pos/pos{i}.jpg') self.tcVars.statusBox.AppendText('image: ' + str(i) + '/' + str(count) + '\n') except: break if key == ord('d'): if i <= count: i += 1 frame = cv2.imread(f'data/pos/pos{i}.jpg') self.tcVars.statusBox.AppendText('image: ' + str(i) + '/' + str(count) + '\n') break if key == ord('x'): if i <= count: os.remove(f'data/pos/pos{i}.jpg') posList.remove( f'pos/pos{posCount}.jpg 1 0 0 {w} {h}\n') posCount -= 1 i += 1 if i <= count: frame = cv2.imread(f'data/pos/pos{i}.jpg') self.tcVars.statusBox.AppendText('image: ' + str(i) + '/' + str(count) + '\n') break if key == 113 or key == 27: i = count + 9000 break cv2.destroyAllWindows() retPath = os.getcwd() os.chdir('data/pos') renameList = [file for file in glob.glob('*.jpg')] def posSort(name): a = re.search('pos(\d+).jpg', name) return int(a.groups(0)[0]) renameList.sort(key=posSort) renameNum = 1 for j in renameList: os.rename(j, f'pos{renameNum}.jpg') renameNum += 1 os.chdir(retPath) return posCount posCount = reviewPics(posCount) # write out background file bgFile = open('data/bg.txt', 'w+') [bgFile.write(i) for i in negList] bgFile.close() # write out dat file datFile = open('data/info.dat', 'w+') [datFile.write(i) for i in posList] datFile.close() self.tcVars.statusBox.AppendText("Positive Count: " + str(posCount) + '\n') self.tcVars.statusBox.AppendText("Negative Count: " + str(negCount) + '\n') cap.release() cv2.destroyAllWindows() try: self.tcVars.w = w self.tcVars.h = h except: pass
tracker_types = [ 'BOOSTING', 'MIL', 'KCF', 'TLD', 'MEDIANFLOW', 'GOTURN', 'MOSSE', 'CSRT' ] tracker_type = tracker_types[2] 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() if not flag == 1: ok, f = video.read() frame = cv2.resize(f, (0, 0), fx=0.5, fy=0.5) ok = tracker.init(frame, bbox) while video.isOpened():
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()
def multi_tracking(yolo, video_path): global percentResize accum_time = 0 curr_fps = 0 fps = "FPS: ??" prev_time = timer() global multi_tracking_enable global arima_predict multi_tracking_enable = True tracker = cv2.MultiTracker_create() camera = cv2.VideoCapture(video_path) ok, image = camera.read() if not ok: print('Failed to read video') exit() boxes = [] frameCount = 1 startFrame = 1 skipFrames = 25 consecutiveframes = 1 initialHistoryCount = 11 skipHistory = 5 extrapolate = 3 dof = 0 yoloCount = 0 countCond = 0 xhistory = [] yhistory = [] depth_history = [] while(True): if(frameCount == startFrame): frame = Image.fromarray(image) frame, boxes = yolo.detect_image(frame) #yolo.close_session() break ok, image = camera.read() frameCount += 1 #np.set_printoptions(suppress = True) boxes = np.asarray(boxes) boxes[:, 2] = boxes[:, 2] - boxes[:, 0] boxes[:, 3] = boxes[:, 3] - boxes[:, 1] boxes = np.ndarray.tolist(boxes) prevBoxes = len(boxes) curBoxes = prevBoxes #print(boxes) #np.savetxt('boxes.txt', boxes, fmt = "%i") #return boxes #boxes = [] manualBox = 0 for i in range(manualBox): box = cv2.selectROI('tracking', image) boxes.append(box) for eachBox in boxes: eachBox = tuple(eachBox) xhistory.append([int(eachBox[0] + eachBox[2] / 2)]) yhistory.append([int(eachBox[1] + eachBox[3] / 2)]) ok = tracker.add(cv2.TrackerMedianFlow_create(), image, eachBox) while(True): ok, image=camera.read() if not ok: break orig_image = image.copy() if(prevBoxes != curBoxes): countCond += 1 if(frameCount % skipFrames == 0): #print(consecutiveframes) consecutiveframes = 1 tracker = cv2.MultiTracker_create() frame = Image.fromarray(image) boxes = [] frame, boxes = yolo.detect_image(frame) yoloCount += 1 boxes = np.asarray(boxes) boxes[:, 2] = boxes[:, 2] - boxes[:, 0] boxes[:, 3] = boxes[:, 3] - boxes[:, 1] boxes = np.ndarray.tolist(boxes) prevBoxes = len(boxes) curBoxes = None xhistory = [] yhistory = [] depth_history = [] for eachBox in boxes: eachBox = tuple(eachBox) xhistory.append([int(eachBox[0] + eachBox[2] / 2)]) yhistory.append([int(eachBox[1] + eachBox[3] / 2)]) ok = tracker.add(cv2.TrackerMedianFlow_create(), image, eachBox) #frameCount += 1 #continue ok, boxes = tracker.update(image) for i in range(len(boxes)): xhistory[i].append(int(boxes[i][0] + boxes[i][2] / 2)) yhistory[i].append(int(boxes[i][1] + boxes[i][3] / 2)) if(arima_predict and len(xhistory[0]) > initialHistoryCount): #if(len(xhistory[i]) > 27): dof = 5 #print(xhistory[0]) for i in range(len(boxes)): history = xhistory[i].copy() history = [xhistory[i][t] for t in range(0, len(xhistory[i]), skipHistory)] xmin = min(history) history[:] = [x - xmin for x in history] xmax = max(history) if(xmax == 0): xmax = 1 history[:] = [x / xmax for x in history] #print('xh', len(history)) for j in range(extrapolate): xmodel = ARIMA(history, order = (dof, 1, 0)) xmodel_fit = xmodel.fit(disp = 0, maxiter=200) xoutput = xmodel_fit.forecast() history.append(xoutput[0]) xhat = int((xoutput[0] * xmax) + xmin) #xhat = xoutput[0] history = yhistory[i].copy() history = [yhistory[i][t] for t in range(0, len(yhistory[i]), skipHistory)] ymin = min(history) history[:] = [y - ymin for y in history] #history = [yhistory[i][0], yhistory[i][int(len(yhistory[i]) / 2)], yhistory[i][len(yhistory[i]) - 1]] ymax= max(history) if(ymax == 0): ymax = 1 history[:] = [y / ymax for y in history] #print('yh', len(history)) for j in range(extrapolate): ymodel = ARIMA(history, order = (dof, 1, 0)) ymodel_fit = ymodel.fit(disp = 0, maxiter=200) youtput = ymodel_fit.forecast() history.append(youtput[0]) yhat = int((youtput[0] * ymax) + ymin) #yhat = youtput[0] cp1 = int(boxes[i][0] + boxes[i][2] / 2) cp2 = int(boxes[i][1] + boxes[i][3] / 2) cv2.arrowedLine(image, (int(xhistory[i][0]),int(yhistory[i][0])), (cp1, cp2), (0, 255, 0), 2) cv2.arrowedLine(image, (cp1, cp2), (xhat, yhat), (0, 0, 255), 2) #slope = math.abs(math.atan((yhat - cp2) / (xhat - cp1))) #speed = math.sqrt((yhat - cp2) * (yhat - cp2) + (xhat - cp1) * (xhat - cp1)) #percentChange = 0.0 #if(yhat >= cp2): p1 = (int(xhat - boxes[i][2] / 2), int(yhat - boxes[i][3] / 2)) p2 = (int(xhat + boxes[i][2] / 2), int(yhat + boxes[i][3] / 2)) cv2.rectangle(image, p1, p2, (255, 255, 255), 1) for newbox in boxes: p1 = (int(newbox[0]), int(newbox[1])) p2 = (int(newbox[0] + newbox[2]), int(newbox[1] + newbox[3])) cv2.rectangle(image, p1, p2, (200,0,0), 2) if(depthMapEstimation): depth_est = image_depth(orig_image) dof = 0 current_depth_est = depth_est.copy() pred_depth_est = depth_est.copy() pd = 'OFF' for i in range(len(boxes)): p1 = (int(boxes[i][0]), int(boxes[i][1])) p2 = (int(boxes[i][0] + boxes[i][2]), int(boxes[i][1] + boxes[i][3])) current_depth = cal_depth_box(depth_est, p1, p2) if(len(depth_history) < len(boxes)): depth_history.append([current_depth]) else: depth_history[i].append(current_depth) if(math.isnan(current_depth)): continue if(len(depth_history[i]) > initialHistoryCount): pd = 'ON' history = depth_history[i].copy() hisotry = np.nan_to_num(history) history = [history[t] for t in range(0, len(history), skipHistory)] dmin = min(history) history[:] = [d - dmin for d in history] dmax = max(history) if(dmax == 0): dmax = 1 history[:] = [d / dmax for d in history] for j in range(extrapolate): dmodel = ARIMA(history, order = (0, 1, 0)) dmodel_fit = dmodel.fit(disp = 0, maxiter=200) doutput = dmodel_fit.forecast() history.append(doutput[0]) #print(doutput[0]) if(not math.isnan(doutput[0])): dhat = int((doutput[0] * dmax) + dmin) else: dhat = current_depth current_depth_est = set_depth(current_depth_est, p1, p2, current_depth) if(math.isnan(current_depth)): print("wtf just happened") cv2.putText(current_depth_est,text=str(int(current_depth)), org=(p1[0], p1[1]), fontFace=cv2.FONT_HERSHEY_SIMPLEX, fontScale=0.50, color=(0, 0, 255), thickness=1) pred_depth_est = set_depth(pred_depth_est, p1, p2, dhat) cv2.putText(pred_depth_est,text=str(int(dhat)), org=(p1[0], p1[1]), fontFace=cv2.FONT_HERSHEY_SIMPLEX, fontScale=0.50, color=(0, 0, 255), thickness=1) cv2.putText(pred_depth_est, text=pd, org=(3, 15), fontFace=cv2.FONT_HERSHEY_SIMPLEX, fontScale=0.50, color=(0, 0, 255), thickness=2) #cv2.namedWindow("curdepth", cv2.WINDOW_NORMAL) current_depth_est = cv2.resize(current_depth_est, (0,0), fx=percentResize, fy=percentResize) cv2.imshow('curdepth', current_depth_est) #cv2.namedWindow("predepth", cv2.WINDOW_NORMAL) pred_depth_est = cv2.resize(pred_depth_est, (0,0), fx=percentResize, fy=percentResize) cv2.imshow('predepth', pred_depth_est) curr_time = timer() exec_time = curr_time - prev_time prev_time = curr_time accum_time = accum_time + exec_time curr_fps = curr_fps + 1 if accum_time > 1: accum_time = accum_time - 1 fps = "FPS: " + str(curr_fps) curr_fps = 0 cv2.putText(image, text=fps, org=(3, 15), fontFace=cv2.FONT_HERSHEY_SIMPLEX, fontScale=0.50, color=(255, 0, 0), thickness=2) #cv2.namedWindow("tracking", cv2.WINDOW_NORMAL) image = cv2.resize(image, (0,0), fx=percentResize, fy=percentResize) cv2.imshow('tracking', image) frameCount += 1 consecutiveframes += 1 k = cv2.waitKey(1) if k == 27 : break # esc pressed print(yoloCount) print(countCond) yolo.close_session()
#if video frame dosent exist, break if not ret: break #when tracking is not on if initBB is None: facerect = cascade.detectMultiScale(frame, scaleFactor=1.3, minNeighbors=1, minSize=(80, 80)) # when face detected if len(facerect) > 0: initBB = (facerect[0][0] / 2, facerect[0][1] / 2, facerect[0][0] + facerect[0][2], facerect[0][1] + facerect[0][3]) print("Detected!:") print(initBB) tracker = cv2.TrackerMedianFlow_create( ) #MedianFlow is also pretty good #tracker = cv2.TrackerTLD_create() tracker.init(frame, initBB) for rect in facerect: cv2.rectangle(frame, tuple(rect[0:2]), tuple(rect[0:2] + rect[2:4]), rectangle_color, thickness=2) #when tracking is on else: (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]