def main():
parser = argparse.ArgumentParser(description='Create driving video.')
parser.add_argument(
'image_folder',
type=str,
default='',
help=
'Path to image folder. The video will be created from these images.')
parser.add_argument('--fps',
type=int,
default=60,
help='FPS (Frames per second) setting for the video.')
parser.add_argument('--processed',
action='store_true',
help='Transform the image back to the model space.')
args = parser.parse_args()
video_file = args.image_folder + '.mp4'
print("Creating video {}, FPS={}".format(video_file, args.fps))
clip = ImageSequenceClip(args.image_folder, fps=args.fps)
if args.processed:
def tmp(im):
processed = utils.process_image(im)
processed = cv2.cvtColor(processed, color_space['src'])
return np.hstack((im, processed))
clip = clip.fl_image(tmp)
clip.write_videofile(video_file)
def main():
parser = argparse.ArgumentParser(description='Create driving video.')
parser.add_argument(
'image_folder',
type=str,
default='',
help='Path to image folder. The video will be created from these images.'
)
parser.add_argument(
'--fps',
type=int,
default=60,
help='FPS (Frames per second) setting for the video.')
args = parser.parse_args()
# convert file folder into list firltered for image file types
image_list = sorted([os.path.join(args.image_folder, image_file)
for image_file in os.listdir(args.image_folder)])
image_list = [image_file for image_file in image_list if os.path.splitext(
image_file)[1][1:].lower() in IMAGE_EXT]
# two methods of naming output video to handle varying environemnts
video_file_1 = args.image_folder + '.mp4'
video_file_2 = args.image_folder + 'output_video.mp4'
print("Creating video {}, FPS={}".format(args.image_folder, args.fps))
clip = ImageSequenceClip(image_list, fps=args.fps)
try:
clip.write_videofile(video_file_1)
except:
clip.write_videofile(video_file_2)
def CreateGif(filename, array, fps=5, scale=1., fmt='gif'):
''' Create and save a gif or video from array of images.
Parameters:
* filename (string): name of the saved video
* array (list or string): array of images name already in order, if string it supposed to be the first part of the images name (before iteration integer)
* fps = 5 (integer): frame per seconds (limit human eye ~ 15)
* scale = 1. (float): ratio factor to scale image hight and width
* fmt (string): file extention of the gif/video (e.g: 'gif', 'mp4' or 'avi')
Return:
* moviepy clip object
'''
if (isinstance(array, str)):
arrsize = len(gb.glob(array + '*.png'))
array = [array + str(i) + '.png' for i in range(arrsize)]
else:
pass
from moviepy.editor import ImageSequenceClip
filename += '.' + fmt
clip = ImageSequenceClip(list(array), fps=fps).resize(scale)
if (fmt == 'gif'):
clip.write_gif(filename, fps=fps)
elif (fmt == 'mp4'):
clip.write_videofile(filename, fps=fps, codec='mpeg4')
elif (fmt == 'avi'):
clip.write_videofile(filename, fps=fps, codec='png')
else:
print('Error! Wrong File extension.')
sys.exit()
command = os.popen('du -sh %s' % filename)
print(command.read())
return clip
def main():
parser = argparse.ArgumentParser(description='创建驾驶视频.')
parser.add_argument('image_folder',
type=str,
default='',
help='图像文件夹的路径。将从这些图像创建视频.')
parser.add_argument('--fps',
type=int,
default=60,
help='FPS (Frames per second) setting for the video.')
args = parser.parse_args()
# 将文件文件夹转换为图像文件类型的列表
image_list = sorted([
os.path.join(args.image_folder, image_file)
for image_file in os.listdir(args.image_folder)
])
image_list = [
image_file for image_file in image_list
if os.path.splitext(image_file)[1][1:].lower() in IMAGE_EXT
]
# 两种处理不同环境的输出视频命名方法
video_file_1 = args.image_folder + '.mp4'
video_file_2 = args.image_folder + 'output_video.mp4'
print("创建视频文件 {}, FPS={}".format(args.image_folder, args.fps))
clip = ImageSequenceClip(image_list, fps=args.fps)
try:
clip.write_videofile(video_file_1)
except:
clip.write_videofile(video_file_2)
def movie(filename: str, array: np.ndarray, fps: int = 10, scale: float = 1.0):
"""
Create a mp4 movie file from a 3D numpy array
>>> import numpy as np
>>> X = np.random.randn(100, 64, 64)
>>> movie('test.mp4', X)
:param filename: The filename of the gif to write to
:param array: A numpy array that contains a sequence of images
:param fps: frames per second (default: 10)
:param scale: how much to rescale each image by (default: 1.0)
Inspired in https://gist.github.com/nirum/d4224ad3cd0d71bfef6eba8f3d6ffd59
"""
# ensure that the file has the .gif extension
basename, _ = os.path.splitext(filename)
filename = basename + '.mp4'
# 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).resize(scale)
clip.write_videofile(filename, fps=fps)
return clip
def run(self):
# Set up video capture
left_video = cv2.VideoCapture(0) #eo_in_path)
right_video = cv2.VideoCapture(1) #self.right_video_in_path)
print('[INFO]: {} and {} loaded'.format(
self.left_video_in_path.split('/')[-1],
self.right_video_in_path.split('/')[-1]))
print('[INFO]: Video stitching starting....')
# Get information about the videos
n_frames = min(int(left_video.get(cv2.CAP_PROP_FRAME_COUNT)),
int(right_video.get(cv2.CAP_PROP_FRAME_COUNT)))
fps = int(left_video.get(cv2.CAP_PROP_FPS))
frames = []
# for _ in tqdm.tqdm(np.arange(n_frames)):
while True:
# Grab the frames from their respective video streams
ok, left = left_video.read()
_, right = right_video.read()
if ok:
cv2.imshow("a", left)
cv2.imshow("b", right)
# Stitch the frames together to form the panorama
stitched_frame = self.stitch([left, right])
# No homography could not be computed
if stitched_frame is None:
print("[INFO]: Homography could not be computed!")
break
# Add frame to video
# stitched_frame = imutils.resize(stitched_frame, width=self.video_out_width)
# stitched_frame = cv2.resize(stitched_frame, (self.video_out_width,self.video_out_width))
frames.append(stitched_frame)
if self.display:
# Show the output images
cv2.imshow("Result", stitched_frame)
# If the 'q' key was pressed, break from the loop
if cv2.waitKey(1) & 0xFF == ord("q"):
break
cv2.destroyAllWindows()
print('[INFO]: Video stitching finished')
# Save video
print('[INFO]: Saving {} in {}'.format(
self.video_out_path.split('/')[-1],
os.path.dirname(self.video_out_path)))
clip = ImageSequenceClip(frames, fps=fps)
clip.write_videofile(self.video_out_path,
codec='mpeg4',
audio=False,
progress_bar=True,
verbose=False)
print('[INFO]: {} saved'.format(self.video_out_path.split('/')[-1]))
def make_gif_of_traj(filename, output_filename, raw=True, fps=5):
file = dd.io.load(filename)
traj_len = len(file)
print(f'trajectory length is {traj_len}')
traj_images = []
a = attrdict.AttrDict({'mean': 0, 'scale': 1})
for i in range(1, traj_len):
data = file[i]
act = obs_to_action(data, file[i - 1], a)
sorted_act = sorted(act, key=np.abs)
if np.abs(sorted_act[0]) == 0 and sorted_act[1] == 0:
print('alert alert')
print(act)
fig, axs = plot_images(data, raw=raw)
fig.canvas.draw()
image = np.frombuffer(fig.canvas.tostring_rgb(), dtype='uint8')
image = image.reshape(fig.canvas.get_width_height()[::-1] + (3, ))
traj_images.append(image)
clip = ImageSequenceClip(traj_images, fps=fps)
print(f'Writing out to {output_filename}.mp4')
clip.write_videofile(f'{output_filename}.mp4', fps=fps)
print(f'Writing out to {output_filename}.gif')
clip.write_gif(f'{output_filename}.gif',
fps=fps,
program='imageio',
opt='wu')
def main():
parser = argparse.ArgumentParser(description='Create driving video.')
parser.add_argument(
'image_folder',
type=str,
default='',
help='Path to image folder. The video will be created from these images.'
)
parser.add_argument(
'--fps',
type=int,
default=60,
help='FPS (Frames per second) setting for the video.')
args = parser.parse_args()
#convert file folder into list firltered for image file types
image_list = sorted([os.path.join(args.image_folder, image_file)
for image_file in os.listdir(args.image_folder)])
image_list = [image_file for image_file in image_list if os.path.splitext(image_file)[1][1:].lower() in IMAGE_EXT]
#two methods of naming output video to handle varying environemnts
video_file_1 = args.image_folder + '.mp4'
video_file_2 = args.image_folder + 'output_video.mp4'
print("Creating video {}, FPS={}".format(args.image_folder, args.fps))
clip = ImageSequenceClip(image_list, fps=args.fps)
try:
clip.write_videofile(video_file_1)
except:
clip.write_videofile(video_file_2)
def export_action(self):
#get the folder containing the images using a file dialog
dlg = QFileDialog()
dlg.setFileMode(QFileDialog.Directory)
folderLocs = QStringList(
) #create a QstringList to hold the location data
if dlg.exec_():
folderLocs = dlg.selectedFiles()
for folderLoc in folderLocs:
#Export the recorder images as video using ffmpeg
print("Grabbing images from: ", str(folderLoc))
folderName = str(
folderLoc
)[-8:] #get the folder name (the last 8 characters) from the directory name
try:
clip = ImageSequenceClip(str(folderLoc),
fps=int(self.writeFPS))
print("Writing file...")
if self.writeMethod == 0:
clip.write_videofile(self.localDir + "/exported/" +
folderName + "_" +
str(self.writeName) + ".avi",
codec=str(self.writeCodec))
elif self.writeMethod == 1:
clip.write_gif(self.localDir + "/exported/" +
folderName + "_" + str(self.writeName) +
".gif",
program=str(self.writeProgram))
except Exception as e:
print("Writing exception check settings.\nException:" +
str(e))
errorBox("Writing exception check settings.\nException:" +
str(e))
def main():
resultFrames = []
clipFileName = input('Введите имя видеофайла для обработки: ')
if not os.path.isfile(clipFileName):
print('Указанный файл не найден')
return
clip = VideoFileClip(clipFileName)
depth = 5
margin = 100
fillerWidth = 320
windowSplit = 2
winCount = 18
searchPortion = 1.
pipAlpha = .7
pipScaleRatio = .35
pipParams = {'alpha': pipAlpha, 'scaleRatio': pipScaleRatio}
ld = Detector(imgMarginWidth=fillerWidth, historyDepth=depth,
margin=margin, windowSplit=windowSplit, winCount=winCount,
searchPortion=searchPortion, veHiDepth=45,
pointSize=64, groupThrd=10, groupDiff=.1, confidenceThrd=.5)
for frame in tqdm(clip.iter_frames()):
dst = ld.getEmbedDetections(src=frame, pipParams=pipParams)
resultFrames.append(dst)
resultClip = ImageSequenceClip(resultFrames, fps=25, with_mask=False)
resultFileName = clipFileName.split('.')[0]
resultFileName = '{}_out_{}.mp4'.format(resultFileName, aux.timeStamp())
resultClip.write_videofile(resultFileName, progress_bar=True)
def main():
parser = argparse.ArgumentParser(description='Create driving video.')
parser.add_argument(
'image_folder',
type=str,
default='',
help=
'Path to image folder. The video will be created from these images.')
parser.add_argument('--fps',
type=int,
default=60,
help='FPS (Frames per second) setting for the video.')
args = parser.parse_args()
setNum = args.image_folder.split('dataset')[1]
setNum = setNum.split('/')[0]
print(setNum)
imageArray = []
with open('dataset%s/data.csv' % setNum, 'rt') as file:
reader = csv.reader(
file) #Create a reader to read the csv file line by line
for line in reader: #For each line in the csv fileine == 1): #If it's not the first line
if (line[0] != 'center'):
imagePath = "dataset{}/png/".format(setNum) + line[0].split(
'IMG\\')[1] #Get the local path to the image
image = pyplot.imread(imagePath) #Read the image
imageArray.append(image)
video_file = args.image_folder + '.mp4'
print("Creating video {}, FPS={}".format(video_file, args.fps))
clip = ImageSequenceClip(imageArray, fps=args.fps)
clip.write_videofile(video_file)
def process_video(video_file, clf, scaler, params):
'''
create bounding box for each frame in a video file
'''
video_clip = VideoFileClip(video_file)
qsize = 6
heatmap_threshold = 3
old_frames = Queue()
new_frames = Queue()
image_sequence = []
for i, f, in enumerate(video_clip.iter_frames()):
print ('processing frame ', i)
fig = plot_bounding_box(f, clf, scaler, params)
if old_frames.qsize() < qsize:
old_frames.put(fig)
else:
average_frame, old_frames = get_frame_aggregate(old_frames)
_ = old_frames.get()
old_frames.put(fig)
heatmap = ro.apply_threshold(average_frame, heatmap_threshold)
labels = label(heatmap)
print(labels[1], 'cars found')
draw_img = ro.draw_labeled_bboxes(np.copy(f), labels)
image_sequence.append(draw_img)
#plt.figure()
#plt.imshow(draw_img)
#plt.show()
clip = ImageSequenceClip(image_sequence, fps=video_clip.fps)
clip.write_videofile("drive_n_%d_t_%d.mp4" %(qsize, heatmap_threshold), audio=False)
def main():
parser = argparse.ArgumentParser(description='Create driving video.')
parser.add_argument(
'image_folder',
type=str,
default='',
help=
'Path to image folder. The video will be created from these images.')
parser.add_argument('--fps',
type=int,
default=60,
help='FPS (Frames per second) setting for the video.')
args = parser.parse_args()
video_file = args.image_folder + '.mp4'
print("Creating video {}, FPS={}".format(video_file, args.fps))
clip = ImageSequenceClip(args.image_folder, fps=args.fps)
# Show preprocessing effects
video_processor = model.VideoProcessor()
clip = clip.fl_image(video_processor.process_frame)
clip.write_videofile(video_file)
def main():
parser = argparse.ArgumentParser(description='Create driving video.')
parser.add_argument(
'image_folder',
type=str,
default='',
help='Path to image folder. The video will be created from these images.'
)
parser.add_argument(
'--fps',
type=int,
default=60,
help='FPS (Frames per second) setting for the video.')
args = parser.parse_args()
setNum = args.image_folder.split('dataset')[1]
setNum = setNum.split('/')[0]
print (setNum)
imageArray = []
with open('dataset%s/data.csv' % setNum,'rt') as file:
reader = csv.reader(file) #Create a reader to read the csv file line by line
for line in reader: #For each line in the csv fileine == 1): #If it's not the first line
if(line[0] != 'center'):
imagePath = "dataset{}/png/".format(setNum) + line[0].split('IMG\\')[1] #Get the local path to the image
image = pyplot.imread(imagePath) #Read the image
imageArray.append(image)
video_file = args.image_folder + '.mp4'
print("Creating video {}, FPS={}".format(video_file, args.fps))
clip = ImageSequenceClip(imageArray, fps=args.fps)
clip.write_videofile(video_file)
def main():
car_detector = CarDetector(5)
car_detector.trian_classifier('vehicles', 'non-vehicles')
# image_files = glob.glob(r'./test_images/test*.jpg')
# subplot_text = '23'
# i=0
# for image_file in image_files:
# i+=1
# img = cv2.imread(image_file)
# draw_image= car_detector.find_cars(img)
# plt.subplot(subplot_text+str(i))
# draw_image=cv2.cvtColor(draw_image,cv2.COLOR_BGR2RGB)
# plt.imshow(draw_image)
# plt.title('Example '+str(i))
# plt.show()
input_clip_file = 'project_video.mp4'
input_clip = VideoFileClip(input_clip_file)
output_clip_file = 'output_project_video.mp4'
output_frame_list = []
for frame in input_clip.iter_frames():
#The algorithms were developed for BGR not RGB
frame = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)
output_frame = car_detector.find_cars(frame)
output_frame = cv2.cvtColor(output_frame, cv2.COLOR_BGR2RGB)
output_frame_list.append(output_frame)
output_clip = ImageSequenceClip(output_frame_list, input_clip.fps)
output_clip.write_videofile(output_clip_file)
def gif(filename, array, fps=10, scale=1.0):
"""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)
scale : float
how much to rescale each image by (default: 1.0)
"""
# 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).resize(scale)
clip.write_gif(filename, fps=fps)
clip.write_videofile(fname + ".mp4", fps=fps)
return clip
def write_frames(self, frames: List[np.ndarray], filepath: str, audio: CompositeAudioClip) -> str:
"""Writes the frames to a given .mp4 filepath (h264 codec)"""
vclip = ImageSequenceClip(frames, fps=self.fps)
audio.set_duration(vclip.duration)
vclip.audio = audio
vclip.write_videofile(filepath, codec='libx264', fps=self.fps)
return filepath
def img_to_video(img_folder, target_file, fps=10):
clip = ImageSequenceClip(img_folder, fps=fps)
clip.write_videofile(target_file, codec='libx264', threads=4)
[
os.remove(os.path.join(img_folder, i)) for i in os.listdir(img_folder)
if i[-4:] != '.mp4'
]
def make_video(path_images_record, path_video_save, fps):
"""
Create an .mp4 video from a set of images
Inputs
----------
path_images_record: str
Path to where the images from the recorded run are saved
path_video_save: str
Path to where the output video will be saved
fps: int
Framed per second in the output video
Outputs
-------
Saves an .mp4 video at 'path_video_save'
"""
image_list = sorted([path_join(path_images_record, image_file)
for image_file in listdir(path_images_record)])
image_list = [image_file for image_file in image_list if splitext(image_file)[1][1:].lower() in IMAGE_EXT]
clip = ImageSequenceClip(image_list, fps = fps)
clip.write_videofile(path_video_save)
def main():
parser = argparse.ArgumentParser(description='Create driving video.')
parser.add_argument(
'image_folder',
type=str,
default='',
help='Path to image folder. The video will be created from these images.'
)
parser.add_argument(
'--side',
type=str,
default='center',
help='center, left, right.'
)
parser.add_argument(
'--fps',
type=int,
default=60,
help='FPS (Frames per second) setting for the video.')
args = parser.parse_args()
train_samples = loadData([args.image_folder], side=args.side)
#print(train_samples)
video_file = './data/' + args.image_folder + '.' + args.side + '.mp4'
print("Creating video {}, FPS={}".format(video_file, args.fps))
clip = ImageSequenceClip(train_samples, fps=args.fps)
clip.write_videofile(video_file)
def run():
num_classes = 2
image_shape = (160, 576)
data_dir = './data'
runs_dir = './runs'
tests.test_for_kitti_dataset(data_dir)
# Download pretrained vgg model
helper.maybe_download_pretrained_vgg(data_dir)
# OPTIONAL: Train and Inference on the cityscapes dataset instead of the Kitti dataset.
# You'll need a GPU with at least 10 teraFLOPS to train on.
# https://www.cityscapes-dataset.com/
with tf.Session() as sess:
# Path to vgg model
vgg_path = os.path.join(data_dir, 'vgg')
# Create function to get batches
get_batches_fn = helper.gen_batch_function(os.path.join(data_dir, 'data_road/training'), image_shape)
# OPTIONAL: Augment Images for better results
# https://datascience.stackexchange.com/questions/5224/how-to-prepare-augment-images-for-neural-network
# TODO: Build NN using load_vgg, layers, and optimize function
input_image, keep_prob, layer3_out, layer4_out, layer7_out = load_vgg(sess, vgg_path)
layer_output = layers(layer3_out, layer4_out, layer7_out, num_classes)
correct_label = tf.placeholder(tf.float32, [None, None, None, num_classes])
learning_rate = tf.placeholder(tf.float32)
logits, train_op, total_loss = optimize(layer_output, correct_label, learning_rate, num_classes)
# TODO: Train NN using the train_nn function
epochs = 175
batch_size = 16 # Tuning Params
learning_curve, mean_iou_curve = train_nn(sess, epochs, batch_size, get_batches_fn, train_op, total_loss, input_image, logits, correct_label, num_classes, keep_prob, learning_rate)
plt.plot(learning_curve)
plt.title('training curves')
plt.ylabel('loss')
plt.xlabel('epochs')
plt.savefig('./learning_curve.png')
plt.plot([i*MEAN_IOU_INTERVAL for i in range(len(mean_iou_curve))], mean_iou_curve)
plt.title('mean iou curves')
plt.ylabel('iou')
plt.xlabel('epochs')
plt.savefig('./mean_iou_curve.png')
#plt.show()
# TODO: Save inference data using helper.save_inference_samples
# helper.save_inference_samples(runs_dir, data_dir, sess, image_shape, logits, keep_prob, input_image)
output_dir = helper.save_inference_samples(runs_dir, data_dir, sess, image_shape, logits, keep_prob, input_image)
# OPTIONAL: Apply the trained model to a video
video_file = 'output.mp4'
fps = 2
print("Creating video {}, FPS={}".format(video_file, fps))
clip = ImageSequenceClip(output_dir, fps=fps)
clip.write_videofile(video_file)
def makemovie(dirname, outfile):
images = []
filecnt = len(os.listdir(dirname)) - 1
for cnt in range(1, filecnt):
images.append(dirname + str(cnt) + '.jpg')
clip = ImageSequenceClip(images, fps=30)
clip.write_videofile(outfile)
def save_with_mp4(output_dir, name):
glob_name = os.path.join(output_dir, name, '*.jpg')
images = glob(glob_name)
if len(images) == 0:
print('Image not found in {}'.format(glob_name), file=sys.stderr)
return
clip = ImageSequenceClip(images, fps=60)
clip.write_videofile(os.path.join(output_dir, '{}.mp4'.format(name)))
def stopPlay(self):
self.timer.stop()
fileName = QtWidgets.QFileDialog.getSaveFileName(
caption='Save Recording', filter='*.mp4')
print('Saving to ' + str(fileName[0]))
if fileName[0] != '':
clip = ImageSequenceClip(self.images, fps=30)
clip.write_videofile(fileName[0], fps=30)
def makeVidFromImgSequence(memes, j):
ids = []
for i in range(0, len(memes)):
ids.append("processed\\" + memes[i]["imgID"])
#Save Video
clip = ImageSequenceClip(ids, fps=0.2)
clip.write_videofile("processVids/output" + str(j) + ".mp4")
def main(ip_dir, video, fps):
# generate the video, from the images in sequence
vimages = [
str(filename)
for filename in sorted(glob.glob(os.path.join(ip_dir + '/*.jpg')))
]
clip = ImageSequenceClip(vimages, fps)
clip.write_videofile(ip_dir + '/' + video + '.mp4', fps)
def main():
"""
Runs when invoking directly from command line
:return:
"""
resultFrames = []
clipFileName = input('Enter video file name: ')
if not os.path.isfile(clipFileName):
print('No such file. Exiting.')
return
clip = VideoFileClip(clipFileName)
# depth = aux.promptForInt(message='Enter history depth in frames: ')
# detectionPointSize = aux.promptForInt(message='Enter Search Margin: ')
# fillerWidth = aux.promptForInt(message='Enter filler width: ')
# windowSplit = aux.promptForInt(message='Enter Window Split: ')
# winCount = aux.promptForInt(message='Enter Window Count for Box Search: ')
# searchPortion = aux.promptForFloat(message='Enter the Search portion (0.0 - 1.0): ')
# pipAlpha = aux.promptForFloat(message='Enter Picture-in-picture alpha: (0.0 - 1.0): ')
# pipScaleRatio = aux.promptForFloat(message='Enter Picture-in-picture scale (0.0 - 1.0): ')
depth = 5
margin = 100
fillerWidth = 320
windowSplit = 2
winCount = 18
searchPortion = 1.
pipAlpha = .7
pipScaleRatio = .35
pipParams = {'alpha': pipAlpha, 'scaleRatio': pipScaleRatio}
print('Total frames: {}'.format(clip.duration * clip.fps))
ld = Detector(imgMarginWidth=fillerWidth,
historyDepth=depth,
margin=margin,
windowSplit=windowSplit,
winCount=winCount,
searchPortion=searchPortion,
veHiDepth=45,
pointSize=64,
groupThrd=10,
groupDiff=.1,
confidenceThrd=.5)
for frame in tqdm(clip.iter_frames()):
dst = ld.embedDetections(src=frame, pipParams=pipParams)
resultFrames.append(dst)
resultClip = ImageSequenceClip(resultFrames, fps=25, with_mask=False)
resultFileName = clipFileName.split('.')[0]
resultFileName = '{}_out_{}.mp4'.format(resultFileName, aux.timeStamp())
resultClip.write_videofile(resultFileName)
def get_output(video_path,
out_filename,
label,
fps=30,
font_size=20,
font_color='white',
resize_algorithm='bicubic',
use_frames=False):
"""Get demo output using ``moviepy``.
This function will generate video file or gif file from raw video or
frames, by using ``moviepy``. For more information of some parameters,
you can refer to: https://github.com/Zulko/moviepy.
Args:
video_path (str): The video file path or the rawframes directory path.
If ``use_frames`` is set to True, it should be rawframes directory
path. Otherwise, it should be video file path.
out_filename (str): Output filename for the generated file.
label (str): Predicted label of the generated file.
fps (int): Number of picture frames to read per second. Default: 30.
font_size (int): Font size of the label. Default: 20.
font_color (str): Font color of the label. Default: 'white'.
resize_algorithm (str): The algorithm used for resizing.
Default: 'bicubic'. For more information,
see https://ffmpeg.org/ffmpeg-scaler.html.
use_frames: Determine Whether to use rawframes as input. Default:False.
"""
try:
from moviepy.editor import (ImageSequenceClip, TextClip, VideoFileClip,
CompositeVideoClip)
except ImportError:
raise ImportError('Please install moviepy to enable output file.')
if use_frames:
frame_list = sorted(
[osp.join(video_path, x) for x in os.listdir(video_path)])
video_clips = ImageSequenceClip(frame_list, fps=fps)
else:
video_clips = VideoFileClip(
video_path, resize_algorithm=resize_algorithm)
duration_video_clip = video_clips.duration
text_clips = TextClip(label, fontsize=font_size, color=font_color)
text_clips = (
text_clips.set_position(
('right', 'bottom'),
relative=True).set_duration(duration_video_clip))
video_clips = CompositeVideoClip([video_clips, text_clips])
out_type = osp.splitext(out_filename)[1][1:]
if out_type == 'gif':
video_clips.write_gif(out_filename)
else:
video_clips.write_videofile(out_filename, remove_temp=True)
def make_video(video_images_files, name, fps=30):
"""Given list of image files, create video"""
# create video
print('\nCreating video...')
clip = ImageSequenceClip(video_images_files, fps)
# write video
clip.write_videofile(name)
return clip
def video(self):
images = [
self.path + "blended/" + f for f in listdir(self.path + "blended")
if isfile(join(self.path + "blended", f))
]
print images
clip = ImageSequenceClip(images, fps=1)
clip.write_videofile(self.path + "video/movie.mp4")
def write_movie(params, logger, observations, step, score, best_agent=True):
observations = [o.transpose(1, 2, 0) * 255.0 for o in observations]
clip = ImageSequenceClip(observations, fps=int(30 / params.frame_skip))
output_dir = logger.get_eval_output()
clip.write_videofile('{}eval{:0004}_{:00005.0f}.mp4'.format(
output_dir, step, score * 100))
if params.use_visdom:
logger.add_video('{}eval{:0004}_{:00005.0f}.mp4'.format(
output_dir, step, score * 100),
best_agent=best_agent)
def videoOutput(imgList, outLocation, numLoops):
# writing video out
frameList = []
for i in range(numLoops):
for img in imgList:
frameList.append(img)
vid_clip = ImageSequenceClip(frameList, fps=10)
vid_clip.write_videofile(outLocation)
return True
def plotme(Elats, Elons, plotEclipse, Clats, Clons, plotConflict):
count = 0
d = os.path.dirname("globeframes/")
if not os.path.exists(d):
os.mkdir(d)
# Rotate the earth
for l in range((DEGPERTURN * count - 180), 180, DEGPERTURN):
fig = plt.figure(figsize=(10, 10))
map = Basemap(projection="ortho", lat_0=23.4, lon_0=l, resolution="l")
# Make the globe more realistic
map.bluemarble(scale=0.2)
if plotEclipse:
# compute the native map projection coordinates for countries.
x, y = map(Elons, Elats)
# plot filled circles at the locations of the contry.
map.plot(x, y, "yo", ms=15, picker=5, mew=2)
if plotConflict:
x, y = map(Clons, Clats)
map.plot(x, y, "rx", ms=10, picker=5, mew=4)
# plot solar eclipse positions
map.plot(x, y, "rx", ms=6)
plt.savefig("globeframes/frame{0}".format((str(count).rjust(3, "0"))), facecolor="k")
count += 1
plt.clf()
plt.close(fig)
print("Percent completed: {} %".format((count * DEGPERTURN / 360) * 100))
frames = []
# Put all the frame names in a list
for i in range(count):
frames.append("./globeframes/frame{0}.png".format((str(i).rjust(3, "0"))))
# Create a video file from the frames
clip = ImageSequenceClip(frames, fps=FPS)
clip.write_videofile("SpinningGlobe.mp4", fps=FPS)
def main():
parser = argparse.ArgumentParser(description='Create driving video.')
parser.add_argument(
'image_folder',
type=str,
default='',
help='Path to image folder. The video will be created from these images.'
)
parser.add_argument(
'--fps',
type=int,
default=60,
help='FPS (Frames per second) setting for the video.')
args = parser.parse_args()
video_file = args.image_folder + '.mp4'
print("Creating video {}, FPS={}".format(video_file, args.fps))
clip = ImageSequenceClip(args.image_folder, fps=args.fps)
clip.write_videofile(video_file)
def run(self):
"""
:return:
"""
# check if folder exists and if not create it
folder = self._name
if not os.path.exists(folder):
os.makedirs(folder)
# absolute path to store animation images to use them to create video file
animation_folder_abs_path = os.path.join(os.getcwd(), folder)
# looop through solution data and create figure with opengl function grabFrameBuffer() every i-th step
for _step in xrange(0, len(self._parent.step), int(self._parent._delta_step)):
filename = "step_%06d"%_step+".png"
# assign step and repaint GL widget
self._parent._step = int(_step)
self._parent._update_GL()
# get image of current opengl widget scene
image = self._parent.OpenGLWidget.grabFrameBuffer()
# abs path to image object of current simulation time step
file_abs_path = os.path.join(animation_folder_abs_path, filename)
# save image to file
image.save(file_abs_path)
# create video object
video = ImageSequenceClip(animation_folder_abs_path, fps=24)#24
# write data to video object
__animation_filename = self._name+".avi"
# check filename
__animation_filename = check_filename(__animation_filename)
video.write_videofile(__animation_filename,codec='mpeg4')
# delete animation folder with animation figures
shutil.rmtree(animation_folder_abs_path)
def arr2aviMPY(fileName, M, fps):
"""Convert gray-scale Numpy 3D image array to AVI file (use moviepy).
Parameters
----------
fileName : str
Path for output AVI file.
M : np.ndarray(uint8)
F x H x W 3D array, representing a sequence of F images, each H x W.
fps : int
frame rate for the output file.
"""
import numpy as np
from moviepy.editor import ImageSequenceClip
D = [np.dstack([m] * 3) for m in M]
clip = ImageSequenceClip(D, fps=fps)
clip.write_videofile(fileName, codec='mpeg4', ffmpeg_params=['-vb','1M'])
#Send a second message to stop the wheel turning
twist.angular.z = 0
pub.publish(twist)
key = '' #Reset the key to empty
degChosen.append(deg) #Add the chosen angle to the appropriate array
print round((time.time() - startTime) * 1000) #Print the total time it took for that frame to be processed
tempAngle += deg #Update the angle
actualDeg.append(tempAngle)
turnOff()
expertInput.join() #Have the expert input thread, which should be done, join back to the main thread
with open("../datasets/dataset_dagger/data.csv", 'wb') as file: #Open the csv file
writer = csv.writer(file, delimiter=',', quotechar='|', quoting=csv.QUOTE_MINIMAL) #Create a writer
writer.writerow(['frame', 'machine angle', 'expert angle', 'chosen angle', 'angle']) #Write the first row that labels the columns
for i in range (len(degChosen)): #For each frame
writer.writerow([i, degMArray[i], degHArray[i], degChosen[i], actualDeg[i]]) #Write the angles to the csv file
#Remove the last frame in the case that there aren't enought angles recorded
if not len(frameArray) == len(actualDeg):
frameArray.pop()
#Create a video using the frames collected
clip = ImageSequenceClip(frameArray, fps=15)
clip.write_videofile('../datasets/dataset_dagger/dagger.mp4') #
def split_video():
movie_title = os.path.split(args.source_path)[-1]
offset_csv = os.path.join(args.target_folder, 'offsets.csv')
offsets = []
video = VideoFileClip(args.source_path, audio=False)
framerate = video.fps
width = (np.size(video.get_frame(0), 1) - args.middle_gap_pixel_size) / 2
left_video = moviepy.video.fx.all.crop(video, x1=0, width=width)
right_video = moviepy.video.fx.all.crop(video, x1=width + args.middle_gap_pixel_size, width=width)
right_frame_iterator = right_video.iter_frames()
output_ind = args.output_starting_ind
for ind, left_frame in enumerate(left_video.iter_frames()):
left_frame = rgb2gray(left_frame)
right_frame = rgb2gray(right_frame_iterator.next())
if (ind % 20 == 0): # INITIALIZE
left_frames = []
right_frames = []
offset_frames = []
first_start = ind
offset = randint(1,10)
second_start = first_start + offset
offset_left = randint(0, 1) == 1
if (ind >= first_start and ind < first_start + 10): # ADD FRAMES
right_frames.append(right_frame)
left_frames.append(left_frame)
if (ind >= second_start and ind < second_start + 10): # ADD OFFSET FRAMES
if (offset_left):
offset_frames.append(left_frame)
else:
offset_frames.append(right_frame)
if (ind % 20 == 19): # SAVE SEGMENT FRAMES TO JPEG
if args.output_images:
assert len(left_frames) == 10, 'Only added ' + str(len(left_frames)) + ' left frames on segment ' + str(output_ind) + '. Should have 10.'
assert len(right_frames) == 10, 'Only added ' + str(len(right_frames)) + ' right frames on segment ' + str(output_ind) + '. Should have 10.'
assert len(offset_frames) == 10, 'Only added ' + str(len(offset_frames)) + ' offset frames on segment ' + str(output_ind) + '. Should have 10.'
for frame_ind, left_frame in enumerate(left_frames):
misc.toimage(left_frame, cmin=np.min(left_frame), cmax=np.max(left_frame)).save(os.path.join(args.target_folder, ('seg-{:06d}-frame-{:02d}-left.jpeg').format(output_ind, frame_ind)))
for frame_ind, right_frame in enumerate(right_frames):
misc.toimage(right_frame, cmin=np.min(right_frame), cmax=np.max(right_frame)).save(os.path.join(args.target_folder, ('seg-{:06d}-frame-{:02d}-right.jpeg').format(output_ind, frame_ind)))
else:
left_video_out = ImageSequenceClip(left_frames, fps=framerate)
left_video_out.write_videofile(os.path.join(args.target_folder, 'seg-{:06d}-left.mp4' % output_ind), codec='libx264', audio=False)
right_video_out = ImageSequenceClip(right_frames, fps=framerate)
right_video_out.write_videofile(os.path.join(args.target_folder, 'seg-{:06d}-right.mp4' % output_ind), codec='libx264', audio=False)
offsets.append({ 'id': '%06d' % output_ind, 'offset_frames': 0 })
output_ind += 1
if (offset_left):
if args.output_images:
for frame_ind, offset_frame in enumerate(offset_frames):
misc.toimage(offset_frame, cmin=np.min(left_frame), cmax=np.max(left_frame)).save(os.path.join(args.target_folder, ('seg-{:06d}-frame-{:02d}-left.jpeg').format(output_ind, frame_ind)))
for frame_ind, right_frame in enumerate(right_frames):
misc.toimage(right_frame, cmin=np.min(right_frame), cmax=np.max(right_frame)).save(os.path.join(args.target_folder, ('seg-{:06d}-frame-{:02d}-right.jpeg').format(output_ind, frame_ind)))
else:
left_video_out = ImageSequenceClip(offset_frames, fps=framerate)
left_video_out.write_videofile(os.path.join(args.target_folder, 'seg-{:06d}-left.mp4' % output_ind), codec='libx264', audio=False)
right_video_out = ImageSequenceClip(right_frames, fps=framerate)
right_video_out.write_videofile(os.path.join(args.target_folder, 'seg-{:06d}-right.mp4' % output_ind), codec='libx264', audio=False)
else:
if args.output_images:
for frame_ind, left_frame in enumerate(left_frames):
misc.toimage(left_frame, cmin=np.min(left_frame), cmax=np.max(left_frame)).save(os.path.join(args.target_folder, ('seg-{:06d}-frame-{:02d}-left.jpeg').format(output_ind, frame_ind)))
for frame_ind, offset_frame in enumerate(offset_frames):
misc.toimage(offset_frame, cmin=np.min(right_frame), cmax=np.max(right_frame)).save(os.path.join(args.target_folder, ('seg-{:06d}-frame-{:02d}-right.jpeg').format(output_ind, frame_ind)))
else:
left_video_out = ImageSequenceClip(left_frames, fps=framerate)
left_video_out.write_videofile(os.path.join(args.target_folder, 'seg-{:06d}-left.mp4' % output_ind), codec='libx264', audio=False)
right_video_out = ImageSequenceClip(offset_frames, fps=framerate)
right_video_out.write_videofile(os.path.join(args.target_folder, 'seg-{:06d}-right.mp4' % output_ind), codec='libx264', audio=False)
offsets.append({ 'id': '{:06d}'.format(output_ind), 'offset_frames': offset })
output_ind += 1
if (ind % 1000 == 0):
print('Finished processing {:d} datapoints.'.format(output_ind))
os.remove(offset_csv)
with open(offset_csv, 'w') as offset_csv_file:
w = csv.DictWriter(offset_csv_file, fieldnames=['id', 'offset_frames'])
w.writeheader()
w.writerows(offsets)
return True
# pip3 install moviepy
from moviepy.editor import ImageSequenceClip
frames = []
for i in range(180):
frames.append("./globeframes/frame{0}.png".format((str(i).rjust(3, "0"))))
clip = ImageSequenceClip(frames, fps=20)
clip.write_videofile("SpinningGlobe.mp4", fps=20) # export as video
# clip.speedx(0.5).write_gif("SpinningGlobe.gif", fps=20) # export as GIF (slow)
