def generate_video_from_list(image_list, save_path, framerate=30, downsample=1, warning=True, debug=True):
'''
create video from a list of images with a framerate
note that: the height and widht of the images should be a multiple of 2
parameters:
image_list: a list of image path
save_path: the path to save the video file
framerate: fps
'''
if debug:
assert islistofstring(image_list), 'the input is not correct'
assert ispositiveinteger(framerate), 'the framerate is a positive integer'
mkdir_if_missing(save_path)
inputdict = {'-r': str(framerate)}
outputdict = {'-r': str(framerate), '-crf': '18', '-vcodec': 'libx264', '-profile:V': 'high', '-pix_fmt': 'yuv420p'}
video_writer = FFmpegWriter(save_path, inputdict=inputdict, outputdict=outputdict)
count = 1
num_images = len(image_list)
for image_path in image_list:
print('processing frame %d/%d' % (count, num_images))
image = load_image(image_path, resize_factor=downsample, warning=warning, debug=debug)
# make sure the height and width are multiple of 2
height, width = image.shape[0], image.shape[1]
if not (height % 2 == 0 and width % 2 == 0):
height += height % 2
width += width % 2
image = image_resize(image, target_size=[height, width], warning=warning, debug=debug)
video_writer.writeFrame(image)
count += 1
video_writer.close()
def visualize_pts_array(input_pts,
color_index=0,
pts_size=20,
label=False,
label_list=None,
label_size=20,
vis_threshold=0.3,
covariance=False,
plot_occl=False,
xlim=None,
ylim=None,
fig=None,
ax=None,
save_path=None,
vis=False,
warning=True,
debug=True,
closefig=True):
'''
plot keypoints with covariance ellipse
parameters:
pts_array: 2(3) x num_pts numpy array, the third channel could be confidence or occlusion
'''
# obtain the points
try:
pts_array = safe_2dptsarray(input_pts,
homogeneous=True,
warning=warning,
debug=debug)
except AssertionError:
pts_array = safe_2dptsarray(input_pts,
homogeneous=False,
warning=warning,
debug=debug)
if debug:
assert is2dptsarray(pts_array) or is2dptsarray_occlusion(
pts_array) or is2dptsarray_confidence(
pts_array), 'input points are not correct'
num_pts = pts_array.shape[1]
# obtain a label list if required but not provided
if debug: assert islogical(label), 'label flag is not correct'
if label and (label_list is None):
label_list = [str(i) for i in xrange(num_pts)]
if label_list is not None and debug:
assert islistofstring(label_list), 'labels are not correct'
# obtain the color index
if islist(color_index):
if debug:
assert not (
plot_occl or covariance
), 'the occlusion or covariance are not compatible with plotting different colors during scattering'
color_tmp = [color_set_big[index_tmp] for index_tmp in color_index]
else:
color_tmp = color_set_big[color_index % len(color_set_big)]
fig, ax = get_fig_ax_helper(fig=fig, ax=ax)
std, conf = None, 0.95
if is2dptsarray(pts_array): # only 2d points without third rows
if debug and islist(color_tmp):
assert len(
color_tmp
) == num_pts, 'number of points to plot is not equal to number of colors provided'
ax.scatter(pts_array[0, :],
pts_array[1, :],
color=color_tmp,
s=pts_size)
pts_visible_index = range(pts_array.shape[1])
pts_ignore_index = []
pts_invisible_index = []
else:
# automatically justify if the third row is confidence or occlusion flag
num_float_elements = np.where(
np.logical_and(
pts_array[2, :] != -1,
np.logical_and(pts_array[2, :] != 0,
pts_array[2, :] != 1)))[0].tolist()
if len(num_float_elements) > 0: type_3row = 'conf'
else: type_3row = 'occu'
if type_3row == 'occu':
pts_visible_index = np.where(pts_array[
2, :] == 1)[0].tolist() # plot visible points in red color
pts_ignore_index = np.where(pts_array[2, :] == -1)[0].tolist(
) # do not plot points with annotation, usually visible, but not annotated
pts_invisible_index = np.where(pts_array[
2, :] == 0)[0].tolist() # plot invisible points in blue color
else:
pts_visible_index = np.where(
pts_array[2, :] > vis_threshold)[0].tolist()
pts_invisible_index = np.where(
pts_array[2, :] <= vis_threshold)[0].tolist()
pts_ignore_index = []
if debug and islist(color_tmp):
assert len(color_tmp) == len(
pts_visible_index
), 'number of points to plot is not equal to number of colors provided'
ax.scatter(pts_array[0, pts_visible_index],
pts_array[1, pts_visible_index],
color=color_tmp,
s=pts_size)
if plot_occl:
ax.scatter(pts_array[0, pts_invisible_index],
pts_array[1, pts_invisible_index],
color=color_set_big[(color_index + 1) %
len(color_set_big)],
s=pts_size)
if covariance:
visualize_pts_covariance(pts_array[0:2, :],
std=std,
conf=conf,
fig=fig,
ax=ax,
debug=debug,
color=color_tmp)
if plot_occl: not_plot_index = pts_ignore_index
else: not_plot_index = pts_ignore_index + pts_invisible_index
if label_list is not None:
for pts_index in xrange(num_pts):
label_tmp = label_list[pts_index]
if pts_index in not_plot_index: continue
else:
# note that the annotation is based on the coordinate instead of the order of plotting the points, so the orider in pts_index does not matter
if islist(color_index):
plt.annotate(
label_tmp,
xy=(pts_array[0, pts_index], pts_array[1, pts_index]),
xytext=(-1, 1),
color=color_set_big[(color_index[pts_index] + 5) %
len(color_set_big)],
textcoords='offset points',
ha='right',
va='bottom',
fontsize=label_size)
else:
plt.annotate(label_tmp,
xy=(pts_array[0, pts_index],
pts_array[1, pts_index]),
xytext=(-1, 1),
color=color_set_big[(color_index + 5) %
len(color_set_big)],
textcoords='offset points',
ha='right',
va='bottom',
fontsize=label_size)
# set axis
if xlim is not None:
if debug:
assert islist(xlim) and len(xlim) == 2, 'the x lim is not correct'
plt.xlim(xlim[0], xlim[1])
if ylim is not None:
if debug:
assert islist(ylim) and len(ylim) == 2, 'the y lim is not correct'
plt.ylim(ylim[0], ylim[1])
return save_vis_close_helper(fig=fig,
ax=ax,
vis=vis,
save_path=save_path,
warning=warning,
debug=debug,
closefig=closefig,
transparent=False)