# blend back-warped line plotting with undistored original image img_blended = cv2.addWeighted(img_undist, 0.7, img_warpback, 1.0, 0) # put text on image put_text_on_img(img_blended, (leftl.curvature+rightl.curvature)/2000, \ measure_deviation_left(leftl.dist2line, rightl.dist2line)) return img_blended # create line tracer tracer = LineTracer() #in_clip = VideoFileClip("project_video.mp4").subclip(0,2) in_clip = VideoFileClip("project_video.mp4") #in_clip = VideoFileClip("challenge_video.mp4") #out_clip = in_clip.fl_image(process_image) #NOTE: this function expects color images!! new_frames = [] for frame in in_clip.iter_frames(): new_frame = process_image(frame, tracer.getLast()) new_frames.append(new_frame) out_clip = ImageSequenceClip(new_frames, fps = 25) out_clip.write_videofile('output_images/project_video.mp4') #ipython_display(out_clip) #%%
# Assemble pictures in a folder, write to a videofile and gif from moviepy.editor import ImageSequenceClip clip = ImageSequenceClip("video_output/output", fps=24) clip.to_videofile("video_output/output/output.mp4", fps=24) # many options available #clip.to_gif("video_output/output/mygif.gif", fps=10) # many options available
def make_video(arrays, episode, out_dir, mode): filename = os.path.join(out_dir, f"{mode}.{episode}.mp4") # array = np.stack(arrays, axis=0) clip = ImageSequenceClip(arrays, fps=1) print(filename) clip.write_videofile(filename)
def imagearray2file(img_array, outpath=None, fps=30): ''' :param nparray: RxCxTxwidthxheightx3 :param outpath: the directory where T images will be dumped for each time point in range T :param fps: fps of the gif file :return: it will return an image list with length T if outpath is given as a png file, an image will be saved for each t in T. if outpath is given as a gif file, an animated image with T frames will be created. ''' import cv2 from human_body_prior.tools.omni_tools import makepath if outpath is not None: makepath(outpath, isfile=True) if not isinstance(img_array, np.ndarray) or img_array.ndim < 6: raise ValueError('img_array should be a numpy array of shape RxCxTxwidthxheightx3') R, C, T, img_h, img_w, img_c = img_array.shape out_images = [] for tIdx in range(T): row_images = [] for rIdx in range(R): col_images = [] for cIdx in range(C): col_images.append(img_array[rIdx, cIdx, tIdx]) row_images.append(np.hstack(col_images)) t_image = np.vstack(row_images) out_images.append(t_image) if outpath is not None: if '.png' in outpath: for tIdx in range(T): if T > 1: cur_outpath = outpath.replace('.png', '_%03d.png'%tIdx) else: cur_outpath = outpath cv2.imwrite(cur_outpath, out_images[tIdx]) while not os.path.exists(cur_outpath): continue # wait until the snapshot is written to the disk elif '.gif' in outpath: import imageio with imageio.get_writer(outpath, mode='I', fps = fps) as writer: for tIdx in range(T): img = out_images[tIdx].astype(np.uint8) img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) writer.append_data(img) elif '.avi' in outpath: fourcc = cv2.VideoWriter_fourcc(*'XVID') video = cv2.VideoWriter(outpath, fourcc, fps, (img_w, img_h), True) for tIdx in range(T): img = out_images[tIdx].astype(np.uint8) img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) video.write(img) video.release() cv2.destroyAllWindows() elif '.mp4' in outpath: from moviepy.editor import ImageSequenceClip animation = ImageSequenceClip(out_images, fps=fps) animation.write_videofile(outpath) return out_images
def process_imgs(srcdir, dstdir): raw_imgs = sorted(glob.glob(srcdir + '/*.jpg')) if not os.path.exists(dstdir): os.makedirs(dstdir) # the number of historical fit to be stored smoothing_factor = 12 # the number of consecutive drop threshold to initiate new search window_reset_threshold = 3 # change threshold to reject a fitting linear_coeff_threshold = 0.3 # Instantiate line object for left and right line left_line = Line() right_line = Line() for i in tqdm(range(0, len(raw_imgs))): # Read in frame image = plt.imread(raw_imgs[i]) # Apply distortion correction undist = cv2.undistort(image, mtx, dist, None, mtx) # Apply color space transform and thresholding combined_binary = mask_color(undist) # Perspective tranform to aerial view warped = transform_aerial_view(undist) binary_warped = transform_aerial_view(combined_binary) # Lane Detection and fitting left_line.current_fit, right_line.current_fit, left_line.allxy, right_line.allxy = detect_and_fit_lane( binary_warped, left_line.best_fit, right_line.best_fit) # Sanity Check #-------------- # Compute the difference between the current fit coeff and the best fit coeff if i > 0: left_line.diffs = left_line.current_fit - left_line.best_fit right_line.diffs = right_line.current_fit - right_line.best_fit # Drop the current fit and use the previous fit coeef # if the linear coeff is over a specified threshold # otherwise, current fit is good to go # the number of consecutive drop is recorded if np.absolute(left_line.diffs[1]) > linear_coeff_threshold: left_line.current_fit = left_line.previous_fits[-1] if left_line.detected == False: left_line.drop_count += 1 left_line.detected = False else: left_line.detected = True left_line.drop_count = 0 if np.absolute(right_line.diffs[1]) > linear_coeff_threshold: right_line.current_fit = right_line.previous_fits[-1] if right_line.detected == False: right_line.drop_count += 1 right_line.detected = False else: right_line.detected = True right_line.drop_count = 0 # When a consecutive of drop has reached the specified threshold # a complete new sliding window search is executed. if (left_line.drop_count >= window_reset_threshold) | ( right_line.drop_count >= window_reset_threshold): # reset the drop count left_line.drop_count = 0 right_line.drop_count = 0 # New window search left_line.current_fit, right_line.current_fit, left_temp, right_temp = detect_and_fit_lane( binary_warped, None, None) # There are chances new window search are not usable, # previous fit is used instead if (left_line.current_fit is None): left_line.current_fit = left_line.previous_fits[-1] else: left_line.allxy = left_temp if (right_line.current_fit is None): right_line.current_fit = right_line.previous_fits[-1] else: right_line.allxy = right_temp left_line.detected = True right_line.detected = True # Clear all the historical fit since a new fit is used left_line.previous_fits = [] right_line.previous_fits = [] # Discard the first element of the history list to # to make room for recent fit coeff. if len(left_line.previous_fits) == smoothing_factor: left_line.previous_fits.pop(0) right_line.previous_fits.pop(0) # Append recent fit coeff. to the history list left_line.previous_fits.append(left_line.current_fit) right_line.previous_fits.append(right_line.current_fit) # Smooth out the coeff. averaging all the value in history list if len(left_line.previous_fits) == 1: left_line.best_fit = left_line.previous_fits[0] right_line.best_fit = right_line.previous_fits[0] else: left_line.best_fit = np.vstack( left_line.previous_fits).mean(axis=0) right_line.best_fit = np.vstack( right_line.previous_fits).mean(axis=0) # Get bird-eye view with marked lane marked = mark_lane(binary_warped, left_line.best_fit, right_line.best_fit, left_line.allxy, right_line.allxy, left_line.detected, right_line.detected) # Print best fit coeff. font = cv2.FONT_HERSHEY_SIMPLEX cv2.putText( marked, 'L-fit: ' + str(np.round(left_line.best_fit, 3).astype(str)), (50, 100), font, 1, (255, 255, 255), 2, cv2.LINE_AA) cv2.putText( marked, 'R-fit: ' + str(np.round(right_line.best_fit, 3).astype(str)), (690, 100), font, 1, (255, 255, 255), 2, cv2.LINE_AA) # Overlay detected lane on perspective image lane_warped = transform_single_point_perspective( undist, left_line.current_fit, right_line.current_fit, left_line.allxy, right_line.allxy) # Compute lane curvature and vehicle offset left_line.radius, right_line.radius, vehicle_pos = compute_lane_curvature( left_line.current_fit, right_line.current_fit) # Print radius for left and right line cv2.putText( lane_warped, 'Left Curv. : ' + str(int(left_line.radius)) + ' | Right Curv. : ' + str(int(right_line.radius)), (80, 100), font, 1.5, (230, 255, 122), 3, cv2.LINE_AA) # Print vehicle relative position to lane center if vehicle_pos < 0: cv2.putText( lane_warped, 'Vehicle is left of ' + str(np.round(np.absolute(vehicle_pos), 3)) + 'm lane center.', (80, 160), font, 1.5, (230, 255, 122), 3, cv2.LINE_AA) else: cv2.putText( lane_warped, 'Vehicle is right of ' + str(np.round(np.absolute(vehicle_pos), 3)) + 'm lane center.', (80, 160), font, 1.5, (230, 255, 122), 3, cv2.LINE_AA) # Create a collage of images as a single frame for final video collage = np.zeros([720, 1280 + 427, 3], dtype='uint8') collage[0:720, 0:1280, :] = lane_warped collage[0:240, 1280:, :] = cv2.cvtColor( cv2.resize(combined_binary, (427, 240), interpolation=cv2.INTER_AREA) * 255, cv2.COLOR_GRAY2RGB) collage[240:480, 1280:, :] = cv2.resize(marked, (427, 240), interpolation=cv2.INTER_AREA) collage[480:720, 1280:, :] = cv2.resize(warped, (427, 240), interpolation=cv2.INTER_AREA) plt.imsave(dstdir + "/" + os.path.basename(raw_imgs[i]), collage, format="jpeg") # Compile video clip = ImageSequenceClip(dstdir, fps=25) clip.write_videofile(dstdir + '.mp4')
TIMELAPSE_FOLDER = "timelapses" OUTPUT_FOLDER = "video" if __name__ == "__main__": for plant_folder in os.listdir(TIMELAPSE_FOLDER): print(plant_folder) image_filename_list = [] last_date = None for image_filename in os.listdir( os.path.join(TIMELAPSE_FOLDER, plant_folder)): date = datetime.strptime(image_filename[:-4], "%Y-%m-%dT%H:%M:%S.%fZ") if last_date is not None: dt = date - last_date while dt > timedelta(days=1): image_filename_list.append( os.path.join(TIMELAPSE_FOLDER, plant_folder, image_filename)) dt -= timedelta(days=1) image_filename_list.append( os.path.join(TIMELAPSE_FOLDER, plant_folder, image_filename)) last_date = date print(image_filename_list) clip = ImageSequenceClip(image_filename_list, fps=10) # clip.write_gif(os.path.join(OUTPUT_FOLDER, plant_folder + ".gif")) clip.write_videofile(filename=os.path.join(OUTPUT_FOLDER, plant_folder + ".mp4"), codec="libx264", bitrate="1000000", audio=False)
def concatenate_frames_to_clip(frames_path, fps=40): frames = os.listdir(frames_path) frames = sorted(frames, key=lambda x: get_index(x)) image_sequence = [os.path.join(frames_path, frame) for frame in frames] clip = ImageSequenceClip(image_sequence, fps=fps) clip.write_videofile("image_clip.mp4")
from scipy import signal y = signal.lfilter(b, a, x=r) return y[::-1] true_discounted_returns = alt(episode_reward_record, 0.99) for i in range(1, len(episode_reward_record)): return_buffer.append([ replay_buffer[-i][0], replay_buffer[-i][1], true_discounted_returns[-i] ]) if len(render_buffer) > 0: from moviepy.editor import ImageSequenceClip clip = ImageSequenceClip(render_buffer, fps=5) clip.write_gif("IQNViz3/ep" + str(ep_id) + '.gif', fps=5) render_buffer = [] episode_reward_record = [] num_steps = 0 ep_id += 1 if len(replay_buffer) >= batch_sz: batch = random.sample(replay_buffer, batch_sz) x_batch = [i[0] for i in batch] a_batch = [i[1] for i in batch] r_batch = [i[2] for i in batch] x_p_batch = [i[3] for i in batch] t_batch = [not i[4] for i in batch]
def make_video(img_folder, out="video.mp4"): imgs = [os.path.join(img_folder, img) for img in os.listdir(img_folder)] clip = ImageSequenceClip(imgs * 5, fps=10) clip.write_videofile(out)
# create a video clip from bunch of image from moviepy.editor import ImageSequenceClip clip = ImageSequenceClip('test', fps=3) clip.write_videofile('crowdai.mp4', audio=False)
def main(arguments: List[str]) -> int: args = parser.parse_args(arguments) sequence_list = os.listdir(args.root) os.makedirs(args.output_dir, exist_ok=True) max_videos = args.max_videos for seq_name in sequence_list[:max_videos]: seq_path = os.path.join(args.root, seq_name) df = pd.read_csv(seq_path) count = 0 time_list = np.sort(np.unique(df["TIMESTAMP"].values)) # Get API for Argo Dataset map avm = ArgoverseMap() city_name = df["CITY_NAME"].values[0] seq_lane_bbox = avm.city_halluc_bbox_table[city_name] seq_lane_props = avm.city_lane_centerlines_dict[city_name] x_min = min(df["X"]) x_max = max(df["X"]) y_min = min(df["Y"]) y_max = max(df["Y"]) lane_centerlines = [] # Get lane centerlines which lie within the range of trajectories for lane_id, lane_props in seq_lane_props.items(): lane_cl = lane_props.centerline if (np.min(lane_cl[:, 0]) < x_max and np.min(lane_cl[:, 1]) < y_max and np.max(lane_cl[:, 0]) > x_min and np.max(lane_cl[:, 1]) > y_min): lane_centerlines.append(lane_cl) seq_out_dir = os.path.join(args.output_dir, seq_name.split(".")[0]) for time in time_list: plt.xlim(x_min, x_max) plt.ylim(y_min, y_max) df_cur = df.loc[df["TIMESTAMP"] <= time] if time == time_list[-1]: viz_sequence(df_cur, lane_centerlines=lane_centerlines, show=False, smoothen=False) else: viz_sequence(df_cur, lane_centerlines=lane_centerlines, show=False, smoothen=False) os.makedirs(seq_out_dir, exist_ok=True) plt.savefig(os.path.join(seq_out_dir, f"{count}.png"), bbox_inches="tight", pad_inches=0) plt.close() count += 1 from moviepy.editor import ImageSequenceClip img_idx = sorted( [int(x.split(".")[0]) for x in os.listdir(seq_out_dir)]) list_video = [f"{seq_out_dir}/{x}.png" for x in img_idx] clip = ImageSequenceClip(list_video, fps=10) video_path = os.path.join(args.output_dir, f"{seq_name.split('.')[0]}.mp4") clip.write_videofile(video_path) shutil.rmtree(seq_out_dir) return 0
def main(): """Make a jazz noise here""" args = get_args() # Variables # Directory containing tar'd or foldered lansat data # indir = r'D:\lansat\Bulk Order Large_lansat_8\test' # How strict do you want the cloud recognition to be, the lower the more strict # how_strict= 0.7 # # GPS Bounding Box for sampling area, [xmin, xmax, ymin, fymax] # xmin ymin xmax ymax - gdal # xmin ymax xmax ymin # x1 = 160785 # y1 = 3467622 # x2 = 169515 # y2 = 3462902 bb = args.bounding_box xmin = int(bb[0]) ymin = int(bb[1]) xmax = int(bb[2]) ymax = int(bb[3]) #-------------------------------------------------------------------------- # -Main- # If you ahve tars still in the directory, these will grab them and untar them tars = glob.glob(os.path.join(args.indir ,'*.tar')) print('Extracting tar files...') # if len(tars) > 1: for tar in tars: out_file = tar.split('.')[0] # making a file for the tars to land if not os.path.exists(out_file): os.makedirs(out_file) one_tar = tarfile.open(tar) one_tar.extractall(out_file) # # Function to take a lansat image and crop it to the sample area in Baker County, GA lv1 = glob.glob(os.path.join(args.indir , '*')) # print(lv1) # print(lv1) print('Extraction complete, cropping Lansat images...') for folder in lv1: if os.path.isdir(folder): folder_name = os.path.basename(folder) if folder_name.startswith('L'): cnt = 1 # print(os.path.join(folder, '*.TIF')) TIFs = glob.glob(os.path.join(folder, '*.TIF')) # print(TIFs) date = folder.split("_")[-4] outdir = os.path.join(args.indir, date) while os.path.isdir(outdir): outdir = outdir + f'_{cnt}' cnt += 1 os.mkdir(outdir) # Itterating through the image list for im in TIFs: # print(im) split = im.split('_') date = split[-6] band = split[-1] filename = date+'_'+band # print(filename) # Opening each one in GDAL img = gdal.Open(im) # print('translating') # Need to add -a_ullr xmin ymax xmax ymin # large extent # 160894,3459609,173729,3468590 # QGIS copy seems to be in xmin ymin xmax ymax # We need to change the input to reflect that for ease of use gdal.Translate(os.path.join(outdir, filename), img, projWin = [xmin, ymax, xmax, ymin]) lv2 = glob.glob(os.path.join(args.indir, '*')) print('Creating cloudy and clear directories for sorting...') if not os.path.exists(os.path.join(args.indir, 'cloudy')): os.makedirs(os.path.join(args.indir, 'cloudy')) if not os.path.exists(os.path.join(args.indir, 'clear')): os.makedirs(os.path.join(args.indir, 'clear')) if not os.path.exists(os.path.join(args.indir, 'NDWI')): os.makedirs(os.path.join(args.indir, 'NDWI')) print('Scanning for cloudcover and running NDWI analysis...') for date_folder in lv2: if (os.path.isdir(date_folder)): date = os.path.basename(date_folder) if not date.startswith('L'): band1_imgs = glob.glob(os.path.join(date_folder , '*B1.TIF')) for img in band1_imgs: filename = os.path.basename(img) # print(img) # pil_im = Image.open(img) # display(pil_im) # Open it, histogram mean, sort testing_img = cv2.imread(img) testing_vals = testing_img.mean(axis=2).flatten() testing_mode = statistics.mode(testing_vals) testing_average = statistics.mean(testing_vals) # print('Testing mode: ',testing_mode) # print('Testing Average: ', testing_average) if testing_mode == 0.0: # print("Black image") if (len([1 for i in testing_vals if i > testing_mode]) >= len(testing_vals)*args.how_strict) or (testing_average > 35) or (testing_average < 10): # print("Cloudy image") # print(date) try: shutil.move(os.path.join(args.indir, date), os.path.join(args.indir, 'cloudy')) except: continue else: # print("Clear image") # print(date) # do NDWI Then move # Calculation # NDWI = (3 - 5)/(3 + 5) date_folder band3 = glob.glob(os.path.join(date_folder, '*B3.TIF')) band5 = glob.glob(os.path.join(date_folder, '*B5.TIF')) b3 = rio.open(band3[0]) b5 = rio.open(band5[0]) green = b3.read() nir = b5.read() ndwi = (nir.astype(float)-green.astype(float))/(nir+green) print(type(ndwi)) # Plotting fig, ax = plt.subplots(1, figsize=(12, 10)) show(ndwi, ax=ax, cmap="coolwarm_r") # testing plt.axis('off') plt.savefig(os.path.join(date_folder, date + '_NDWI.TIF'), bbox_inches = 'tight') plt.savefig(os.path.join(args.indir, 'NDWI' , date + '_NDWI.TIF'), bbox_inches = 'tight') b3.close() b5.close() try: shutil.move(os.path.join(args.indir, date), os.path.join(args.indir, 'clear')) except: continue ndwi_TIFs = glob.glob(os.path.join(args.indir, 'NDWI', '*.TIF')) for i in ndwi_TIFs: # Add coordinates img = gdal.Open(i) gdal.Translate(i.replace('.TIF', '_reprojected.TIF'), img, outputBounds = [xmin, ymax, xmax, ymin]) # Labeling # pic_name = os.path.basename(i) # pic_name = pic_name.replace('.TIF', '') # img = cv2.imread(i) # height, width, channels = img.shape # font = cv2.FONT_HERSHEY_SIMPLEX # cv2.putText(img,pic_name,(int(width/2),height, font, 1,(0,0,0),2)) # cv2.imwrite(i.replace('.TIF', '_labeled.TIF'), img) # ndwi_TIFs_labeled = glob.glob(os.path.join(args.indir, 'NDWI', '*labeled.TIF')) clip = ImageSequenceClip(ndwi_TIFs,fps=.20) clip.write_gif(os.path.join(args.indir, 'NDWI', 'final.gif')) print(f'Finished analysis, find NDWI outputs at {os.path.join(args.indir,'NDWI')}.') # -------------------------------------------------- if __name__ == '__main__': main()
print y_pos.shape print pol.shape (timestamps, x_pos, y_pos, pol) = dvsproc.clean_up_events(timestamps, x_pos, y_pos, pol, window=1000) frames, fs, _ = dvsproc.gen_dvs_frames(timestamps, x_pos, y_pos, pol, num_frames, fs=3) print "Length of produced frames: ", len(frames) new_frames = [] for frame in frames: tmp_frame = (((frame+fs)/float(2*fs))*255).astype(np.uint8) new_frames.append(tmp_frame) clip = ImageSequenceClip(new_frames, fps=20) clip.write_gif(seq_save_path, fps=30) print "Sequence %s is saved at %s" % (img_name, seq_save_path) elif option == "caltech256-ps": caltech_fn = "INI_Caltech256_10fps_20160424.hdf5" caltech_path = os.path.join(data_path, caltech_fn) caltech_db = h5py.File(caltech_path, mode="r") caltech_stats_path = os.path.join(stats_path, "caltech256_stats.pkl") caltech_save_path = os.path.join(data_path, "caltech256_ps.eps") img_num = 60 f = file(caltech_stats_path, mode="r") caltech_stats = pickle.load(f) f.close()
def run(outdir, train_mode): # Build network. initializer = tf.keras.initializers.VarianceScaling() X = tf.placeholder(tf.float32, shape=[None, n_inputs]) hidden = tf.layers.dense(X, N_HIDDEN, activation=tf.nn.elu, kernel_initializer=initializer) logits = tf.layers.dense(hidden, n_outputs) outputs = tf.nn.sigmoid(logits) # probability of action 0 (left) p_left_and_right = tf.concat(axis=1, values=[outputs, 1 - outputs]) action = tf.multinomial(tf.log(p_left_and_right), num_samples=1) # Optimizer, gradients. y = 1. - tf.to_float(action) cross_entropy = tf.nn.sigmoid_cross_entropy_with_logits(labels=y, logits=logits) optimizer = tf.train.AdamOptimizer(LEARNING_RATE) grads_and_vars = optimizer.compute_gradients(cross_entropy) gradients = [grad for grad, variable in grads_and_vars] gradient_placeholders = [] grads_and_vars_feed = [] for grad, variable in grads_and_vars: gradient_placeholder = tf.placeholder(tf.float32, shape=grad.get_shape()) gradient_placeholders.append(gradient_placeholder) grads_and_vars_feed.append((gradient_placeholder, variable)) training_op = optimizer.apply_gradients(grads_and_vars_feed) # For TensorBoard. episode_reward = tf.placeholder(dtype=tf.float32, shape=[]) tf.summary.scalar('reward', episode_reward) init = tf.global_variables_initializer() saver = tf.train.Saver() if train_mode: hp_save_dir = hp_directory(outdir) with tf.Session() as sess: init.run() # For TensorBoard. print('hp_save_dir') train_writer = tf.summary.FileWriter(hp_save_dir, sess.graph) for iteration in range(n_iterations): all_rewards = [] all_gradients = [] for game in range(N_GAMES_PER_UPDATE): current_rewards = [] current_gradients = [] obs = env.reset() for step in range(n_max_steps): action_val, gradients_val = sess.run( [action, gradients], feed_dict={X: obs.reshape(1, n_inputs)}) obs, reward, done, info = env.step(action_val[0][0]) current_rewards.append(reward) current_gradients.append(gradients_val) if done: break all_rewards.append(current_rewards) all_gradients.append(current_gradients) avg_reward = np.mean(([np.sum(r) for r in all_rewards])) print('\rIteration: {}, Reward: {}'.format(iteration, avg_reward, end='')) all_rewards = discount_and_normalize_rewards( all_rewards, discount_rate=DISCOUNT_RATE) feed_dict = {} for var_index, gradient_placeholder in enumerate( gradient_placeholders): mean_gradients = np.mean([ reward * all_gradients[game_index][step][var_index] for game_index, rewards in enumerate(all_rewards) for step, reward in enumerate(rewards) ], axis=0) feed_dict[gradient_placeholder] = mean_gradients sess.run(training_op, feed_dict=feed_dict) if iteration % save_iterations == 0: print('Saving model to ', hp_save_dir) model_file = '{}/my_policy_net_pg.ckpt'.format(hp_save_dir) saver.save(sess, model_file) # Also save event files for TB. merge = tf.summary.merge_all() summary = sess.run(merge, feed_dict={episode_reward: avg_reward}) train_writer.add_summary(summary, iteration) obs = env.reset() steps = [] done = False else: # Make a gif. from moviepy.editor import ImageSequenceClip model_file = '{}/my_policy_net_pg.ckpt'.format(outdir) with tf.Session() as sess: sess.run(tf.global_variables_initializer()) saver.restore(sess, save_path=model_file) # Run model. obs = env.reset() done = False steps = [] rewards = [] while not done: s = env.render('rgb_array') steps.append(s) action_val = sess.run(action, feed_dict={X: obs.reshape(1, n_inputs)}) obs, reward, done, info = env.step(action_val[0][0]) rewards.append(reward) print('Final reward :', np.mean(rewards)) clip = ImageSequenceClip(steps, fps=30) clip.write_gif('cartpole.gif', fps=30)
def get_output(video_path, out_filename, label, fps=30, font_scale=0.5, font_color='white', target_resolution=None, resize_algorithm='bicubic', use_frames=False): """Get demo output using ``moviepy``. This function will generate video file or gif file from raw video or frames, by using ``moviepy``. For more information of some parameters, you can refer to: https://github.com/Zulko/moviepy. Args: video_path (str): The video file path or the rawframes directory path. If ``use_frames`` is set to True, it should be rawframes directory path. Otherwise, it should be video file path. out_filename (str): Output filename for the generated file. label (str): Predicted label of the generated file. fps (int): Number of picture frames to read per second. Default: 30. font_scale (float): Font scale of the label. Default: 0.5. font_color (str): Font color of the label. Default: 'white'. target_resolution (None | tuple[int | None]): Set to (desired_width desired_height) to have resized frames. If either dimension is None, the frames are resized by keeping the existing aspect ratio. Default: None. resize_algorithm (str): Support "bicubic", "bilinear", "neighbor", "lanczos", etc. Default: 'bicubic'. For more information, see https://ffmpeg.org/ffmpeg-scaler.html use_frames: Determine Whether to use rawframes as input. Default:False. """ if video_path.startswith(('http://', 'https://')): raise NotImplementedError try: from moviepy.editor import ImageSequenceClip except ImportError: raise ImportError('Please install moviepy to enable output file.') # Channel Order is BGR if use_frames: frame_list = sorted( [osp.join(video_path, x) for x in os.listdir(video_path)]) frames = [cv2.imread(x) for x in frame_list] else: video = decord.VideoReader(video_path) frames = [x.asnumpy()[..., ::-1] for x in video] if target_resolution: w, h = target_resolution frame_h, frame_w, _ = frames[0].shape if w == -1: w = int(h / frame_h * frame_w) if h == -1: h = int(w / frame_w * frame_h) frames = [cv2.resize(f, (w, h)) for f in frames] textsize = cv2.getTextSize(label, cv2.FONT_HERSHEY_DUPLEX, font_scale, 1)[0] textheight = textsize[1] padding = 10 location = (padding, padding + textheight) if isinstance(font_color, str): font_color = webcolors.name_to_rgb(font_color)[::-1] frames = [np.array(frame) for frame in frames] for frame in frames: cv2.putText(frame, label, location, cv2.FONT_HERSHEY_DUPLEX, font_scale, font_color, 1) # RGB order frames = [x[..., ::-1] for x in frames] video_clips = ImageSequenceClip(frames, fps=fps) out_type = osp.splitext(out_filename)[1][1:] if out_type == 'gif': video_clips.write_gif(out_filename) else: video_clips.write_videofile(out_filename, remove_temp=True)
frames = [] for episode in range(3): done = False state = env.reset() frame = env.render() frames.append(np.asarray(frame, dtype="int32")) while not done: tensor_state = torch.FloatTensor(state).unsqueeze(0).to(device) action = q_net.select_greedyaction(tensor_state) print(action) done, reward = env.step(action) state = env.player frame = env.render() frames.append(np.asarray(frame, dtype="int32")) clip = ImageSequenceClip(frames, fps=20) clip.write_gif('test.gif', fps=20) plt.figure(1) plt.title('Performance over learning (DQN)') plt.plot(episode_rewards[:, 0], episode_rewards[:, 1]) plt.xlabel('time steps') plt.ylabel('total reward') plt.figure(2) plt.title('Performance on Test Env (DQN)') xv = np.arange(EVAL_EVERY - 1, N_EPISODES + 1, EVAL_EVERY) plt.plot(episode_rewards[xv, 0], episode_rewards[xv, 2], ':o') plt.xlabel('time steps') plt.ylabel('expected total reward (greedy policy)') plt.show()
plt.ylabel('Cases') plt.legend(['Susceptible', 'Infectious', 'Dead', 'Recovered']) plt.subplot(224) plt.plot(Stat2.index, Stat2['Healthy'], 'b') plt.plot(Stat2.index, Stat2['infected'], 'r') plt.plot(Stat2.index, Stat2['Dead'], 'k') plt.plot(Stat2.index, Stat2['Cured'], 'g') plt.xlabel('Days') plt.ylabel('Cases') plt.legend(['Susceptible', 'Infectious', 'Dead', 'Recovered']) #data=np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8) fig.canvas.draw() #data=np.fromstring(fig.canvas.tostring_rgb(), dtype=np.uint8, sep='') data = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8) data = data.reshape(fig.canvas.get_width_height()[::-1] + (3, )) #plt.show() ims.append(data) plt.clf() plt.cla() from moviepy.editor import ImageSequenceClip #Somehow doesn't work if put at the top, possible conflict with matplotlib clip = ImageSequenceClip(ims, fps=3) clip.write_gif('simulation.gif', fps=3) clip.write_videofile('simulation.mp4', fps=3)
def SaveGIF(self, clip, name, fps=10): clip = ImageSequenceClip(clip, fps=fps) clip.write_gif("{}/images/{}.gif".format(self.LOG_PATH, name), fps=fps)
# write video stream vidfile.write(frame) if frame_id >= 1000: print("recorded 1000 frames") break print("%.3f %d %.3f %d %d(ms)" % (ts, frame_id, angle, btn, int((time.time() - ts) * 1000))) if fpv_video: textColor = (255, 255, 255) bgColor = (0, 0, 0) for i in xrange(len(frame_arr)): newImage = Image.new('RGBA', (100, 20), bgColor) drawer = ImageDraw.Draw(newImage) drawer.text((0, 0), "Frame #{}".format(i), fill=textColor) drawer.text((0, 10), "Angle:{}".format(angle_arr[i]), fill=textColor) newImage = cv2.cvtColor(np.array(newImage), cv2.COLOR_BGR2RGBA) frame_arr[i] = cm.overlay_image(frame_arr[i], newImage, x_offset=0, y_offset=0) #Create a video using the frames collected clip = ImageSequenceClip(frame_arr, fps=30) clip.write_videofile('fpv-video.mp4') # print("Finish..") turn_off()
image_dir = '/home/mia/backup/research/autonomous_driving/cityscapes/dataset/val_images' image_list = os.listdir(image_dir) image_list.sort() print(f'{len(image_list)} frames found') test = load_img(f'{image_dir}/{image_list[1]}') test = img_to_array(test) pipeline(test, video=False) for image_dir in ['stuttgart_00', 'stuttgart_01', 'stuttgart_02']: os.mkdir(f'outputs/{image_dir}') image_list = os.listdir(image_dir) image_list.sort() print(f'{len(image_list)} frames found') for i in tqdm(range(len(image_list))): try: test = load_img(f'{image_dir}/{image_list[i]}') test = img_to_array(test) segmap = pipeline(test, video=False, fname=f'{image_list[i]}', folder=image_dir) if segmap == False: break except Exception as e: print(str(e)) clip = ImageSequenceClip(sorted(glob(f'outputs/{image_dir}/*')), fps=18, load_images=True) clip.write_videofile(f'{image_dir}.mp4')
def make_movie(imgs, filename): clip = ImageSequenceClip(imgs, fps=int(30 / args.frame_repeat)) clip.write_videofile(filename)
def main(): logging.basicConfig( format='%(asctime)s [%(name)s] [%(levelname)s] %(message)s') log = logging.getLogger("TimeLapse") log.setLevel(LogLevel) log.info("TimeLapse Starting!") #Read in the Cameras! camfile = open("cams.json") cameras = json.load(camfile) camfile.close() for x in cameras.keys(): try: os.mkdir(x) os.mkdir(x + "-mp4") except Exception as e: log.error("Could not create folder " + x + "!") log.error("Exception: " + str(e)) log.info("Added Camera " + x) if cameras[x]["type"] == "etag": cameras[x]["instance"] = ETagDownload(cameras[x]["url"], x) if cameras[x]["type"] == "max-age": cameras[x]["instance"] = MaxAgeDownload(cameras[x]["url"], x) if cameras[x]["type"] == "max-age-etag": cameras[x]["instance"] = MaxAgeETagDownload(cameras[x]["url"], x) cameras[x]["instance"].start() while True: command = input(">") if command == "list-cams": for x in cameras.keys(): log.info(x + ": Running? " + str(cameras[x]["instance"].is_running)) elif command.startswith("stopcam"): cam = command.split(" ")[1] if not cam in cameras.keys(): log.error("Invalid Camera name") else: log.info("Camera " + cam + " stopped!") cameras[cam]["instance"].stop() elif command.startswith("startcam"): cam = command.split(" ")[1] if not cam in cameras.keys(): log.error("Invalid Camera name") else: log.info("Camera " + cam + " started!") cameras[cam]["instance"].start() elif command.startswith("save"): for x in cameras.keys(): cameras[x]["instance"].stop() log.info("All Camers Stopped!") for x in cameras.keys(): log.info("Saving " + x) data = livejson.File(x + "-mp4/cat.json") t = str(int(time.time())) q = ImageSequenceClip(x, fps=cameras[x]["fps"]) q.write_videofile(x + "-mp4/" + t + ".mp4") data[t] = glob(x + "/*.jpg") for y in glob(x + "/*.jpg"): os.remove(y) log.info("All Cameras started!") for x in cameras.keys(): cameras[x]["instance"].start() elif command.startswith("stopcams"): for x in cameras.keys(): cameras[x]["instance"].stop() log.info("All Camers Stopped!") elif command.startswith("startcams"): for x in cameras.keys(): cameras[x]["instance"].start() log.info("All Camers Stopped!") elif command == "stop": log.info("Stopping all cameras and halting!") for x in cameras.keys(): cameras[x]["instance"].stop() break elif command == "help": log.info("help: Shows this.") log.info("list-cams: Lists the current cameras.") log.info("stopcam: Stops a cameras recording.") log.info("startcam: Starts a camera recording.") log.info("stop: Stops this program.") else: log.error("Command not found! " + command)
def get_output(video_path, out_filename, label, fps=30, font_size=20, font_color='white', target_resolution=None, resize_algorithm='bicubic', use_frames=False): """Get demo output using ``moviepy``. This function will generate video file or gif file from raw video or frames, by using ``moviepy``. For more information of some parameters, you can refer to: https://github.com/Zulko/moviepy. Args: video_path (str): The video file path or the rawframes directory path. If ``use_frames`` is set to True, it should be rawframes directory path. Otherwise, it should be video file path. out_filename (str): Output filename for the generated file. label (str): Predicted label of the generated file. fps (int): Number of picture frames to read per second. Default: 30. font_size (int): Font size of the label. Default: 20. font_color (str): Font color of the label. Default: 'white'. target_resolution (None | tuple[int | None]): Set to (desired_width desired_height) to have resized frames. If either dimension is None, the frames are resized by keeping the existing aspect ratio. Default: None. resize_algorithm (str): Support "bicubic", "bilinear", "neighbor", "lanczos", etc. Default: 'bicubic'. For more information, see https://ffmpeg.org/ffmpeg-scaler.html use_frames: Determine Whether to use rawframes as input. Default:False. """ if video_path.startswith(('http://', 'https://')): raise NotImplementedError try: from moviepy.editor import (CompositeVideoClip, ImageSequenceClip, TextClip, VideoFileClip) except ImportError: raise ImportError('Please install moviepy to enable output file.') if use_frames: frame_list = sorted( [osp.join(video_path, x) for x in os.listdir(video_path)]) video_clips = ImageSequenceClip(frame_list, fps=fps) else: # revert the order to suit ``VideoFileClip``. # (weight, height) -> (height, weight) target_resolution = (target_resolution[1], target_resolution[0]) video_clips = VideoFileClip(video_path, target_resolution=target_resolution, resize_algorithm=resize_algorithm) duration_video_clip = video_clips.duration text_clips = TextClip(label, fontsize=font_size, color=font_color) text_clips = (text_clips.set_position( ('right', 'bottom'), relative=True).set_duration(duration_video_clip)) video_clips = CompositeVideoClip([video_clips, text_clips]) out_type = osp.splitext(out_filename)[1][1:] if out_type == 'gif': video_clips.write_gif(out_filename) else: video_clips.write_videofile(out_filename, remove_temp=True)