def save_video(self): """ Generate video out of self.state_history and save it. This variable needs to be updated during the simulation. """ import matplotlib.pyplot as plt from moviepy.editor import VideoClip from moviepy.video.io.bindings import mplfig_to_npimage history_of_states = self.state_history #duration_in_seconds = len(history_of_states) / 4 duration_in_seconds = len(history_of_states) fig, ax = plt.subplots() frames_per_second = len(history_of_states) / duration_in_seconds def make_frame(t): ax.clear() ax.grid(False) ax.imshow(history_of_states[int(t * frames_per_second)], cmap="gist_ncar") ax.tick_params(axis='both', which='both', bottom=False, top=False, left=False, right=False, labelleft=False, labelbottom=False) return mplfig_to_npimage(fig) animation = VideoClip(make_frame, duration=duration_in_seconds) animation.write_videofile(self.env.video_filename, fps=frames_per_second)
def video(): if 1: snd = AudioFileClip("space.mp3") clip = VideoClip(c.animation, duration=snd.duration / 30.) clip = clip.set_audio(snd).set_duration(snd.duration / 30.) clip.write_videofile('cam.mp4', fps=24)
def create_NN_comparison(clip, h5, nnh5, inds2plot=np.arange(100), pad=400, outfname=None): """ Give movipy.videofile, dlc tracked h5 and RNN h5, plot indices in inds2plot and save as outfname. """ tlag = h5.shape[0] - nnh5.shape[0] h5 = h5[tlag:] center = medfilt2d(h5[:, 8, :2], [7, 1]) h5 = egoh5(h5) connections = [[0, 2, 5, 10, 12], [0, 1, 4, 7, 9, 12], [0, 3, 6, 8, 11, 12], [1, 2, 3], [4, 5, 6], [7, 8], [9, 10, 11]] fig, ax = plt.subplots(figsize=(10, 10)) def make_frame(i): t = inds2plot[int(i * clip.fps)] ax.clear() ax.imshow(clip.get_frame((t + tlag) / clip.fps)) for l in connections: ax.plot(h5[t, l, 0] + center[t, 0], h5[t, l, 1] + center[t, 1], color='royalblue', alpha=0.5, lw=3)[0] ax.plot(nnh5[t, l, 0] + center[t, 0], nnh5[t, l, 1] + center[t, 1], color='orangered', alpha=0.5, lw=3)[0] ax.set_xlim([center[t, 0] - pad, center[t, 0] + pad]) ax.set_ylim([center[t, 1] - pad, center[t, 1] + pad]) ax.axis('off') return mplfig_to_npimage(fig) animation = VideoClip(make_frame, duration=inds2plot.shape[0] / clip.fps) # animation.write_gif('matplotlib.gif', fps=clip.fps) if outfname is None: outfname = 'videos/vid_' + ''.join( [np.random.choice(list(string.ascii_letters)) for _ in range(20)]) + '.mp4' animation.write_videofile(outfname, fps=clip.fps, audio=False, threads=12) print('Video saved as ', outfname) else: if outfname[-4:] != '.mp4': outfname += '.mp4' outfname = 'videos/' + outfname animation.write_videofile(outfname, fps=clip.fps, audio=False, threads=12) print('Video saved as ', outfname)
def save_animation(self, name): self._index = 0 duration = self.num_data // self.fps anim = VideoClip(make_frame=self.make_frame, duration=duration) # anim.write_gif(os.path.join(self.DIR, name), fps=self.fps) anim.write_videofile(os.path.join(self.DIR, name), fps=self.fps, audio=False) print(duration)
def main(): parser = argparse.ArgumentParser( prog='AniMaker', description='动画短片制作器by lzy2002 site:lzy2002.com') parser.add_argument('-i', '--inputs', help='输入文件所在目录', required=True) parser.add_argument('-o', '--output', help='输出文件', default='movie.mp4') parser.add_argument('-f', '--fps', help='帧频fps', default=24) parser.add_argument('-rf', '--recordfps', help='录制帧频fps', default=60) parser.add_argument('-t', '--time', help='时长s', default=5) args = parser.parse_args() animation = VideoClip(make_frame(args.inputs, float(args.recordfps), int(args.fps), float(args.time)), duration=float(args.time)) animation.write_videofile(args.output, fps=int(args.fps))
def saveMovie(self, zoomfactor=1.0, savename='None', appendix='', update=False, fps=25): """ save tif file as mp4 using moviepy library. The duration of movie file is determined as 3 times of realtime video. Input: zoomfactor = 0.5 (default), save image using resampling savename = default format [tif file name]_z[zoomefactor].mp4 Return: VidoeClip object in moviepy library """ if ('moviepy' not in dir()): from moviepy.editor import VideoClip if ('cv2' not in dir()): import cv2 if (savename == 'None'): savename = '{}_z{:.1f}_{}.mp4'.format(self._meta['fname'][:-4], zoomfactor, appendix) if not update: if os.path.exists(savename): if self._debug: print('... movie file already exists: %s' % savename) return False if self._single: if self._debug: print('... not movie file') return False cmap = plt.get_cmap(self._meta['cmapname']) def make_frame(t): #self._curframe = int(t * (self._frameN - 1) / (self._duration * 3.0)) self._curframe = int(t * fps) img0 = self.getframe(frame=self._curframe, dtypes='uint8') if zoomfactor != 1.0: img0 = cv2.resize(img0, None, fx=zoomfactor, fy=zoomfactor, interpolation=cv2.INTER_CUBIC) img = np.delete(cmap(img0), 3, 2) #return img return (img * 255.0).astype('uint8') #animation = VideoClip(make_frame, duration=self._duration * 3.0) animation = VideoClip(make_frame, duration=float(self._meta.N()/fps)) animation.write_videofile(savename, fps=fps, codec='libx264', \ threads=8, audio=False, preset='medium', verbose=False) self._animation = animation print("""To play movie file in jupyter notebook: from IPython.display import Video Video("{}")""".format(savename))
def trajectory_video(trajectory, filename, xlim=(-10, 10), ylim=(-10, 10), callback=None, axisOff=True): """Create video of the track and saves it in working directory Parameters --------- filename : string name of the file to be saved into xlim : touple(2) of float xlimits of the fideo ylim : touple(2) of float ylimits of the video callback: what to axisOff : bool Returns -------- saved mp4 video at fiven filepath """ WIDTH = 900 HEIGHT = 600 DPI = 150 FPS = 25 DURATION = np.max(trajectory.time) - np.min(trajectory.time) fig, axis = plt.subplots(figsize=(1.0 * WIDTH / DPI, 1.0 * HEIGHT / DPI), dpi=DPI) def make_frame(t): axis.clear() (tx, ty) = trajectory.position_for_time(t + np.min(trajectory.time)) axis.plot(tx, ty, "ko") axis.set_xlim(xlim) axis.set_ylim(ylim) axis.set_title("Time {:.2f} s".format(t)) if not callback is None: callback(axis) if axisOff: plt.axis('off') return mplfig_to_npimage(fig) animation = VideoClip(make_frame, duration=DURATION) #animation.write_gif(filename, fps=FPS) animation.write_videofile(filename, fps=FPS) pass
def animate_wave_function_collapse(fn, seconds_per_state=0.5): size = (32, 32) tn = wfc.seq_target_name(fn, 1, "overlapping", size) ts, result = dep.create(tn) full_duration = len(result) * seconds_per_state def makeframe(t): state_index = int(t / seconds_per_state) return result[min(state_index, len(result)-1)] anim = VideoClip(makeframe, duration=full_duration) nfn = os.path.splitext(fn)[0] + ".collapse.mp4" anim.write_videofile(nfn, fps=FRAMERATE) nfn = os.path.splitext(fn)[0] + ".collapsed.png" imsave(nfn, result[-1])
def make_skeleton_animation(frames, index, fps, movies_dir): DEFAULT_FPS = 30.0 def make_frame(t): verticies = frames[int(t * DEFAULT_FPS)] edges = zip(range(len(CONNECT)), CONNECT) arr = render_offscreen(verticies, edges, WIDTH, HEIGHT) return arr duration = frames.shape[0] / DEFAULT_FPS animation = VideoClip(make_frame, duration=duration) file_path = os.path.join(movies_dir, "sequence_{}.mp4".format(index)) animation.write_videofile(file_path, fps=fps)
def save_movie(make_frame, duration, filename, fps=20): """Writes an animation to disk""" anim = VideoClip(make_frame, duration=duration) if filename.endswith('.gif'): anim.write_gif(filename, fps=fps) elif filename.endswith('.mp4'): anim.write_videofile(filename, fps=fps) else: raise ValueError( f'Invalid file type for {filename}. Must be .gif or .mp4') return anim
def ani_gen(self, path, title="", cmap='binary', duration=3e2): bset.clear() fig, ax = plt.subplots(1, figsize=(4, 4), facecolor=(1, 1, 1)) def make_frame(t): ax.clear() ax.axis('off') ax.set_title(title, fontsize=16) self.step() self.plot(ax, cmap) return (mplfig_to_npimage(fig)) ani = VideoClip(make_frame, duration=duration) ani.write_videofile(path, fps=50) return
class Animation(object): def __init__(self, fps=24): self.fps = fps self.reset() def reset(self): self.frames = [] self._iter = -1 def add_frame(self, image): """ image should be a (height, width, 3) np.ndarry """ self.frames.append(np.copy(image)) def anim_fn(self, fn, data): """ fn: a function that returns a plot data: an iterable """ for i in range(len(data)): p = fn(data[:i]) self.add_frame(p.numpy()) def rotate_3d(self, plot, duration=8): nframes = duration * self.fps change_angle = 360.0 / nframes azim = plot.canvas.azim for i in range(nframes): plot.set_camera(azim=azim + i * change_angle) self.frames.append(plot.numpy()) def _make(self, t): self._iter += 1 # Weird bug where idx might be = len(self.frames) idx = min(self._iter, len(self.frames) - 1) return self.frames[idx] def save(self, path): from moviepy.editor import VideoClip fname, ext = os.path.splitext(path) duration = (len(self.frames) - 1) / float(self.fps) self.animation = VideoClip(self._make, duration=duration) if 'gif' in ext: self.animation.write_gif(path, fps=self.fps) else: self.animation.write_videofile(path, fps=self.fps) self._iter = -1
def create_animation(name, files, output_path, worker_mem): ''' Creates an animation single tiff file from a list of tiff files. ''' sys.stdout = open(os.devnull, "w") sys.stderr = open(os.devnull, "w") # Add the last file twice to avoid it getting dropped from the animation. files.extend(files[-1:]) frame_generator = FrameGenerator(name, files, output_path, worker_mem) duration = len(files) animation = VideoClip(frame_generator.make_frame, duration=duration) animation.write_videofile(os.path.join(output_path, "{}.avi".format(name)), fps=1, codec="png") return name
def run_animation(args, target, outfile): """Creates an animated crash based on a still image input""" stepsize = args.animate img = util.read_img(target) bounds = foreground.get_fg_bounds(img.shape[1], args.max_depth) max_depth = bounds.max_depth crash_params = crash.CrashParams( max_depth, args.threshold, args.bg_value, args.rgb_select) depths = range(max_depth, -stepsize, -stepsize) depths = [d for d in depths if d > 0] depths.append(0) n_frames = len(depths) n_procs = max(args.in_parallel, 1) fps = args.fps duration = len(depths) / fps img = util.read_img(target) options = _options(args.reveal_foreground, args.reveal_background, args.crash, args.reveal_quadrants) source_img = util.read_img(target) fg, bounds = foreground.find_foreground(source_img, crash_params) def make_frame(time): frame_no = int(round(time * fps)) if frame_no >= n_frames: frame_no = n_frames - 1 depth = depths[-frame_no] img = source_img.copy() if depth: params = crash.CrashParams( depth, args.threshold, args.bg_value, args.rgb_select) new_fg, new_bounds = foreground.trim_foreground(img, fg, params) new_img = _process_img(img, new_fg, new_bounds, options) else: new_img = source_img return new_img animation = VideoClip(make_frame, duration=duration) clip = animation.to_ImageClip(t=duration) clip.duration = 0.1 clip.write_videofile(outfile, fps=fps, audio=False) animation.write_videofile("__temp_crash.mp4", fps=fps, audio=False, preset=args.compression, threads=args.in_parallel) os.rename("__temp_crash.mp4", outfile)
def write_video_clip_to_file(self, video_clip: VideoClip, output_path: Opt[str] = None, *, audio: Union[str, bool] = True, verbose: bool = False, progress_bar: bool = True, **kwargs): """ Writes a video clip to file in the specified directory Parameters ---------- video_clip output_path audio Audio for the video clip. Can be True to enable, False to disable, or an external audio file. verbose Whether output to stdout should include extra information during writing progress_bar Whether to output progress information to stdout kwargs List of other keyword arguments to pass to moviepy's write_videofile """ # Prepend crf to ffmpeg_params ffmpeg_params = ['-crf', str(self.crf)] + self.ffmpeg_params audio_bitrate = str(self.audio_bitrate) + 'k' video_clip.write_videofile(output_path, audio=audio, preset=self.preset, codec=self.codec, audio_codec=self.audio_codec, audio_bitrate=audio_bitrate, ffmpeg_params=ffmpeg_params, **kwargs, verbose=verbose, progress_bar=progress_bar) return output_path
def save_video(self, video: VideoClip, video_filename: str, output_appendix: str = "_output") -> None: """Save the resulting video. :param video: the processed VideoClip :param video_filename: original file name :param output_appendix: appendix to add to file :return: None """ output_filename = append_to_file_name(video_filename, output_appendix) video.set_audio(self.audio) video.write_videofile( output_filename, codec="libx264", audio_codec="aac", temp_audiofile=output_filename + ".tmp", remove_temp=True, fps=self.video.fps, )
def render(render_frame, frames, fps, size, filename): """ Create a movie using the given render_frame function """ # Wrapper so that the render function gets passed a surface to draw to, # and a frame number. def make_frame(t): surface = pygame.Surface(size) render_frame(surface, int(t*fps)) # Flip the surface around it's x/y axis (main diagonal), to account for display # issues with the movie rendering. surface = pygame.transform.rotate(surface, -90) surface = pygame.transform.flip(surface, True, False) return pygame.surfarray.pixels3d(surface) # Create the animation... animation = VideoClip(make_frame, duration=frames/fps) # Write to the movie file... animation.write_videofile(filename, fps=fps)
def show_animation( self, a_function_which_returns_an_image_according_to_a_time_variable, duration=3, fps=24, saving_path=None): """ the function looks like `func(t)`. t is a float variable in seconds, for example, 1.2 = 1 second + 0.2 second """ def wrap_function(t): array = a_function_which_returns_an_image_according_to_a_time_variable( t) assert isinstance( array, np.ndarray), "this function should return an numpy array" if array.shape[2] == 4: array = array[:, :, 0:3] return array animation = VideoClip(wrap_function, duration=duration) if self._notebook: result = animation.ipython_display(fps=fps, loop=True, autoplay=True) self._IPython.display.display(result) else: animation.preview(fps=fps) if saving_path != None: if len(saving_path.split(".")) > 0: extension = saving_path.split(".")[-1] if extension.lower() == "gif": animation.write_gif(saving_path, fps=fps) elif extension.lower() == "mp4": animation.write_videofile(saving_path, fps=fps) else: print("you can only save gif or mp4!") exit()
def run_moving_crash(args, target, outfile): """Runs a moving crash based on moving (gif/mp4) inputs""" video = VideoFileClip(target) img = video.get_frame(t=0) # first frame of the video bounds = foreground.get_fg_bounds(img.shape[1], args.max_depth) max_depth = bounds.max_depth crash_params = crash.CrashParams( max_depth, args.threshold, args.bg_value, args.rgb_select) options = _options(args.reveal_foreground, args.reveal_background, args.crash, args.reveal_quadrants, args.bg_value) frames = video.iter_frames(fps=video.fps) def make_frame(_): frame = next(frames) fg, bounds = foreground.find_foreground(frame, crash_params) return _process_img(frame, fg, bounds, options) output_video = VideoClip( make_frame, duration=video.duration-(4/video.fps)) # trim last 4 frms output_video.write_videofile( outfile, preset=args.compression, fps=video.fps, threads=args.in_parallel)
def save_fitness_histogram_movie(): from moviepy.editor import VideoClip from moviepy.video.io.bindings import mplfig_to_npimage from algorithm.parameters import params def make_frame(t): """ returns an image of the frame at time t """ # ... create the frame with any library fitness = fitness_list[int(t)] __sum_fit = sum(fitness) __mean_fit = float(__sum_fit) / float(len(fitness)) from scipy.stats import tstd, iqr, variation, entropy __sd_fit = tstd(fitness) __iqr = iqr(fitness) __v = variation(fitness) __e = entropy(fitness) fig = plt.figure() plt.hist(fitness) # ,bins=int(params['POPULATION_SIZE']*0.1)) plt.title("Moving Point - Population Fitness Histogram - Generation " + str(int(t))) plt.axis([0, 20000, 0, params['POPULATION_SIZE']]) plt.ylabel('#Individuals') plt.xlabel('Fitness') plt.grid(True) __hist_text = "$\mu=" + "{0:.2f}".format( __mean_fit) + ",\ \sigma=" + "{0:.2f}".format( __sd_fit) + ",\ entropy=" + "{0:.2f}".format( __e) + ",\ iqr=" + "{0:.2f}".format(__iqr) + "$" plt.text(1000, params['POPULATION_SIZE'] * .9, __hist_text) return mplfig_to_npimage(fig) # (Height x Width x 3) Numpy array filename = params['FILE_PATH'] + str( params['TIME_STAMP']) + '/fitnessdistribution' fps = 1 duration = params['GENERATIONS'] + 1 animation = VideoClip(make_frame, duration=duration) #animation.resize(width=1280,height=720) animation.write_videofile(filename + ".mp4", fps=fps) # export as video
def save_video(self): if self.movie_filename is not None: history_of_states = self.state_history duration_in_seconds = len(history_of_states) / 4 fig, ax = plot.subplots() frames_per_second = len(history_of_states) / duration_in_seconds def make_frame(t): ax.clear() ax.grid(False) ax.imshow(history_of_states[int(t * frames_per_second)]) ax.tick_params(axis='both', which='both', bottom=False, top=False, left=False, right=False, labelleft=False, labelbottom=False) return mplfig_to_npimage(fig) animation = VideoClip(make_frame, duration=duration_in_seconds) animation.write_videofile(self.movie_filename, fps=frames_per_second)
def make_frame(t): index = int(FPS * t) canvas = np.zeros(CANVAS_SIZE + (3, ), dtype="uint8") canvas.fill(255) for i in range(len(video_dirs)): im = imread(video_files[i][index]) x, y = i // 2, i % 2 # hardcoded for 4 videos p = [ x * (IMSIZE[0] + PAD_SIZE + FONT_HEIGHT), y * (IMSIZE[1] + PAD_SIZE) ] p[0] += FONT_HEIGHT p[1] += IMSIZE[1] // 2 - 100 canvas = cv.putText(canvas, title[i], (p[1], p[0]), cv.FONT_HERSHEY_SIMPLEX, 1, [0, 0, 0], 2, cv.LINE_AA) p[1] -= IMSIZE[1] // 2 - 100 p[0] += PAD_SIZE #stx, sty = x * (IMSIZE[0] + PAD_SIZE), y * (IMSIZE[1] + PAD_SIZE) canvas[p[0]:p[0] + IMSIZE[0], p[1]:p[1] + IMSIZE[1]] = im return canvas animation = VideoClip(make_frame, duration=TOTAL_TIME) animation.write_videofile(args.output, fps=FPS)
class _Scatter(object): """relative frame length is the length of each single frame measured as a fraction of the whole experiment duration. """ def __init__(self, visualizer=None, dimension=3, relative_frame_length=0.01, rotate=False, speedup_factor=1.0, smoothness_factor=0.5, export_format='mp4'): self.visualizer = visualizer self.dimension = dimension self.relative_frame_length = relative_frame_length # should be within (0.0, 1.0] self.duration = self.visualizer.spikes[-1][0] # in ms self.angle = -90 self.rotate = rotate self.speedup = speedup_factor self.scatter_plot = None self.window_size = self.duration * relative_frame_length # some quantity in ms self.window_step = self.window_size * smoothness_factor # some quantity in ms self.window_start = 0 self.window_end = self.window_start + self.window_size self.frame_count = int( (self.duration - self.window_size) / self.window_step) + 1 self.fps = int( (self.frame_count / (self.duration / 1000)) * self.speedup) if self.fps == 0: self.fps = 1 # initialise figure and axes and setup other details self.cbar_not_added = True self._setup_plot() self.file_format = export_format # print("duration", int((self.duration/1000+1)/speedup_factor)) from moviepy.editor import VideoClip self.anim = VideoClip(self._update_frame, duration=int( (self.duration / 1000 + 1) / speedup_factor)) def _change_angle(self): self.angle = (self.angle + 0.5) % 360 def _setup_plot(self): self.fig = plt.figure() if self.dimension == 3: self.ax = self.fig.add_subplot(111, projection='3d') self.ax.set_xlim3d(0, self.visualizer.network_dimensions['dim_x']) self.ax.set_xlabel('x') self.ax.set_ylim3d(self.visualizer.network_dimensions['max_d'], self.visualizer.network_dimensions['min_d']) self.ax.set_ylabel('depth') self.ax.set_zlim3d(0, self.visualizer.network_dimensions['dim_y']) self.ax.set_zlabel('y') else: self.ax = self.fig.add_subplot(111) self.ax.set_xlim(0, self.visualizer.network_dimensions['dim_x']) self.ax.set_xlabel('x') self.ax.set_ylim(0, self.visualizer.network_dimensions['dim_y']) self.ax.set_ylabel('y') self.ax.set_title("Network's subjective sense of reality", fontsize=16) self.ax.set_autoscale_on(False) def _update_frame(self, time): from moviepy.video.io.bindings import mplfig_to_npimage if self.dimension == 3: if self.rotate: self._change_angle() self.ax.view_init(30, self.angle) # clear the plot from the old data if self.scatter_plot is not None: self.scatter_plot.remove() # reimplement in a more clever way so that movie generation is in total O(n) not O(nm) current_frame = [] for s in self.visualizer.spikes: if s[0] > self.window_end: self.window_start += self.window_step self.window_end = self.window_start + self.window_size break if s[0] > self.window_start: current_frame.append((s[1], s[2], s[3])) current_frame = np.asarray(current_frame) if current_frame.size > 0: # be careful of the coordinate-axes orientation. up/down should be x! if self.dimension == 3: self.scatter_plot = self.ax.scatter( current_frame[:, 0], current_frame[:, 2], current_frame[:, 1], s=25, marker='s', lw=0, c=current_frame[:, 2], cmap=plt.cm.get_cmap( "brg", self.visualizer.network_dimensions['max_d'] + 1), vmin=self.visualizer.network_dimensions['min_d'], vmax=self.visualizer.network_dimensions['max_d']) if self.cbar_not_added: cbar = self.fig.colorbar(self.scatter_plot) cbar.set_label('Perceived disparity in pixel units', rotation=270) cbar.ax.get_yaxis().labelpad = 15 self.cbar_not_added = False else: self.scatter_plot = self.ax.scatter( current_frame[:, 0], current_frame[:, 1], s=25, marker='s', lw=0, c=current_frame[:, 2], cmap=plt.cm.get_cmap( "brg", self.visualizer.network_dimensions['max_d'] + 1), vmin=self.visualizer.network_dimensions['min_d'], vmax=self.visualizer.network_dimensions['max_d']) # find some better solution than this flag hack if self.cbar_not_added: cbar = self.fig.colorbar(self.scatter_plot) cbar.set_label('Perceived disparity in pixel units', rotation=270) cbar.ax.get_yaxis().labelpad = 15 self.cbar_not_added = False else: self.scatter_plot = self.ax.scatter([], []) return mplfig_to_npimage(self.fig) def show(self): plt.show( ) # or better use plt.draw()?, not sure but I think this might freeze when updating... def save(self): dim = "3D" if self.dimension == 3 else "2D" if not os.path.exists("./animations"): os.makedirs("./animations") i = 0 while os.path.exists("./animations/{0}_{2}_{1}.gif" .format(self.visualizer.experiment_name, i, dim)) or \ os.path.exists("./animations/{0}_{2}_{1}.mp4" .format(self.visualizer.experiment_name, i, dim)): i += 1 if self.file_format == 'gif': self.anim.write_gif(filename="./animations/{0}_{2}_{1}.gif".format( self.visualizer.experiment_name, i, dim), fps=self.fps, verbose=self.visualizer.verbose) elif self.file_format == 'mp4': print("INFO: Generating movie with duration of {0}s at {1}fps.". format(int((self.duration / 1000 + 1) / self.speedup), self.fps)) self.anim.write_videofile( filename="./animations/{0}_{2}_{1}.mp4".format( self.visualizer.experiment_name, i, dim), fps=self.fps, codec='mpeg4', bitrate='2000k', audio=False, verbose=self.visualizer.verbose) else: print("ERROR: The export format is not supported.")
global line print("time: {time}, line: {lime}".format(time=t, line=line)) # vyplneni trojrozmerneho pole nulami frame = numpy.zeros((HEIGHT, WIDTH, 3)) # vykresleni jedine vodorovne usecky if line < HEIGHT: frame[line].fill(255) line += 1 return frame # vytvoreni video klipu animation = VideoClip(make_frame, duration=10) # export videa do formatu MPEG-4 animation.write_videofile("line.mp4", fps=24) # znovunastaveni pocitadla line = 0 # export videa do formatu Ogg Video File animation.write_videofile("line.ogv", fps=24) # znovunastaveni pocitadla line = 0 # export videa do formatu GIF animation.write_gif("line.gif", fps=24)
myclip = VideoFileClip('file3763.mov') iter_frames = myclip.iter_frames() mean=(0.485, 0.456, 0.406) std=(0.229, 0.224, 0.225) def make_frame(t): orig_img = next(iter_frames) x, orig_img = load_test_from_numpy(orig_img, ctx=ctx) ids, scores, bboxes, drivable_maps = net(x.as_in_context(ctx)) # ids, scores, bboxes = [xx[0].asnumpy() for xx in [ids, scores, bboxes]] ids = ids[0].asnumpy() scores = scores[0].asnumpy() bboxes = bboxes[0].asnumpy() drivable_maps = drivable_maps[0] # print(ids.context, scores.context, bboxes.context, drivable_maps.context) mask = drivable_maps.transpose((1,2,0)).as_in_context(mx.cpu()) mask = re_size(mask) orig_img = plot_drivable_map(orig_img, mask) res_img = draw_bbox(orig_img, bboxes, scores, ids, thresh=0.5, class_names=CLASSES,colors=colors) return res_img animation = VideoClip(make_frame, duration=duration) animation.write_videofile(name + '.mp4', fps=30)
M_0=np.zeros((2,2*nlags+affine)), K_0=10*np.eye(2*nlags+affine), affine=affine) for state in range(Nmax)], ) model.add_data(data) ############### # inference # ############### from moviepy.video.io.bindings import mplfig_to_npimage from moviepy.editor import VideoClip fig = model.make_figure() plt.set_cmap('terrain') plot_slice = slice(0,300) model.plot(fig=fig,draw=False,plot_slice=plot_slice) def make_frame_mpl(t): model.resample_model() model.plot(fig=fig,update=True,draw=False,plot_slice=plot_slice) plt.tight_layout() return mplfig_to_npimage(fig) animation = VideoClip(make_frame_mpl, duration=10) animation.write_videofile('gibbs.mp4',fps=30)
def export_moviepy(sequence, filename, rate=30, bitrate=None, width=None, height=None, codec='mpeg4', pixel_format='yuv420p', autoscale=None, quality=None, verbose=True, options=None, rate_range=(16, 32)): """Export a sequence of images as a standard video file using MoviePy. Parameters ---------- sequence : any iterator or array of array-like images The images should have two dimensions plus an optional third dimensions representing color. filename : string name of output file rate : integer, optional frame rate of output file, 30 by default NB: The output frame rate will be limited between `rate_range` bitrate : integer or string, optional Preferably use the parameter `quality` for controlling the bitrate. width : integer, optional By default, set the width of the images. height : integer, optional By default, set the height of the images. If width is specified and height is not, the height is autoscaled to maintain the aspect ratio. codec : string a valid video encoding, 'mpeg4' by default. Must be supported by the container format. Examples are {'mpeg4', 'wmv2', 'libx264', 'rawvideo'} Check https://www.ffmpeg.org/ffmpeg-codecs.html#Video-Encoders. pixel_format: string, optional Pixel format, 'yuv420p' by default. Another possibility is 'bgr24' in combination with the 'rawvideo' codec. quality: number or string, optional For 'mpeg4' codec: sets qscale:v. 1 = high quality, 5 = default. For 'libx264' codec: sets crf. 0 = lossless, 23 = default. For 'wmv2' codec: sets fraction of lossless bitrate, 0.01 = default autoscale : boolean, optional Linearly rescale the brightness to use the full gamut of black to white values. False by default for uint8 readers, True otherwise. verbose : boolean, optional Determines whether MoviePy will print progress. True by default. options : dictionary, optional Dictionary of parameters that will be passed to ffmpeg. Avoid using {'qscale:v', 'crf', 'pixel_format'}. rate_range : tuple of two numbers As extreme frame rates have playback issues on many players, by default the frame rate is limited between 16 and 32. When the desired frame rate is too low, frames will be multiplied an integer number of times. When the desired frame rate is too high, frames will be skipped at constant intervals. See Also -------- http://zulko.github.io/moviepy/ref/VideoClip/VideoClip.html#moviepy.video.VideoClip.VideoClip.write_videofile """ if VideoClip is None: raise ImportError('The MoviePy exporter requires moviepy to work.') if options is None: options = dict() ffmpeg_params = [] for key in options: ffmpeg_params.extend(['-{}'.format(key), str(options[key])]) if rate <= 0: raise ValueError export_rate = _normalize_framerate(rate, *rate_range) clip = VideoClip(CachedFrameGenerator(sequence, rate, autoscale, to_bgr=(pixel_format == 'bgr24'))) clip.duration = len(sequence) / rate if not (height is None and width is None): clip = clip.resize(height=height, width=width) if codec == 'wmv2' and bitrate is None and quality is None: quality = 0.01 if quality is not None: if codec == 'libx264': ffmpeg_params.extend(['-crf', str(quality)]) elif codec == 'mpeg4': ffmpeg_params.extend(['-qscale:v', str(quality)]) elif codec == 'wmv2': if bitrate is not None: warnings.warn("(wmv) quality is ignored when bitrate is set.") else: bitrate = quality * _estimate_bitrate(clip.size, export_rate) else: raise NotImplemented if format is not None: ffmpeg_params.extend(['-pixel_format', str(pixel_format)]) if bitrate is not None: bitrate = str(bitrate) clip.write_videofile(filename, export_rate, codec, bitrate, audio=False, verbose=verbose, ffmpeg_params=ffmpeg_params)
#print probe.name, "at", probe.position if probe.name in displayed_probes: list_lines[line_index].set_data(probe.time_buffer, probe.value_buffer) line_index+=1 xmin, xmax = ax1.get_xlim() if o.t > xmax: ax1.set_xlim(xmin, 2*xmax) ax1.figure.canvas.draw() NF_mp.set_data(xrange(0,width), NF.V) NF_firing.set_data(xrange(0,width), NF.GainFunction(NF.V)) if RECORD_VIDEO: return mplfig_to_npimage(fig) else: return list_lines from time import time t0 = time() print list_obj ## call the animator. blit=True means only re-draw the parts that have changed. if not RECORD_VIDEO: anim = animation.FuncAnimation(fig, animate, frames=simulation_time, interval=5 , blit=True, init_func= init, repeat=False) else: from moviepy.editor import VideoClip from moviepy.video.io.bindings import mplfig_to_npimage anim = VideoClip(animate, duration = simulation_time/60) anim.write_videofile("bartest_"+str(end_bar-start_bar)+".mp4", fps = 60) t1 = time() print((t1 - t0)) plt.show()
# Make super short video (so the analysis is quick!) vname='brief' newvideo=os.path.join(cfg['project_path'],'videos',vname+'.mp4') try: #you need ffmpeg command line interface subprocess.call(['ffmpeg','-i',video[0],'-ss','00:00:00','-to','00:00:00.4','-c','copy',newvideo]) except: #for windows: from moviepy.editor import VideoFileClip,VideoClip clip = VideoFileClip(video[0]) clip.reader.initialize() def make_frame(t): return clip.get_frame(1) newclip = VideoClip(make_frame, duration=1) newclip.write_videofile(newvideo,fps=30) deeplabcut.analyze_videos(path_config_file,[newvideo],save_as_csv=True, destfolder=dfolder) print("CREATE VIDEO") deeplabcut.create_labeled_video(path_config_file,[newvideo], destfolder=dfolder) print("Making plots") deeplabcut.plot_trajectories(path_config_file,[newvideo], destfolder=dfolder) print("EXTRACT OUTLIERS") deeplabcut.extract_outlier_frames(path_config_file,[newvideo],outlieralgorithm='jump',epsilon=0,automatic=True, destfolder=dfolder) file=os.path.join(cfg['project_path'],'labeled-data',vname,"machinelabels-iter"+ str(cfg['iteration']) + '.h5')
if probe.name in displayed_probes: list_lines[line_index].set_data(probe.time_buffer, probe.value_buffer) line_index+=1 xmin, xmax = ax1.get_xlim() if o.t > xmax: ax1.set_xlim(xmin, 2*xmax) ax1.figure.canvas.draw() NF_mp.set_data(xrange(0,width), NF.V) NF_firing.set_data(xrange(0,width), NF.GainFunction(NF.V)) if RECORD_VIDEO: return mplfig_to_npimage(fig) else: return list_lines from time import time t0 = time() print list_obj ## call the animator. blit=True means only re-draw the parts that have changed. if not RECORD_VIDEO: anim = animation.FuncAnimation(fig, animate, frames=simulation_time, interval=5 , blit=True, init_func= init, repeat=False) else: from moviepy.editor import VideoClip from moviepy.video.io.bindings import mplfig_to_npimage anim = VideoClip(animate, duration = simulation_time/60) anim.write_videofile("test2.mp4", fps = 60) t1 = time() print((t1 - t0)) plt.show()
import numpy as np from moviepy.editor import VideoClip def make_frame(t): """ returns an image of the frame at time t """ # ... create the frame with any library return np.zeros((300, 400, 3)) # (Height x Width x 3) Numpy array animation = VideoClip(make_frame, duration=3) # 3-second clip # For the export, many options/formats/optimizations are supported animation.write_videofile("my_animation.mp4", fps=24) # export as video animation.write_gif("my_animation.gif", fps=24) # export as GIF (slow)
idx = [i for i in range(len(time_sum)-1) if t<=time_sum[i]][0] # print "======", jpegs[idx/2], "======", idx delta_fade = time_sum[idx]-time_sum[idx-1] fade_to = (t-time_sum[idx-1])/delta_fade # fraction fade_from = 1-fade_to # fraction frame_for_time_t_BGR_frame0 = fade_from * cv2.imread(jpegs[idx/2],cv2.CV_LOAD_IMAGE_COLOR) frame_for_time_t_BGR_frame1 = fade_to * cv2.imread(jpegs[idx/2+1],cv2.CV_LOAD_IMAGE_COLOR) # BLENDED FRAME frame_for_time_t_BGR_frame01 = frame_for_time_t_BGR_frame0 + frame_for_time_t_BGR_frame1 frame_for_time_t_BGR_frame01 = frame_for_time_t_BGR_frame01.astype('uint8') # convert from float to uint8 frame_for_time_t = cv2.cvtColor(frame_for_time_t_BGR_frame01, cv2.COLOR_BGR2RGB) # BGR-RGB COLOR return frame_for_time_t clip = VideoClip(make_frame, duration=time_sum[-1])#.set_audio(audio) # x-second clip if audio_on: audio = AudioFileClip("audioclip.mp3") audio = audio.set_duration(time_sum[-1]) clip = clip.set_audio(audio) clip.write_videofile("my_animation_%sfps_dummy.mp4" %fps, fps=fps) # export as video #clip.write_gif("my_animation.gif", fps=24) # export as GIF
def main(argv): animation = VideoClip(make_frame, duration=60) # durration is seconds animation.write_videofile("my_animation.mp4", fps=6) # export as video animation.write_gif("my_animation.gif", fps=6) # export as GIF (slow
def export_moviepy(sequence, filename, rate=30, bitrate=None, width=None, height=None, codec='mpeg4', pixel_format='yuv420p', autoscale=None, quality=None, verbose=True, options=None, rate_range=(16, 32)): """Export a sequence of images as a standard video file using MoviePy. Parameters ---------- sequence : any iterator or array of array-like images The images should have two dimensions plus an optional third dimensions representing color. filename : string name of output file rate : integer, optional frame rate of output file, 30 by default NB: The output frame rate will be limited between `rate_range` bitrate : integer or string, optional Preferably use the parameter `quality` for controlling the bitrate. width : integer, optional By default, set the width of the images. height : integer, optional By default, set the height of the images. If width is specified and height is not, the height is autoscaled to maintain the aspect ratio. codec : string a valid video encoding, 'mpeg4' by default. Must be supported by the container format. Examples are {'mpeg4', 'wmv2', 'libx264', 'rawvideo'} Check https://www.ffmpeg.org/ffmpeg-codecs.html#Video-Encoders. pixel_format: string, optional Pixel format, 'yuv420p' by default. Another possibility is 'bgr24' in combination with the 'rawvideo' codec. quality: number or string, optional For 'mpeg4' codec: sets qscale:v. 1 = high quality, 5 = default. For 'libx264' codec: sets crf. 0 = lossless, 23 = default. For 'wmv2' codec: sets fraction of lossless bitrate, 0.01 = default autoscale : boolean, optional Linearly rescale the brightness to use the full gamut of black to white values. False by default for uint8 readers, True otherwise. verbose : boolean, optional Determines whether MoviePy will print progress. True by default. options : dictionary, optional Dictionary of parameters that will be passed to ffmpeg. Avoid using {'qscale:v', 'crf', 'pixel_format'}. rate_range : tuple of two numbers As extreme frame rates have playback issues on many players, by default the frame rate is limited between 16 and 32. When the desired frame rate is too low, frames will be multiplied an integer number of times. When the desired frame rate is too high, frames will be skipped at constant intervals. See Also -------- http://zulko.github.io/moviepy/ref/VideoClip/VideoClip.html#moviepy.video.VideoClip.VideoClip.write_videofile """ if VideoClip is None: raise ImportError('The MoviePy exporter requires moviepy to work.') if options is None: options = dict() ffmpeg_params = [] for key in options: ffmpeg_params.extend(['-{}'.format(key), str(options[key])]) if rate <= 0: raise ValueError export_rate = _normalize_framerate(rate, *rate_range) clip = VideoClip( CachedFrameGenerator(sequence, rate, autoscale, to_bgr=(pixel_format == 'bgr24'))) clip.duration = len(sequence) / rate if not (height is None and width is None): clip = clip.resize(height=height, width=width) if codec == 'wmv2' and bitrate is None and quality is None: quality = 0.01 if quality is not None: if codec == 'libx264': ffmpeg_params.extend(['-crf', str(quality)]) elif codec == 'mpeg4': ffmpeg_params.extend(['-qscale:v', str(quality)]) elif codec == 'wmv2': if bitrate is not None: warnings.warn("(wmv) quality is ignored when bitrate is set.") else: bitrate = quality * _estimate_bitrate(clip.size, export_rate) else: raise NotImplemented if format is not None: ffmpeg_params.extend(['-pixel_format', str(pixel_format)]) if bitrate is not None: bitrate = str(bitrate) clip.write_videofile(filename, export_rate, codec, bitrate, audio=False, verbose=verbose, ffmpeg_params=ffmpeg_params)
def draw_animation(): animation = VideoClip(make_frame=make_frame, duration=duration) animation.write_videofile("matplotlib.mp4", fps=20)
class Animate(object): """ Moviepy related functions (based on matplotlib routines below) """ def moviepy_update(self, i): self.update(i) if SAVE_VEC_FRAMES: if i * FPS % VEC_FRAME_STEP == 0: self.save_vec_frame(i) return mplfig_to_npimage(self.fig) if USE_MOVIEPY else None def moviepy_animate(self): self.prepare() if USE_MOVIEPY: self.ani = VideoClip( self.moviepy_update, duration=self.bf.particles.get_number_of_frames() / FPS) # FIXME: duration in seconds else: for i in range(self.bf.particles.get_number_of_frames()): print(i) self.moviepy_update(i) def moviepy_save_to_file(self, filename): if USE_MOVIEPY: self.ani.write_videofile(filename, fps=FPS) def save_vec_frame(self, i): self.fig.savefig("%s-frame-ts%d.pdf" % (self.output_filename, i * 30)) """ Matplotlib related functions """ def update(self, i): """ Update dynamic particle properties. """ if DRAW_PARTICLES: particles = next(self.particle_data) if DRAW_TIME: # FIXME: evtl. in Simulationszeit konvertieren, also *saving_timestep #self.ax.set_title(r'$t_s$=%3.2f' % (i*FPS)) #self.ax.set_title(r'$t_s$=%03d' % (i*FPS)) self.ax.set_title(r'$t_s$=%d' % (i * FPS)) #self.ax.set_title(r'$t_s$=%d' % (i*FPS), fontsize=80) if not USE_BOUNDARY_REDRAW: for (ep, es) in zip( self.ells, particles ): # FIXME: self.ells = [] after add_artist(e) for e in ells ep.center = es['position'] if not isinstance( ep, matplotlib.patches.Circle ): # FIXME: das ist noch nicht so wirklich schön ep.angle = degrees(es['angle']) if DRAW_PARTICLE_IDS: self.labels[es['id']].set_position(xy=es['position']) ### VERSION MIT WIEDERHOLDUNGEN AN RÄNDERN else: [box_width, box_height] = self.__box_size translations = [ np.array([dx, dy]) for dx in [box_width, -box_width, 0] for dy in [box_height, -box_height, 0] ] for (ep, es) in zip( self.ells2, particles ): # FIXME: self.ells = [] after add_artist(e) for e in ells ep.set_offsets(es['position'] + translations) if (ep._heights != ep._widths).all(): ep._angles = np.repeat((es['angle']), 9) if DRAW_PARTICLE_IDS: self.labels[es['id']].set_position(xy=es['position']) ### ENDE DER 2. Version def prepare(self): """ Initialization of the particle patches. """ self.plot_cellspace() #particles = next(self.particle_data) particles = next(self.particle_static_data) if not DRAW_FIG_AXES: self.ax.axis('off') if DRAW_PARTICLES: if not USE_BOUNDARY_REDRAW: #self.ells = [Ellipse(xy=e['position'], width=2*e['major'], height=2*e['minor'], angle=degrees(e['angle'])) for e in particles] #self.ells = [getattr(matplotlib.patches, e['type'])(xy=e['position'], width=2*e['major'], height=2*e['minor'], angle=degrees(e['angle'])) for e in particles] self.ells = [] self.labels = {} for e in particles: # FIXME: das ist noch nicht so wirklich schön if e['type'] == "Ellipse": self.ells.append( matplotlib.patches.Ellipse(xy=e['position'], width=2 * e['major'], height=2 * e['minor'], angle=degrees( e['angle']))) elif e['type'] == "Circle": self.ells.append( matplotlib.patches.Circle(xy=e['position'], radius=e['radius'])) if DRAW_PARTICLE_IDS: self.labels[e['id']] = self.ax.text(e['position'][0], e['position'][1], ("%d" % e['id']), fontsize=12, color='white') for e in self.ells: self.ax.add_artist(e) k = e.height / e.width # Antrag (R/G) """"(r,g,b)=(0,0,1) if k>0.5: (g,b) = (0.54902, 0) """ # R/B (r, g, b) = (0, 1, 0) if k > 0.5: (r, b) = 1, 0 e.set_facecolor([r, g, b ]) # FIXME: encode angle or particle type else: ### VERSION MIT WIEDERHOLDUNGEN AN RÄNDERN self.ells2 = [] [box_width, box_height] = self.__box_size translations = [ np.array([dx, dy]) for dx in [box_width, -box_width, 0] for dy in [box_height, -box_height, 0] ] for e in particles: if e['type'] == "Ellipse": # FIXME: this should be done in boundary module! widths = np.repeat(2 * e['major'], 9) heights = np.repeat(2 * e['minor'], 9) angles = np.repeat(degrees(e['angle']), 9) (r, g, b) = (0, 0, 1) if e['minor'] / e['major'] > 0.5: (r, g, b) = ( 1, 0, 0 ) # probably not too useful, because pinned particles have same color # (g,b)=(0.54902,0) elif e['type'] == "Circle": widths = np.repeat(2 * e['radius'], 9) heights = np.repeat(2 * e['radius'], 9) angles = np.repeat(0, 9) (r, g, b) = (1, 0, 0) if e['pinned'] == True: (r, g, b) = (1, 0, 0) if DRAW_PARTICLE_IDS: self.labels[e['id']] = self.ax.text(e['position'][0], e['position'][1], ("%d" % e['id']), fontsize=12, color='white') XY = e['position'] + translations ec = EllipseCollection(widths, heights, angles, units='x', offsets=XY, transOffset=self.ax.transData) ec.set_facecolor([r, g, b]) self.ells2.append(ec) self.ax.add_collection(ec) def plot_cellspace(self): """ Plots the Delaunay triangulation of the cellspace. """ system = arb() self.cellspace = DelaunayCellspace(system=system, grid_points=self.grid_data) if DRAW_CELLS: self.ax.triplot(self.cellspace._grid_points[:, 0], self.cellspace._grid_points[:, 1], self.cellspace.triang.simplices.copy()) self.__grid_to_box_corners() (xmin, xmax, ymin, ymax) = self.__box_corners self.ax.set_xlim(xmin, xmax) self.ax.set_ylim(ymin, ymax) if DRAW_CELL_NEIGHBOURS: ### load boundaries as well to show appropriate neighbours system.cellspace = self.cellspace from bedsim.boundary import PeriodicBox self.boundary = PeriodicBox(system=system) system.boundary = self.boundary ### np.random.seed(3) for cell in self.cellspace.cells: #print("cs = ", cell._simplex) #if (cell._simplex == np.array([15, 21, 16])).all(): #if (cell._simplex == np.array([15, 11, 10])).all(): #if (cell._simplex == np.array([21, 17, 16])).all(): if (cell._simplex == np.array([5, 1, 0])).all(): cell_points = self.cellspace._grid_points[cell._simplex] mpoint = np.sum(cell_points, axis=0) / len(cell_points) for neigh in cell.neighbours: neigh_cell_points = self.cellspace._grid_points[ neigh._simplex] neigh_mpoint = np.sum(neigh_cell_points, axis=0) / len(neigh_cell_points) self.ax.arrow(mpoint[0], mpoint[1], neigh_mpoint[0] - mpoint[0] + np.random.normal(0, 0.1), neigh_mpoint[1] - mpoint[1] + np.random.normal(0, 0.1), head_width=0.05, head_length=0.1, fc='r', ec='r') #self.ax.text(mpoint[0], mpoint[1], "I'm a cell") """ # OBSOLETE: def animate(self): self.ani = animation.FuncAnimation(self.fig, self.update, frames=self.bf.particles.get_number_of_frames(), interval=10, blit=True, init_func=self.prepare) # FIXME: frames def save_to_file(self, filename): self.ani.save(filename, fps=25, extra_args=['-vcodec', 'libx264']) """ def load_from_file(self, filename): self.bf = BedfileReader(filename) self.particle_data = self.bf.particles.load_dynamics( ) # FIXME: im Moment ist noch alles dynamisch. Das wird sich aber bald ändern! self.particle_static_data = self.bf.particles.load_statics() self.grid_data = self.bf.system.grid def __init__(self, input_filename, output_filename): self.ells = [] self.load_from_file(input_filename) self.fig, self.ax = plt.subplots(figsize=FIGSIZE) self.ax.set_aspect(1) self.ax.set_ylim(0, 10) # FIXME self.ax.set_xlim(0, 10) # FIXME self.labels = {} self.__box_size = np.array([10, 10]) self.__box_center = np.array([5, 5]) self.__box_corners = (0, 10, 0, 10) # matplotlib # self.animate() #self.save_to_file(output_filename) self.output_filename = output_filename # moviepy self.moviepy_animate() self.moviepy_save_to_file(output_filename) def __grid_to_box_corners(self): ## FIXME: generalize this """ Calculate the corners of the simulation box from the cell grid. """ [x, y] = self.cellspace._grid_points.transpose() [xmin, xmax, ymin, ymax] = [np.amin(x), np.amax(x), np.amin(y), np.amax(y)] [width, height] = [xmax - xmin, ymax - ymin] self.__box_size = np.array([width, height]) self.__box_center = np.array([(xmin + xmax) / 2, (ymin + ymax) / 2]) self.__box_corners = (xmin, xmax, ymin, ymax) self.extent = np.fabs(np.array([xmax, ymax]) - np.array([xmin, ymin]))
""" T01,Joint1 = PlanarTransformationMatrix(Angle1,[0,0],np.identity(4)) T12,Joint2 = PlanarTransformationMatrix(Angle2,[0,-Length1],T01) T23,Endpoint = PlanarTransformationMatrix(0,[0,-Length2],T12) Radius = 0.5 plt.figure() ax = plt.gca() plt.plot([0],[0],'ko') plt.plot([Joint1[0], Joint2[0], Endpoint[0]],[Joint1[1], Joint2[1], Endpoint[1]],"0.75",lw=3) plot_link(ax, Joint1, Radius, Length1, Angle1, Joint2,"0.55") plot_link(ax, Joint2, Radius, Length2, Angle1+Angle2, Endpoint, "0.55") quick_2D_plot_tool(ax,'x','y','Drawing Rotating Links') return(ax) ax1 = plot_2_link_planar_model(np.pi/6,np.pi/6,5,5) ax2 = plot_2_link_planar_model(np.pi/2,np.pi/2,4,3) plt.imshow((ax1,ax2)) from moviepy.editor import VideoClip def make_frame(t): frame_for_time_t = plot_2_link_planar_model(Angle1[t],Angle2[t],5,5) return frame_for_time_t # (Height x Width x 3) Numpy array Angle1 = np.arange(0,np.pi,0.001) Angle2 = np.arange(0,np.pi/2,0.0005) animation = VideoClip(make_frame, duration=3) # 3-second clip # For the export, many options/formats/optimizations are supported animation.write_videofile("my_animation.mp4", fps=24) # export as video animation.write_gif("my_animation.gif", fps=24) # export as GIF (slow)
def render_gif(pov_file, args): prog_args = [] clock_args = {'fps': None, 'initial_clock': 0, 'final_clock': None, 'initial_frame': 0, 'final_frame': None, } for arg in args: if '=' in arg: key,value = arg.split('=') key = key.strip().lower() if key in clock_args: clock_args[key] = float(value) else: prog_args.append(arg) else: prog_args.append(arg) FPS = clock_args['fps'] initial_clock = clock_args['initial_clock'] final_clock = clock_args['final_clock'] initial_frame = clock_args['initial_frame'] final_frame = clock_args['final_frame'] time_scaling = 1.0 if (FPS is not None and final_clock is not None and final_frame is not None): would_be_FPS = (final_frame-initial_frame) / (final_clock-initial_clock) time_scaling = FPS / would_be_FPS if FPS is None: if (final_clock is not None and final_frame is not None): FPS = (final_clock-initial_clock) / (final_frame-initial_frame) else: raise ValueError('FPS must be set at top of file') if final_clock is None: if (FPS is not None and final_frame is not None): final_clock = initial_clock + (final_frame-initial_frame)/FPS else: raise ValueError('Final_Clock must be set at top of file') if final_frame is None: if (FPS is not None and final_clock is not None): final_frame = initial_frame + (final_clock-initial_clock)*FPS else: raise ValueError('Final_Frame must be set at top of file') make_frame = frame_gen(pov_file, prog_args, initial_clock, time_scaling) clip = VideoClip(make_frame, duration=(final_clock-initial_clock)/time_scaling) # output_gif = pov_file.replace('.pov','.gif') # clip.write_gif(output_gif, fps=FPS, # program='ffmpeg') output_mp4 = pov_file.replace('.pov','.mp4') clip.write_videofile(output_mp4, fps=FPS, codec='libx264', bitrate='500k', audio=False) print('')
def make_frame(t): """Deklarace callback funkce zavolane pri renderingu kazdeho snimku videa.""" offset = 4 * t / DURATION - 2 print(offset) w = 1 / (z + 2j)**2 + 1 / (z - offset)**2 img = colorize(w) fig = plt.figure(figsize=(20, 20)) plt.subplot(111) subplot = fig.add_subplot(111) subplot.imshow(img) # konverze na objekt typu "frame" return mplfig_to_npimage(fig) # vytvoreni video klipu animation = VideoClip(make_frame, duration=DURATION) # export videa do formatu Ogg/Vorbis animation.write_videofile('complex.ogv', fps=FPS, progress_bar=False, bitrate="800000")
def make_frame(t): """Vytvoreni jednoho snimku videa.""" global scale print("time: {t}, scale: {s}".format(t=t, s=scale)) # vyplneni trojrozmerneho pole nulami frame = numpy.zeros((HEIGHT, WIDTH, 3)) calc_mandelbrot(WIDTH, HEIGHT, MAXITER, palette_mandmap.palette, x0, y0, scale, frame) scale *= scale_factor return frame # vytvoreni video klipu animation = VideoClip(make_frame, duration=15) # export videa do formatu Ogg Video File # animation.write_videofile("mandelbrot_zoom.ogv", fps=20, progress_bar=False, bitrate="2000000") animation.write_videofile("mandelbrot_zoom.ogv", fps=20, progress_bar=False, bitrate="300000") # export videa do formatu MPEG-4 # animation.write_videofile("mandelbrot_zoom.mp4", fps=20, progress_bar=False, bitrate="700000") # export videa do formatu GIF # animation.write_gif("colors.gif", fps=25)
self.program.bind(gloo.VertexBuffer(data)) self.program['u_model'] = self.model self.program['u_view'] = self.view self.program['u_size'] = 5 / self.translate gloo.set_state('translucent', depth_test=False) self.program['u_clock'] = 0.0 def on_resize(self, event): width, height = event.size gloo.set_viewport(0, 0, width, height) self.projection = perspective(45.0, width / float(height), 1.0, 1000.0) self.program['u_projection'] = self.projection def animation(self, t): """ Added for animation with MoviePy """ self.program['u_clock'] = 2*t gloo.clear('black') self.program.draw('points') return _screenshot((0, 0, self.size[0], self.size[1]))[:,:,:3] if __name__ == '__main__': from moviepy.editor import VideoClip canvas = Canvas() canvas.show() clip = VideoClip(canvas.animation, duration=np.pi).resize(0.3) clip.write_videofile('atom3.mp4', fps=20) #clip.write_gif('atom3.gif', fps=20, opt='OptimizePlus')