def make_video(images, outvid=None, fps=5, size=None, is_color=True, format="XVID"): """ Create a video from a list of images. @param outvid output video @param images list of images to use in the video @param fps frame per second @param size size of each frame @param is_color color @param format see http://www.fourcc.org/codecs.php @return see http://opencv-python-tutroals.readthedocs.org/en/latest/py_tutorials/py_gui/py_video_display/py_video_display.html The function relies on http://opencv-python-tutroals.readthedocs.org/en/latest/. By default, the video will have the size of the first image. It will resize every image to this size before adding them to the video. """ from cv2 import VideoWriter, VideoWriter_fourcc, imread, resize import os fourcc = VideoWriter_fourcc(*format) vid = None for image in images: if not os.path.exists(image): raise FileNotFoundError(image) img = imread(image) if vid is None: if size is None: size = img.shape[1], img.shape[0] vid = VideoWriter(outvid, fourcc, float(fps), size, is_color) if size[0] != img.shape[1] and size[1] != img.shape[0]: img = resize(img, size) vid.write(img) vid.release() return vid
def extract_video(self): import cv2 import numpy as np from cv2 import VideoWriter, VideoWriter_fourcc img_size = self.whole_game[0].shape[:-1] print(img_size) FPS = 10 seconds = 10 fourcc = VideoWriter_fourcc(*'MP42') num_file = len(os.listdir('./outputs')) level_name = 'level_1_map_05' # must change to name of level path_to_save = os.path.join('./outputs', level_name + '.avi') video = VideoWriter(path_to_save, fourcc, float(FPS), img_size) draw = False for i, frame in enumerate(self.whole_game): print("Extract frame {}".format(i)) frame = frame.transpose(1, 0, 2) frame = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR) video.write(frame) if random.randint(0, 100) < 30 and not draw: draw = True cv2.imwrite('map_01.png', frame) video.release() print("Extracted successfully.") print(self.cnt / 60 * 1000, self.score)
def save_vid(filename, image_stack, codec='MJPG', fps=30, **kwargs): """Saves image stack as a video file (better compression than gifs) Args: ----- filename (str): path to savefile image_stack (np.ndarray): image stack in [z/t,x,y,c] format codec (str): opencv fourcc compatible codec, 4 char long str """ fourcc = VideoWriter_fourcc(*codec) out = VideoWriter(filename, fourcc, fps, image_stack.shape[1:3][::-1], **kwargs) # Rescale for video compatible format if not image_stack.dtype is np.uint8: image_stack = ((image_stack - image_stack.min()) / (image_stack.max() - image_stack.min()) * 255).astype('uint8') # image_stack = np.clip(image_stack *255, 0,255).astype('uint8') for i in range(image_stack.shape[0]): if image_stack.shape[-1] == 1: out.write(cvtColor(image_stack[i], COLOR_GRAY2RGB)) elif image_stack.shape[-1] == 3: out.write(image_stack[i]) else: raise ValueError( f"Wrong number of channels for frame, should be 1 or 3, is {image_stack[i].shape[-1]}" ) out.release()
def recreer_video(tab_video): print '--Suppression de bruit ...' # recuperer la table des images en supprimant les images etranges tab_sans_bruit = supprimer_bruit(tab_video) print '--Recherche de premier frame ...' tab_final = trouver_premier_frame(tab_sans_bruit) from cv2 import VideoWriter, imread, resize tab_final = tab_final[::-1] size = None fourcc = cv2.cv.CV_FOURCC(*'XVID') vid = None # recreer le video corriger avec le nom video_corrige.avi for i in range(0, len(tab_final) - 1): k = tab_final[i] img = imread('./frames/frame%d.jpg' % k) if vid is None: if size is None: size = img.shape[1], img.shape[0] vid = VideoWriter('./video_corrige.avi', fourcc, float(25), size, True) if size[0] != img.shape[1] and size[1] != img.shape[0]: img = resize(img, size) vid.write(img) print '*********** Video cree ***************' vid.release()
def video_from_folder(folder, output, fps): ''' builds a video from all the .pngs in a folder IN: folder, output location, frames per second OUT: save location ''' print("GETTING .PNG FROM:\t{}".format(folder)) import os filenames = os.listdir(folder) for fichier in filenames[:]: # filelist[:] makes a copy of filelist. if not (fichier.endswith(".png")): filenames.remove(fichier) from cv2 import VideoWriter, VideoWriter_fourcc, imread, destroyAllWindows print("CREATING VIDEO") fourcc = VideoWriter_fourcc(*'mp4v') vid = None for file in filenames: img = imread("{}/{}".format(folder, file)) # now that we have an image we can setup vid if vid is None: size = img.shape[1], img.shape[0] print("SIZE:\t{}".format(size)) # false for is_color vid = VideoWriter(output, fourcc, float(fps), size) vid.write(img) vid.release() destroyAllWindows() return output
class Processer: def __init__(self, input_file, output_file, FPS=30, max_count=-1): self.vidcap = VideoCapture(input_file) success, self.image = self.vidcap.read() self.width = int(self.vidcap.get(4)) self.height = int(self.vidcap.get(3)) fourcc = VideoWriter_fourcc(*'XVID') self.videoWriter = VideoWriter(output_file, fourcc, float(FPS), (self.height, self.width)) self.max_count = max_count def run(self, proc_func, end_proc=None): count = 0 success = True while success and (count < self.max_count or self.max_count == -1): result = proc_func(self.image, count, self.width, self.height) self.videoWriter.write(result) success, self.image = self.vidcap.read() print('Count:', count) count += 1 if end_proc is not None: end_proc(self.videoWriter) self.videoWriter.release() self.vidcap.release() print('Total count:', count)
def make_video(outvid, images=None, fps=30, size=None, is_color=True, format="FMP4"): """ Create a video from a list of images. @param outvid output video @param images list of images to use in the video @param fps frame per second @param size size of each frame @param is_color color @param format see http://www.fourcc.org/codecs.php @return see http://opencv-python-tutroals.readthedocs.org/en/latest/py_tutorials/py_gui/py_video_display/py_video_display.html The function relies on http://opencv-python-tutroals.readthedocs.org/en/latest/. By default, the video will have the size of the first image. It will resize every image to this size before adding them to the video. """ from cv2 import VideoWriter, VideoWriter_fourcc, imread, resize fourcc = VideoWriter_fourcc(*format) vid = None for image in images: if not os.path.exists(image): raise FileNotFoundError(image) img = imread(image) if vid is None: if size is None: size = img.shape[1], img.shape[0] vid = VideoWriter(outvid, fourcc, float(fps), size, is_color) if size[0] != img.shape[1] and size[1] != img.shape[0]: img = resize(img, size) vid.write(img) vid.release() return vid
def jpg_to_video(char_image_path, FPS): video_fourcc = VideoWriter_fourcc( *"MP42") # 设置视频编码器,这里使用使用MP42编码器,可以生成更小的视频文件 char_img_path_list = [ char_image_path + r'/{}.jpg'.format(i) for i in range(1, number + 1) ] # 生成目标字符图片文件的路径列表 char_img_test = Image.open(char_img_path_list[1]).size # 获取图片的分辨率 if not os.path.exists('video'): os.mkdir('video') video_writter = VideoWriter('video/new_char_video.avi', video_fourcc, FPS, char_img_test) sum = len(char_img_path_list) count = 0 for image_path in char_img_path_list: img = cv2.imread(image_path) video_writter.write(img) end_str = '100%' count = count + 1 process_bar(count / sum, start_str='', end_str=end_str, total_length=15) video_writter.release() print('\n') print('=======================') print('The video is finished!') print('=======================')
def _write_frames_to_videofile(self, filename, path=None): '''Write frames to videofile ''' # Init openCV VideoWriter fourcc = VideoWriter_fourcc(*self.options["codec"]) if path is not None: filename_out = os.path.join( path, '{0}.{1}'.format(filename, self.options["container"])) else: filename_out = './{0}.{1}'.format(filename, self.options["container"]) # print(filename_out) video = VideoWriter( filename_out, fourcc, float(self.options["fps"]), (self.options["image_width"], self.options["image_height"]), isColor=False ) # path, codec, fps, size. Note, the isColor the flag is currently supported on Windows only # Write frames to videofile frame-by-frame for index in np.arange(self.frames.shape[2]): video.write(self.frames[:, :, index]) video.release()
def create_video(radio: Radio): if not os.path.exists(Video.output_dir): print("Folder", Video.output_dir, 'does not exist. Creating...') os.makedirs(Video.output_dir) video = VideoWriter(Video.output_dir + os.sep + str(radio.radio_id) + '_temp.mp4', Video.fourcc, Video.fps, (Video.width, Video.height)) clip_count = len(radio.timestamps) - 1 for i in range(clip_count): if (radio.timestamps[i] not in radio.timeline.keys()): print(radio.timestamps[i], "has no corresponding image, load cover as backup") frame = Frame.create_cover(radio) else: frame = Frame.create_page(radio.timeline[radio.timestamps[i]], radio) frame_count = (radio.timestamps[i + 1] - radio.timestamps[i]) * Video.fps for j in range(frame_count): video.write(frame) video.release() video_clip = VideoFileClip(Video.output_dir + os.sep + str(radio.radio_id) + '_temp.mp4') print(video_clip.duration) audio_clip = AudioFileClip(os.sep.join(['.', 'cache', str(radio.radio_id), 'audio', radio.audio.local_name])) video_clip.audio = audio_clip if config['test']: video_clip = video_clip.subclip(0, min(200, video_clip.duration)) video_clip.write_videofile(Video.output_dir +os.sep+ str(radio.radio_id)+" "+radio.title +".mp4", fps=Video.fps) print("{} finished!".format(radio.title)) os.remove(Video.output_dir+os.sep+str(radio.radio_id)+'_temp.mp4')
def photo2video(videoName='./cache/output.mp4', fps=25, imgs='./cache/output_img'): '''将图片转换为视频,图片读取路径./cache/output_img.mp4,视频默认写入路径./movie/output.mp4,待合成图片默认文件夹路径./cache/output_img INPUTS videoName 视频写入路径 fps 视频帧率 imgs 待合成图片文件夹路径 OUTPUTS None ''' #获取图像分辨率 img = cv2.imread(imgs + '/1.jpg') sp = img.shape height = sp[0] width = sp[1] size = (width, height) fourcc = VideoWriter_fourcc(*'mp4v') videoWriter = VideoWriter(videoName, fourcc, fps, size) photos = os.listdir(imgs) for photo in range(len(photos)): frame = cv2.imread(imgs + '/' + str(photo) + '.jpg') videoWriter.write(frame) videoWriter.release() #合成新生成的视频和音频 if (os.path.exists('./movie/output.mkv')): os.remove('./movie/output.mkv') command = 'ffmpeg -i ./movie/output.mp4 -i ./cache/audio/audio.wav -c copy ./movie/output.mkv' subprocess.call(command, shell=True, stdout=open('/dev/null', 'w'), stderr=subprocess.STDOUT) #os.remove('./cache/output.mp4') print('[*] 生成视频成功,路径为./cache/output.mkv')
def move_image_on_background(pattern, background): ''' The function creates a video of the pattern moving horizontally over a given background Parameters: ----------- pattern: <np.array, 35x35> The pattern supposed to move over the background background: <np.array, 260x346> A white background of the given size ''' fourcc = VideoWriter_fourcc(*'HFYU') video = VideoWriter('./videos/moving_pattern_for_sampling_exp.avi', fourcc, 30, (346, 260)) background[112:147, 0:35] = pattern frame = background count = 0 for _ in range(0, 346-34): cv2.imwrite("video_images/frame%04d.png" % count, cv2.cvtColor(frame,cv2.COLOR_GRAY2RGB)) video.write(cv2.cvtColor(frame,cv2.COLOR_GRAY2RGB)) shifted_frame = np.roll(frame, 1, axis=1) frame = shifted_frame video.write(frame) count+=1 cv2.destroyAllWindows() video.release()
def make_video(images, outvid=None, fps=30, size=None, is_color=True, format="x264"): # install on ubuntu: # sudo apt-get install ffmpeg x264 libx264-dev """ Create a video from a list of images. @param outvid output video @param images list of images to use in the video @param fps frame per second @param size size of each frame @param is_color color @param format see http://www.fourcc.org/codecs.php @return see http://opencv-python-tutroals.readthedocs.org/en/latest/py_tutorials/py_gui/py_video_display/py_video_display.html The function relies on http://opencv-python-tutroals.readthedocs.org/en/latest/. By default, the video will have the size of the first image. It will resize every image to this size before adding them to the video. """ fourcc = VideoWriter_fourcc(*format) vid = None for img in images: if vid is None: if size is None: size = img.shape[1], img.shape[0] vid = VideoWriter(outvid, fourcc, float(fps), size) if size[0] != img.shape[1] and size[1] != img.shape[0]: img = resize(img, size) img_ = cv2.cvtColor(img, cv2.COLOR_RGB2BGR) vid.write(img_) vid.release() cv2.destroyAllWindows() return vid
def make_video(photos_path, video_path, video_name): cap = VideoCapture(v_path) fps = cap.get(CAP_PROP_FPS) cap.release() mkdir(video_path) images_cnt = jpgcount(photos_path) print(f'{images_cnt} imagenes') img = [] # Cargar las imágenes for i in range(images_cnt): img.append(imread(photos_path + '/frame' + str(i) + '.jpg')) height, width, _ = img[1].shape # Inicializar el video video = VideoWriter(video_path + '/' + video_name + '.mp4', VideoWriter_fourcc(*'MP4V'), fps, (width, height)) print('Codificando video') # Insertar cada imagen for j in range(images_cnt): video.write(img[j]) # Cerrar proceso destroyAllWindows() video.release() print('Video Codificado')
def build_video_from_files(directory: str, filename: str, fps: int, size: tuple=None, is_color: bool=True, format: str="XVID"): """ Create a video from a folder of images, sorted by filename. By default, the video will have the size of the first image. It will resize every image to this size before adding them to the video. :param directory: path to files :param filename: name of video :param fps: frames per second :param size: video dimensions :param is_color: colour video :param format: see http://www.fourcc.org/codecs.php :return: http://opencv-python-tutroals.readthedocs.org/en/latest/py_tutorials/py_gui/py_video_display/py_video_display.html """ fourcc = VideoWriter_fourcc(*format) vid = None for file in sorted(os.listdir(directory)): if not os.path.exists(file): raise FileNotFoundError(file) image = imread(file) if vid is None: if size is None: size = image.shape[1], image.shape[0] vid = VideoWriter(filename, fourcc, fps, size, is_color) try: if size[0] != image.shape[1] and size[1] != image.shape[0]: image = resize(image, size) except AttributeError: print(file) vid.write(image) vid.release() return vid
def generate_vid(dir_path, vid_format='XVID', outvid=None, fps=25, size=None, is_color=True): from cv2 import VideoWriter, VideoWriter_fourcc, imread, resize fourcc = VideoWriter_fourcc(*vid_format) # out = cv2.VideoWriter(video_name, fourcc, 20.0, (640,480)) vid = None images = [str(p) for p in pathlib.Path(dir_path).iterdir()] natural_sort(images) for image in images: if not os.path.exists(image): raise Exception('Image path does not exist: %s' % image) img = imread(image) if vid is None: if size is None: size = img.shape[1], img.shape[0] vid = VideoWriter(outvid, fourcc, float(fps), size, is_color) if size[0] != img.shape[1] and size[1] != img.shape[0]: img = resize(img, size) vid.write(img) vid.release() return vid
def make_video(images, outvid=None, fps=5, size=None, is_color=True, format="XVID"): """ Create a video from a list of images. @param outvid output video @param images list of images to use in the video @param fps frame per second @param size size of each frame @param is_color color @param format see http://www.fourcc.org/codecs.php """ # fourcc = VideoWriter_fourcc(*format) # For opencv2 and opencv3: if int(cv2.__version__[0]) > 2: fourcc = cv2.VideoWriter_fourcc(*format) else: fourcc = cv2.cv.CV_FOURCC(*format) vid = None for image in images: assert os.path.exists(image) img = imread(image) if vid is None: if size is None: size = img.shape[1], img.shape[0] vid = VideoWriter(outvid, fourcc, float(fps), size, is_color) if size[0] != img.shape[1] and size[1] != img.shape[0]: img = resize(img, size) vid.write(img) vid.release()
async def make_video_and_upload(self): outvid = self.OUTPUT_VIDEO_NAME fps = 24; size = (320, 240); is_color = 1; fourcc = VideoWriter_fourcc(*'XVID') vid = None images = [] for i in range(0, self.max_count): images.append(self.VIDEO_IMAGES_FOLDER_NAME+"/image" + str(i) + ".jpg") for image in images: if not os.path.exists(image): raise FileNotFoundError(image) img = imread(image) if vid is None: if size is None: size = img.shape[1], img.shape[0] vid = VideoWriter(outvid, fourcc, float(fps), size, is_color) if size[0] != img.shape[1] and size[1] != img.shape[0]: img = resize(img, size) vid.write(img) vid.release() self.insta.uploadVideo("video.avi", thumbnail=self.OUTPUT_IMAGE_NAME, caption="#memorieswithcozmo");
def draw_speed(video_path: str, speed_path: str, output_video: str) -> None: reader = VideoCapture(video_path) writer = VideoWriter( output_video, VideoWriter_fourcc(*"mp4v"), 20, (640, 480), ) data = loadtxt(speed_path, delimiter="\n", dtype="float32") frame_id = 0 while reader.isOpened(): ret, frame = reader.read() if not ret: break putText( frame, f"{data[frame_id]:0.3f}", (250, 420), FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2, ) writer.write(frame) frame_id += 1 if frame_id == data.shape[0]: break reader.release() writer.release()
def make_video(outvid, images=None, fps=30, size=None, is_color=True, format="AVC1"): """ Create a video from a list of images. @param outvid output video @param images list of images to use in the video @param fps frame per second @param size size of each frame @param is_color color @param format see http://www.fourcc.org/codecs.php @return see http://opencv-python-tutroals.readthedocs.org/en/latest/py_tutorials/py_gui/py_video_display/py_video_display.html """ from cv2 import VideoWriter, VideoWriter_fourcc, imread, resize fourcc = VideoWriter_fourcc(*format) vid = None print('len(images):', len(images)) for image in images: if not os.path.exists(image): raise FileNotFoundError(image) img = imread(image) if vid is None: if size is None: size = img.shape[1], img.shape[0] vid = VideoWriter(outvid, fourcc, float(fps), size, is_color) if size[0] != img.shape[1] and size[1] != img.shape[0]: img = resize(img, size) vid.write(img) vid.release() return vid
class VideoOutput(): def __init__(self, opt): self.out_dir = os.path.join(opt.results_dir, opt.name, '%s_%s' % (opt.phase, opt.epoch)) self.out_file = os.path.join(self.out_dir, opt.name + opt.phase + ".avi") self.writer = None if (os.path.exists(self.out_file)): os.remove(self.out_file) def writeFrame(self, visuals): i = 0 for label, im_data in visuals.items(): im = util.tensor2im(im_data) #.transpose(2,1,0) if (i == 0): display = im else: display = np.concatenate((display, im), axis=1) i += 1 #print(display.shape) if (self.writer == None): dims = display.shape[1], display.shape[0] self.writer = VideoWriter(self.out_file, VideoWriter_fourcc(*"XVID"), 30.0, dims, True) self.writer.write(cv2.cvtColor(display, cv2.COLOR_RGB2BGR)) def close(self): self.writer.release()
def mri2vid(mri_data, dir_file, filename_no_ext, n_width, n_height, FramesPerSec): print(filename_no_ext + ' - MRI video started') output_file_no_ext = dir_file + filename_no_ext n_frames = len(mri_data) # compressed # fourcc = VideoWriter_fourcc(*'MP4V') # uncompressed 8-bit fourcc = VideoWriter_fourcc(*'Y800') video = VideoWriter(output_file_no_ext + '.avi', fourcc, float(FramesPerSec), (n_width, n_height), 0) for n in range(n_frames): frame = np.uint8(255 * mri_data[n]).reshape(n_width, n_height, 1) video.write(frame) print('frame ', n, ' done', end='\r') video.release() print(filename_no_ext + ' - MRI video finished')
class Writer(WriterBase): def __init__(self, file: str, fourcc: Union[int, str, Iterable[str]], fps: float, frame_size: Tuple[int, int], is_color: bool = True, *args, **kwargs): super(Writer, self).__init__(file, args, kwargs) self._fourcc: int = _fourcc(fourcc) self._fps: float = fps self._frame_size: Tuple[int, int] = frame_size self._is_color: bool = is_color self._stream: Optional[VideoWriter] = None def write_frame(self, frame: np.ndarray) -> None: self._stream.write(frame) self._position += 1 def open(self, file: str = "", *args, **kwargs) -> None: if not self.closed: self.close() if file: self._file = file self._stream = VideoWriter(self._file, self._fourcc, self._fps, self._frame_size, self._is_color) self._closed = False def close(self) -> None: if not self.closed: self._stream.release() self._initialize_property()
def videoconvert(inp): capture = VideoCapture(inp) inp_ext = inp.split(".") fpsin = capture.get(CAP_PROP_FPS) count = 0 success = 1 while success: success, image = capture.read() if (success == False and image == None): pass else: imwrite("zzimg%d.jpg" % count, image) count += 1 outfile = inp_ext[0] + '_output.mp4' fourcc = VideoWriter_fourcc(*'DIVX') fpsout = fpsin img = imread("zzimg0.jpg") height, width, layers = img.shape size = (width, height) out = VideoWriter(outfile, fourcc, fpsout, size, 0) for i in range(count): img = imread("zzimg%d.jpg" % i, 0) out.write(img) print( "Video Converted to Grayscale, Please check the folder for the output file: ", outfile) out.release() capture.release() return outfile
def save_out(output_path, out_matrix): out = VideoWriter(output_path, VideoWriter_fourcc(*'mp4v'), fps, (out_matrix.shape[2], out_matrix.shape[1])) for frame in out_matrix: out.write(frame) out.release()
def convert_frames_to_video(self, frame_array, debug_frame_array): """ Takes list of frames and converts them to a video Parameters ---------- frame_array : [] Frames to be converted. """ height, width, layers = frame_array[0].shape size = (width, height) date = time.strftime("%c") date = time.strftime("%Y-%m-%d %H:%M") path_out = str(date) + '_' + str(self.count) path_out = path_out.replace(" ", "_") path_out = path_out.replace(":", "") print(path_out) self.count += 1 out = VideoWriter(path_out + '.avi', VideoWriter_fourcc('M', 'J', 'P', 'G'), self.fps, size) for i in range(len(frame_array)): out.write(frame_array[i]) out.release() path_out = "debug-" + path_out + '_' + str(self.confidence) out = VideoWriter(path_out + '.avi', VideoWriter_fourcc('M', 'J', 'P', 'G'), self.fps, size) for i in range(len(debug_frame_array)): out.write(debug_frame_array[i]) out.release() self.trigger = False
def images_to_video(filenames, output, fps): ''' builds a video from a list of images IN: list of filenames for images, where to output, , frames per second OUT: filename for output video ''' from cv2 import VideoWriter, VideoWriter_fourcc, imread, destroyAllWindows print("CREATING VIDEO") fourcc = VideoWriter_fourcc(*'mp4v') vid = None for file in filenames: img = imread(file) # now that we have an image we can setup vid if vid is None: size = img.shape[1], img.shape[0] print("SIZE:\t{}".format(size)) # false for is_color vid = VideoWriter(output, fourcc, float(fps), size) vid.write(img) vid.release() destroyAllWindows() return output
def makeanimation(): from cv2 import VideoWriter, VideoWriter_fourcc import glob # get width, heigth, frames f = open("./frames/0.ppm", "r") line0 = f.readline() line1 = f.readline().split(" ") width, height = int(line1[0]), int(line1[1]) frames = len(glob.glob("./frames/*.ppm")) FPS = 60 fourcc = VideoWriter_fourcc(*'mp4v') video = VideoWriter('./fractal.mp4', fourcc, float(FPS), (width, height)) frame = np.zeros((height, width, 3), dtype=np.uint8) for i in range(frames): f = open(f"./frames/{i}.ppm", "r") line0 = f.readline() line1 = f.readline() for x in range(height): for y in range(width): c = float(f.readline().split(" ")[0])%256 frame[x, y] = [c, c, c] video.write(frame) print(f"Writing frame {i}") video.release() print("done")
def make_video(subs, outimg=None, fps=30, size=None, is_color=True, format="XVID"): fourcc = VideoWriter_fourcc(*format) vid = None total_frames=0 subslist = [{"content":s.text, "start":to_deltatime(s.start), "end": to_deltatime(s.end)} for s in subs if len(s.text.strip()) >0] for (i, sub) in enumerate(subslist): image = paths[0][format_text(sub["content"])][0] if not os.path.exists(image): raise FileNotFoundError(image) img = imread(image) if vid is None: if size is None: size = img.shape[1], img.shape[0] vid = VideoWriter('video.mp4', fourcc, float(fps), size, is_color) if size[0] != img.shape[1] and size[1] != img.shape[0]: img = resize(img, size) print(sub) if len(subslist) == i + 1: frames = int(sub["end"].total_seconds()*fps - total_frames) else: frames = int(subslist[i+1]["start"].total_seconds()*fps - total_frames) total_frames = frames + total_frames for i in range(frames): vid.write(img) vid.release() return vid
class Video_writer(): def __init__(self, videosource, fps, width, height, result): print("Initializing video writer.") self.audiofile = "tempaudio.mp3" self.videosource = videosource self.tempresult = "tempres.avi" try: if path.exists(self.tempresult): remove(self.tempresult) except WindowsError: print "Tempresult is being used" self.result = result fourcc = VideoWriter_fourcc(*'XVID') self.out = VideoWriter(self.tempresult, fourcc, fps, (int(width), int(height))) def get_audio_clip(self): if path.exists(self.audiofile): remove(self.audiofile) mv.ffmpeg_extract_audio(self.videosource, self.audiofile) return def merge_audio_video(self): print("Merging audio and video.") self.get_audio_clip() mv.ffmpeg_merge_video_audio(self.tempresult, self.audiofile, self.result) remove(self.audiofile) def write_frame(self, frame): # test # if not self.start: # self.start_window() #self.frame.DisplayNext(frame) #self.img.set_img(frame) #test #cv2.imshow('prototype',frame) self.out.write(frame) def finish_video(self, sound=True): print("Finishing video.") self.out.release() if sound: try: self.merge_audio_video() except: shutil.copy2(self.tempresult, self.result) else: shutil.copy2(self.tempresult, self.result) remove(self.tempresult) def quit(self): print("Quiting.") self.out.release() if path.exists(self.audiofile): remove(self.audiofile) if path.exists(self.tempresult): remove(self.tempresult)
def video_maker(images, outimg=None, fps=24, size=None, is_color=True, format="mp4v"): global overallTimeElapsed print("Overall Encryption time: %.2f" % overallTimeElapsed) fourcc = VideoWriter_fourcc(*format) vid = None outvid = './dirty_video.mp4' for image in images: if not os.path.exists(image): raise FileNotFoundError(image) img = imread(image) if vid is None: if size is None: size = img.shape[1], img.shape[0] vid = VideoWriter(outvid, fourcc, float(fps), size, is_color) if size[0] != img.shape[1] and size[1] != img.shape[0]: img = resize(img, size) vid.write(img) vid.release() print('Video Encrypted.') return vid
def make_video(images, output_path, fps=0.5, size=(640, 480), is_color=True): """ Create a video from a list of images. """ fourcc = VideoWriter_fourcc(*"XVID") vid = VideoWriter(output_path, fourcc, fps, size, is_color) for image in images: img = imread(image) vid.write(img) vid.release() return
class CV_Writer(object): """docstring for CV_Writer""" def __init__(self, file_loc,frame_rate,frame_size): super(CV_Writer, self).__init__() self.writer = VideoWriter(file_loc, VideoWriter_fourcc(*'DIVX'), float(frame_rate), frame_size) def write_video_frame(self, input_frame): self.writer.write(input_frame.img) def write_video_frame_yuv422(self, input_frame): raise NotImplementedError def release(self): self.writer.release()
def make_video(images, outvid=None, fps=5, size=None, is_color=True, format="XVID"): """ Creates a video from a list of images. @param outvid output video @param images list of images to use in the video @param fps frames per second @param size size of each frame @param is_color color @param format see `fourcc <http://www.fourcc.org/codecs.php>`_ @return `VideoWriter <http://opencv-python-tutroals.readthedocs.org/en/latest/py_tutorials/ py_gui/py_video_display/py_video_display.html>`_ The function relies on `opencv <http://opencv-python-tutroals.readthedocs.org/en/latest/>`_. By default, the video will have the size of the first image. It will resize every image to this size before adding them to the video. The function does not use :epkg:`moviepy` but it is a a recommended module to do that. """ if len(images) == 0: raise ValueError("no image to convert into a video") from cv2 import VideoWriter, VideoWriter_fourcc, imread, resize # pylint: disable=E0401 fourcc = VideoWriter_fourcc(*format) vid = None for image in images: if not os.path.exists(image): raise FileNotFoundError(image) img = imread(image) if vid is None: if size is None: size = img.shape[1], img.shape[0] vid = VideoWriter(outvid, fourcc, float(fps), size, is_color) if size[0] != img.shape[1] and size[1] != img.shape[0]: img = resize(img, size) vid.write(img) vid.release() return vid
def captureTStamp(files, duration, cod, fps=0, verbose=True): ''' guarda por un tiempo en minutos (duration) el video levantado desde la direccion indicada en el archvo indicado. tambíen archivos con los time stamps de cada frame. files = [ur, saveVideoFile, saveDateFile, saveMillisecondFile] duration = time in mintes cod = codec fps = frames per second for video to be saved verbose = print messages to screen si fpscam=0 trata de llerlo de la captura. para fe hay que especificarla para opencv '2.4.9.1' Examples -------- from cameraUtils import captureTStamp # para la FE duration = 1 # in minutes files = ['rtsp://192.168.1.48/live.sdp', "/home/alumno/Documentos/sebaPhDdatos/vca_test_video.avi", "/home/alumno/Documentos/sebaPhDdatos/vca_test_tsFrame.txt"] fpsCam = 12 cod = 'XVID' captureTStamp(files, duration, cod, fps=fpsCam) # %% para la PTZ duration = 0.2 # in minutes files = ["rtsp://192.168.1.49/live.sdp", "/home/alumno/Documentos/sebaPhDdatos/ptz_test_video.avi", "/home/alumno/Documentos/sebaPhDdatos/ptz_test_tsFrame.txt"] fpsCam = 20 cod = 'XVID' captureTStamp(files, duration, cod, fpsCam) ''' fcc = fourcc(cod[0],cod[1],cod[2],cod[3]) # Códec de video if verbose: print(files) print("Duration",duration,"minutes") print("fps",fps) print("codec",cod) # Inicializacion tFin = datetime.datetime.now() + datetime.timedelta(minutes=duration) ts = list() # timestamp de la captura # abrir captura cap = VideoCapture(files[0]) while not cap.isOpened(): cap = VideoCapture(files[0]) print("capture opened") # configurar writer w = int(cap.get(frame_width)) h = int(cap.get(frame_height)) if not fps: fps = cap.get(prop_fps) #para fe especificar los fps pq toma cualquier cosa con la propiedad out = VideoWriter(files[1], fcc, fps,( w, h), True) if verbose: print("capture open",cap.isOpened()) print("frame size",w,h) print("output opened",out.isOpened()) if not out.isOpened() or not cap.isOpened(): out.release() cap.release() # exit function if unable to open cap or out return s0 = getsize(files[1]) # initial filesize before writing frame # Primera captura ret, frame = cap.read() if ret: t = datetime.datetime.now() ts.append(t) out.write(frame) if verbose: print("first frame captured") # Segunda captura ret, frame = cap.read() if ret: t = datetime.datetime.now() ts.append(t) out.write(frame) if verbose: print("second frame captured") # Tercera captura ret, frame = cap.read() if ret: t = datetime.datetime.now() ts.append(t) out.write(frame) if verbose: print("third frame captured") s1 = getsize(files[1]) # size after saving 3 frames if s1==s0: out.release() cap.release() print("error when saving 3 frames, exiting") return 1 # error while saving first frame to file print(tFin) # loop while (t <= tFin): ret, frame = cap.read() if ret: t = datetime.datetime.now() ts.append(t) out.write(frame) if verbose: print(tFin,t) print("seconds elapsed",cap.get(pos_msec)/1000) print(frame.size) # end of loop # release and save out.release() cap.release() if verbose: print('loop exited, cap, out released, times saved to files') savetxt(files[2],ts, fmt= ["%s"]) return 0 # success
def run(self, show=False, save=False, tk_var_frame=None): if show: namedWindow('Movie') namedWindow('Tracking') if save: bgs = np.shape(self.background) fsize = (bgs[0], bgs[1]*2) writer = VideoWriter() writer.open(os.path.join(self.trial_dir,'%s_tracking_movie'%self.trial_name),self.fourcc,37.,frameSize=(fsize[1],fsize[0]),isColor=True) self.results['n_frames'] = 0 consecutive_skips = 0 while True: valid,frame = self.get_frame(self.mov,skip=self.resample-1) if not valid: break diff = absdiff(frame,self.background) _, diff = threshold(diff, self.diff_thresh, 1, THRESH_BINARY) diff = diff*self.rooms_mask edges = Canny(diff.astype(np.uint8), self.cth1, self.cth2) contours, hier = findContours(edges, RETR_EXTERNAL, CHAIN_APPROX_TC89_L1) contours = [c for c in contours if not any([pa.contains_point(contour_center(c)) for pa in self.paths_ignore])] if consecutive_skips>self.consecutive_skip_threshold: consecutive_skips=0 possible = contours else: possible = [c for c in contours if dist(contour_center(c),self.last_center)<self.translation_max] if len(possible) == 0: center = self.last_center self.results['skipped'] += 1 consecutive_skips+=1 if self.path_l.contains_point(center): self.results['left_assumed']+=1 if self.path_r.contains_point(center): self.results['right_assumed']+=1 if self.path_c.contains_point(center): self.results['middle_assumed']+=1 else: chosen = possible[np.argmax([contourArea(c) for c in possible])] center = contour_center(chosen) self.results['centers'].append(center) self.results['heat'][center[1],center[0]] += 1 if self.path_l.contains_point(center): self.results['left']+=1 if self.path_r.contains_point(center): self.results['right']+=1 if self.path_c.contains_point(center): self.results['middle']+=1 self.results['centers_all'].append(center) #display if show or save: showimg = np.copy(frame).astype(np.uint8) if self.path_l.contains_point(center): color = (0,0,0) elif self.path_r.contains_point(center): color = (255,255,255) else: color = (120,120,120) circle(showimg, tuple(center), radius=10, thickness=5, color=color) if show: cv2imshow('Movie',showimg) cv2imshow('Tracking', diff) waitKey(1) #/display if save: save_frame = np.zeros([fsize[0], fsize[1], 3],dtype=np.uint8) save_frame[:,:np.shape(frame)[1]] = cvtColor(showimg.astype(np.float32), CV_GRAY2RGB) save_frame[:,np.shape(frame)[1]:] = cvtColor((diff*255).astype(np.float32), CV_GRAY2RGB) writer.write(save_frame) self.results['n_frames'] += 1 self.last_center = center if tk_var_frame != None: tk_var_frame[0].set('%i/%i'%(self.results['n_frames'], len(self.time)/float(self.resample) )) tk_var_frame[1].update() #pbar.update(self.results['n_frames']) #pbar.finish() if save: writer.release() self.end()
def run(self, show=False, save=False, tk_var_frame=None, wait=1, start_pos='none'): #interfaces if show or save: fsize = (self.width*2, self.height) save_frame = np.zeros([self.height, self.width*2, 3], dtype=np.uint8) if show: namedWindow('Tracking') if save: writer = VideoWriter() writer.open(self.fh.make_path('tracking.avi'),self.fourcc,round(self.fs),frameSize=fsize,isColor=True) #run self.framei = 0 self.pos = [] self.t = [] self.guess = [] self.contour = [] self.pct_xadj = [] self.heat = np.zeros((self.height,self.width)) consecutive_skips = 0 if start_pos == 'x': start_pts = [self.xori_adj, self.xoli_adj] elif start_pos == 'y': start_pts = [self.yori_adj, self.yoli_adj] elif start_pos == 'z': start_pts = [self.zori_adj, self.zoli_adj] elif start_pos == 'c': start_pts = [self.zori, self.xori, self.yori] elif start_pos == 'none': start_pts = [self.zori, self.xori, self.yori] consecutive_skips = self.consecutive_skip_threshold+1 self.last_center = np.mean(self.pts[np.array(start_pts)],axis=0).astype(int) self.last_contour = np.array([self.last_center]) valid,frame,ts = self.get_frame(self.mov,skip=self.resample-1) while valid: possible,diff_raw = self.find_possible_contours(frame,consecutive_skips) self.pct_xadj.append(np.mean( diff_raw[self.xadj_idxs[:,0],self.xadj_idxs[:,1]])) if len(possible) == 0: center = self.last_center contour = self.last_contour self.guess.append(True) consecutive_skips+=1 else: contour,center = self.choose_best_contour(possible) self.guess.append(False) consecutive_skips = 0 self.pos.append(center) self.contour.append(contour) self.t.append(ts) self.heat[center[1],center[0]] += 1 if show or save: lframe = self.label_frame(frame, center) save_frame[:,:self.width, :] = cvtColor(lframe.astype(np.float32), CV_GRAY2RGB) save_frame[:,self.width:, :] = cvtColor((self.diff*255).astype(np.float32), CV_GRAY2RGB) if show: self.show_frame(save_frame, wait=wait) if save: writer.write(save_frame) self.last_center = center self.last_contour = contour valid,frame,ts = self.get_frame(self.mov,skip=self.resample-1) if tk_var_frame != None: tk_var_frame[0].set('%i/%i'%(self.results['n_frames'], len(self.time)/float(self.resample) )) tk_var_frame[1].update() if save: writer.release() self.end()