def single_video_calculation(file, file_path, pulse_label_data): start_time = time.time() w_div = 16 h_div = 8 bpm_values = np.zeros((h_div, w_div), dtype='float64') video_frames, fps = load_video(file_path) video_frames = video_frames[22:310] frame_count, width, height = get_video_dimensions(video_frames) roi_width = int(width / w_div) roi_height = int(height / h_div) width = roi_width * w_div height = roi_height * h_div for x in range(0, width, roi_width): for y in range(0, height, roi_height): roi_ind_x = int(x / roi_width) roi_ind_y = int(y / roi_height) roi_time_series = video_frames[:, y:y + roi_height, x:x + roi_width] # Spatial Averaging used when ROIs are extracted time_series = np.mean(roi_time_series, axis=(1, 2)) # Pulse-Signal Extraction bpm, pruned_fft, fft, heart_rates, raw, H, h, norm_channels, time_series = pos_based_method_improved(time_series, fps) # bpm, pruned_fft = extract_pos_based_method_improved(time_series, fps) plot_results(bpm, pruned_fft, fft, heart_rates, raw=raw, overlap_signal=H, pulse_signal=h, norm_channels=norm_channels, time_series=time_series) bpm_values[roi_ind_y, roi_ind_x] = bpm print("Fortschritt: %.2f %%" % ((x+1.0) / width*100.0))
def extr_single_video_calculation(in_file, in_file_path, out_dir): # load video video_frames, fps = load_video(in_file_path) video_frames = video_frames[22:358] frame_count, width, height = get_video_dimensions(video_frames) # Giant ndarray for pulse-signals for height*width of a Videos pulse_signal_data = np.zeros([height, width, 44], dtype='float64') # BPM-map only for visualisation bpm_map = np.zeros([height, width], dtype='float16') # For plotting the skin and pulse matrices last_frame = video_frames[frame_count - 1] last_frame_clone = last_frame.copy() # Load all pulse value belonging to a certain video in array pulse_lower, pulse_upper = get_pulse_vals_from_label_data( load_reference_data(), in_file) for x in range(0, width): for y in range(0, height): # get pixel sequence px_time_series = video_frames[:, y, x] # call POS-Function bpm, pruned_fft = extract_pos_based_method_improved( px_time_series, fps) # write extracted pulse frequencies to ndarray pulse_signal_data[y, x] = pruned_fft # fill up bpm-map bpm_map[y, x] = bpm print("Completed: %.2f %%" % ((x + 1.0) / width * 100.0)) # compare bpms with reference bpms lower and upper weak_skin_map = compare_pulse_vals(bpm_map, pulse_lower, pulse_upper) # check neighbouring BPMs strong_skin_map = eliminate_weak_skin(weak_skin_map, skin_neighbors=5) # For plotting the skin and pulse matrices out_file_path = os.path.join(out_dir, 'no_nan_' + in_file[:-4]) plot_title = in_file + ' BPM: ' + str(pulse_lower) + '-' + str(pulse_upper) plot_and_save_results(plot_title, last_frame_clone, bpm_map, weak_skin_map, strong_skin_map, out_file_path) np.save(out_file_path, pulse_signal_data) print("--- File Completed after %s seconds ---" % (time.time() - start_time)) print('Saved to ' + out_file_path)
return roi_bpm, heart_rates, fft1, hann_window_signal, S if __name__ == '__main__': start_time = time.time() dir_path = os.path.join('..', 'assets', 'Vid_Original', 'Kuenstliches_Licht') file = '00130.MTS' file_path = os.path.join(dir_path, file) w_div = 16 h_div = 8 bpm_values = np.zeros((h_div, w_div), dtype='float64') print(file_path) vid_data, fps = load_video(file_path) vid_data = vid_data[50:300] frame_count, width, height = get_video_dimensions(vid_data) print('Cutted length: ' + str(frame_count)) # w_steps = width/w_div # h_steps = height/h_div roi_mean_frames = np.zeros((frame_count, w_div, h_div, 3), dtype='float64') # for j, frame in enumerate(vid_data): # # Spatial Averaging roi_means_2DArray, frame_devided = devide_frame_into_roi_means( frame, w_div, h_div)
if __name__ == '__main__': face_cascade_path = os.path.join('C:/', 'Anaconda3', 'pkgs', 'opencv3-3.1.0-py35_0', 'Library', 'etc', 'haarcascades', 'haarcascade_frontalface_default.xml') dir_path = os.path.join('assets', 'Vid_Original') file = '00112.MTS' file_path = os.path.join(dir_path, file) window_numbers = 6 window_size = 40 frame_count = window_numbers * window_size + 1 video_frames, fps = load_video(file_path) video_frames = video_frames[1:frame_count] print('Reduced Frame Count: ' + str(len(video_frames))) face_cascade = cv2.CascadeClassifier(face_cascade_path) # Create time series array of the roi means viola_roi_sequence = [] for j, frame in enumerate(video_frames): roi_face = viola(frame) viola_roi_sequence.append(roi_face) # blurred_roi = cv2.blur(roi_face, (5, 5)) # cv2.imshow('blurred_roi', roi_face)
def extr_roi_single_video_calculation(in_file, in_file_path, out_dir): # determine how to devide frame into rois w_div = 16 h_div = 8 # load video video_frames, fps = load_video(in_file_path) video_frames = video_frames[22:358] frame_count, width, height = get_video_dimensions(video_frames) w_steps = int(width / w_div) h_steps = int(height / h_div) # Giant ndarray for pulse-signals for height*width of a Videos pulse_signal_data = np.zeros([h_div, w_div, 44], dtype='float64') # BPM-map only for visualisation bpm_map = np.zeros((h_div, w_div), dtype='float64') # Load all pulse values belonging to a certain video in array pulse_lower, pulse_upper = get_pulse_vals_from_label_data( load_reference_data(), in_file) # For plotting the skin and pulse matrices plot_title = file + ' BPM: ' + str(pulse_lower) + '-' + str(pulse_upper) fig = plt.figure(figsize=(20, 15)) fig.suptitle(plot_title, fontsize=20, fontweight='bold') tick_fontsize = 11 txt_coord_x = 0.05 txt_coord_y = 0.9 txt_fontsize = 21 sub1 = fig.add_subplot(221) sub2 = fig.add_subplot(222) sub3 = fig.add_subplot(223) sub4 = fig.add_subplot(224) last_frame = video_frames[frame_count - 1] last_frame_clone = last_frame.copy() # The odd rest is cutted here width = w_steps * w_div height = h_steps * h_div for x in range(0, width, w_steps): for y in range(0, height, h_steps): roi_ind_x = int(x / w_steps) roi_ind_y = int(y / h_steps) # get roi volumes roi_time_series = video_frames[:, y:y + h_steps, x:x + w_steps] # Spatial Averaging roi_time_series_avg = np.mean(roi_time_series, axis=(1, 2)) # call POS-Function bpm, pruned_fft = extract_pos_based_method_improved( roi_time_series_avg, fps) # fill up bpm-map bpm_map[roi_ind_y, roi_ind_x] = bpm # write extracted pulse frequencies to ndarray pulse_signal_data[roi_ind_y, roi_ind_x] = pruned_fft # For plotting the skin and pulse matrices sub1.text(x + w_steps / 2, y + h_steps / 2, round(bpm, 1), color=(0.0, 0.0, 0.0), fontsize=7, va='center', ha='center') cv2.rectangle(last_frame_clone, (x, y), (x + w_steps, y + h_steps), (0, 0, 0), 2) print("Fortschritt: %.2f %%" % ((x + 1.0) / width * 100.0)) # compare bpms with reference bpms lower and upper weak_skin_map = compare_pulse_vals(bpm_map, pulse_lower, pulse_upper) # check neighbouring BPMs strong_skin_map = eliminate_weak_skin(weak_skin_map, skin_neighbors=3) # For plotting the skin and pulse matrices out_file_path = os.path.join(out_dir, 'me_' + in_file[:-4]) bgr_last_frame = cv2.cvtColor(last_frame_clone, cv2.COLOR_RGB2BGR) sub1.text(txt_coord_x, txt_coord_y, '(a)', color='white', fontsize=txt_fontsize, horizontalalignment='center', transform=sub1.transAxes) sub1.tick_params(axis='both', which='major', labelsize=tick_fontsize) sub1.imshow(bgr_last_frame) sub2.text(txt_coord_x, txt_coord_y, '(b)', color='white', fontsize=txt_fontsize, horizontalalignment='center', transform=sub2.transAxes) sub2.tick_params(axis='both', which='major', labelsize=tick_fontsize) sub2.matshow(bpm_map, cmap=plt.cm.gray) sub3.text(txt_coord_x, txt_coord_y, '(c)', color='white', fontsize=txt_fontsize, horizontalalignment='center', transform=sub3.transAxes) sub3.tick_params(axis='both', which='major', labelsize=tick_fontsize) sub3.matshow(weak_skin_map, cmap=plt.cm.gray) sub4.text(txt_coord_x, txt_coord_y, '(d)', color='white', fontsize=txt_fontsize, horizontalalignment='center', transform=sub4.transAxes) sub4.tick_params(axis='both', which='major', labelsize=tick_fontsize) sub4.matshow(strong_skin_map, cmap=plt.cm.gray) plt.tight_layout() # plt.show() fig.savefig(out_file_path + '.png') plt.close() # tp, fp, fn and tn of POS-Algorithm of one video # is summed up with a global variable for all videos vid_true_positives, vid_false_positives, vid_false_negatives, vid_true_negatives = compare_with_skin_mask( file, weak_skin_map, h_div, w_div) global true_positives global false_positives global false_negatives global true_negatives true_positives += vid_true_positives false_positives += vid_false_positives false_negatives += vid_false_negatives true_negatives += vid_true_negatives print("--- File Completed after %s seconds ---" % (time.time() - start_time)) np.save(out_file_path, pulse_signal_data) print('Saved to ' + out_file_path)
def skin_detection_algorithm_single_video(_file, _dir_path, _dest_folder, show_figure=False): file_path = os.path.join(_dir_path, _file) # define the upper and lower boundaries of the HSV pixel # intensities to be considered 'skin' # white skin-tone lower = np.array([0, 50, 50], dtype="uint8") upper = np.array([25, 255, 255], dtype="uint8") # # colored skin-tone 00128 # lower = np.array([0, 80, 30], dtype="uint8") # upper = np.array([15, 255, 180], dtype="uint8") video_frames, fps = load_video(file_path) frame_count, width, height = get_video_dimensions(video_frames) video_frames = video_frames[22:50] skin_arr = np.ones([height, width]) max_vals = [] min_vals = [] # keep looping over the frames in the video for i, frame in enumerate(video_frames): # To check which HSV values are needed for a certain person # cv2.rectangle(frame, (850, 530), (860, 550), (0, 255, 0), 2) # cv2.rectangle(frame, (600, 1000), (860, 1080), (0, 255, 0), 2) # frame[1000:1080, 600:860] rect_hsv = cv2.cvtColor(frame[230:250, 750:760], cv2.COLOR_BGR2HSV) # print(rect_hsv)q max_in_rect = np.amax(rect_hsv, axis=(0, 1)) min_in_rect = np.amin(rect_hsv, axis=(0, 1)) # print(np.mean(rect_hsv, axis=(0, 1))) max_vals.append(max_in_rect) min_vals.append(min_in_rect) # resize the frame, convert it to the HSV color space, # and determine the HSV pixel intensities that fall into # the speicifed upper and lower boundaries converted = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) skin_mask = cv2.inRange(converted, lower, upper) # apply a series of erosions and dilations to the mask # using an elliptical kernel kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (11, 11)) skin_mask = cv2.erode(skin_mask, kernel, iterations=2) skin_mask = cv2.dilate(skin_mask, kernel, iterations=2) # blur the mask to help remove noise, then apply the # mask to the frame skin_mask = cv2.GaussianBlur(skin_mask, (3, 3), 0) skin = cv2.bitwise_and(frame, frame, mask=skin_mask) # show the skin in the image along with the mask cv2.imshow("images", np.hstack([frame, skin])) # cv2.imshow("images", skin) # if the 'q' key is pressed, stop the loop if cv2.waitKey(1) & 0xFF == ord("q"): break # Reduce by 1 if pixel is not a skin pixel mean_skin = np.mean(skin, axis=2) low_values_indices = mean_skin < 1 skin_arr[low_values_indices] -= 1 # Where values are lower than threshold final_mask = np.ones([height, width]) low_values_indices = skin_arr < -2 final_mask[low_values_indices] = 0 fig = plt.figure(figsize=(17, 9)) sub1 = fig.add_subplot(111) sub1.set_title('Norm. Avg.') sub1.imshow(final_mask, cmap=plt.cm.gray) file_path_out = os.path.join(_dest_folder, 'Skin_' + _file[:-4]) fig.savefig(file_path_out + '.jpg') if show_figure: plt.show() # Save it as .npy file # np.save(file_path_out, final_mask) print('Saved to ' + file_path_out) # cleanup the camera and close any open windows cv2.destroyAllWindows()
def normalize_frames(stddev_of_frames, mean, frame): frame = frame / mean return frame # def calculate_chrom(): if __name__ == '__main__': filename = 'assets\\output_1.1.mp4' vid_frames, fps, width, height = load_video(filename) blue_vals = [] green_vals = [] red_vals = [] mean_of_frames = calculate_mean_over_interval(vid_frames) print("Mean: " + str(mean_of_frames[50, 145])) stddev_of_frames = calculate_std_deviation_over_interval(vid_frames) print(stddev_of_frames) for frame in vid_frames: # red, green, blue = split_into_rgb_channels(frame) # green_image = np.zeros((green.shape[0], green.shape[1], 3), dtype=green.dtype) # green_image[:, :, 1] = green
import numpy as np import cv2 from matplotlib import pyplot as plt from Video_Tools import load_video from Video_Tools import get_frames_dimension start_time = time.time() dir = 'assets\\Videos Original' file = '00101.mts' path = dir + '\\' + file print(path) vid_data, fps = load_video(path) L, width, height = get_frames_dimension(vid_data) print('Frames: ' + str(L)) intensity_frames = np.zeros((L, height, width, 1), dtype='float64') intensity_array = [] i = 1 for frame in vid_data: gray_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) gray_frame_nxt = cv2.cvtColor(vid_data[i], cv2.COLOR_BGR2GRAY) diff = gray_frame - gray_frame_nxt intensity_between_frames = np.sum(np.abs(diff)) / (width * height)
bound_low = (np.abs(frequencies - freq_min)).argmin() bound_high = (np.abs(frequencies - freq_max)).argmin() fft[:bound_low] = 0 fft[bound_high:-bound_high] = 0 fft[-bound_low:] = 0 result = np.ndarray(shape=data.shape, dtype='float') result[:] = scipy.fftpack.ifft(fft, axis=0) result *= amplification_factor return result if __name__ == '__main__': filename = 'assets\\output_1.mp4' vid_data, fps = load_video(filename) """Graph the average value of the video as well as the frequency strength""" averages = [] height, width = vid_data.shape[1:3] for frame in vid_data: gray_frames = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) blured_frame = cv2.blur(gray_frames, (5, 5)) center = (int(width / 2), int(height / 2)) print(center) cv2.circle(blured_frame, (0, 0), 1, (0, 0, 255), -1) cv2.imshow("blured_frame", blured_frame) bandpassed = temporal_bandpass_filter(blured_frame, fps) averages.append(bandpassed[(0, 0)])
cv2.rectangle(frame, (x, y), (x + roi_width, y + roi_height), (0, 255, 0), 1) return roi, frame if __name__ == '__main__': filename = '00073.MTS' out_filename = 'new_00073.avi' input_path = os.path.join('assets', filename) output_path = os.path.join('assets', out_filename) # path = "assets\\ROIs\\Original\\" + filename vid_frames, fps = load_video(input_path) fourcc = cv2.VideoWriter_fourcc('L', 'A', 'G', 'S') out = cv2.VideoWriter(output_path, fourcc, fps, (1080, 1920)) # zum Verkürzen des Videos # [x:] = remove from beginning cutted_frames = vid_frames[400:808] for frame in cutted_frames: # # Show results # cv2.imshow('Frames', frame) if cv2.waitKey(1) & 0xFF == ord('q'): break