def save_video(self, video, audio, path, experimental_ffmpeg=False): with tempdir() as dirpath: # Save the video file writer = sio.FFmpegWriter(dirpath + "/tmp.avi", inputdict={ '-r': str(self.video_rate) + "/1", }, outputdict={ '-r': str(self.video_rate) + "/1", }) for i in range(video.shape[0]): writer.writeFrame(np.rollaxis(video[i, :, :, :], 0, 3)) writer.close() # Save the audio file wav.write(dirpath + "/tmp.wav", self.audio_rate, audio) in1 = ffmpeg.input(dirpath + "/tmp.avi") in2 = ffmpeg.input(dirpath + "/tmp.wav") if experimental_ffmpeg: out = ffmpeg.output(in1['v'], in2['a'], path, strict='-2', loglevel="panic") else: out = ffmpeg.output(in1['v'], in2['a'], path, loglevel="panic") out.run()
def save_video(self, video, audio, path, fs, overwrite=True, experimental_ffmpeg=False, scale=None): if not os.path.isabs(path): path = os.getcwd() + "/" + path with tempdir() as dirpath: # Save the video file writer = sio.FFmpegWriter(dirpath + "/tmp.avi", inputdict={'-r': str(self.video_rate) + "/1", }, outputdict={'-r': str(self.video_rate) + "/1", } ) for i in range(video.shape[0]): frame = np.rollaxis(video[i, :, :, :], 0, 3) if scale is not None: frame = tf.rescale(frame, scale, anti_aliasing=True, multichannel=True, mode='reflect') writer.writeFrame(frame) writer.close() # Save the audio file wav.write(dirpath + "/tmp.wav", fs, audio) in1 = ffmpeg.input(dirpath + "/tmp.avi") in2 = ffmpeg.input(dirpath + "/tmp.wav") if experimental_ffmpeg: out = ffmpeg.output(in1['v'], in2['a'], path, strict='-2', loglevel="panic") else: out = ffmpeg.output(in1['v'], in2['a'], path, loglevel="panic") if overwrite: out = out.overwrite_output() out.run()
def __start__(self, name): self._maskfile = None self._resultfiles = {} self._masknames = tuple(maskname for maskname in self.masks.keys()) basename = _os.path.splitext(name)[0] ensure_directory(self.maskdir) ensure_directory(self.resultdir) for roiname, roi in get_items(self.ROIs): if roi.is_empty(): continue resultpath = _os.path.join( self.resultdir, "Results_{0}_{1}.csv".format(basename, roiname)) # TODO: create mask file try: self._resultfiles[roiname] = open(resultpath, 'w') self._resultfiles[roiname].write('Slice,' + ','.join( _mask_entries(m) for m in self._masknames)) self._resultfiles[roiname].write('\n') except: _print_exc() print_status("*** could not open: {0}".format(resultpath)) if len(self._resultfiles) == 0: raise RuntimeError("nothing to output for {0}".format(name)) # maskpath = _os.path.join(self.maskdir, "MASK_{0}.avi".format(basename, roiname)) maskpath = _os.path.join(self.maskdir, "MASK_{0}.mp4".format(basename, roiname)) try: self._maskfile = _vio.FFmpegWriter(maskpath, outputdict=OUTPUT_SPECS) except: _print_exc() print_status("*** could not open: {0}".format(maskpath))
def _record_frame(): global video_out last_frame_time = None out_fps = 30 out_frame_interval = 1.0 / out_fps while not video_out_should_stop: frame_index = video_out_queue.get() if frame_index is None: break assert frame_index in data_source._frames frame = data_source._frames[frame_index]['bgr'] h, w, _ = frame.shape if video_out is None: # video_out = cv.VideoWriter( # args.record_video, cv.VideoWriter_fourcc(*'H264'), # out_fps, (w, h), # ) video_out = skv.FFmpegWriter(args.record_video) now_time = time.time() if last_frame_time is not None: time_diff = now_time - last_frame_time while time_diff > 0.0: #video_out.write(frame) video_out.writeFrame(np.flip(frame, axis=-1)) time_diff -= out_frame_interval last_frame_time = now_time #video_out.release() video_out.close() with video_out_done: video_out_done.notify_all()
def run(self): """ Continually write images to the filename specified by a command queue. """ if not self.camera.is_running: self.camera.start() while True: if not self.cmd_q.empty(): cmd = self.cmd_q.get() if cmd[0] == 'stop': self.out.close() self.recording = False elif cmd[0] == 'start': filename = cmd[1] self.out = si.FFmpegWriter(filename) self.recording = True self.count = 0 if self.recording: if self.count == 0: image, _, _ = self.camera.frames() if self.data_buf is None: self.data_buf = np.zeros( [1, image.height, image.width, image.channels]) self.data_buf[0, ...] = image.raw_data self.out.writeFrame(self.data_buf) self.count += 1 if self.count == self.rate: self.count = 0
def predict(data_dir, output_dir, checkpoint, batch_size): in_place, output_video_t = build_forward(INPUT_SIZE, NUM_FRAMES, tf.estimator.ModeKeys.PREDICT) saver = tf.train.Saver() with tf.Session() as sess: try: saver.restore(sess, 'weights/{}_best'.format(checkpoint)) except Exception as e: print('{}: {} is not a valid checkpoint to restore from.'.format(e, checkpoint)) prediction_folder = os.path.join(output_dir, 'output') # check that prediction folder exists if not os.path.exists(prediction_folder): os.mkdir(prediction_folder) input_videos = glob.glob(os.path.join(data_dir, '/*.mp4')) for ivf in input_videos: in_video = vidio.vread(ivf) out_video = sess.run([output_video_t], { in_place : in_video[:NUM_FRAMES, :INPUT_SIZE, :INPUT_SIZE] }) base_filename = ivf.split('/')[-1] out_filename = os.path.join(prediction_folder, base_filename) writer = vidio.FFmpegWriter(out_filename) for i in range(out_video.shape[0]): writer.writeFrame(out_video[i,...]) writer.close()
def main(): # parse the arguments parser = argparse.ArgumentParser(description='Retouch video partially.') parser.add_argument('--src_path', type=str, default='../originals', help='source path') parser.add_argument('--dst_path', type=str, default='../retouch_temporal_videos', help='destination path') parser.add_argument('--intensity', type=str, default='strong', help='strong or weak') args = parser.parse_args() SRC_PATH = args.src_path DST_PATH = args.dst_path INTENSITY = args.intensity methods = ["blur", "median", "noise"] fnames = glob(join(SRC_PATH, "*.mp4")) for fname in fnames: vOriginal = np.array(vio.vread(fname, inputdict={})) vRetouched = np.zeros(vOriginal.shape) fn, w, h, c = vOriginal.shape start_fn = int(fn / 3) end_fn = int(fn * 2 / 3) for method in methods: print("processing {}".format( join(DST_PATH, INTENSITY, method, fname.split("\\")[-1]))) for idx in range(fn): if idx >= start_fn and idx <= end_fn: vRetouched[idx] = manipulate(vOriginal[idx], method, intensity=INTENSITY) else: vRetouched[idx] = vOriginal[idx] write_option['-b:v'] = "800k" writer = vio.FFmpegWriter(filename=join(DST_PATH, INTENSITY, method, fname.split("\\")[-1]), inputdict={'-r': fps}, outputdict=write_option) for frame in vRetouched: writer.writeFrame(frame) writer.close()
def __init__(self, vreader, output_record_path="", output_video_path="", heatmap=False): # Parameters self.vreader = vreader self.heatmap = heatmap self.output_video_flag = True if output_video_path else False self.output_record_flag = True if output_record_path else False self.vwriter = skv.FFmpegWriter(output_video_path) if self.output_video_flag else None self.results_recorder = open(output_record_path, "w") if self.output_record_flag else None # Initialization actions self._initialize_results_recorder()
def decrypt_vid(self, src, dest): vid = skv.vread(src) # extract LSB and then set to 0 lsb = np.bitwise_and(vid, 1).astype(bool) vid[:] = np.bitwise_and(vid, ~1) binary = self.binarize_4d(vid) self.arnold_4d(lsb, n=(192 - len(vid))) # localize xor = np.bitwise_xor(binary, lsb) params = {'-c:v': 'ffv1'} with skv.FFmpegWriter(dest, outputdict={'-c:v': 'ffv1'}) as f: [f.writeFrame(xor[n] * 192) for n in range(len(vid))]
def tamper_vid(self, src, dest, n_tamper=20, save=False): vid = skv.vread(src) t, x, y, _ = vid.shape rand_t = np.random.randint(t, size=n_tamper) rand_x = np.random.randint(x, size=n_tamper) rand_y = np.random.randint(y, size=n_tamper) rand_z = np.random.randint(255, size=n_tamper) for n in range(n_tamper): vid[rand_t[n], rand_x[n]:rand_y[n], rand_x[n]: rand_y[n], :] = rand_z[n] with skv.FFmpegWriter(dest, outputdict={'-c:v': 'ffv1'}) as f: [f.writeFrame(vid[n]) for n in range(len(vid))] if save: tmp = np.zeros(vid.shape, dtype=vid.dtype) for n in range(n_tamper): tmp[rand_t[n], rand_x[n]:rand_y[n], rand_x[n]: rand_y[n], :] = rand_z[n] with skv.FFmpegWriter( dest.replace('.avi', '_tmp.avi'), outputdict={'-c:v': 'ffv1'}) as f: [f.writeFrame(tmp[n]) for n in range(len(tmp))]
def process_directories(model_dirs, out_dir, gpu_idx=0): """Load the latest snapshot in each of the given model directories, and render a video for each test variant corresponding to the train variants in the model. Note that the video will show all models in sequence.""" set_seeds(DEFAULT_SEED) register_envs() if out_dir: os.makedirs(out_dir, exist_ok=True) if gpu_idx is None: dev = torch.device('cpu') else: dev = torch.device(f'cuda:{gpu_idx}') # we're going to keep a video writer for each env writers_by_env = {} for model_idx, model_dir in enumerate(model_dirs): print(f"Loading model from '{model_dir}' " f"(model {model_idx+1}/{len(model_dirs)})") latest_path = get_latest_path(os.path.join(model_dir, "itr_LATEST.pkl")) model = load_state_dict_or_model(latest_path) model = model.to(dev) test_envs = get_test_envs(model.env_ids_and_names) for test_env in test_envs: if test_env not in writers_by_env: vid_name = generate_vid_name(test_env) out_path = os.path.join(out_dir, vid_name) print(f" Writing video for '{test_env}' to '{out_path}'") writer = vidio.FFmpegWriter(out_path, outputdict={ '-r': str(DEFAULT_FPS), '-vcodec': 'libx264', '-pix_fmt': 'yuv420p', }) writers_by_env[test_env] = writer else: print(f" Writing video for '{test_env}'") writer = writers_by_env.get(test_env) # will be something like, e.g., "movetocorner-testjitter.mp4" for frame in generate_frames(model=model, env_name=test_env, dev=dev, seed=DEFAULT_SEED + model_idx, ntraj=NTRAJ_PER_MODEL, fps=DEFAULT_FPS): writer.writeFrame(frame) for writer in writers_by_env.values(): writer.close()
def combine_graphs_to_video(self, frame_rate='120/1'): all_graphs_paths = glob(os.path.join(self.get_graph_dir(), "*.png")) total_graphs_num = len(all_graphs_paths) self.vwriter = skv.FFmpegWriter(self.get_video_path(), inputdict={'-r': frame_rate}, outputdict={'-r': frame_rate}) print("Generate video...") for idx in range(total_graphs_num): print("\r{}/{}".format(idx, total_graphs_num), end="", flush=True) graph_path = self.get_graph_path(idx) im = ski.imread(graph_path) self.vwriter.writeFrame(im) self.vwriter.close()
def encrypt_vid(self, src, dest): """ Runs encryption on videos. Assumes a square matrix divisible by 4. """ vid = skv.vread(src) # set LSB to 0 vid[:] = np.bitwise_and(vid, ~1) binary = self.binarize_4d(vid) self.arnold_4d(binary, n=len(vid)) # embed watermark log.info('Embedding watermark and saving') vid[:] = np.bitwise_or(vid, binary) params = {'-c:v': 'ffv1'} with skv.FFmpegWriter(dest, outputdict={'-c:v': 'ffv1'}) as f: [f.writeFrame(vid[n]) for n in range(len(vid))]
def write_snippets_to_disk(idxs, output_path, name: str = 'Output', fps: int = 10, only_frames: bool = False): idx = 0 for start, end, conf in idxs: frames = job.Parallel( n_jobs=MAX_JOBS, verbose=0)(job.delayed(cv2.imread)(join( output_path, SUBFOLDER_PROCESSED, f'{j}.jpg')) for j in range(start, end)) frames = [ np.zeros((850, 850, 3), dtype=np.uint8) if f is None or f.size == 0 else f for f in frames ] max_height = max(frames, key=lambda img: img.shape[0]).shape[0] max_width = max(frames, key=lambda img: img.shape[1]).shape[1] avg_size = sum([f.shape[0] for f in frames]) / len(frames) frames = [ utl.pad_image_to_size(f, (max_height, max_width)) for f in frames ] #out = cv2.VideoWriter(join(output_path, SUBFOLDER_RESULTS, f'{name}_{i}.a'), cv2.VideoWriter_fourcc('H', '2', '6', '4'), fps, size) if not only_frames: out = io.FFmpegWriter(join(output_path, SUBFOLDER_RESULTS, f'{name}_{idx}_{conf}.mp4'), inputdict={ '-r': str(fps), '-s': f'{max_width}x{max_height}' }, outputdict={ '-vcodec': 'libx264', '-crf': '0', '-preset': 'slow' }) for frame in frames: out.writeFrame(frame[:, :, [2, 1, 0]]) out.close() else: for i, frame in enumerate(frames): cv2.imwrite( join(output_path, SUBFOLDER_RESULTS, f'{name}_{idx}_{conf}_{i}.png'), frame) idx += 1
def get_video(video_name, start_secs, end_secs, vid_quality=1, save_dir=DEFAULT_PATH, table_name=VIDEO_TABLE_NAME): """Retrieve video from start seconds up to end seconds. Also adjust the shrink the video frame rate according to vid_quality. """ pool = happybase.ConnectionPool(size=3) with pool.connection() as connection: table = connection.table(table_name) # first get the frame rate metadata = table.row(video_name, columns=[b'mtd:fr', b'mtd:rows', b'mtd:cols', b'mtd:channels']) #import pdb; pdb.set_trace() framerate = metadata.get(b'mtd:fr', DEFAULT_FRAMERATE).decode() row_count = int(metadata[b'mtd:rows'].decode()) col_count = int(metadata[b'mtd:cols'].decode()) channels = int(metadata[b'mtd:channels'].decode()) if len(framerate.split('/')) > 1: num, denum = framerate.split('/') framerate = int(num)/int(denum) framerate = round(framerate) #frame rate = how many frames make one sec start_frame = start_secs * framerate end_frame = end_secs * framerate framerate = round(framerate/vid_quality) # adjust the frame rate according to the video quality cols = [] for i in range(start_frame, end_frame, vid_quality): cols.append(('cts:%s' % i).encode()) video_data = table.row(video_name, columns=cols) #temp_dir = tempfile.mkdtemp() filepath = os.path.join(save_dir, os.path.basename(video_name)) vwriter = videoio.FFmpegWriter(filepath, inputdict={'-r': str(framerate), }, outputdict={ '-vcodec': 'libx264', '-pix_fmt': 'yuv420p', '-r': str(framerate), }) for col in cols: b64_string = video_data.get(col, '') if b64_string: try: frame = np.frombuffer(base64.b64decode(b64_string), np.uint8) frame = np.reshape(frame, (row_count, col_count, channels)) vwriter.writeFrame(frame) except Exception as ex: print('error reading frame: %s, error: %s' % (col, str(ex))) vwriter.close() return filepath
def save_video(movpath, fname_mov_orig, fname_mov_rig, fname_AC, fname_ACbf, dsratio): """ Parameters ---------- movpath : fname_mov_orig : fname_mov_rig : fname_AC : fname_ACbf : dsratio : Returns ------- """ mov_orig = np.load(fname_mov_orig, mmap_mode='r') mov_rig = np.load(fname_mov_rig, mmap_mode='r') mov_ac = np.load(fname_AC, mmap_mode='r') mov_acbf = np.load(fname_ACbf, mmap_mode='r') vw = skv.FFmpegWriter(movpath, inputdict={'-framerate': '30'}, outputdict={'-r': '30'}) for fidx in range(0, mov_orig.shape[0], dsratio): print("writing frame: " + str(fidx)) fm_orig = mov_orig[fidx, :, :] * 255 fm_rig = mov_rig[fidx, :, :] * 255 fm_acbf = mov_acbf[fidx, :, :] * 255 fm_ac = mov_ac[fidx, :, :] * 255 fm = np.concatenate([ np.concatenate([fm_orig, fm_rig], axis=1), np.concatenate([fm_acbf, fm_ac], axis=1) ], axis=0) vw.writeFrame(fm) vw.close()
def generate_video(path, lenght): writer = io.FFmpegWriter( "D:\Grabacion.avi", outputdict={ '-vcodec': 'libx264', #use the h.264 codec '-crf': '0', #set the constant rate factor to 0, which is lossless '-preset': 'veryslow' #the slower the better compression, in princple, try #other options see https://trac.ffmpeg.org/wiki/Encode/H.264 }) for i in range(lenght): img = cv2.imread(path + '\\' + f'img{i}.jpg') frame = np.asarray(img) frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) writer.writeFrame(frame[:, :, ::-1]) writer.close()
def create_video(path): writer = io.FFmpegWriter("output_video.avi", outputdict={ '-vcodec': 'libx264', '-crf': '0', '-preset': 'veryslow' }) cap = cv2.VideoCapture(path) func = np.vectorize(lambda x: round(x, 1)) while True: ret, frame = cap.read() if not ret: break img = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) img = cv2.resize(img, (480, 270)) arr = np.asarray(img) / 255.0 arr = func(arr) elements = set(tuple(list(arr.flatten()))) range_colors = np.linspace(0, 255, len(elements)) data = dict(zip(elements, range_colors)) for i in range(270): for j in range(480): value = arr[i][j] img[i][j] = data[value] #img = cv2.cvtColor(img,cv2.COLOR_GRAY2BGR) cv2.imshow('frame', img) writer.writeFrame(img) if cv2.waitKey(1) == ord('q'): break cap.release() writer.close() cv2.destroyAllWindows()
def draw_predictions_video(results, video, markersize=4, cmap_name=DEFAULT_COLORMAP, p_cutoff=PCUTOFF): """Draw pre-calculated joint locations into video frames. """ video_path = Path(video) clip = VideoFileClip(str(video_path)).to_RGB() ny, nx, fps = clip.h, clip.w, clip.fps df = pd.read_hdf(results) scorer = 'reichler' joints = list(np.unique(df.columns.get_level_values(1))) cmap = plt.cm.get_cmap(cmap_name, len(joints)) clip_out = io.FFmpegWriter(str(video_path.with_suffix('.labeled.mp4')), inputdict={'-r': str(clip.fps)}, outputdict={'-r': str(clip.fps)}) num_frames = math.ceil(clip.duration * clip.fps) for index, frame in enumerate( tqdm(clip.iter_frames(dtype='uint8'), total=num_frames)): for bpindex, bp in enumerate(joints): if df[scorer][bp]['likelihood'].values[index] > p_cutoff: xc = int(df[scorer][bp]['x'].values[index]) yc = int(df[scorer][bp]['y'].values[index]) # rr, cc = circle_perimeter(yc, xc, radius) # tqdm.write(str((xc, yc, bp))) rr, cc = draw.circle(yc, xc, markersize, shape=(ny, nx)) frame[rr, cc, :] = [c * 255 for c in cmap(bpindex)[:3]] clip_out.writeFrame(frame) clip_out.close() clip.close()
def main(out_path, fps, demo_paths): all_demos = load_demos(demo_paths) frame_segments = map(get_frames, all_demos) out_dir = os.path.dirname(out_path) if out_dir: print(f"Will make dir '{out_dir}' if it does not exist yet") os.makedirs(out_dir, exist_ok=True) print(f"Writing video to '{out_path}'") writer = vidio.FFmpegWriter(out_path, outputdict={ '-r': str(fps), '-vcodec': 'libx264', '-pix_fmt': 'yuv420p', }) nframes = 0 for frame_segment in frame_segments: print(f"Writing frame segment ({nframes} frames written so far)") for frame in frame_segment: writer.writeFrame(frame) nframes += 1 print(f"Done! ({nframes} frames written in total)")
def triggerRecord(self): if self.record.get() == 0: with self.record_lock: written_video_frames = 0 pupil_video_writer = skv.FFmpegWriter( 'data_acquisition/pupil_video.avi', outputdict={ '-vcodec': 'libx264', '-b': '30000000', '-vf': 'setpts=4*PTS' }) for frame in self.pupil_video_frames: pupil_video_writer.writeFrame(frame) written_video_frames += 1 print "wrote a frame!" print "finished writing!" pupil_video_writer.close() self.pupil_video_frames = [] frame_number = 0 pupil_data_file = open('data_acquisition/pupil_data.txt', 'w+') for frame_number in range(1, len(self.pupil_data_list) + 1): pupil_center, pupil_radius = self.pupil_data_list[ frame_number - 1] if pupil_center is None or pupil_radius is None: pupil_data_file.write( "Frame: %d No pupil detected!\n" % frame_number) else: pupil_data_file.write( "Frame: %d Pupil Center: %s Pupil Radius: %d\n" % (frame_number, pupil_center, pupil_radius)) print "video frames vs data frames", written_video_frames, frame_number pupil_data_file.close() self.pupil_data_list = []
def main(): flags = parse_args() images = sorted(os.listdir(os.path.join(flags.data, 'depth'))) frames = [] for i, image in enumerate(images): print(f"Reading image {image}", end='\r') path = os.path.join(flags.data, 'depth', image) depth = np.load(path) max_depth = 7.5 depth_m = depth / 1000.0 depth_map = np.clip(1.0 - depth_m / max_depth, 0.0, 1.0) depth_map = cm.inferno(depth_map) frames.append((depth_map * 255).astype(np.uint8)) writer = io.FFmpegWriter(os.path.join(flags.data, 'depth_video.mp4')) try: for i, frame in enumerate(frames): print(f"Writing frame {i:06}" + " " * 10, end='\r') writer.writeFrame(frame) finally: writer.close()
def make_video_ffmpeg(mat, save_path, fps=60, outputdict={'-vcodec': 'rawvideo'}, normalize=True, vmin=None, vmax=None, clip=False, clip_low=50, clip_high=99, gray=False): """Make a video from mat Args: mat: (num_frames, num_rows, num_cols) """ from skvideo import io as skio if isinstance(mat, torch.Tensor): mat = mat.detach().cpu().numpy() if gray and mat.ndim > 3: mat = mat.reshape(-1, *mat.shape[-2:]) if normalize: from matplotlib.colors import Normalize if clip: vmin = get_percentile(mat, clip_low) vmax = get_percentile(mat, clip_high) if vmin is None: vmin = mat.min() if vmax is None: vmax = mat.max() norm = Normalize(vmin=vmin, vmax=vmax, clip=clip) mat = 255 * norm(mat) mat = mat.astype(np.uint8) writer = skio.FFmpegWriter(save_path, {'-r': f'{fps}'}, outputdict=outputdict) for i in range(len(mat)): writer.writeFrame(mat[i]) writer.close()
def parseVideo(self, vname, vtype, dst_path): """parse Video and write as a mp4 file # arguments vname: input video name dst_path: destination directory path, not file name """ # Data format of cliped_Frames is # [num_frames, num_clips, 256, 256, 3] if vtype == "MVQP": height = 1080 width = 2048 elif vtype == "MCLV": height = 1080 width = 1920 elif vtype == "XIPH2": height = 1080 width = 1920 elif vtype == "MCML": height = 2160 width = 3840 cliped_Frames = [] num_clips = 0 print("***********: ", vname) ##################################### Store the cliped video as numpy array in self.cliped_Frames with open(vname, 'rb') as stream: m = mmap.mmap(stream.fileno(), 0, access=mmap.ACCESS_READ) for idx in range(self.num_frames): try: # if number of video frame is less than self.num_frames, it stops reading video YUV = np.zeros([height, width, 3], dtype=np.uint8) YUV[:, :, 0] = np.frombuffer(m, dtype=np.uint8, count=width * height, offset = int(idx * width * height * 1.5)).reshape(height, width) YUV[:, :, 1] = np.frombuffer(m, dtype=np.uint8, count=(width // 2) * (height // 2), offset = int(idx * width * height * 1.5 + width * height )).reshape(height // 2, width // 2).repeat(2, axis=0).repeat(2, axis=1) YUV[:, :, 2] = np.frombuffer(m, dtype=np.uint8, count=(width // 2) * (height // 2), offset = int(idx * width * height * 1.5 + width * height * 1.25 )).reshape(height // 2, width // 2).repeat(2, axis=0).repeat(2, axis=1) RGB = cv2.cvtColor(YUV, cv2.COLOR_YUV2RGB) except Exception as e: print(e) break # Divide large size frame into 256x256 size video num_clips, clips = self.clip_frame(RGB, height, width, flag=False) cliped_Frames.append(clips) ###################################### Write the numpy array as mp4 file cliped_Frames = np.array(cliped_Frames) # bitrates = ["500k", "600k", "700k", "800k"] bitrates = ["27M"] for clip_idx in range(num_clips): clip = cliped_Frames[:, clip_idx] for bitrate in bitrates: write_option['-b:v'] = bitrate dir_path = join(dst_path, bitrate) try: makedirs(dir_path) except: pass output_fname = join(dir_path, "{}_{}.mp4".format(basename_without_extension(vname), str(clip_idx))) writer = vio.FFmpegWriter(filename=output_fname, inputdict={'-r': fps, '-pix_fmt': 'rgb24'}, outputdict=write_option) for frame in clip: writer.writeFrame(frame) writer.close()
def main(): # parse the arguments parser = argparse.ArgumentParser(description='Retouch video.') parser.add_argument('--src_path', type=str, default='./trainS_input', help='source path') parser.add_argument('--dst_path', type=str, default='./trainS_output', help='destination path') parser.add_argument('--intensity', type=str, default='strong', help='strong or weak') args = parser.parse_args() # source directory validation check src_path = args.src_path dst_path = args.dst_path intensity = args.intensity # method validation check bitrates = ["500k", "600k", "700k", "800k"] methods = ["blur", "median", "noise"] # methods = ["original"] # set destination directory name for method in methods: for bitrate in bitrates: try: makedirs(join(dst_path, "retouch_"+intensity, method, bitrate)) pass except FileExistsError: pass counter = 1 fnames = glob.glob(join(src_path, "*k", "*.mp4")) print("%8s| file name" % "counter") # retouch video for fname in fnames: # video read meta = vio.ffprobe(fname) vid = np.array(vio.vread(fname)) vid_retouched = np.zeros(vid.shape) fn, w, h, c = vid.shape if w != 256 or h != 256 or c != 3: print("================ wrong size file: \"{}\"".format(fname)) continue # parse bitrate from file name bitrate = fname.split("\\")[-2] for method in methods: # get manipulated frame for i in range(fn): vid_retouched[i,:,:,:] = manipulate(vid[i,:,:,:], method, intensity=intensity) # manipulate.py 참고 vid_retouched = vid_retouched.astype(np.uint8) # set output file name output_file = join(dst_path, "retouch_"+intensity, method, bitrate, basename(fname)) print("%8d: %s" % (counter , output_file)) counter += 1 # load writer with parameter # "-vcodec = libx264" : h.264 codec # "-r = 30" : fps # "-g = 4" : GOP size # "-bf = 0" : number of b frame # "-b:v = bitrate" : bitrate # "-pix_fmt = yuv420p" : color space write_option = {'-vcodec': 'libx264', '-r': '30', '-g': '4', '-bf': '0', '-b:v': bitrate, '-pix_fmt': 'yuv420p'} writer = vio.FFmpegWriter(filename=output_file, inputdict={'-r': '30'}, outputdict=write_option) for i in range(fn): writer.writeFrame(vid_retouched[i, :, :, :]) # writer.writeFrame(vid_retouched) writer.close() print("Process end on directory \"%s\"" % src_path)
params_mean.interpolate('cubic') fig, ax = plt.subplots(7,1) for i, x in enumerate(['x','y','a','b','t', 'v', 'e']): ax[i].scatter(params_mean[x], s=0.5, alpha=0.2, c='k') ########################## #fig, ax = plt.subplots(4,1) thetas = np.linspace(0, np.pi*2, num=200, endpoint=False) emod = measure.EllipseModel() fn = '/home/lab/pupil_vids/nick3_track2.mp4' #fourcc = cv2.VideoWriter_fourcc(*"X264") writer = io.FFmpegWriter(fn) ell_params = fitutils.clean_lists(x_list, y_list, a_list, b_list, t_list, v_list, n_list) ell_params = basic_filter(ell_params, ix, iy, rad, e_thresh=0.6) ell_out = fitutils.filter_outliers(df_fill, neighbors=1000) ell_smooth = fitutils.smooth_estimates(ell_out, hl=5) vid = cv2.VideoCapture(vid_fn) #vid.set(cv2.CAP_PROP_POS_MSEC, 350000) frame_counter = count() cv2.namedWindow('run', flags=cv2.WINDOW_NORMAL) for i in xrange(len(ell_smooth)): k = cv2.waitKey(1) & 0xFF if k == ord('\r'): break
generator = blur_rdn.BlurRDN(2, 3, 64, 64, 16, 8).to(DEVICE) elif net_type == "esrgen16": generator = newer_esrgan_generator.esrgan16(2, pretrained=False).to(DEVICE) elif net_type == "esrgen23": generator = newer_esrgan_generator.esrgan23(2, pretrained=False).to(DEVICE) d = torch.load(checkpoint_path) generator.load_state_dict(d["generator"]) generator.eval() vcsan = cv2.VideoCapture(movie_path) suc, img = vcsan.read() out = vio.FFmpegWriter(save_name + ".mp4", outputdict={ '-vcodec': 'libx264', '-crf': str(compression_level), '-preset': 'veryslow' }) out_bic = vio.FFmpegWriter(save_name + "bic.mp4", outputdict={ '-vcodec': 'libx264', '-crf': str(compression_level), '-preset': 'veryslow' }) ind = 0 progbar = pyprind.ProgBar(end_frame - start_frame + 1, title="Inference") bic = transforms.Resize((img.shape[0] * scale, img.shape[1] * scale), interpolation=PIL.Image.BICUBIC) while suc: if start_frame <= ind <= end_frame: with torch.no_grad(): img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) / 255
def main(): # parse the arguments parser = argparse.ArgumentParser(description='Retouch video.') parser.add_argument('--src_path', type=str, default='../27M', help='source path') parser.add_argument('--gt_path', type=str, default='../gt', help='ground truth path') parser.add_argument('--dst_path', type=str, default='../retouch_spatial', help='destination path') parser.add_argument('--intensity', type=str, default='extreme', help='strong or weak') args = parser.parse_args() # source directory validation check src_path = args.src_path gt_path = args.gt_path dst_path = args.dst_path intensity = args.intensity # method validation check bitrate = "27M" methods = ["blur", "median", "noise"] # methods = ["original"] # set destination directory name for method in methods: try: makedirs(join(dst_path, intensity, method)) pass except FileExistsError: pass counter = 1 fnames = glob.glob(join(src_path, "*.mp4")) gt_names = glob.glob(join(gt_path, "*.png")) print("%8s| file name" % "counter") # retouch video for fname in fnames: gt = None for gt_name in gt_names: if basename(fname).split('.')[0] in gt_name: gt = im2double(cv2.imread(gt_name, cv2.IMREAD_COLOR)) # video read meta = vio.ffprobe(fname) vid = np.array(vio.vread(fname)) vid_retouched = np.zeros(vid.shape) fn, w, h, c = vid.shape # parse bitrate from file name for method in methods: # get manipulated frame for i in range(fn): retouched = manipulate(vid[i, :, :, :], method, intensity=intensity) # manipulate.py 참고 original = vid[i, :, :, :] retouched_spatial = gt * retouched + (1 - gt) * original vid_retouched[i, :, :, :] = retouched_spatial vid_retouched = vid_retouched.astype(np.uint8) # load writer with parameter # "-vcodec = libx264" : h.264 codec # "-r = 30" : fps # "-g = 4" : GOP size # "-bf = 0" : number of b frame # "-b:v = bitrate" : bitrate # "-pix_fmt = yuv420p" : color space output_file = join(dst_path, intensity, method, basename(fname)) write_option = { '-vcodec': 'libx264', '-r': '30', '-g': '4', '-bf': '0', '-b:v': bitrate, '-pix_fmt': 'yuv420p' } writer = vio.FFmpegWriter(filename=output_file, inputdict={'-r': '30'}, outputdict=write_option) for i in range(fn): writer.writeFrame(vid_retouched[i, :, :, :]) # writer.writeFrame(vid_retouched) writer.close() # set output file name print("%8d: %s" % (counter, output_file)) counter += 1 print("Process end on directory \"%s\"" % src_path)
dataset.data_std, dataset.dim_to_ignore, ) restored = convert_to_3d(restored, dataset.kinematic_tree, False) vid_3D = create_video_3d( restored, [0, 0, 1], dataset, "test_3d", use_limits=True, use_posInd=True, ) writer = vio.FFmpegWriter( path.join(save_path, f"kps_3d_world_unproc#{nr}.mp4")) for frame in vid_3D: writer.writeFrame(frame) writer.close() vid = np.stack(vid, axis=0) writer = vio.FFmpegWriter( path.join(save_path, f"test_video_kps_img_expmap#{nr}.mp4")) for frame in vid: writer.writeFrame(frame) writer.close()
def inference(name: str, net: torch.nn.Module, device: torch.device, length: float = 0, start: float = 0, batch: int = 1, cut: bool = False, normalize: bool = False, crf: int = 17, tune: str = None) -> None: net.eval() norm = ds.get_normalization() trn = trf.get_predict_transform(*ds.predict_res) cap = cv2.VideoCapture(ds.SAVE_DIR + 'data/video/' + name + '.mp4') fps = cap.get(cv2.CAP_PROP_FPS) cap.set(cv2.CAP_PROP_POS_FRAMES, int(round(start * fps))) w, h = ds.predict_res w *= ds.scale h *= ds.scale if normalize: path = ds.SAVE_DIR + 'data/output/' + name + '_sr_n.mp4' else: path = ds.SAVE_DIR + 'data/output/' + name + '_sr.mp4' outputdict = { '-vcodec': 'libx264', '-crf': '%d' % crf, '-preset': 'veryslow', '-r': '%g' % fps } if tune is not None: outputdict['-tune'] = tune out = vio.FFmpegWriter(path, inputdict={ '-r': '%g' % fps, }, outputdict=outputdict) i = 0 if length != 0: total = int(round(length * fps)) else: total = cap.get(cv2.CAP_PROP_FRAME_COUNT) iter_bar = pyprind.ProgBar(total, title='Inference ' + name, stream=sys.stdout) frame_list = [] end = False with torch.no_grad(): while True: ret, frame = cap.read() if not ret or (length != 0 and i >= length * fps): if not end: end = True else: break else: frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) frame = norm(trn(image=frame)["image"]).to(device) frame_list.append(frame) if len(frame_list) == batch or (end and len(frame_list) > 0): frames = torch.stack(frame_list) if cut: pieces = utils.cut_image(frames) out_pieces = [] for piece in pieces: out_pieces.append(net(piece)) output = utils.glue_image(out_pieces) else: output = net(frames) for j in range(len(frame_list)): if normalize: out_frame = correct_colors(output[j, :, :, :], frames[j, :, :, :]) else: out_frame = output[j, :, :, :] out.writeFrame( cv2.cvtColor(convert_to_cv_8bit(out_frame), cv2.COLOR_RGB2BGR)) frame_list.clear() i += 1 iter_bar.update() cap.release() out.close()