def create_timelapse_video(input_image, image_id, path): print("Matched with one of the frame of video with id: " + image_id) images = load_frames(path + image_id + ".mp4") total_frame = len(images) image_files = [] count = 0 printProgressBar(0, total_frame, prefix='Progress:', suffix='Complete', length=50) for image in images: count += 1 printProgressBar(count + 1, total_frame, prefix='Progress:', suffix='Complete', length=50) if not image is None: styled_image = color_transfer(image, input_image) name = "styled_image" + str(count) + ".jpg" cv2.imwrite(name, styled_image) read_frame = cv2.imread(name) image_files.append(name) clip = ImageSequenceClip(image_files, fps=10) clip.write_videofile('output.mp4') cv2.destroyAllWindows() for k in image_files: os.system("rm " + k)
def write_gif(filepath, images, fps=24): """Saves a sequence of images as an animated GIF. Parameters ---------- filepath: str The filepath ending with *.gif where to save the file. images: list(3-D array) or 4-D array A list of images or a 4-D array where the first dimension represents the time axis. fps: int, optional The frame rate. """ # to list if not isinstance(images, list): splitted = np.split(images, images.shape[0]) images = [np.squeeze(s, axis=(0, )) for s in splitted] elif len(images) == 0: return # ensure directory exists dirpath = os.path.dirname(filepath) if not os.path.exists(dirpath): os.makedirs(dirpath) # scale factor for float factor = 1 if tt.utils.image.is_float_image(images[0]): factor = 255 clip = ImageSequenceClip([img * factor for img in images], fps=fps) clip.write_gif(filepath, verbose=False)
def gif(filename, array, fps=10): """Creates a gif given a stack of images using moviepy Notes ----- works with current Github version of moviepy (not the pip version) https://github.com/Zulko/moviepy/commit/d4c9c37bc88261d8ed8b5d9b7c317d13b2cdf62e Usage ----- >>> X = randn(100, 64, 64) >>> gif('test.gif', X) Parameters ---------- filename : string The filename of the gif to write to array : array_like A numpy array that contains a sequence of images fps : int frames per second (default: 10) """ from moviepy.video.io.ImageSequenceClip import ImageSequenceClip # ensure that the file has the .gif extension fname, _ = os.path.splitext(filename) filename = fname + '.gif' # copy into the color dimension if the images are black and white if array.ndim == 3: array = array[..., np.newaxis] * np.ones(3) # make the moviepy clip clip = ImageSequenceClip(list(array), fps=fps) clip.write_gif(filename, fps=fps) return clip
def run(self): clip = ImageSequenceClip(self.list, fps=self.fps) clip.write_videofile(self.path) # to video # clip.write_gif(self.path.replace("mp4", "gif")) # to gif # """生成gif""" # imageio.mimsave('what.gif',self.gif_list) self.trigger.emit() shutil.rmtree('temp')
def _generate_from_frames(self, frames: List[Frame], fps): images = [] for f in frames: images.append(f.image) clip = ImageSequenceClip(images, fps=fps) audio_clip = self.audio.subclip(frames[0].timestamp, frames[-1].timestamp) new_clip = clip.set_audio(audio_clip) return new_clip
def test_exifrotate(): image_file = 'media/balloons_portrait.jpg' with ImageSequenceClip([image_file], fps=1) as clip: frame = clip.get_frame(0) assert frame.meta['EXIF_MAIN']['ExifImageWidth'] == 4032 assert frame.meta['EXIF_MAIN']['ExifImageHeight'] == 3024 assert frame.meta['EXIF_MAIN']['Orientation'] == 6 assert clip.size == (3024, 4032) with ImageSequenceClip([image_file], fps=1, imageio_params={'exifrotate': False}) as clip: assert clip.size == (4032, 3024)
def test_1(): images=[] durations=[] for i in range(5): durations.append(i) images.append("media/python_logo.png") durations.append(i) images.append("media/python_logo_upside_down.png") clip = ImageSequenceClip(images, durations=durations) assert clip.duration == sum(durations) clip.write_videofile("/tmp/ImageSequenceClip1.mp4", fps=30)
def test_1(): images = [] durations = [] for i in range(5): durations.append(i) images.append("media/python_logo.png") durations.append(i) images.append("media/python_logo_upside_down.png") clip = ImageSequenceClip(images, durations=durations) assert clip.duration == sum(durations) clip.write_videofile("/tmp/ImageSequenceClip1.mp4", fps=30)
def do_actual_lapse(lapse_instance_id, fps, output_size, image_path_list=[], image_id_list=[]): image_path_list = [str(i) for i in image_path_list ] #forcing str moviepy/issues/293 # print image_path_list try: clip = ImageSequenceClip(image_path_list, fps=fps) except ValueError as exc: [generate_thumbs.delay(i) for i in image_id_list] do_actual_lapse.retry(kwargs={ "lapse_instance_id": lapse_instance_id, "fps": fps, "output_size": output_size, "image_path_list": image_path_list, "image_id_list": image_id_list }, exc=exc, countdown=15) lapse_instance = AutoLapseInstance.objects.get(pk=lapse_instance_id) uuid = shortuuid.uuid() alfile = AutoLapseInstanceFile.objects.create(instance=lapse_instance, output_size=output_size, uuid=uuid) path_prefix = target_path_generator(alfile, prefix=settings.MEDIA_ROOT) if not os.path.exists(path_prefix): os.makedirs(path_prefix) # print path_prefix if clip.h % 2 != 0: clip.size = (clip.w, clip.h - 1) if clip.w % 2 != 0: clip.size = (clip.w - 1, clip.h) clip.write_videofile( video_mp4_name_generator(alfile, prefix=settings.MEDIA_ROOT)) clip.write_videofile( video_webm_name_generator(alfile, prefix=settings.MEDIA_ROOT)) clip.write_gif(gif_name_generator(alfile, prefix=settings.MEDIA_ROOT)) alfile.file_video_mp4 = video_mp4_name_generator(alfile) alfile.file_video_webm = video_webm_name_generator(alfile) alfile.file_video_gif = gif_name_generator(alfile) alfile.save() lapse_instance.status = LapseInstanceStatus.COMPLETED lapse_instance.save()
def gen_video(data_dir, output_data_dir, sess, image_shape, input_image, keep_prob, logits): if os.path.exists(output_data_dir): shutil.rmtree(output_data_dir) os.makedirs(output_data_dir, exist_ok=True) for name, image in gen_test_output(sess, logits, keep_prob, input_image, data_dir, image_shape): file_name = os.path.join(output_data_dir, name) scipy.misc.imsave(file_name, image) vid_clip = ImageSequenceClip(output_data_dir, fps=10) result_video = os.path.join(output_data_dir, "result.mp4") vid_clip.write_videofile(result_video) return result_video
def make_weekly_movie(cam: Cam, executor): root = Path(conf.root_dir) / 'data' / cam.name path = root / 'regular' / 'imgs' start = pendulum.yesterday() logger.info(f'Running make weekly movie for ww{start.week_of_year}') week_ago = start.subtract(weeks=1).date() sequence = [] morning = pendulum.Time(6) evening = pendulum.Time(18) for day in sorted(list(path.iterdir()), key=lambda x: pendulum.from_format(x.name, 'DD_MM_YYYY')): if pendulum.from_format(day.name, 'DD_MM_YYYY').date() > week_ago: for img in sorted(day.iterdir()): t_img = img.name.split('.')[0] t_img = pendulum.from_format(t_img, 'DD_MM_YYYY_HH-mm-ss').time() if morning < t_img < evening: sequence.append(str(img)) sequence = check_sequence_for_gray_images(sequence, executor) txt_clip = make_txt_movie(sequence, 100, executor) logger.info(f'Composing clip for weekly movie ww{start.week_of_year}') image_clip = ImageSequenceClip(sequence, fps=100) clip = CompositeVideoClip([image_clip, txt_clip.set_position(('right', 'top'))], use_bgclip=True) movie_path = root / 'regular' / 'weekly' / f'ww{start.week_of_year}.mp4' movie_path.parent.mkdir(parents=True, exist_ok=True) clip.write_videofile(str(movie_path), audio=False) logger.info(f'Finished with clip for weekly movie ww{start.week_of_year}') return Movie(clip.h, clip.w, movie_path, sequence[seq_middle(sequence)])
def make_txt_movie(sequence, fps): logger.debug('Creating txt movie..') txt_clip = [] with futures.ThreadPoolExecutor() as pool: for item in pool.map(ts_clip, sequence): txt_clip.append(item) return ImageSequenceClip(txt_clip, fps=fps)
def video_frame(fct_frame, **kwargs): """ Creates a video from drawing or images. *fct_frame* can either be a function which draws a picture at time *t* or a list of picture names or a folder. Créé une vidéo à partir de dessins ou d'images. *fct_frame* est soit une fonction qui dessine chaque image à chaque instant *t*, une liste de noms d'images ou un répertoire. @param fct_frame function like ``def make_frame(t: float) -> numpy.ndarray``, or list of images or folder name @param kwargs additional arguments for function `make_frame <https://zulko.github.io/moviepy/getting_started/videoclips.html#videoclip>`_ @return :epkg:`VideoClip` """ if isinstance(fct_frame, str): if not os.path.exists(fct_frame): raise FileNotFoundError( "Unable to find folder '{0}'".format(fct_frame)) imgs = os.listdir(fct_frame) exts = {'.jpg', '.jpeg', '.png', '.bmp', '.tiff'} imgs = [ os.path.join(fct_frame, _) for _ in imgs if os.path.splitext(_)[-1].lower() in exts ] return video_frame(imgs, **kwargs) elif isinstance(fct_frame, list): for img in fct_frame: if not os.path.exists(img): raise FileNotFoundError( "Unable to find image '{0}'".format(img)) return ImageSequenceClip(fct_frame, **kwargs) else: return VideoClip(fct_frame, **kwargs)
def clip_to_html(clip: Union[VideoClip, np.ndarray], verbose=False, fps=24, **kwargs) -> str: """Convert a MoviePy clip to an HTML string. .. code-block:: python from IPython.display import display clip = ImageSequenceClip(list(np_video)) display(clip_to_html(clip)) Args: clip: MoviePy clip. verbose: Whether to print out FFmpeg information during encoding fps: FPS of clip **kwargs: Any kwargs to pass down to :py:func:`html_embed` Returns: String of HTML with a ``<video>`` tag and base64 encoded media. Useful for use with ``IPython.display.display`` to show videos. """ if isinstance(clip, (np.ndarray, list)): clip = ImageSequenceClip(list(clip), fps=fps) assert hasattr(clip, "write_videofile") if clip.fps is None: clip.fps = fps if not verbose: rd_kwargs = {"logger": None} else: rd_kwargs = dict() return html_embed(clip, rd_kwargs=rd_kwargs, **kwargs)
def make_video(curdir, nbjobs=1): print("looking up files in ", curdir) rep_out = re.match(r".*rep(?P<num>\d+).*", curdir) if rep_out: rep = int(rep_out.group('num')) else: rep = 0 allfiles = glob(j(curdir, 'screenshot_custom_*.png')) if rep < replim: # Only deal with the first reps filesbygen = defaultdict(list) for fname in allfiles: name = basename(fname) out = re.match(r"""screenshot_custom_.+_ gen_(?P<gen>\d+) (?:_ind_(?P<ind>\d+))? .*\.png""", name, re.VERBOSE) if out: gen = out.group("gen") if out.group("ind"): gen += "i" + out.group("ind") filesbygen[gen].append(fname) for gen, files in filesbygen.items(): print("making movie for {}".format(gen)) outname = j(curdir, '../mov_{}.mp4'.format(gen)) try: newmov = ImageSequenceClip(sorted(files), fps=60) except: print(files) raise if exists(outname): print("{} already found, concatenating.".format(basename(outname))) prev = VideoFileClip(outname) newmov = concatenate_videoclips([prev, newmov]) verbose = sys.stdout.isatty() newmov.write_videofile(outname, fps=60, verbose=verbose, progress_bar=verbose, threads=nbjobs) print("{} created".format(basename(outname))) for pngfile in files: os.remove(pngfile) else: print("Do not make movie for this rep {}, already have others".format(rep)) for pngfile in allfiles: os.remove(pngfile)
def make_movie(movie_name, input_folder, output_folder, file_format, fps, output_format='mp4', reverse=False): """ function that makes the movie of the images data :param movie_name: name of the movie :type movie_name: string :param input_folder: folder where the image series is located :type input_folder: string :param output_folder: folder where the movie will be saved :type output_folder: string :param file_format: sets the format of the files to import :type file_format: string :param fps: frames per second :type fps: numpy, int :param output_format: sets the format for the output file supported types .mp4 and gif animated gif create large files :type output_format: string (, optional) :param reverse: sets if the movie will be one way of there and back :type reverse: bool (, optional) """ # searches the folder and finds the files file_list = glob.glob('./' + input_folder + '/*.' + file_format) # Sorts the files by number makes 2 lists to go forward and back list.sort(file_list) file_list_rev = glob.glob('./' + input_folder + '/*.' + file_format) list.sort(file_list_rev, reverse=True) # combines the file list if including the reverse if reverse: new_list = file_list + file_list_rev else: new_list = file_list if output_format == 'gif': # makes an animated gif from the images clip = ImageSequenceClip(new_list, fps=fps) clip.write_gif(output_folder + '/{}.gif'.format(movie_name), fps=fps) else: # makes and mp4 from the images clip = ImageSequenceClip(new_list, fps=fps) clip.write_videofile(output_folder + '/{}.mp4'.format(movie_name), fps=fps)
def test_3(): images = [] durations = [2] images.append("media/grayscale_landscape.png") # image is grayscale, should be transformed into rgb with ImageSequenceClip(images, durations=durations) as clip: assert clip.duration == sum(durations) clip.write_videofile(os.path.join(TMP_DIR, "ImageSequenceClip3.mp4"), fps=30)
def save_video(frames, path, fps=15): from moviepy.video.io.ImageSequenceClip import ImageSequenceClip temp_dir = tempfile.TemporaryDirectory() logger.info("saving video", num_frames=len(frames), fps=fps, path=path, temp_dir=temp_dir.name) try: for i, frame in enumerate(tqdm(frames)): if torch.is_tensor(frame): frame = frame.permute(1, 2, 0).detach().cpu().numpy() frame_path = Path(temp_dir.name, f'{i:08d}.jpg') imageio.imsave(frame_path, (frame * 255).astype(np.uint8)) video = ImageSequenceClip(temp_dir.name, fps=fps) video.write_videofile(str(path), preset='ultrafast', fps=fps) finally: temp_dir.cleanup()
def test_2(): images = [] durations = [] durations.append(1) images.append("media/python_logo.png") durations.append(2) images.append("media/matplotlib_demo1.png") #images are not the same size.. with pytest.raises(Exception): ImageSequenceClip(images, durations=durations).close()
def narrated_image_seq(narration_path, image_dir, fmt): """ Create video which displays looping slideshow of images and attaches audio of narrator reading section text." """ audio_clip_text = AudioFileClip(narration_path + f'_text.{fmt}').set_fps(1) images = files_in_directory(image_dir) return (ImageSequenceClip( sequence=images, durations=const_list(IMG_DURATION, len(images)), load_images=True).set_position(('center', 400)).fx( vfx.loop, duration=audio_clip_text.duration).set_audio(audio_clip_text))
def test_1(): images=[] durations=[] for i in range(5): durations.append(i) images.append("media/python_logo.png") durations.append(i) images.append("media/python_logo_upside_down.png") with ImageSequenceClip(images, durations=durations) as clip: assert clip.duration == sum(durations) clip.write_videofile(os.path.join(TMP_DIR, "ImageSequenceClip1.mp4"), fps=30)
def merge_images_and_audio(images: DataList, audio: np.ndarray, video_duration: float, sound_hz: int, video_name: str): """ Creates video with sound from image list and music. Args: images: List of images represented by a h x w x 3 numpy array. audio: A Numpy array representing the sound, of size Nx1 for mono, Nx2 for stereo. video_duration: Duration of the video in seconds (should be the same as the audio file). sound_hz: The hz of the audio file. video_name: The name of the resulting video file """ # todo there is still a problem with the audio here # the audio should always contain two channels # then the hz should also work for mono and dual clip = ImageSequenceClip(images, durations=[video_duration / len(images)] * len(images)) s = audio.reshape((len(audio), 2)) # transform it from (N) to (N, 2) audio = AudioArrayClip(s, sound_hz) clip = clip.set_audio(audio) clip.write_videofile(video_name, fps=len(images) / video_duration)
def display_video(video: Union[torch.Tensor, np.ndarray, List[np.ndarray]], format="THWC", fps=12): """ Args: video: Video array or tensor with values ranging between 0--255. format: TCHW in any order, describing the data layour of the video array """ if isinstance(video, list): video = np.stack(video) if isinstance(video, torch.Tensor): video = video.numpy() video = np.einsum(f"{format} -> THWC", video.astype(np.uint8)) _, height, width, _ = video.shape if height % 2 != 0: video = video[:, :-1, :, :] if width % 2 != 0: video = video[:, :, :-1, :] print(video.shape) frames: List[np.ndarray] = list(video) clip = ImageSequenceClip(frames, fps=fps) return clip.ipython_display()
def make_movie(cam: Cam, day: str, regular: bool = True): regular = 'regular' if regular else '' root = Path(conf.root_dir) / 'data' / cam.name path = root / 'regular' / 'imgs' / day logger.info(f'Running make movie for {path}:{day}') # sequence = check_sequence_for_gray_images(sorted(str(p) for p in path.iterdir())) sequence = sorted(str(p) for p in path.iterdir()) txt_clip = make_txt_movie(sequence, cam.fps) logger.info(f'Composing clip for {path}:{day}') image_clip = ImageSequenceClip(sequence, fps=cam.fps) logger.info(f'ImageSequenceClip ready') clip = CompositeVideoClip( [image_clip, txt_clip.set_position(('right', 'top'))], use_bgclip=True) logger.info(f'CompositeVideoClip ready') movie_path = root / regular / 'clips' / f'{day}.mp4' movie_path.parent.mkdir(parents=True, exist_ok=True) clip.write_videofile(str(movie_path), audio=False)
def test(self): total_reward = 0 for i in range(self.config.conf['test-num']):# quat = self.ref_motion.euler_to_quat(0,0,0) _ = self.env._reset(Kp=self.config.conf['Kp'], Kd=self.config.conf['Kd'], base_pos_nom=[0,0,1.575], base_orn_nom=quat, fixed_base=True) # state = self.env._reset(Kp=self.config.conf['Kp'], Kd=self.config.conf['Kd'], base_pos_nom=[0, 0, 1.175], fixed_base=False) q_nom = self.ref_motion.ref_motion_dict() base_orn_nom = self.ref_motion.get_base_orn() # state = self.env._reset(Kp=self.config.conf['Kp'], Kd=self.config.conf['Kd'], q_nom=q_nom, base_orn_nom=base_orn_nom, base_pos_nom=[0, 0, 1.175], fixed_base=False) # self.env._setupCamera() self.env.startRendering() self.env._startLoggingVideo() for step in range(self.max_step_per_episode): if step>=2*self.network_freq and step<4*self.network_freq: action = [0,0,0,0,0,0,0,0,0.1,0,0] else: action = [0,0,0,0,0,0,0,0,0,0,0] # action = np.clip(action, self.config.conf['actor-output-bounds'][0], # self.config.conf['actor-output-bounds'][1]) action = np.array([action]) if len(np.shape(action)) == 0 else np.array(action) rgb=self.env._render(roll=0,pitch=0,yaw=90) print(rgb.shape) self.image_list.append(rgb) for i in range(self.sampling_skip): # action = self.control.rescale(ref_action, self.config.conf['action-bounds'], # self.config.conf['actor-output-bounds']) _,_,_,_ = self.env._step(action) self.logging.add_run('action', action) joint_angle = self.control.get_joint_angle() self.logging.add_run('joint_angle', joint_angle) readings = self.env.getExtendedReading() ob = self.env.getObservation() for l in range(len(ob)): self.logging.add_run('observation' + str(l), ob[l]) # for key, value in readings.items(): # self.logging.add_run(key, value) self.env._stopLoggingVideo() self.env.stopRendering() ave_reward = total_reward/self.config.conf['test-num'] print(ave_reward) self.logging.save_run() clip = ImageSequenceClip(self.image_list, fps=25) clip.write_gif(self.dir_path+'/test.gif') clip.write_videofile(self.dir_path+'/test.mp4', fps=25, audio=False)
def do_actual_lapse(lapse_instance_id, fps, output_size, image_path_list=[], image_id_list=[]): image_path_list = [str(i) for i in image_path_list] #forcing str moviepy/issues/293 # print image_path_list try: clip = ImageSequenceClip(image_path_list, fps=fps) except ValueError as exc: [generate_thumbs.delay(i) for i in image_id_list] do_actual_lapse.retry(kwargs={"lapse_instance_id":lapse_instance_id, "fps":fps, "output_size":output_size, "image_path_list":image_path_list, "image_id_list":image_id_list}, exc=exc, countdown=15) lapse_instance = AutoLapseInstance.objects.get(pk=lapse_instance_id) uuid = shortuuid.uuid() alfile = AutoLapseInstanceFile.objects.create(instance=lapse_instance, output_size=output_size, uuid=uuid) path_prefix = target_path_generator(alfile, prefix=settings.MEDIA_ROOT) if not os.path.exists(path_prefix): os.makedirs(path_prefix) # print path_prefix if clip.h % 2 != 0: clip.size = (clip.w, clip.h -1) if clip.w % 2 != 0: clip.size = (clip.w - 1, clip.h) clip.write_videofile(video_mp4_name_generator(alfile, prefix=settings.MEDIA_ROOT)) clip.write_videofile(video_webm_name_generator(alfile, prefix=settings.MEDIA_ROOT)) clip.write_gif(gif_name_generator(alfile, prefix=settings.MEDIA_ROOT)) alfile.file_video_mp4 = video_mp4_name_generator(alfile) alfile.file_video_webm = video_webm_name_generator(alfile) alfile.file_video_gif = gif_name_generator(alfile) alfile.save() lapse_instance.status = LapseInstanceStatus.COMPLETED lapse_instance.save()
def job(item): fn = item outpath = os.path.join(fn, 'flow.mp4') if not os.path.exists(outpath): flows = torch.stack([ torch.from_numpy(read_flow(_)) for _ in glob(os.path.join(fn, '*.flo')) ]) flows = list(normalize_flows(flows)) flows = list(flows) rgb_flows = [make_uint8(flow2rgb(_.numpy())) for _ in flows] vid = ImageSequenceClip(rgb_flows, fps=8) vid.write_videofile(outpath, fps=8, verbose=False, logger=None) vid.close()
def make_beatmeter( stack: ExitStack, beatmeter: str, fps: float, duration: float, dims: (int, int), ): xdim, ydim = dims beat_image_filenames = [ str(os.path.join(beatmeter, filename)) for filename in sorted(os.listdir(beatmeter))[:ceil(duration * fps)] ] beatmeter = stack.enter_context( ImageSequenceClip(beat_image_filenames, fps=fps)) # resize and fit beatmeter # pylint: disable=no-member new_height = (beatmeter.h * xdim / beatmeter.w) beatmeter = resize(beatmeter, (xdim, new_height)) beatmeter = beatmeter.set_position(("center", ydim - 20 - beatmeter.h)) return beatmeter
def generateClip(self, filename): glutHideWindow() self.runSimulation() clip = ImageSequenceClip(self.frames, fps=self.FPS) clip.write_videofile(filename, fps=self.FPS)
'image': open('./image_data/frame' + str(currentframe) + '.jpg', 'rb'), }, headers={'api-key': 'PUT API KEY FOR DEEPAI HERE'} ) response = r.json() print(response) imagelink = requests.get(response['output_url']) file = open("./deep_image/" + str(currentframe) + '.jpg', "wb") file.write(imagelink.content) file.close() currentframe += 1 else: break cap = cv2.VideoCapture("video.mp4") fpsa = cap.get(cv2.CAP_PROP_FPS) print(fpsa) im = Image.open('./deep_image/0.jpg') print(im.size) print(type(im.size)) w, h = im.size clip = ImageSequenceClip("./deep_image/", fps = fpsa) clip.write_videofile("deep_video.mp4", fps=clip.fps, audio_bitrate="1000k", bitrate="4000k")
from moviepy import * from moviepy.editor import * from moviepy.video.VideoClip import TextClip from moviepy.video.compositing.CompositeVideoClip import CompositeVideoClip from moviepy.video.io.ImageSequenceClip import ImageSequenceClip import os from moviepy.video.io.VideoFileClip import VideoFileClip basic_directory = 'img' basic_files = os.listdir(basic_directory) clip = ImageSequenceClip([ '{0}/{1}'.format(basic_directory, basic_files[0]), '{0}/{1}'.format(basic_directory, basic_files[1]), '{0}/{1}'.format(basic_directory, basic_files[2]), '{0}/{1}'.format(basic_directory, basic_files[3]), ], fps=0.5) clip.write_videofile("myHolidays_edited.mp4", audio='music/sunny.mp3') clip = VideoFileClip("myHolidays_edited.mp4").subclip(0, 15) clip.write_videofile("myHolidays_edited.mp4", codec='mpeg4')
for r, (inputData, outputData, t0, t1, v0, v1, neuron_data) in enumerate(simulated): times = [t for t, v in neuron_data.values()[0]] nodes = list(neuron_data.keys()) time_data = [] for i, t in enumerate(times): tdata = {} for n in nodes: tdata[n] = neuron_data[n][i][1] tdata[0] = 0.0 if inputData[0] == 0 else -75.0 tdata[1] = 0.0 if inputData[1] == 0 else -75.0 time_data.append(tdata) for ti, (t, tdata) in enumerate(zip(times, time_data)): node_colors = {} for n, v in tdata.items(): node_colors[n] = voltage_to_color(v) fn = 'spiking-{0:04d}'.format(len(filenames)) dot = visualize.draw_net(winner, filename=fn, view=False, node_names=node_names, node_colors=node_colors, fmt='png', show_disabled=False, prune_unused=True) filenames.append(dot.filename + '.png') clip = ImageSequenceClip(filenames, fps=30) clip.write_videofile('spiking.mp4', codec="mpeg4", bitrate="2000k") for fn in filenames: os.unlink(fn) os.unlink(fn[:-4])
def test(self): total_reward = 0 for i in range(self.config.conf['test-num']): # # _ = self.env._reset(Kp=self.config.conf['Kp'], Kd=self.config.conf['Kd'], base_pos_nom=[0,0,1.5], fixed_base=True) state = self.env._reset(Kp=self.config.conf['Kp'], Kd=self.config.conf['Kd'], base_pos_nom=[0, 0, 1.175], fixed_base=False) q_nom = self.ref_motion.ref_motion_dict() base_orn_nom = self.ref_motion.get_base_orn() # state = self.env._reset(Kp=self.config.conf['Kp'], Kd=self.config.conf['Kd'], q_nom=q_nom, base_orn_nom=base_orn_nom, base_pos_nom=[0, 0, 1.175], fixed_base=False) # self.env._setupCamera() self.env.startRendering() self.env._startLoggingVideo() self.ref_motion.reset(index=0) # self.ref_motion.random_count() self.control.reset( w_imitation=self.config.conf['imitation-weight'], w_task=self.config.conf['task-weight']) for step in range(self.max_step_per_episode): # self.env._setupCamera() t = time.time() gait_phase = self.ref_motion.count / self.ref_motion.dsr_length ref_angle = self.ref_motion.ref_joint_angle() ref_vel = self.ref_motion.ref_joint_vel() self.env.checkSelfContact() state = self.env.getExtendedObservation() state = np.squeeze(state) state = np.append(state, [ np.sin(np.pi * 2 * gait_phase), np.cos(np.pi * 2 * gait_phase) ]) # state = np.append(state,[0,0]) action, actor_info = self.agent.agent.actor.get_action(state) mean = actor_info['mean'] logstd = actor_info['logstd'] action = mean # action = np.clip(action, self.config.conf['actor-output-bounds'][0], # self.config.conf['actor-output-bounds'][1]) action = np.array([action]) if len( np.shape(action)) == 0 else np.array(action) f = self.env.rejectableForce_xy(1.0 / self.network_freq) rgb = self.env._render() print(rgb.shape) self.image_list.append(rgb) # action = self.control.rescale(ref_action, self.config.conf['action-bounds'], # self.config.conf['actor-output-bounds']) self.control.update_ref(ref_angle, ref_vel, []) next_state, reward, terminal, info = self.control.control_step( action, self.force, gait_phase) self.ref_motion.index_count() total_reward += reward ob = self.env.getObservation() ob_filtered = self.env.getFilteredObservation() # for l in range(len(ob)): # self.logging.add_run('observation' + str(l), ob[l]) # self.logging.add_run('filtered_observation' + str(l), ob_filtered[l]) self.logging.add_run('action', action) self.logging.add_run('ref_action', ref_angle) joint_angle = self.control.get_joint_angle() self.logging.add_run('joint_angle', joint_angle) readings = self.env.getExtendedReading() # for key, value in readings.items(): # self.logging.add_run(key, value) self.logging.add_run('task_reward', info['task_reward']) self.logging.add_run('imitation_reward', info['imitation_reward']) self.logging.add_run('total_reward', info['total_reward']) # # while 1: # if(time.time()-t)>1.0/self.network_freq: # break if terminal: break self.env._stopLoggingVideo() self.env.stopRendering() clip = ImageSequenceClip(self.image_list, fps=25) clip.write_gif(self.dir_path + '/test.gif') clip.write_videofile(self.dir_path + '/test.mp4', fps=25, audio=False) ave_reward = total_reward / self.config.conf['test-num'] print(ave_reward) self.logging.save_run()
def video_map_images_people(video_or_file, resize=('max2', 400), fps=None, with_times=False, logger=None, dtype=None, class_to_keep=15, fLOG=None, **kwargs): """ Extracts characters from a movie. The movie is composed with an image and a `mask <https://zulko.github.io/moviepy/ref/AudioClip.html?highlight=mask#moviepy.audio.AudioClip.AudioClip.set_ismask>`_. Extrait les personnages d'un film, le résultat est composé d'une image et d'un masque transparent qui laissera apparaître l'image d'en dessous si cette vidéo est aposée sur une autre. @param video_or_file string or :epkg:`VideoClip` @param resize see :meth:`predict <code_beatrix.ai.image_segmentation.DLImageSegmentation.predict>` @param fps see @see fn video_enumerate_frames @param with_times see @see fn video_enumerate_frames @param logger see @see fn video_enumerate_frames @param dtype see @see fn video_enumerate_frames @param class_to_keep class to keep from the image, it can a number (15 for the background, a list of classes, a function which takes an image and the prediction and returns an image) @param fLOG logging function @param kwargs see @see cl DLImageSegmentation @return :epkg:`VideoClip` .. warning:: A couple of errors timeout, out of memory... The following processes might be quite time consuming or memory consuming. If it is the case, you should think of reducing the resolution, the number of frames per seconds (*fps*). You can also split the video and process each piece independently and finally concatenate them. .. exref:: :title: Extract characters from a video. The following example shows how to extract a movie with people and without the background. It works better if the contrast between the characters and the background is high. :: from code_beatrix.art.video import video_extract_video, video_save from code_beatrix.art.videodl import video_map_images vide = video_extract_video("something.mp4", 0, 5) vid2 = video_map_images(vide, fps=10, name="people", logger='bar') video_save(vid2, "people.mp4") The function returns something like the the following. The character is wearing black and the background is quite dark too. That explains that the kind of large halo around the character. .. video:: videodl.mp4 """ if isinstance(class_to_keep, int): def local_mask(img, pred): img[pred != class_to_keep] = 0 return img elif isinstance(class_to_keep, (set, tuple, list)): def local_mask(img, pred): dist = set(pred.ravel()) rem = set(class_to_keep) for cl in dist: if cl not in rem: img[pred == cl] = 0 return img elif callable(class_to_keep): local_mask = class_to_keep else: raise TypeError( "class_to_keep should be an int, a list or a function not {0}". format(type(class_to_keep))) if fLOG: fLOG('[video_map_images_people] loads deep learning model') model = DLImageSegmentation(fLOG=fLOG, **kwargs) iter = video_enumerate_frames(video_or_file, fps=fps, with_times=with_times, logger=logger, dtype=dtype, clean=False) if fLOG is not None: if fps is not None: every = max(fps, 1) unit = 's' else: every = 20 unit = 'i' if fLOG: fLOG('[video_map_images_people] starts extracting characters') seq = [] for i, img in enumerate(iter): if not logger and fLOG is not None and i % every == 0: fLOG('[video_map_images_people] process %d%s images' % (i, unit)) if resize is not None and isinstance(resize[0], str): if len(img.shape) == 2: resize = DLImageSegmentation._new_size(img.shape, resize) else: resize = DLImageSegmentation._new_size(img.shape[:2], resize) img, pred = model.predict(img, resize=resize) img2 = local_mask(img, pred) seq.append(img2) if fLOG: fLOG('[video_map_images_people] done.') return ImageSequenceClip(seq, fps=fps)