def main():
clips = []
with open("names.txt") as f:
name = f.readlines()
print(name)
for i in name:
i = i.split('\n')[0]
clips.append(make(i))
print(clips)
concatenate_videoclips(clips).set_fps(30).write_videofile("飞跃起点理.mp4")
exit()
clip1 = ImageClip("./images/2.jpg")
txt = TextClip("吼哇!123ASDasd".encode("utf-8"),
font="SimSun",
color='white',
fontsize=48)
txt_col = txt.on_color(size=(clip1.w, txt.h + 10),
color=(0, 0, 0),
pos=(6, 'center'),
col_opacity=0.6).set_pos(lambda t: ((200), (800)))
w, h = moviesize = clip1.size
txt_mov = txt_col.set_pos(lambda t: (max(w / 30, int(w - 1 * w * t)),
max(5 * h / 6, int(100 * t))))
CompositeVideoClip([
clip1, txt_mov
]).set_duration(1).set_fps(30).write_videofile("my_concatenation.mp4")
CompositeVideoClip([clip1, txt_mov
]).set_duration(1).set_fps(30).save_frame("test.png",
t="00:00:01")
def create_video_of_list_of_clips(clips, output):
print('Rendering video to location %s' % (output))
final_clips = []
for clip in clips:
path = constants.DOWNLOAD_LOCATION + clip.channel.slug + '/' + clip.slug + '.mp4'
print(path)
video = VideoFileClip(path)
title = TextClip(txt=clip.channel.name + ': ' + clip.title,
font='Amiri-regular',
color='white',
fontsize=55).set_duration(8)
title_mov = title.set_pos((0.05, 0.8), relative=True)
# Create video object with text
final_clip = CompositeVideoClip([video, title_mov]).resize((1280, 720))
final_clips.append(final_clip)
# Remove from memory
del title
del video
del final_clip
# Add clips together
finished = concatenate_videoclips(final_clips, method='compose')
# Render video
finished.write_videofile(output, fps=30)
def label_clip(video_path, label, start_second, end_second):
clip = VideoFileClip(video_path)
text_clip = TextClip(label, fontsize=40, color='white', bg_color='red')
text_clip = text_clip.set_pos(('center', 'bottom'))
text_clip = text_clip.set_start(start_second).set_duration(end_second -
start_second)
return CompositeVideoClip([clip, text_clip])
def generate(self, avatars, text, usernames, kwargs):
name = uuid.uuid4().hex + '.gif'
@after_this_request
def remove(response): # pylint: disable=W0612
try:
os.remove(name)
except (FileNotFoundError, OSError, PermissionError):
pass
return response
clip = VideoFileClip("assets/kowalski/kowalski.gif")
text = TextClip(text,
fontsize=36,
method='caption',
size=(245, None),
align='West',
color='black',
stroke_color='black',
stroke_width=1,
font='Verdana').set_duration(clip.duration)
text = text.set_position((340, 65)).set_duration(clip.duration)
text = rotate(text, angle=10, resample='bilinear')
video = CompositeVideoClip([clip, text]).set_duration(clip.duration)
video.write_gif(name)
clip.close()
video.close()
return send_file(name, mimetype='image/gif')
def subscribers_video():
subscriber_videos = []
random.seed()
with open(join(settings.VIDEO_ASSETS, "subscribers.txt")) as f:
subscribers = f.read()
subscribers = subscribers.split("\n")[:-1]
background = ImageClip(join(settings.IMAGE_ASSETS,
"subscribers_bg.png")).set_duration(duration)
title = TextClip(
txt="SPECIAL THANKS TO OUR SUBSCRIBERS!",
color='white',
font='gill_sans.txt',
fontsize=60).set_duration(duration)
title = title.set_pos((350, 10))
t1 = 1
for sub_name in subscribers:
t1 += 0.2
t0 = math.log(t1)
subscriber = TextClip(
txt=sub_name, color='white', font='gill_sans.txt',
fontsize=40).set_duration(duration)
x, y = random.random() * 1700, random.random() * 940 + 100
subscriber = subscriber.set_pos(
lambda t, t0=t0, x=x, y=y: ((x, (y, -200)[t < t0])))
subscriber_videos.append(subscriber)
audioclip = VideoFileClip(join(settings.VIDEO_ASSETS, "gunfire.mp4"))
final = CompositeVideoClip(
[audioclip, background, title] + subscriber_videos,
size=((1920, 1080))).fadeout(0.2)
return final
def Gen_Video(self, beat_times, mp3path, uuid):
FONT_URL = '../font/heimi.TTF'
with open(uuid + '.txt', 'r', encoding='utf-8') as f:
text_str = f.read()
word_list = text_str.split('\n')
clips = []
for index, beat_time in enumerate(beat_times[:-1]):
if index >= len(word_list):
break
print(f'{index + 1}/{len(beat_times)}——{word_list[index]}')
text_clip = TextClip(
word_list[index],
fontsize=320 // 8,
color='white',
size=(320, 640),
method='caption',
font=FONT_URL) \
.set_start(beat_time) \
.set_end(beat_times[index + 1])
text_clip = text_clip.set_pos('center')
clips.append(text_clip)
final_clip = CompositeVideoClip(clips)
audio_clip = AudioFileClip(mp3path)
final_video = final_clip.set_audio(audio_clip)
final_video.write_videofile(str(uuid) + '.mp4',
fps=30,
codec='mpeg4',
preset='ultrafast',
audio_codec="libmp3lame",
threads=4)
def write_video_file(file_path, pred_label_score, gt_info, save_dir):
video_clip = VideoFileClip(file_path)
text_clip = TextClip(txt=pred_label_score,
font='utils/SimHei.ttf',
color='white',
fontsize=32,
bg_color='black',
align='West').set_pos(
("left", "top")).set_duration(video_clip.duration)
compose_list = [video_clip, text_clip]
if gt_info != "":
gt_text_clip = TextClip(txt=gt_info,
font='utils/SimHei.ttf',
color='white',
fontsize=32,
bg_color='black',
align='East').set_pos(
("right", "bottom")).set_duration(
video_clip.duration)
compose_list.append(gt_text_clip)
result = CompositeVideoClip(compose_list)
video_name = os.path.basename(file_path)
result.write_videofile(save_dir + "/" + video_name,
fps=25,
codec='libx264',
audio_codec='aac',
temp_audiofile='temp-audio.m4a',
remove_temp=True)
def prepend_intertitle(
self,
size: Optional[Size] = None,
color: str = DEFAULT_INTERTITLE_COLOR,
font: str = DEFAULT_INTERTITLE_FONT,
fontsize: int = DEFAULT_INTERTITLE_FONTSIZE,
position: str = DEFAULT_INTERTITLE_POSITION,
duration: int = DEFAULT_INTERTITLE_DURATION,
):
if not self.meta.text:
logger.warning('%s: Missing intertitle text')
return
logger.info('%s: Intertitle "%s"', self.meta.path, self.meta.text)
if not size:
size = Size(width=self.video_file_clip.w,
height=self.video_file_clip.h)
text_clip = TextClip(
self.meta.text.replace('|', '\n'),
size=(size.width * INTERTITLE_TEXT_WIDTH_FACTOR, None),
color=color,
font=font,
fontsize=fontsize,
method='caption',
align='center',
)
composite_clip = CompositeVideoClip([text_clip.set_pos(position)],
(size.width, size.height))
intertitle_clip = composite_clip.subclip(0, duration)
self.video_file_clip = concatenate_videoclips(
[intertitle_clip, self.video_file_clip], method='compose')
def video_render(txt_file,image_file,sound_file,save_file):
from moviepy.editor import ImageClip
from moviepy.editor import CompositeVideoClip
from moviepy.editor import CompositeAudioClip
from moviepy.editor import TextClip
from moviepy.editor import AudioFileClip
from moviepy.editor import concatenate
from moviepy.config import change_settings
change_settings({"IMAGEMAGICK_BINARY": "/usr/local/bin/convert"})
text=[]
with open(txt_file,'r') as file:
for lines in file:
if lines!="\n":
text.append(lines.rstrip('\n'))
durs=[]
for i in text:
res = len(re.findall(r'\w+', i))
if res/2>3:
durs.append(res/2)
else:
durs.append(3)
total_duration=sum(durs)
a_clip = AudioFileClip(sound_file)
if a_clip.duration<total_duration:
new_audioclip = CompositeAudioClip([a_clip, a_clip.set_start(a_clip.duration-1)]).set_duration(total_duration+3)
else:
new_audioclip=a_clip.set_duration(total_duration+3)
screen=(1920,1080)
clip_list = []
i=0
for string in text:
duration=durs[i]
i+=1
try:
txt_clip = TextClip(string, fontsize = 70, color = 'white', method='caption',size=screen ).set_duration(duration).set_pos('center')
clip_list.append(txt_clip)
except UnicodeEncodeError:
txt_clip = TextClip("Issue with text", fontsize = 70, color = 'white').set_duration(2)
clip_list.append(txt_clip)
final_text_clip = concatenate(clip_list, method = "compose").set_start(3)
v_clip = ImageClip(image_file).set_duration(total_duration+3)
video=CompositeVideoClip([v_clip, final_text_clip])
# video = video.set_audio(AudioFileClip('sound/Serenity (1).mp3'))
video = video.set_audio(new_audioclip)
video.write_videofile(save_file,
codec='libx264',
fps=10,
threads=4,
audio_codec='aac',
temp_audiofile='temp-audio.m4a',
remove_temp=True
)
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 description_helper(self, description, currloc, position, clip):
txt = TextClip(description, font='Arial', color="MediumSpringGreen", \
fontsize=44)
txt_col = txt.on_color(col_opacity=0).set_duration(clip.duration).\
set_start(currloc)
txt_mov = txt_col.set_position(('center', position))
return txt_mov
def sub_config(txt):
text_clip = TextClip(txt,
font='Helvetica Neue',
fontsize=40,
color='white')
text_clip = text_clip.on_color(size=(int(text_clip.w * 1.05),
int(text_clip.h * 1.05)),
col_opacity=0.5)
return text_clip
def annotate(clip, txt, speaker, txt_color='white', fontsize=30, font='Arial'):
""" Writes a text at the bottom of the clip. """
txt_colors = ['red', 'black', 'white', 'blue', 'green']
txtclip = TextClip(txt,
fontsize=fontsize,
font=font,
color=txt_colors[speaker])
cvc = CompositeVideoClip([clip, txtclip.set_pos(('center', 'bottom'))])
return cvc.set_duration(clip.duration)
def __init__(self, *args, **kwargs):
self.clips = []
self.add_timestamp = kwargs.pop("timestamp", False)
self.timelapse = ImageSequenceClip(*args, **kwargs)
self.clips.append(self.timelapse)
if self.add_timestamp:
txt_clip = TextClip("MoviePy ROCKS", fontsize=50, color="white")
self.txt_clip = txt_clip.set_pos("center").set_duration(5)
self.clips.append(self.txt_clip)
super(TimestampedImageSequenceClip, self).__init__(self.clips)
def __init__(self, *args, **kwargs):
self.clips = []
self.add_timestamp = kwargs.pop('timestamp', False)
self.timelapse = ImageSequenceClip(*args, **kwargs)
self.clips.append(self.timelapse)
if self.add_timestamp:
txt_clip = TextClip("MoviePy ROCKS", fontsize=50, color='white')
self.txt_clip = txt_clip.set_pos('center').set_duration(5)
self.clips.append(self.txt_clip)
super(TimestampedImageSequenceClip, self).__init__(self.clips)
def build_main(self, clip, max_duration: int = 0) -> StoryBuild:
"""Build clip
:clip: Clip object (VideoFileClip, ImageClip)
:max_duration: Result duration in seconds
:return: StoryBuild (with new path and mentions)
"""
clips = []
# Background
if self.bgpath:
assert self.bgpath.exists(),\
f'Wrong path to background {self.bgpath}'
background = ImageClip(str(self.bgpath))
clips.append(background)
# Media clip
clip_left = (self.width - clip.size[0]) / 2
clip_top = (self.height - clip.size[1]) / 2
if clip_top > 90:
clip_top -= 50
media_clip = clip.set_position((clip_left, clip_top))
clips.append(media_clip)
mention = self.mentions[0] if self.mentions else None
# Text clip
caption = "@%s" % mention.user.username if mention.user.username else self.caption
text_clip = TextClip(caption,
color="white",
font="Arial",
kerning=-1,
fontsize=100,
method="label")
text_clip_left = (self.width - 600) / 2
text_clip_top = clip_top + clip.size[1] + 50
offset = (text_clip_top + text_clip.size[1]) - self.height
if offset > 0:
text_clip_top -= offset + 90
text_clip = text_clip.resize(width=600).set_position(
(text_clip_left, text_clip_top)).fadein(3)
clips.append(text_clip)
# Mentions
mentions = []
if mention:
mention.x = 0.49892962 # approximately center
mention.y = (text_clip_top + text_clip.size[1] / 2) / self.height
mention.width = text_clip.size[0] / self.width
mention.height = text_clip.size[1] / self.height
mentions = [mention]
duration = max_duration
if max_duration and clip.duration and max_duration > clip.duration:
duration = clip.duration
destination = tempfile.mktemp('.mp4')
CompositeVideoClip(clips, size=(self.width, self.height))\
.set_fps(24)\
.set_duration(duration)\
.write_videofile(destination, codec='libx264', audio=True, audio_codec='aac')
return StoryBuild(mentions=mentions, path=destination)
def make(name):
clip1 = ImageClip("./images/{}.jpg".format(name))
txt = TextClip(name.encode("utf-8"),
font="SimSun",
color='white',
fontsize=96)
txt = txt.on_color(size=(clip1.w, txt.h + 10),
color=(0, 0, 0),
pos=(6, "center"),
col_opacity=0.6)
txt = txt.set_pos(lambda t: (max(clip1.w / 7, int(
clip1.w - 1 * clip1.w * t)), max(3 * clip1.h / 4, int(100 * t))))
return CompositeVideoClip([clip1, txt]).set_duration(3)
def textclip():
text_1 = (TextClip("剪辑不易 \n 关注啊", fontsize=70, color='white', font="FZZJ.TTF")
.set_position(lambda t: ('center', 100 - t))
.set_duration(15))
text_2 = (TextClip("赶快右侧 \n 点赞啦", fontsize=70, color='red', font="FZZJ.TTF")
.set_position(lambda t: ('center', 900 - t))
.set_duration(15))
clip1 = VideoFileClip("cut_video.mp4").fx(vfx.mirror_x)
print(clip1.duration)
result = CompositeVideoClip([clip1.set_position('center'), text_1, text_2],
size=[540, 1024]) # Overlay text on video
result.write_videofile("final.mp4")
def render(self, talk, act, exp, move, render_video, dft_exp_dt=0.2):
if self.cache_dir is not None:
cache_video = '{}.mp4'.format(
get_macro_act_key(talk, act, exp, move))
cache_video = os.path.join(self.cache_dir, cache_video)
if os.path.exists(cache_video):
clip = VideoFileClip(cache_video)
clip.write_videofile(render_video)
return
act_clip = self.act_assets[act]
default_exp_clip = self.exp_assets['null']
exp_clip = self.exp_assets[exp]
if talk == '':
clips = [
act_clip,
default_exp_clip.set_position(
lambda t: (291, 160)).set_duration(dft_exp_dt)
]
else:
talk_clip = TextClip(talk,
font='data/SimHei.ttf',
color='green',
method='caption',
fontsize=30)
clips = [
act_clip,
talk_clip.set_position(('center', 50)),
default_exp_clip.set_position(
lambda t: (291, 160)).set_duration(dft_exp_dt)
]
clips.append(
exp_clip.set_position(lambda t: (291, 160)).set_start(dft_exp_dt))
ts = dft_exp_dt + exp_clip.duration
if ts < act_clip.duration:
clips.append(
default_exp_clip.set_position(
lambda t: (291, 160)).set_duration(act_clip.duration -
ts).set_start(ts))
if move != 'null':
move_clip = self.move_assets[move]
clips.append(move_clip.set_position(('center', 650)))
final_clip = CompositeVideoClip(clips).set_duration(act_clip.duration)
final_clip.write_videofile(render_video)
def process_package(source: str, parameters: AnnotationParameters):
log.info(''.join(["SOURCE: ", source]))
main_clip = VideoFileClip(source)
log.info(''.join([
"Parameters: Font size: ",
str(parameters.font_size), " Text: ", parameters.text,
" duration: ",
str(parameters.duration), " color:", parameters.color
]))
txt_clip = TextClip(parameters.text,
fontsize=parameters.font_size,
color=parameters.color)
txt_clip = txt_clip.set_pos('center').set_duration(parameters.duration)
video = CompositeVideoClip([main_clip, txt_clip])
log.info(''.join(["Video processed correctly: "]))
return video
def background_clip(self):
return TextClip(
txt=self.text,
color=TEXT_COLOR_AFTER,
fontsize=FONT_SIZE,
size=self.clip_size,
)
def foreground_clip(self):
clip = TextClip(txt=self.text,
color=TEXT_COLOR,
fontsize=FONT_SIZE,
size=self.clip_size)
clip.mask.get_frame = self.mask_frame
return clip
def collage(output_video, *input_videos):
input_clips = []
for path in input_videos:
video_clip = VideoFileClip(path)
_, _, amp = os.path.basename(path).partition("@")
amp, _, _ = amp.partition('.')
text_clip = (TextClip(
txt='Amplified {}'.format(amp) if amp else 'Input',
color='white',
method='label',
fontsize=32,
font='Helvetica-Bold').set_duration(
video_clip.duration).set_position(('center', 0.05),
relative=True))
clip = CompositeVideoClip((video_clip, text_clip), use_bgclip=True)
input_clips.append(clip)
if len(input_clips) < 4:
num_columns = 1
elif len(input_clips) < 5:
num_columns = 2
else:
num_columns = 3
final_clip = clips_array([
input_clips[i:i + num_columns]
for i in range(0, len(input_clips), num_columns)
])
final_clip.write_videofile(output_video, audio=False)
return output_video
def createPartition(index, videoData):
os.chdir("videos/" + str(index))
#Get the start and end second from the YAML Config and edit all of the videos into clips that can be concatinated.
start = videoData['startFrame']
end = videoData['endFrame']
print(start, end)
mp4 = findmp4()
print(mp4)
os.chdir(cwd)
fileLoc = 'videos' + '\\' + str(index) + '\\' + mp4
video = VideoFileClip(fileLoc).subclip(start - 4, end + 2).fx(
vfx.fadeout, duration=1).fx(vfx.fadein, duration=5)
# Make the text. Many more options are available.
txt_clip = (TextClip(videoData['date'],
fontsize=35,
color='white',
font='Hans Kendrick').set_position(
("center", 80)).set_duration(5).fx(
vfx.fadeout, duration=1.5).fx(vfx.fadein,
duration=3))
result = CompositeVideoClip([video, txt_clip]) # Overlay text on video
result.write_videofile(
"partitions\\" + str(index) +
".mp4") # Write the partition into a new partition folder
os.chdir(cwd)
video.close()
txt_clip.close()
result.close()
def generate(self, avatars, text, usernames, kwargs):
name = uuid.uuid4().hex + '.mp4'
if len(text) >= 400:
text = text[:400] + '...'
@after_this_request
def remove(response): # pylint: disable=W0612
try:
os.remove(name)
except (FileNotFoundError, OSError, PermissionError):
pass
return response
clip = VideoFileClip("assets/letmein/letmein.mp4")
textclip = TextClip(txt=text, bg_color='White', fontsize=32, font='Verdana', method='caption', align='west', size=(clip.size[0], None)).set_duration(clip.duration)
color = ColorClip((clip.size[0], textclip.size[1]), color=(255, 255, 255), ismask=False).set_duration(clip.duration)
video = CompositeVideoClip([clip.set_position(("center", textclip.size[1])), color, textclip],
size=(clip.size[0], textclip.size[1] + clip.size[1]))
video.write_videofile(name, threads=4, preset='superfast', verbose=False)
clip.close()
video.close()
return send_file(name, mimetype='video/mp4')
def make_test_vid(note_vid, segments, fname):
t = 0
clips = []
padding = 2
i = 0
for note, (start, end) in segments:
clip = note_vid.subclip(start, end)
clip = clip.set_start(t)
clips.append(clip)
txt = (TextClip("%d %s" % (i, note),
color='white',
font='Ubuntu-Bold',
fontsize=22).margin(1).margin(
top=30, left=30, opacity=0.0).set_pos(
('left',
'top')).set_duration(end - start +
padding).set_start(t))
clips.append(txt)
t += (end - start) + padding
i += 1
print(t, i)
full_video = CompositeVideoClip(clips)
print('full length %f' % full_video.duration)
full_video.write_videofile(fname, threads=20)
def gifEngine(starttime,
endtime,
videofileloc,
srtfileloc,
outfileloc,
logger='gifEngine.log'):
logging.basicConfig(filename=logger, level=logging.DEBUG)
logger = logging.getLogger(__name__)
prolog.basic_config()
# creating the initial GIF
try:
generator = lambda txt: TextClip(
txt, font='Impact', fontsize=28, color='white')
video = VideoFileClip(videofileloc)
sub = SubtitlesClip(srtfileloc, generator).set_position(
("center", "bottom"), relative=True)
composite = CompositeVideoClip([video, sub])
composite = composite.subclip(starttime, endtime)
composite.write_gif(outfileloc,
program='ffmpeg',
opt='palettegen',
logger=logger,
verbose=True) # using new palettegen opt
return 0
except (IOError, OSError) as err:
return err
def generate_caption(pos, proj_id, vid_id, capt, colour, font, font_size):
pos = [int(p) for p in pos]
print(pos)
vid = VideoFileClip(
os.path.join(app.config['BASE_DIR'], app.config['VIDS_LOCATION'],
str(proj_id),
str(vid_id) + ".mp4"))
vid = vid.subclip(0, vid.duration).resize((852, 480))
print(int(sizes[font_size] * 0.44357))
caption = TextClip(txt=capt,
fontsize=int(sizes[font_size] * 0.44357),
color='#' + str(colour),
font=font).set_position(pos).set_duration(vid.duration)
vid = CompositeVideoClip([vid, caption])
ts = time.time()
st = datetime.datetime.fromtimestamp(ts).strftime('%Y-%m-%d-%H-%M-%S')
vid.save_frame(os.getcwd() + '/app/static/img/' + str(proj_id) +
'/{}_frame_caption_{}.png'.format(str(vid_id), st))
return '/static/img/{}/{}_frame_caption_{}.png'.format(
str(proj_id), str(vid_id), st)
def video_collage(vid_names, ordering, probs, correct_class_prob, labels):
sel_clips = []
for i in range(6):
vname = vid_names[ordering[i]]
# Load all the metadata for this video
with open(vname.replace(
'images/', 'scenes/').replace('.avi', '.json'), 'r') as fin:
metadata = json.load(fin)
gt = np.argmax(labels[ordering[i]])
pred = np.argmax(probs[ordering[i]])
pred_map = location_predictions_to_map(probs[ordering[i]], metadata)
print(vname, gt, pred, correct_class_prob[ordering[i]])
main_video = VideoFileClip(vname).margin(3)
sel_clips.append(CompositeVideoClip([
clips_array([[
main_video,
ImageSequenceClip(pred_map, fps=main_video.fps),
]]),
TextClip(
"GT {} Pred {}".format(gt, pred),
font=MOVIEPY_FONT)
.set_pos((10, 10))
.set_duration(main_video.duration),
]))
return clips_array(chunkify(sel_clips, 3))
def from_generators(gif_file_name, feeding_data, how_many_images_to_generate, image_generator):
frames = []
duration_pre_image = 0.5
feeding_angle = feeding_data.steering_angle
for index in range(how_many_images_to_generate):
image, angle = image_generator(feeding_data)
text = TextClip(txt="angle:{:.2f}/{:.2f}".format(feeding_angle, angle),
method="caption", align="North",
color="white", stroke_width=3, fontsize=18)
text = text.set_duration(duration_pre_image)
frames.append(CompositeVideoClip([
ImageClip(image, duration=duration_pre_image),
text
]))
final = concatenate_videoclips(frames)
final.write_gif(gif_file_name, fps=2)
def generateVideo(text, line2, vId):
sum = 0
fnlTxt = ""
lines = [[], []]
for ind, c in enumerate(text.split(" ")):
if sum + len(c) <= charLimit:
lines[0] += c
if ind != 0:
fnlTxt += " "
fnlTxt += c
sum += len(c)
elif sum + len(c) <= charLimit * 2:
if len(lines[1]) == 0:
fnlTxt += "\n"
if len(lines[1]) != 0:
fnlTxt += " "
lines[1] += c
fnlTxt += c
sum += len(c)
print(fnlTxt)
# Create the text
txt_clip = (TextClip(
fnlTxt, fontsize=ftSz, color="white", font=fontPth,
align="West").set_position("left").set_start(0.6).set_duration(1.4))
line2C = (TextClip(
line2, fontsize=ftSz, color="white", font=fontPth,
align="center").set_position("left").set_start(2).set_duration(2.4))
line2C = line2C.set_position(lambda t: (w * 0.1, 1.8 * h / 6))
line2E = (TextClip(line2,
fontsize=ftSz,
color="white",
font=fontPth,
align="center").set_position("left").set_start(
4.4).set_duration(0.6).fadeout(0.6))
line2E = line2E.set_position(lambda t: (w * 0.1, 1.8 * h / 6))
txt_mov = txt_clip.set_pos(lambda t: ( # animate the text
min((w * 0.1), int(-txt_clip.w - 500 + 2.7 * w * t)), # X
max(1.8 * h / 6, int(100 * t)), # Y # Y
))
rName = text + "." + ext
nName = f"{vId}.{ext}"
result = CompositeVideoClip([video, txt_mov, line2C,
line2E]) # Overlay text on video
result.write_videofile(rName, fps=video.reader.fps) # Many options...
# Moves the video file to the render directory
shutil.move(rName, "render/" + nName)
return filename
def get_number_textclip(self) -> TextClip:
metadata = self.get_metadata()
return TextClip(
f"#{metadata['number_in_series']}",
fontsize=130,
font="Arial-Bold",
color="gold4",
).set_position((0.04, 0.8), relative=True)
def add_caption(caption, clip):
text = (TextClip(caption,
font='Amiri-regular',
color='white',
fontsize=80).margin(40).set_duration(
clip.duration).on_color(
color=(0, 0, 0), col_opacity=0.6))
return CompositeVideoClip([clip, text])
def generate_vid_list(self, option, currloc):
tmpclips = []
totalcliptime = 0
for fldr_date in self.FLDR_DATES:
folderloc = os.path.join(SECTIONS_PATH, option, 'videos', \
str(fldr_date))
datafolderloc = os.path.join(SECTIONS_PATH, option, 'data', \
str(fldr_date))
for root, _, filenames in os.walk(folderloc):
for filename in fnmatch.filter(filenames, '*.mp4'):
datavar = filename.split('.')[0]
dname = os.path.join(datafolderloc, datavar + ".json")
if not os.path.isfile(dname):
sys.stderr.write("ERROR: no data found for: %s\n" % \
dname)
continue
else:
with open(dname) as json_file:
json_data = json.load(json_file)
if self.check_blacklisted_users(json_data["username"]):
continue
fname = os.path.join(root, filename)
if not os.path.isfile(fname):
sys.stderr.write("ERROR: no video found for: %s\n" % \
fname)
continue
else:
sys.stdout.write("Adding file name: %s\n" % \
fname[len(SECTIONS_PATH)+1:])
try:
clip = (VideoFileClip(fname).resize((1157, 830)).\
set_start(currloc).crossfadein(1).\
set_position("center").\
set_position((383, 88)))
except:
sys.stderr.write("ERROR: cannot open video: %s\n" % \
fname)
sys.stderr.write("DELETING: %s\n" % fname)
os.remove(fname)
sys.stderr.write("DELETING: %s\n" % dname)
os.remove(dname)
continue
tmpclips.append(clip)
# add creator image
self.make_creator_icon(json_data["avatarUrl"], \
datavar + ".jpg")
creatorclip = (ImageClip(datavar + ".jpg", \
transparent=True).set_start(currloc).\
set_duration(clip.duration).\
set_position((383, 10)))
tmpclips.append(creatorclip)
time.sleep(1)
os.remove(datavar + ".jpg")
# add creator name
try:
creatortxt = TextClip(json_data["username"].encode(\
'ascii', 'ignore'), font='Arial-Black', \
color="MediumSpringGreen", fontsize=30)
except:
sys.stderr.write("\nERROR: using default username.\n")
creatortxt = TextClip("Default UserName", \
font='Arial-Black', \
color="MediumSpringGreen", \
fontsize=30)
creatortxt_col = creatortxt.on_color(col_opacity=0).\
set_duration(clip.duration).\
set_start(currloc)
creatortxt_mov = creatortxt_col.set_position((465, 23))
tmpclips.append(creatortxt_mov)
# add the description
desc_clip = self.create_description(\
json_data["description"], currloc, clip)
for item in desc_clip:
tmpclips.append(item)
currloc += clip.duration
totalcliptime += clip.duration
return (tmpclips, currloc, totalcliptime)
ylabel('frequency (Hz)')
tight_layout()
savefig('tmp.png', dpi=25)
def write_audio_clips_to_disk(variations, sample_freq):
for p in variations.keys()[:]:
wavfile.write('sound.wav', sample_freq, variations[p].astype(int16))
if __name__ == '__main__':
screensize = (854, 480)
clips = []
# intro screen
intro_txt = TextClip("""119 Variations\non a theme by Samsung\n'The whistling ringtone'""",
color='white',
font='Baskerville Old Face Normal',
kerning=5,
fontsize=35)
intro_txt = intro_txt.set_pos('center').set_duration(5)
intro_cvc = CompositeVideoClip( [intro_txt],
size=screensize, transparent=True)
clips.append(intro_cvc)
# load sound file
from scipy.io import wavfile
sample_freq, whistle = wavfile.read("samsung_ringtone.wav")
t = arange(whistle.shape[0], dtype=float32) / sample_freq
# segment it
def create_video(request):
screensize = (720,460)
txtClip = TextClip('Cool effect', color='white', font="Amiri-Bold",
kerning=5, fontsize=100)
cvc = CompositeVideoClip( [txtClip.set_pos('center')],
size=screensize)
# THE NEXT FOUR FUNCTIONS DEFINE FOUR WAYS OF MOVING THE LETTERS
# helper function
rotMatrix = lambda a: np.array( [[np.cos(a),np.sin(a)],
[-np.sin(a),np.cos(a)]] )
def vortex(screenpos,i,nletters):
d = lambda t : 1.0/(0.3+t**8) #damping
a = i*np.pi/ nletters # angle of the movement
v = rotMatrix(a).dot([-1,0])
if i%2 : v[1] = -v[1]
return lambda t: screenpos+400*d(t)*rotMatrix(0.5*d(t)*a).dot(v)
def cascade(screenpos,i,nletters):
v = np.array([0,-1])
d = lambda t : 1 if t<0 else abs(np.sinc(t)/(1+t**4))
return lambda t: screenpos+v*400*d(t-0.15*i)
def arrive(screenpos,i,nletters):
v = np.array([-1,0])
d = lambda t : max(0, 3-3*t)
return lambda t: screenpos-400*v*d(t-0.2*i)
def vortexout(screenpos,i,nletters):
d = lambda t : max(0,t) #damping
a = i*np.pi/ nletters # angle of the movement
v = rotMatrix(a).dot([-1,0])
if i%2 : v[1] = -v[1]
return lambda t: screenpos+400*d(t-0.1*i)*rotMatrix(-0.2*d(t)*a).dot(v)
# WE USE THE PLUGIN findObjects TO LOCATE AND SEPARATE EACH LETTER
letters = findObjects(cvc) # a list of ImageClips
# WE ANIMATE THE LETTERS
def moveLetters(letters, funcpos):
return [ letter.set_pos(funcpos(letter.screenpos,i,len(letters)))
for i,letter in enumerate(letters)]
clips = [ CompositeVideoClip(moveLetters(letters,funcpos),
size = screensize).subclip(0,5)
for funcpos in [vortex, cascade, arrive, vortexout] ]
# WE CONCATENATE EVERYTHING AND WRITE TO A FILE
final_clip = concatenate_videoclips(clips)
audio_clip = AudioFileClip("media/music.aac").subclip(0, final_clip.duration)
final_clip = final_clip.set_audio(audio_clip).afx(afx.audio_fadeout, 1.0)
#final_clip = vfx.resize(final_clip, (570, 570))
final_clip.write_videofile('videos/coolTextEffects.mp4',
fps=23, codec='libx264',
audio_bitrate='1000k', bitrate='4000k')
#final_clip.write_gif('videos/coolGif.gif', fps=23)
html = "<html><body><div>Video successfully created<div><a href='http://localhost:8000'><button>Back</button></a></body></html>"
return HttpResponse(html)
