def play(self, env, directory, mode):
""" Returns the total reward for an episode of the game."""
steps = []
state = env.reset()
done = False
tot_reward = 0
actions = [0] * self.actions
while not done:
if mode != "Train":
s = env.render("rgb_array")
steps.append(s)
action = self.predict_action(state)
actions[action] += 1
state, reward, done, _ = env.step(action)
tot_reward += reward
self.cur_reward = tot_reward
if mode != "Train" and tot_reward > self.max_reward:
print("New high reward: ", tot_reward)
clip = ImageSequenceClip(steps, fps=30)
clip.write_gif("~/breakout.gif", fps=30)
self.max_reward = tot_reward
print("ACTIONS TAKEN", actions)
return tot_reward
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 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(argv): if os.path.exists(OUTPUT_DIR): shutil.rmtree(OUTPUT_DIR) os.makedirs(OUTPUT_DIR) clip = ImageSequenceClip(data.images, fps=60) new_clip = clip.fl_image(process_image) new_clip.write_videofile(VIDEO_OUTPUT, audio=False)
def saturate_clip(self, clip, fps=None):
# extract frames from the clip and saturate them
new_frames = []
total = int(clip.duration * fps) + 1
for frame in tqdm(clip.iter_frames(fps), total=total):
frame = img_as_ubyte(self.saturate_frame(frame))
new_frames.append(frame)
# create and return a new clip from the saturated frames
new_clip = ImageSequenceClip(new_frames, fps=fps)
new_clip = new_clip.set_audio(clip.audio)
return new_clip
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 make_gif():
files = []
for (dirpath, dirnames, filenames) in walk("input"):
files.extend(["input/" + x for x in filenames if ".jpg" in x])
image_names = ["output/frame_{}.jpg".format(x) for x in range(len(files))]
for i in range(len(files)):
im = Image.open(files[i])
im.thumbnail(pic_size, Image.ANTIALIAS)
print image_names[i]
im.save(image_names[i], quality=100)
newName = "result.gif"
clip = ImageSequenceClip(image_names, fps=4)
clip.write_gif(newName, fuzz=False)
for f in image_names:
remove(f)
print ""
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'])
video_save_path = join(data_path, "retina-simulation",
"horse-riding.gif")
parvo_save_path = join(data_path, "retina-simulation",
"horse-riding-parvo.gif")
magno_save_path = join(data_path, "retina-simulation",
"horse-riding-magno.gif")
parvo_frames = []
magno_frames = []
origin_frames = []
for frame in frames:
retina.run(frame)
origin_frames.append(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
parvo_frame = retina.getParvo()
parvo_frame = cv2.cvtColor(parvo_frame, cv2.COLOR_BGR2RGB)
parvo_frames.append(parvo_frame)
magno_frames.append(retina.getMagno())
clip = ImageSequenceClip(parvo_frames, fps=30)
clip.write_gif(parvo_save_path, fps=30)
print "[MESSAGE] Parvo frames is saved at: %s" % (parvo_save_path)
clip = ImageSequenceClip(magno_frames, fps=30)
clip.write_gif(magno_save_path, fps=30)
print "[MESSAGE] Magno frames is saved at: %s" % (magno_save_path)
clip = ImageSequenceClip(origin_frames, fps=30)
clip.write_gif(video_save_path, fps=30)
print "[MESSAGE] Original frames is saved at: %s" % (video_save_path)
###
import numpy as np
import os
import sys
import glob
from moviepy.editor import ImageSequenceClip
file_list = glob.glob(os.path.join('./image_02/', '*.png'))
file_list.sort()
clip = ImageSequenceClip(file_list, fps=15)
name = '15.gif'
#clip.write_gif(name, fps=15)
clip.write_videofile("15.mp4", fps=15)
def _make_gif(self, frames):
clip = ImageSequenceClip(frames, fps=10)
# clip = ImageSequenceClip('./tempdir/', fps=10, with_mask=True)
clip.write_gif(filename + '.gif')
from moviepy.editor import VideoFileClip
from moviepy.editor import ImageSequenceClip
import glob
fps = 20
image_paths = glob.glob(
'../input/lisa_traffic_light_dataset/lisa-traffic-light-dataset/daySequence1/daySequence1/frames/*.jpg'
)
image_paths.sort()
print(image_paths[:5])
clip = ImageSequenceClip(image_paths, fps=fps)
clip.write_videofile(
'../input/lisa_traffic_light_dataset/input/test_data/day_seq1.mp4',
fps=fps)
print('DONE')
(img.shape[0] + data.worldmap.shape[0], img.shape[1] * 2, 3))
output_image[:img.shape[0], :img.shape[1]] = img
# Let's create more images to add to the mosaic, first a warped image
warped = perspect_transform(img, source, destination)
output_image[:img.shape[0], img.shape[1]:] = warped
# Overlay worldmap with ground truth map
map_add = cv2.addWeighted(data.worldmap, 1, data.ground_truth, 0.5, 0)
output_image[img.shape[0]:, :data.worldmap.shape[1]] = np.flipud(map_add)
# Then putting some text over the image
cv2.putText(output_image,
"Populate this image with your analyses to make a video!",
(20, 20), cv2.FONT_HERSHEY_COMPLEX, 0.4, (255, 255, 255), 1)
if data.count < len(data.images) - 1:
data.count += 1 # Keep track of the index in the Databucket()
return output_image
# Define pathname to save the output video
output = 'test_mapping.mp4'
data = Databucket(
) # Re-initialize data in case you're running this cell multiple times
clip = ImageSequenceClip(data.images,
fps=60) # Note: output video will be sped up because
# recording rate in simulator is fps=25
new_clip = clip.fl_image(
process_image) #NOTE: this function expects color images!!
new_clip.write_videofile(output, audio=False)
model = model.to(device)
if args["video"]:
video_clip = VideoFileClip(VIDEO_IN, audio=False)
audio_clip = AudioFileClip(VIDEO_IN)
current_directory = os.getcwd()
tmp_directory = os.path.join(current_directory, TMP_DIR)
if not os.path.exists(tmp_directory):
os.makedirs(tmp_directory)
for i, frame in enumerate(video_clip.iter_frames()):
frame = get_numpy_transform(frame).unsqueeze(0)
pred = model(frame.to(device)).cpu().detach().numpy()[0]
save_image(tmp_directory + "/" + str(i).zfill(5) + ".png", pred)
video = ImageSequenceClip(sequence=tmp_directory + "/",
fps=video_clip.fps)
video = video.set_audio(audio_clip)
video.write_videofile(VIDEO_OUT, audio=True)
shutil.rmtree(tmp_directory + "/")
elif args["webcam"]:
# webcam mode, process frames in webcam stream
cv2.startWindowThread()
cv2.namedWindow("frame")
while True:
# Read an image.
cap = cv2.VideoCapture(0)
ret, frame = cap.read()
cap.release()
image = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
image = load_image(None, Image.fromarray(image))
fileName = input('请输入保存文件的文件夹: ')
# 创建文件夹
if not os.path.isdir(fileName):
os.mkdir(fileName)
# 用于控制是否结束程序
recording = True
# 图像列表
imageList = []
# 时间差
recordTime = 0
# 创建线程
t = threading.Thread(target=get_pictures, daemon=True)
t.start()
print('Recording screen to %s.mp4, press Ctrl-C to stop' % fileName)
try:
while 1:
input()
except Exception as e:
recording = False
# ImageSequenceClip 用于合成图像 fps:每秒中填充图像的帧数(帧/秒),数值越大，图像越清晰
print("imageList:%s----fps=%d" %
(imageList, int(len(imageList) / recordTime)))
clip = ImageSequenceClip(imageList,
fps=int(len(imageList) / recordTime))
# 保存图像
clip.write_videofile('%s.mp4' % fileName)
fname = 'tmp_images/tmp_image_' + str(idx).zfill(4) + '.jpg'
img = cv2.cvtColor(test_image, cv2.COLOR_RGB2BGR)
cv2.imwrite(fname, img)
# create a set of images in a temporary folder to of box scan
for box in boxes:
while box.out_of_bounds == 0:
idx += 1
fname = 'tmp_images/tmp_image_' + str(idx).zfill(4) + '.jpg'
img = draw_box(test_image, box, boxlist)
if box.out_of_bounds == 0:
img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
cv2.imwrite(fname, img)
box.reset()
# write video file
clip = ImageSequenceClip("tmp_images", fps=40)
clip.write_videofile("boxscan.mp4")
#-----------------------------#
### Make Final Output Video ###
#-----------------------------#
make_output_video = True
if make_output_video is True:
heatmap = HeatMap(image=test_image)
video_output = 'project_video_out.mp4'
clip1 = VideoFileClip("project_video.mp4")
video_clip = clip1.fl_image(make_output_image)
video_clip.write_videofile(video_output, audio=False)
def write_video(images, fps, out_filename):
print("Creating video {}, FPS={}".format(out_filename, fps))
clip = ImageSequenceClip(images, fps=fps)
clip.write_videofile(out_filename)
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
import glob
from moviepy.editor import ImageSequenceClip
images_dir = './results/baby30/train_latest/videos/7/'
## Change XX to be objective images name
v = 'g05_c02'
images_list = glob.glob(images_dir + "v_BabyCrawling_{}**.png".format(v))
images_list.sort()
ouput_file = './{}.mp4'.format(v)
fps = 1
if __name__ == '__main__':
clip = ImageSequenceClip(images_list, fps=fps)
clip.write_videofile(ouput_file, fps=fps, audio=False)
def get_output(video_path,
out_filename,
label,
fps=30,
font_scale=0.5,
font_color='white',
target_resolution=None,
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_scale (float): Font scale of the label. Default: 0.5.
font_color (str): Font color of the label. Default: 'white'.
target_resolution (None | tuple[int | None]): Set to
(desired_width desired_height) to have resized frames. If either
dimension is None, the frames are resized by keeping the existing
aspect ratio. Default: None.
resize_algorithm (str): Support "bicubic", "bilinear", "neighbor",
"lanczos", etc. Default: 'bicubic'. For more information,
see https://ffmpeg.org/ffmpeg-scaler.html
use_frames: Determine Whether to use rawframes as input. Default:False.
"""
if video_path.startswith(('http://', 'https://')):
raise NotImplementedError
try:
from moviepy.editor import ImageSequenceClip
except ImportError:
raise ImportError('Please install moviepy to enable output file.')
# Channel Order is BGR
if use_frames:
frame_list = sorted(
[osp.join(video_path, x) for x in os.listdir(video_path)])
frames = [cv2.imread(x) for x in frame_list]
else:
video = decord.VideoReader(video_path)
frames = [x.asnumpy()[..., ::-1] for x in video]
if target_resolution:
w, h = target_resolution
frame_h, frame_w, _ = frames[0].shape
if w == -1:
w = int(h / frame_h * frame_w)
if h == -1:
h = int(w / frame_w * frame_h)
frames = [cv2.resize(f, (w, h)) for f in frames]
textsize = cv2.getTextSize(label, cv2.FONT_HERSHEY_DUPLEX, font_scale,
1)[0]
textheight = textsize[1]
padding = 10
location = (padding, padding + textheight)
if isinstance(font_color, str):
font_color = webcolors.name_to_rgb(font_color)[::-1]
frames = [np.array(frame) for frame in frames]
for frame in frames:
cv2.putText(frame, label, location, cv2.FONT_HERSHEY_DUPLEX,
font_scale, font_color, 1)
# RGB order
frames = [x[..., ::-1] for x in frames]
video_clips = ImageSequenceClip(frames, fps=fps)
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)
from rlbench.action_modes.gripper_action_modes import Discrete
from rlbench.environment import Environment
from rlbench.observation_config import ObservationConfig
from rlbench.tasks import CloseBox
from rlbench.demo import Demo
from mohou.types import RGBImage
if __name__ == '__main__':
obs_config = ObservationConfig()
obs_config.set_all(True)
env = Environment(action_mode=MoveArmThenGripper(
arm_action_mode=JointPosition(), gripper_action_mode=Discrete()),
obs_config=ObservationConfig(),
headless=True)
env.launch()
task = env.get_task(CloseBox)
task.reset()
rgb_seq = []
for i in range(30):
gripper = 0.0
action = np.ones(7) * 0.01 * i
obs, _, _ = task.step(np.array(action.tolist() + [0]))
rgb = RGBImage(obs.overhead_rgb)
rgb_seq.append(rgb)
clip = ImageSequenceClip([img.numpy() for img in rgb_seq], fps=50)
clip.write_gif("tmp.gif", fps=50, loop=1)
images_list = []
for i in range(len(jpeg_files)):
img = cv2.imread(
'C:/Users/DBM/Desktop/DAVIS-JPEGImages/JPEGImages/night-race/' +
jpeg_files[i])
seg = cv2.imread(
'C:/Users/DBM/Desktop/DAVIS-JPEGImages/Annotations/night-race/' +
jpeg_files[i].split('.')[0] + '.png', cv2.IMREAD_GRAYSCALE)
height, width = img.shape[:2]
seg = (seg == 38)
image_of_the_guy = np.zeros((height, width, 3), np.uint8) #create template
image_without_the_guy = np.zeros((height, width, 3),
np.uint8) #create template
image_of_the_guy[:, :,
1] = seg * img[:, :, 1] #only red color channel is needed
image_without_the_guy[:, :, 0] = np.logical_xor(seg, True) * img[:, :, 0]
image_without_the_guy[:, :, 1] = np.logical_xor(seg, True) * img[:, :, 1]
image_without_the_guy[:, :, 2] = np.logical_xor(seg, True) * img[:, :, 2]
image = image_of_the_guy + image_without_the_guy
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
#os.chdir(r'C:\Users\DBM\Desktop\results')
#cv2.imwrite(jpeg_files[i].split('.')[0]+'.png', image)
images_list.append(image)
clip = ImageSequenceClip(images_list, fps=25)
clip.write_videofile('part1_video3.mp4', codec='mpeg4')
def startVideo(self):
print("Starting Video...")
self.run_video = True
while self.run_video:
ret,frame = self.camera.read()
if ret == True:
# get frames from CNT class
print("Capturing Frame: ", self.counter)
# resize and save the frame as a jpeg image locally
frame2resize = cv2.resize(frame,(0,0),fx=self.frame,fy=self.frame)
cv2.imwrite(self.localDir + "/frames/frame.jpg", frame2resize)
# # # Based on the chosen transmission method the images are either sent over LAN or via HACKRF
if(self.counter >= self.skipValue):
# # # if we are transmitting over LAN
if self.transMeth == 0:
try:
print("sending image: ", self.counter , " over LAN")
self.sendFile(self.localDir + "/frames/frame.jpg")
# finally reset the counter
self.counter = 0
except Exception as e:
print("Socket error.\nException:" + str(e))
self.counter = 0
self.run_video = False
break
# # # if we are tranmsitting over HACKRF with IQ modulation
elif self.transMeth == 1:
try:
print("Encoding frame: ", self.counter)
# frame can be flipped depending on receiving waterfall
if self.flipFrame == True:
frame_toSend = cv2.flip(frame2resize, 0)
else:
frame_toSend = frame2resize
cv2.imwrite(self.localDir + "/frames/frameSmallG.jpg", frame_toSend)
# use the IQstream converter to convert the image into a hackrf tranmsission file
tran = Image2IQFile(self.transSamp,self.lineTime,self.outputFile,self.sourceFile)
tran.convert()
print("Transmiting frame: ")
# transmit the saved image using the hackRF
os.system("hackrf_transfer -t " + self.localDir + "/frames/frameSmallG.iqhackrf -f " + str(self.transFreq) + " -b " + str(self.transBand) + " -s " + str(self.transSamp) + " -x 20 -a 1")
# finally reset the counter
self.counter = 0
except Exception as e:
print("HACKRF IQ Tx error.\nException:" + str(e))
self.counter = 0
self.run_video = False
errorBox("HACKRF IQ Tx error.\nException:" + str(e))
break
# # # if we are transmitting over HACKRF with PAL modulation
elif self.transMeth == 2:
try:
print("Encoding Video with ", self.counter, " images.")
clip = ImageSequenceClip("recording", 10)
print("Writing file...")
clip.write_videofile(self.localDir + "/toSend.mp4",codec = "libx264")
os.system("hacktv -f "+str(self.transFreq)+" -m i -g 47 "+self.localDir+"/toSend.mp4")
# finally reset the counter
self.counter = 0
except Exception as e:
print("HACKRF Pal Tx error.\nException:" + str(e))
self.counter = 0
self.run_video = False
errorBox("HACKRF Pal Tx error.\nException:" + str(e))
break
# if we are using PAL transmission save a number of images
if self.transMeth == 2:
cv2.imwrite(self.localDir + "/recording/" + str(self.counter) + ".jpg", frame2resize)
else:
print("skipping Frame: ", self.counter)
self.counter = self.counter + 1
# do operations to make cv2 video compatible with PyQt5
color_swapped_image = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
height, width, _ = color_swapped_image.shape
qt_image = QImage(color_swapped_image.data,
width,
height,
color_swapped_image.strides[0],
QImage.Format_RGB888)
self.video_signal.emit(qt_image)# emit the QImage
# set the default image and transmit it
self.emitted_signal = self.video_signal.emit(self.pause_image)
def main(data_json_path, mode="dense_optical_flow", video_generation="no"):
json_file = open(model_path, 'r')
loaded_model_val = json_file.read()
json_file.close()
model_val = model_from_json(loaded_model_val)
print("Loaded the model")
# load the trained weights
if mode == "dense_optical_flow":
model_val.load_weights(model_weights_path + 'DenseOptflow_weights.h5')
else:
model_val.load_weights(model_weights_path + 'rgb_weights.h5')
print("trained weights loaded")
# compile the model
model_val.compile(loss='mse', optimizer='adam')
print("compiled the model")
# load the json data, with image names and the speeds
with open(data_json_path) as data_file:
data = json.load(data_file)
print("loading the test data...")
if mode == "dense_optical_flow":
x = load_data.load_XDenseOptFlowInput(data)
y_actual = load_data.load_yDenseOptFlowLabels(data)
else:
x = load_data.load_xInput(data)
y_actual = load_data.load_yLabels(data)
# evaluate the weights
print('evaluating....')
score = model_val.evaluate(x, y_actual, 64, verbose=1)
print('Evaluation loss: %f' % score)
print('predicting.....')
y = model_val.predict(x)
y = y.flatten()
y_predicted = y
# smoothing the predicted data, can be removed
if mode == "dense_optical_flow":
# smooth using Savitzky-Golay filter
y_predicted = scipy.signal.savgol_filter(
y, 101, 3) # 101 window length and fit using 3 order polynomial
else:
# smooth using Savitzky-Golay filter
y_predicted = scipy.signal.savgol_filter(
y, 51, 3) # 51 window length and fit using 3 order polynomial
# Plotting speed actual vs predicted
plt.figure(0)
#plt.plot(y, label = 'Training Prediction')
plt.plot(y_predicted, label='Training Prediction smoothed')
plt.plot(y_actual, label='Actual Dataset')
plt.title('speed: Actual vs Predicted')
plt.xlabel('Number of images')
plt.ylabel('speed')
plt.legend(loc='upper left')
if mode == "dense_optical_flow":
plt.savefig('speed predicted optical flow')
else:
plt.savefig('speed predicted rgb')
print("Saved speed plot to disk")
plt.close()
# annotate the images and save
if video_generation == "yes":
print('generating video.....')
for i in range(0, len(y_predicted)):
if mode == "dense_optical_flow":
cur_im = cv2.imread(images_extracted_path +
"%f.jpg" % data[i][0])
nxt_im = cv2.imread(images_extracted_path +
"%f.jpg" % data[i + 1][0])
xt = nxt_im.copy()
cv2.putText(xt, 'Act Speed = ' + str(y_actual[i]), (10, 40),
cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 0, 0), 2)
cv2.putText(xt, 'Pred Speed = ' + str(y_predicted[i]),
(10, 80), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 0, 0),
2)
error = y_actual[i] - y_predicted[i]
cv2.putText(xt, 'Error = ' + str(error), (10, 120),
cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
# get the visulaoisations for the flow
vis_flow, vis_hsv, vis_rgb_hsv = drawDenseOptFlow(
cur_im, nxt_im)
# merge all the vis
merged1 = np.hstack((xt, vis_flow))
merged2 = np.hstack((vis_hsv, vis_rgb_hsv))
merged = np.vstack((merged1, merged2))
# save the images
cv2.imwrite(data_output_path + "%i.jpg" % i, merged)
else:
xt = cv2.imread(images_extracted_path + "%f.jpg" % data[i][0])
cv2.putText(xt, 'Act Speed = ' + str(y_actual[i]), (10, 40),
cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 0, 0), 2)
cv2.putText(xt, 'Pred Speed = ' + str(y_predicted[i]),
(10, 80), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 0, 0),
2)
error = y_actual[i] - y_predicted[i]
cv2.putText(xt, 'Error = ' + str(error), (10, 120),
cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
# save the images
cv2.imwrite(data_output_path + "%i.jpg" % i, xt)
if i % 1000 == 0:
print("%d frames processed" % i)
# generate the video, from the predicted annotated images
vimages = [
data_output_path + "%d.jpg" % i
for i in range(0, len(y_predicted))
]
clip = ImageSequenceClip(vimages, fps=25)
if mode == "dense_optical_flow":
clip.write_videofile('speed_predicted_optDense_flow.mp4', fps=25)
else:
clip.write_videofile('speed_predicted_rgb.mp4', fps=25)
def make_video(img_folder, out="video.mp4"):
imgs = [os.path.join(img_folder, img) for img in os.listdir(img_folder)]
clip = ImageSequenceClip(imgs * 5, fps=10)
clip.write_videofile(out)
def nparray_to_video(
fname,
data,
clim="auto",
cmap="gray",
codec="h264",
fps=24,
ffmpeg_params=["-pix_fmt", "yuv420p"],
):
"""
Save 3D (t, y, x) numpy array to disk as movie. Uses matplotlib colormaps for rescaling / coloring data,
and uses moviepy.editor.ImageSequenceClip for movie creation.
Warning : this function duplicates the input data in memory.
fname : string
Filename with extension (.avi, .mp4, etc).
data : 3D numpy array
Each 2D array along the first axis of data will be a frame in the movie.
clim : length-2 list, tuple, or ndarray, or string
Upper and lower intensity limits to display from data. Defaults to 'auto'
If clim='auto', the min and max of data will be used as the clim.
Before applying the colormap, data will be clipped from clim[0] to clim[1].
cmap : string denoting a matplotlib colormap
Colormap used for displaying frames from data. Defaults to 'gray'.
codec : string
Which video codec to use. Defaults to 'h264'. See moviepy.editor.ImageSequenceClip.writevideofile.
fps : int or float
Frames per second of the movie. Defaults to 24.
ffmpeg_params : list of strings
Arguments sent to ffmpeg during movie creation. Defaults to ['-pix_fmt', 'yuv420p'], which is necessary for
creating movies that OSX understands.
"""
from numpy import pad
from moviepy.editor import ImageSequenceClip
# ffmpeg errors if the dimensions of each frame are not divisible by 2
if data.shape[1] % 2 == 1:
data = pad(data, ((0, 0), (0, 1), (0, 0)), mode="minimum")
if data.shape[2] % 2 == 1:
data = pad(data, ((0, 0), (0, 0), (0, 1)), mode="minimum")
data_rgba = apply_cmap(data, cmap=cmap, clim=clim)
clip = ImageSequenceClip([d for d in data_rgba], fps=fps)
clip.write_videofile(
fname,
audio=False,
codec=codec,
fps=fps,
ffmpeg_params=ffmpeg_params,
bitrate="50000k",
)
frames = []
radial_intensities = []
for i in sim_pos:
a = scene(i).render(
width=pov_width,
height=pov_height,
antialiasing=pov_antialiasing,
remove_temp=False,
)
b = np.sum(a, axis=2)
frames.append(a)
print(i)
clip = ImageSequenceClip(frames, fps=5)
clip.write_gif("no_soller.gif")
##### render with soller
frames = []
radial_intensities = []
for i in sim_pos:
a = scene(i, useSoller=True).render(
width=pov_width,
height=pov_height,
antialiasing=pov_antialiasing,
remove_temp=False,
)
b = np.sum(a, axis=2)
# Use the [moviepy](https://zulko.github.io/moviepy/) library to process images and create a video.
#
# In[ ]:
# Import everything needed to edit/save/watch video clips
from moviepy.editor import VideoFileClip
from moviepy.editor import ImageSequenceClip
# Define pathname to save the output video
output = './output/test_mapping.mp4'
data = Databucket() # Re-initialize data in case you're running this cell multiple times
# Note: output video will be sped up because
clip = ImageSequenceClip(data.images, fps=60)
# recording rate in simulator is fps=25
# NOTE: this function expects color images!!
new_clip = clip.fl_image(process_image)
get_ipython().magic('time new_clip.write_videofile(output, audio=False)')
# ### This next cell should function as an inline video player
# If this fails to render the video, try running the following cell (alternative video rendering method). You can also simply have a look at the saved mp4 in your `/output` folder
# In[ ]:
output = './output/test_mapping.mp4'
from IPython.display import HTML
HTML("""
def getImageClips(pics, speed):
return ImageSequenceClip(pics, fps=speed)
def run(outdir, train_mode):
# Build network.
initializer = tf.keras.initializers.VarianceScaling()
X = tf.placeholder(tf.float32, shape=[None, n_inputs])
hidden = tf.layers.dense(
X, N_HIDDEN, activation=tf.nn.elu, kernel_initializer=initializer)
logits = tf.layers.dense(hidden, n_outputs)
outputs = tf.nn.sigmoid(logits) # probability of action 0 (left)
p_left_and_right = tf.concat(axis=1, values=[outputs, 1 - outputs])
action = tf.multinomial(tf.log(p_left_and_right), num_samples=1)
# Optimizer, gradients.
y = 1. - tf.to_float(action)
cross_entropy = tf.nn.sigmoid_cross_entropy_with_logits(
labels=y, logits=logits)
optimizer = tf.train.AdamOptimizer(LEARNING_RATE)
grads_and_vars = optimizer.compute_gradients(cross_entropy)
gradients = [grad for grad, variable in grads_and_vars]
gradient_placeholders = []
grads_and_vars_feed = []
for grad, variable in grads_and_vars:
gradient_placeholder = tf.placeholder(tf.float32, shape=grad.get_shape())
gradient_placeholders.append(gradient_placeholder)
grads_and_vars_feed.append((gradient_placeholder, variable))
training_op = optimizer.apply_gradients(grads_and_vars_feed)
# For TensorBoard.
episode_reward = tf.placeholder(dtype=tf.float32, shape=[])
tf.summary.scalar('reward', episode_reward)
init = tf.global_variables_initializer()
saver = tf.train.Saver()
if train_mode:
hp_save_dir = hp_directory(outdir)
with tf.Session() as sess:
init.run()
# For TensorBoard.
print('hp_save_dir')
train_writer = tf.summary.FileWriter(hp_save_dir, sess.graph)
for iteration in range(n_iterations):
all_rewards = []
all_gradients = []
for game in range(N_GAMES_PER_UPDATE):
current_rewards = []
current_gradients = []
obs = env.reset()
for step in range(n_max_steps):
action_val, gradients_val = sess.run(
[action, gradients], feed_dict={X: obs.reshape(1, n_inputs)})
obs, reward, done, info = env.step(action_val[0][0])
current_rewards.append(reward)
current_gradients.append(gradients_val)
if done:
break
all_rewards.append(current_rewards)
all_gradients.append(current_gradients)
avg_reward = np.mean(([np.sum(r) for r in all_rewards]))
print('\rIteration: {}, Reward: {}'.format(
iteration, avg_reward, end=''))
all_rewards = discount_and_normalize_rewards(
all_rewards, discount_rate=DISCOUNT_RATE)
feed_dict = {}
for var_index, gradient_placeholder in enumerate(gradient_placeholders):
mean_gradients = np.mean([
reward * all_gradients[game_index][step][var_index]
for game_index, rewards in enumerate(all_rewards)
for step, reward in enumerate(rewards)
],
axis=0)
feed_dict[gradient_placeholder] = mean_gradients
sess.run(training_op, feed_dict=feed_dict)
if iteration % save_iterations == 0:
print('Saving model to ', hp_save_dir)
model_file = '{}/my_policy_net_pg.ckpt'.format(hp_save_dir)
saver.save(sess, model_file)
# Also save event files for TB.
merge = tf.summary.merge_all()
summary = sess.run(merge, feed_dict={episode_reward: avg_reward})
train_writer.add_summary(summary, iteration)
obs = env.reset()
steps = []
done = False
else: # Make a gif.
from moviepy.editor import ImageSequenceClip
model_file = '{}/my_policy_net_pg.ckpt'.format(outdir)
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
saver.restore(sess, save_path=model_file)
# Run model.
obs = env.reset()
done = False
steps = []
rewards = []
while not done:
s = env.render('rgb_array')
steps.append(s)
action_val = sess.run(action, feed_dict={X: obs.reshape(1, n_inputs)})
obs, reward, done, info = env.step(action_val[0][0])
rewards.append(reward)
print('Final reward :', np.mean(rewards))
clip = ImageSequenceClip(steps, fps=30)
clip.write_gif('cartpole.gif', fps=30)
# 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)
pub.publish(twist)
#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 create_video_clip_from_frames(frame_list, fps):
""" Function takes a list of video frames and puts them together in a sequence"""
visual_clip = ImageSequenceClip(
frame_list, fps=fps) #put frames together using moviepy
return visual_clip #return the ImageSequenceClip
"""
self.frame_ct += 1
self.current_heatmap = self.car_search_retinanet(img)
self.update_history() # update lane parameters
# save the annotated images
heatmap = apply_threshold(self.current_heatmap, self.heatmap_thresh)
labels = label(heatmap)
imcopy = np.copy(img)
draw_labeled_bboxes(imcopy, labels)
self.antn_img.append(imcopy)
def update_history(self):
if self.detected == False:
self.recent_heatmap.append(np.copy(self.current_heatmap))
self.detected = True
else:
self.current_heatmap = self.decay_factor * self.current_heatmap + \
(1 - self.decay_factor) * self.recent_heatmap[-1]
self.recent_heatmap.append(np.copy(self.current_heatmap))
if __name__ == "__main__":
clip = VideoFileClip('project_video.mp4')
clip = [frame for frame in clip.iter_frames()]
ct = car_tracker()
for img in tqdm(clip):
ct.detect_car_from_img(img)
gif_clip = ImageSequenceClip(ct.antn_img, fps=25)
gif_clip.write_videofile('video_output.mp4')
class DetectShots():
def __init__(self, file_path):
self.frame_diff_interval, self.total_pixels = 10, 320 * 240
self.shot_similarity_threshold, self.abrupt_trans_cnt = 3, 8
self.upper_bound, self.lower_bound, = 0.45, 0.25
self.hist, self.fd, self.shots, = [], [], []
self.total_shots, self.total_frames = 0, 0
self.key_frames, self.out, self.D = [], [], []
self.shot_scene, self.scenes = [], []
self.avg_shot_length, self.shot_cut_freq = [], []
self.file_path = file_path
self.file = cv2.VideoCapture(file_path)
self.filename = file_path[file_path.rfind('/') + 1:]
self.fps = self.file.get(cv2.CAP_PROP_FPS)
self.T = int(self.fps * 150) #2.5min
# def multiprocessed_fd_calc(self):
# self.total_frames = int(self.file.get(cv2.CAP_PROP_FRAME_COUNT))
# with mp.Pool(4) as p:
# a = p.apply_async(
# calc_frame_diff_v2,
# args=(1, self.total_frames//4, self.file_path, self.frame_diff_interval, 1, self.total_pixels)
# )
# b = p.apply_async(
# calc_frame_diff_v2,
# args=(self.total_frames//4, self.total_frames//2, self.file_path, self.frame_diff_interval, 2, self.total_pixels)
# )
# c = p.apply_async(
# calc_frame_diff_v2,
# args=(self.total_frames//2, 3*self.total_frames//4, self.file_path, self.frame_diff_interval, 3, self.total_pixels)
# )
# d = p.apply_async(
# calc_frame_diff_v2,
# args=(3*self.total_frames//4, self.total_frames, self.file_path, self.frame_diff_interval, 4, self.total_pixels)
# )
# p.close()
# p.join()
# print("its done")
# res1, res2, res3, res4 = a.get(), b.get(), c.get(), d.get()
# self.fd = res1["fd"] + res2["fd"] + res3["fd"] + res4["fd"]
# self.hist = res1["hist"] + res2["hist"] + res3["hist"] + res4["hist"]
def multithreaded_fd_calc(self):
"""
Creates threads and file pointers for multithreading frame
difference calculation
"""
self.total_frames = int(self.file.get(cv2.CAP_PROP_FRAME_COUNT))
self.hist = [0] * self.total_frames
self.fd = [0] * self.total_frames
# need different file pointers for multithreading
tmp_file1 = cv2.VideoCapture(self.file_path)
tmp_file2 = cv2.VideoCapture(self.file_path)
# each function processes a third of the file
f1 = lambda: self.calc_frame_diff(1, self.total_frames // 3, self.file)
f2 = lambda: self.calc_frame_diff(self.total_frames // 3, 2 * self.
total_frames // 3, tmp_file1)
f3 = lambda: self.calc_frame_diff(2 * self.total_frames // 3, self.
total_frames, tmp_file2)
a = HelperThread("Frame Difference 1", f1)
b = HelperThread("Frame Difference 2", f2)
c = HelperThread("Frame Difference 3", f3)
a.start(), b.start(), c.start()
a.join(), b.join(), c.join()
tmp_file2.release(), tmp_file1.release()
def calc_frame_diff(self, st, end, file):
"""
Calculates the histogram difference between frames
self.frame_diff_interval apart. Helps detect shot boundaries.
"""
# set the opencv file pointer to read frame no st next
file.set(1, st - 1)
# housekeeping
counter = max(0, st - 1)
# iterate for the entire range of frames (st, end)
while file.isOpened() and counter < end:
suc, fr = file.read()
if not suc: break
fr = cv2.resize(fr, (320, 240))
gray_fr = cv2.cvtColor(fr, cv2.COLOR_BGR2GRAY)
# the frame's histogram
hist_fr = cv2.calcHist([gray_fr], [0], None, [256], [0, 256])
# save the histogram/frame diff -
# calculating it for frames self.frame_diff_interval apart
# helps detect both gradual and abrupt transitions
if counter >= self.frame_diff_interval:
tmp = np.abs(hist_fr -
self.hist[counter - self.frame_diff_interval])
fd = np.sum(tmp) / (2 * self.total_pixels)
self.fd[counter - self.frame_diff_interval] = fd
# save the histogram
self.hist[counter] = hist_fr
counter += 1
def find_shots(self):
"""
Using the frame difference calculated before, it finds shot
boundaries and saves the end frame no. of each shot in
self.shots.
"""
counter = 0
# a local maxima in FD indicates a potential gradual transition
diff_fd = np.diff(self.fd)
# iterate!
for i in range(2, self.total_frames - 2):
# naively checking for local maxima
# in diff_fd, x corresponds to x-1
local_max = diff_fd[i + 1] < 0 and diff_fd[i] > 0
# if this FD is above a threshold and a local max, it
# corresponds to a gradual transition boundary
if self.fd[i] > self.upper_bound and local_max:
# add only if shots are 8s apart
if not search(self.shots, int(i - self.fps * 8),
int(i + self.fps * 8)):
self.shots.append(i - self.frame_diff_interval)
# check for abrupt transition boundary
else:
# if a series of FD are above a certain threshold, it
# is an abrupt transition
if self.fd[i] > self.lower_bound and self.fd[
i - 1] > self.lower_bound:
counter += 1
else:
counter = 0
if counter >= self.abrupt_trans_cnt:
counter = 0
if not search(self.shots, i - self.fps * 8,
i + self.fps * 8):
self.shots.append(i - self.abrupt_trans_cnt -
self.frame_diff_interval)
self.total_shots = len(self.shots)
def find_key_frames(self):
self.key_frames = []
with mp.Pool(4) as p:
args = [self.shots, self.hist, self.total_pixels]
a = p.apply_async(find,
args=(
*args,
0,
self.total_shots // 2,
1,
self.fps,
))
b = p.apply_async(find,
args=(
*args,
self.total_shots // 2,
self.total_shots,
2,
self.fps,
))
p.close()
p.join()
self.key_frames = a.get() + b.get()
def group_into_scenes(self):
D = []
for i in range(0, self.total_shots):
lim, j = self.key_frames[i][0] + self.T, i + 1
while j < self.total_shots and self.key_frames[j][0] <= lim:
tmp = np.array([[0] * 256]).reshape((256, 1))
for i_key_frame in self.key_frames[i]:
for j_key_frame in self.key_frames[j]:
x = np.abs(self.hist[i_key_frame] -
self.hist[j_key_frame])
tmp = tmp + x
tmp = np.sum(tmp) / (2 * self.total_pixels)
D.append({'f1': i, 'f2': j, 'fd': tmp})
j += 1
self.shot_scene = [i for i in range(0, self.total_shots)]
D.sort(key=lambda o: o["fd"])
for ob in D:
if ob['fd'] > self.shot_similarity_threshold:
break
self.shot_scene[ob['f1']] = ob['f1']
self.shot_scene[ob['f2']] = ob['f1']
def path_compress(index, arr):
if arr[index] == index:
return
path_compress(arr[index], arr)
arr[index] = arr[arr[index]]
for i in range(0, self.total_shots):
path_compress(i, self.shot_scene)
def process(self):
"""
This is what should be called to calculate stuff
"""
self.multithreaded_fd_calc()
self.find_shots()
self.find_key_frames()
self.group_into_scenes()
def get_shots(self):
# convert = lambda a : a//60 + (a/60 - a//60)*0.6
shots = [i / self.fps for i in self.shots]
return {"timestamps": shots, "frames": self.shots}
def get_key_frames(self):
frame_time_stamps = []
for shot in self.key_frames:
frame_time_stamps.append([])
for key_frame in shot:
frame_time_stamps[-1].append(key_frame / self.fps)
return {"timestamps": frame_time_stamps, "frames": self.key_frames}
def get_scenes(self):
self.scenes = [[] for i in range(0, self.total_shots)]
i = 0
while i < self.total_shots:
# the ith shot belongs to self.shot_scene[i] root shot
self.scenes[self.shot_scene[i]].append(i)
i = i + 1
# removing shots that weren't root thus getting scenes
while self.scenes.count([]) > 0:
self.scenes.remove([])
return self.scenes
def get_average_shot_length(self):
self.avg_shot_length, mx = [], 0
tot_scene = len(self.scenes)
for i in range(0, tot_scene):
l, cnt = 0, 0
for ob in self.scenes[i]:
pre = 0 if ob == 0 else self.shots[ob - 1]
l += (self.shots[ob] - pre)
cnt += 1
l = l / cnt
self.avg_shot_length.append(l)
return np.array(self.avg_shot_length)
def get_shot_cut_freq(self):
self.shot_cut_freq = []
for i in range(0, len(self.scenes)):
self.shot_cut_freq.append(1 / len(self.scenes[i]))
return self.shot_cut_freq
def save_key_frames(self):
frame_list = []
for shot in self.key_frames:
for fr in shot:
self.file.set(1, fr - 1)
fr = np.array(self.file.read()[1])
fr = cv2.cvtColor(fr, cv2.COLOR_BGR2RGB)
frame_list.append(fr)
self.out = ImageSequenceClip(frame_list, fps=1)
self.out.write_videofile('[FabBits] ' + self.filename, codec='libx264')
def save(self):
self.save_key_frames()
from moviepy.editor import ImageSequenceClip
img_names = [str(i) + '.png' for i in range(10)]
clip = ImageSequenceClip(img_names, fps=2)
clip.write_gif('herd_immune.gif')
# Accumulator to smooth
auxBox = boxes
if not math.fmod(count, 10):
auxBox[0:int(len(boxes) * 0.35)] = []
releaseBox = auxBox
# Detecting Heat labels
heat = add_heat(heat, releaseBox)
heat = apply_threshold(heat, 3)
heatmap = np.clip(heat, 0, 255)
labels = label(heatmap)
draw_labeled, Labeled_bboxList = draw_labeled_bboxes(
np.copy(C_frames), labels)
bb = np.array(Labeled_bboxList)
bb_NMS = non_max_suppression_fast(bb, 0.3)
# Save Frame by Frame. Debug Pourpose
draw_bboxes(C_frames_B, bb_NMS, (0, 0, 220))
path = './temp/' + '{:05d}'.format(count) + 'frames' + '.png'
cv2.imwrite(path, C_frames_B)
count += 1
temp = glob.glob('temp/*.png')
clip = ImageSequenceClip(temp, fps=24)
clip.write_videofile('finalisimo000.mp4')
#video.write_videofile('video.mp4', audio=False)
display=DISPLAY_FRAMES,
pov_thread=THREAD_PER_AGENT,
)
with Pool(NUM_AGENT) as p:
for message in p.imap_unordered(func, batch):
# (TODO) POVray error within child process could be an issue
pbar.update()
else:
for filename in batch:
render(
filename,
width=WIDTH,
height=HEIGHT,
display=DISPLAY_FRAMES,
pov_thread=multiprocessing.cpu_count(),
)
pbar.update()
# Create Video using moviepy
for view_name in stage_scripts.keys():
imageset_path = os.path.join(OUTPUT_IMAGES_DIR, view_name)
imageset = [
os.path.join(imageset_path, path)
for path in os.listdir(imageset_path)
if path[-3:] == "png"
]
imageset.sort()
filename = OUTPUT_FILENAME + "_" + view_name + ".mp4"
clip = ImageSequenceClip(imageset, fps=FPS)
clip.write_videofile(filename, fps=FPS)
cv2.FONT_HERSHEY_SIMPLEX, 1.5, (200, 200, 200), 3)
# Put the sub image in final image
y_start = int(n * sub_img_size[1])
inpaint[1080:1656, y_start:y_start + sub_img_size[1], :] = cv2.resize(
sub_imgs[n], (sub_img_size[1], sub_img_size[0]))
# Put Border for 16:9 scaling
inpaint = cv2.resize(
cv2.copyMakeBorder(inpaint, 0, 0, 512, 512, cv2.BORDER_CONSTANT),
(1920, 1080))
cv2.imshow('Lane Detection', inpaint)
cv2.waitKey(1)
# Save this Frame
if os.path.exists(output_video_frames) is False:
os.makedirs(output_video_frames)
cv2.imwrite(
os.path.join(output_video_frames,
'frame_' + str(frame_id).zfill(4) + '.png'), inpaint)
clip.release()
# Create output video
print('Creating Video.')
video_file = output_video_file
clip = ImageSequenceClip(output_video_frames, fps=25)
clip.write_videofile(video_file)
def make_gif(files, name):
from moviepy.editor import ImageSequenceClip
clip = ImageSequenceClip(files, fps=5)
clip.write_gif("{name}".format(name=name), fps=5)
in_file = os.path.join(input_dir, file_name)
out_file = os.path.join(out_dir, file_name)
print(out_file)
iresult = np.zeros(img.shape)
iimg = mpimg.imread(in_file)
try:
iresult = pipeline_final(iimg, mtx, dist, M, M_inv)
except:
print("Nije proslo za frame : " + str(i))
mpimg.imsave(out_file, iresult)
isorted.append(out_file)
print("Done storing images")
import os
from moviepy.editor import ImageSequenceClip
img_dir = "project_video29"
images = os.listdir(img_dir)
print(len(images))
image_list = []
count = len(images)
for i in range(1, count):
file_name = str(i) + ".jpg"
out_file = os.path.join(img_dir, file_name)
image_list.append(out_file)
video_file = img_dir + "_video.mp4"
fps = 20
print("Creating video {}, FPS={}".format(video_file, fps))
clip = ImageSequenceClip(image_list, fps=fps)
clip.write_videofile(video_file)
print("Done creating video")
def main():
if not os.path.exists("bot-fights"):
os.makedirs("bot-fights")
h = html2text.HTML2Text()
mastodon = Mastodon(client_id='pokefight.secret',
access_token='user_pokefight.secret',
api_base_url='https://social.wxcafe.net')
if os.path.exists(".since_id") and open(".since_id").read().isdigit():
since_id = int(open(".since_id").read())
else:
since_id = 0
while 42:
for i in reversed(mastodon.notifications(since_id=since_id)):
# we don't care about the rest
if i["type"] != "mention":
continue
status = i["status"]
status_id = status["id"]
visibility = status["visibility"]
since_id = max(since_id, i["id"])
message = h.handle(status["content"]).strip()
# here html2text will remove the @domain.com from [email protected]
# because it's hidden in the html, let's reput it
for mention in status["mentions"]:
link_re = '\[[^)]+\]\(' + re.escape(mention["url"]) + '\)'
message = re.sub(link_re, mention["acct"], message)
message = re.sub("\s+", " ", message.lower())
print
# repr to avoid writting on several lines
print "[%s] %s" % (i["id"], repr(message))
if not message.startswith(
("@pokefight", "pokefight", "[@pokefight")):
# we ignore status where we aren't directly mentionned
continue
match = REGEX.search(message)
if not match:
# answer that you've failed
print "message '%s' didn't matched regex" % message
print mastodon.status_post(
"@%s sorry, I couldn't understand your command :(\n\nPlease send me a message in this form:\n\n @pokefight [email protected] used some power on [email protected]\n\nOr:\n\n @pokefight [email protected] used some power on [email protected], not effective\n\nIf you'd like the power to be not effective)"
% i["account"]["acct"],
in_reply_to_id=status_id,
visibility="direct",
)["uri"]
continue
_, attacker, power, _, defender, effectiveness = match.groups()
if attacker.startswith("["):
print attacker, "->", attacker.split("(")[1][:-1]
attacker = attacker.split("(")[1][:-1]
if defender.startswith("["):
print defender, "->", defender.split("(")[1][:-1]
defender = defender.split("(")[1][:-1]
effective = effectiveness in ("effective", None)
try:
attacker, defender = fill_users(mastodon, attacker, defender)
action, result = generate_images(
attacker,
defender,
power,
text=("It's super-", "effective!") if effective else
("It's not very", "effective..."))
except Exception as e:
import traceback
traceback.print_exc()
print e
continue
action_filename = "bot-fights/" + str(status_id) + "_action.png"
result_filename = "bot-fights/" + str(status_id) + "_result.png"
mp4_filename = "bot-fights/" + str(status_id) + ".mp4"
action.save(action_filename)
result.save(result_filename)
print "-> %s %s" % (action_filename, result_filename)
# mastodon compression/convertion algorithm seems to ignore the
# last frame of a gif/mp4 (or at least readuce its duration of
# something like 0.1 or 0.01 seconds for some reason
# therefor a 2 frames gif looks like a 1 frame gif which sucks
# to fix this, we repeat the image sequences several times and
# remove the last frame, this seems to fix it (yes, that's ugly)
CompositeVideoClip([
ImageSequenceClip(
([action_filename, result_filename] * 20)[:-1],
fps=(1. / 2.5))
]).write_videofile(mp4_filename, fps=(1 / 2.5))
mp4_media_post = mastodon.media_post(mp4_filename)
if i["account"]["acct"] not in (attacker.acct, defender.acct):
text = ".@%s used %s on @%s! (from @%s)" % (
attacker.acct, power, defender.acct, i["account"]["acct"]),
else:
text = ".@%s used %s on @%s!" % (attacker.acct, power,
defender.acct),
print mastodon.status_post(
text,
# ".%s used %s on %s! (from @%s)" % (attacker.acct, power, defender.acct, i["account"]["acct"]),
in_reply_to_id=status_id,
media_ids=[mp4_media_post],
# don't spam global timeline
visibility=visibility
if visibility != "public" else "unlisted",
)["uri"]
open(".since_id", "w").write(str(since_id))
time.sleep(5)
for root, dirs, files in os.walk(thumbnail_per_frame_dir):
for fname in files:
if fname.endswith(".jpg"):
filepath = os.path.join(root, fname)
try:
key = int(fname.replace('.jpg', ''))
except Exception as e:
print(e)
key = None
if key is not None:
directory[key] = filepath
new_paths = []
for k in sorted(directory.keys()):
new_filepath = directory[k]
new_paths.append(new_filepath)
clip1 = ImageSequenceClip(new_paths, fps=30)
clip1.write_videofile(output_video1) # without audio
# can also convert each filepath into its own frame
my_clips = []
for path in new_paths:
frame = ImageClip(path)
# print(frame.img) numpy array
my_clips.append(frame.img)
clip2 = ImageSequenceClip(my_clips, fps=30)
clip2.write_videofile(output_video2) # without audio
print y_pos.shape
print pol.shape
(timestamps, x_pos,
y_pos, pol) = dvsproc.clean_up_events(timestamps, x_pos,
y_pos, pol, window=1000)
frames, fs, _ = dvsproc.gen_dvs_frames(timestamps, x_pos, y_pos,
pol, num_frames, fs=3)
print "Length of produced frames: ", len(frames)
new_frames = []
for frame in frames:
tmp_frame = (((frame+fs)/float(2*fs))*255).astype(np.uint8)
new_frames.append(tmp_frame)
clip = ImageSequenceClip(new_frames, fps=20)
clip.write_gif(seq_save_path, fps=30)
print "Sequence %s is saved at %s" % (img_name, seq_save_path)
elif option == "caltech256-ps":
caltech_fn = "INI_Caltech256_10fps_20160424.hdf5"
caltech_path = os.path.join(data_path, caltech_fn)
caltech_db = h5py.File(caltech_path, mode="r")
caltech_stats_path = os.path.join(stats_path, "caltech256_stats.pkl")
caltech_save_path = os.path.join(data_path, "caltech256_ps.eps")
img_num = 60
f = file(caltech_stats_path, mode="r")
caltech_stats = pickle.load(f)
f.close()
