def getTimeAxis(video_file_path, video_frame, srt_file_path, x, y, w, h, threshhold=0.7):
"""
x, y, w, h means the cut position of the video
:return: output a srt subtitle file which contains time axis set
"""
myclip = VideoFileClip(video_file_path)
dt = 1. / video_frame
frames = int(myclip.duration / dt)
keyFrames = list([])
keyFrames.append(0)
im1 = Image.fromarray(myclip.get_frame(0)).crop((x, y, x+w, y+h))
for i in range(frames):
im2 = Image.fromarray(myclip.get_frame(i/24.)).crop((x, y, x+w, y+h))
print("\nimg: %d\timg: %d" % (i-1, i), end='\t')
ratio = calc_similar(im2, im1)
print(ratio)
if ratio < threshhold: # idk why sometimes the ratio > 1 so i adjust it with a factor of some number
keyFrames.append(i)
# print("ratio: ", ratio, " < 0.7, add key frame!-------------------")
# else:
# print("ratio: ", ratio, " > 0.7, they are the same words!")
im1 = im2
print(keyFrames)
with open(srt_file_path, 'w') as f:
for i in range(len(keyFrames) - 1):
f.writelines(('%d' % i, '\n', getTime(keyFrames[i]/24), ' --> ', getTime(keyFrames[i + 1]/24), '\n\n'))
class MoviePyReader(FramesSequence):
class_priority = 4
@classmethod
def class_exts(cls):
return {'mov', 'mp4', 'avi', 'mpeg', 'wmv', 'mkv'}
def __init__(self, filename):
if VideoFileClip is None:
raise ImportError('The MoviePyReader requires moviepy to work.')
self.clip = VideoFileClip(filename)
self.filename = filename
self._fps = self.clip.fps
self._len = int(self.clip.fps * self.clip.end)
first_frame = self.clip.get_frame(0)
self._shape = first_frame.shape
self._dtype = first_frame.dtype
def get_frame(self, i):
return Frame(self.clip.get_frame(i / self._fps), frame_no=i)
def __len__(self):
return self._len
@property
def frame_shape(self):
return self._shape
@property
def frame_rate(self):
return self._fps
@property
def pixel_type(self):
return self._dtype
class MoviePyReader(FramesSequence):
class_priority = 4
@classmethod
def class_exts(cls):
return {'mov', 'mp4', 'avi', 'mpeg', 'wmv', 'mkv'}
def __init__(self, filename):
if VideoFileClip is None:
raise ImportError('The MoviePyReader requires moviepy to work.')
self.clip = VideoFileClip(filename)
self.filename = filename
self._fps = self.clip.fps
self._len = int(self.clip.fps * self.clip.end)
first_frame = self.clip.get_frame(0)
self._shape = first_frame.shape
self._dtype = first_frame.dtype
def get_frame(self, i):
return Frame(self.clip.get_frame(i / self._fps), frame_no=i)
def __len__(self):
return self._len
@property
def frame_shape(self):
return self._shape
@property
def frame_rate(self):
return self._fps
@property
def pixel_type(self):
return self._dtype
def SelectFrames(videopath, filename, x1, x2, y1, y2, cropping, videotype,
start, stop, Task, selectionalgorithm):
''' Selecting frames from videos for labeling.'''
if start > 1.0 or stop > 1.0 or start < 0 or stop < 0 or start >= stop:
print(
"Please change start & stop, they should form a normalized interval with 0<= start < stop<=1."
)
else:
basefolder = 'data-' + Task + '/'
auxiliaryfunctions.attempttomakefolder(basefolder)
videos = auxiliaryfunctions.GetVideoList(filename, videopath,
videotype)
for vindex, video in enumerate(videos):
print("Loading ", video)
clip = VideoFileClip(os.path.join(videopath, video))
print("Duration of video [s], ", clip.duration, "fps, ", clip.fps,
"Cropped frame dimensions: ", clip.size)
####################################################
# Creating folder with name of experiment and extract random frames
####################################################
folder = video.split('.')[0]
auxiliaryfunctions.attempttomakefolder(
os.path.join(basefolder, folder))
indexlength = int(np.ceil(np.log10(clip.duration * clip.fps)))
# Extract the first frame (not cropped!) - useful for data augmentation
index = 0
image = img_as_ubyte(clip.get_frame(index * 1. / clip.fps))
io.imsave(
os.path.join(basefolder, folder,
"img" + str(index).zfill(indexlength) + ".png"),
image)
if cropping == True:
# Select ROI of interest by adjusting values in myconfig.py
clip = clip.crop(y1=y1, y2=y2, x1=x1, x2=x2)
print("Extracting frames ...")
if selectionalgorithm == 'uniform':
frames2pick = frameselectiontools.UniformFrames(
clip, numframes2pick, start, stop)
elif selectionalgorithm == 'kmeans':
frames2pick = frameselectiontools.KmeansbasedFrameselection(
clip, numframes2pick, start, stop)
else:
print(
"Please implement this method yourself and send us a pull request!"
)
frames2pick = []
indexlength = int(np.ceil(np.log10(clip.duration * clip.fps)))
for index in frames2pick:
try:
image = img_as_ubyte(clip.get_frame(index * 1. / clip.fps))
io.imsave(
os.path.join(
basefolder, folder,
"img" + str(index).zfill(indexlength) + ".png"),
image)
except FileNotFoundError:
print("Frame # ", index, " does not exist.")
class MoviePy(Loader):
def __init__(self, video_path, parent_dir=''):
super().__init__(video_path, parent_dir)
self.video = VideoFileClip(self.path, audio=False)
self.fps = self.video.fps
def read_iter(self, batch_size=1, limit=None, stride=1, start=0):
# start and limit should be in original frame indices
images, image_ids = [], []
positions = np.arange(0, self.video.duration * self.fps,
stride / self.fps)
start = start // stride
end = start + limit // stride if limit is not None else None
for pos in positions[:start]:
self.video.get_frame(pos)
for image_id, pos in enumerate(positions[start:end]):
image = self.video.get_frame(pos)
image = np.ascontiguousarray(image[:, :, ::-1])
image = torch.as_tensor(image)
images.append(image)
image_ids.append(image_id)
if len(images) == batch_size:
yield images, image_ids
images, image_ids = [], []
if len(images) > 0:
yield images, image_ids
def speed_test_moviepy(video_dir, video_list=VIDEO_LIST):
from moviepy.editor import VideoFileClip
for video_name in video_list:
print('\t', video_name, flush=True)
bar = ProgressBar().start()
clip = VideoFileClip(osp.join(video_dir, video_name))
for i in bar(range(int(clip.duration * clip.fps))):
clip.get_frame(i / clip.fps)
def speed_test_moviepy(video_dir, video_list=VIDEO_LIST):
from moviepy.editor import VideoFileClip
for video_name in video_list:
print('\t', video_name, flush=True)
start = time.time()
clip = VideoFileClip(osp.join(video_dir, video_name))
frame = 0
for i in tqdm(range(int(round(clip.duration * clip.fps)))):
clip.get_frame(i / clip.fps)
frame += 1
total = time.time() - start
print('\t frame:', frame)
print('\t', total, flush=True)
def main():
"""Start here..."""
# project_video.mp4
project_video = VideoFileClip('./project_video.mp4')
sample_img = project_video.get_frame(0)
zone = LaneBoundaryZone(sample_img.shape[0], sample_img.shape[1])
project_video_lane = project_video.fl_image(zone.locate_lane_bounds)
project_video_lane.write_videofile(
'./output_videos/project_video_lane.mp4', audio=False)
# challenge_video.mp4
challenge_video = VideoFileClip('./challenge_video.mp4')
sample_img = challenge_video.get_frame(0)
zone = LaneBoundaryZone(sample_img.shape[0], sample_img.shape[1])
zone.hough_threshold = 39
zone.v_thresh_min = 165
zone.s_thresh_min = 51
zone.min_lane_slope = 0.6
zone.y_thresh_min = 12
zone.x_thresh_min = 8
zone.min_windows_per_lane = 2
zone.combine_pipeline_method = 'or_related_and_groups'
challenge_video_lane = challenge_video.fl_image(zone.locate_lane_bounds)
challenge_video_lane.write_videofile(
'./output_videos/challenge_video_lane.mp4', audio=False)
# harder_challenge_video.mp4
harder_challenge_video = VideoFileClip('./harder_challenge_video.mp4')
sample_img = harder_challenge_video.get_frame(0)
zone = LaneBoundaryZone(sample_img.shape[0], sample_img.shape[1])
zone.hough_threshold = 39
zone.v_thresh_min = 246
zone.s_thresh_min = 73
zone.min_lane_slope = 0.3
zone.y_thresh_min = 21
zone.x_thresh_min = 24
zone.min_windows_per_lane = 2
zone.min_lane_line_cluster_size = 7
zone.horizon_frame_smooth_size = 6
zone.lane_find_window_height = 10
zone.lane_find_margin = 10
zone.proportion_image_height_levels = 0.33
zone.lane_curve_radius_min = 0
zone.lane_diverge_max = 0.15
zone.min_inverse_noise_factor = 5000
zone.combine_pipeline_method = 'and_related_or_groups'
harder_challenge_video_lane = harder_challenge_video.fl_image(
zone.locate_lane_bounds)
harder_challenge_video_lane.write_videofile(
'./output_videos/harder_challenge_video_lane.mp4', audio=False)
def process_clip():
clip = VideoFileClip(file_path, target_resolution=[720, 1280])
# I WAS going to get the last 10 seconds but nvm
if clip.duration > 10:
clip = clip.subclip(0, -clip.duration + 10)
safe_duration = max(0, clip.duration - 0.1)
# Freeze fram stuff
freeze_frame_sound = AudioFileClip(
"assets/wellberightback/sound.mp3")
freeze_frame = ImageClip(clip.get_frame(safe_duration))\
.fx(vfx.painting, black=0.001)\
.fx(vfx.colorx, factor=0.8).set_duration(freeze_frame_sound.duration)
text = ImageClip("assets/wellberightback/text.png")\
.set_pos( lambda t: (50, 50) )
freeze_compos = CompositeVideoClip([freeze_frame, text])\
.set_duration(freeze_frame_sound.duration).set_audio(freeze_frame_sound)
# Final clip
final_clip = concatenate_videoclips([clip, freeze_compos])
return final_clip, [
clip, freeze_frame_sound, freeze_frame, text, freeze_compos
]
class UI_Main(object):
def setup_UI(self, MainWindow):
MainWindow.setObjectName("MainWIndow")
MainWindow.resize(800, 600)
self.video = VideoFileClip(
r'C:\Users\jklew\Videos\Music\Fractalia.MP4')
self.centralWidget = QWidget(MainWindow)
self.centralWidget.setObjectName("centralWidget")
self.pixmap_label = QLabel(self.centralWidget)
self.pixmap_label.setGeometry(QRect(0, 0, 841, 511))
self.pixmap_label.setText("")
self.pixmap_label
im_np = self.video.get_frame(0)
print(im_np.dtype)
# im_np = np.ones((1800,2880,3),dtype='uint8')
# im_np = np.transpose(im_np, (1,0,2))
# im_np = np.transpose(im_np,(1,0,2)).copy()
# im_np = im_np.copy()
qimage = QImage(im_np, im_np.shape[1], im_np.shape[0],
QImage.Format_RGB888)
pixmap = QPixmap(qimage)
# pixmap = pixmap.scaled(640,400, Qt.KeepAspectRatio)
self.pixmap_label.setPixmap(pixmap)
self.pixmap_label.setScaledContents(True)
self.pixmap_label.setObjectName("Photo")
MainWindow.setCentralWidget(self.centralWidget)
self.retranslateUI(MainWindow)
QMetaObject.connectSlotsByName(MainWindow)
def retranslateUI(self, MainWindow):
_translate = QCoreApplication.translate
MainWindow.setWindowTitle(_translate("MainWindow", "MainWindow"))
def get_samples(subject_id):
arousal_label_path = root_dir / 'Ratings_affective_behaviour_CCC_centred/arousal/{}.csv'.format(
subject_id)
valence_label_path = root_dir / 'Ratings_affective_behaviour_CCC_centred/valence/{}.csv'.format(
subject_id)
clip = VideoFileClip(
str(root_dir / "Video_recordings_MP4/{}.mp4".format(subject_id)))
subsampled_audio = clip.audio.set_fps(16000)
video_frames = []
audio_frames = []
for i in range(1, 7501):
time = 0.04 * i
video = clip.get_frame(time)
audio = np.array(
list(subsampled_audio.subclip(time - 0.04,
time).iter_frames())).mean(1)[:640]
video_frames.append(video)
audio_frames.append(audio.astype(np.float32))
arousal = np.loadtxt(str(arousal_label_path), delimiter=',')[:, 1][1:]
valence = np.loadtxt(str(valence_label_path), delimiter=',')[:, 1][1:]
return video_frames, audio_frames, np.dstack([arousal, valence
])[0].astype(np.float32)
def _read_video_thumbnail(
data: bytes,
video_ext: str = "mp4",
frame_ext: str = "png",
max_size: Tuple[int, int] = (1024, 720)
) -> Tuple[bytes, int, int]:
# We don't have any way to read the video from memory, so save it to disk.
temp_file = _temp_file_name(video_ext)
with open(temp_file, "wb") as file:
file.write(data)
# Read temp file and get frame
clip = VideoFileClip(temp_file)
frame = clip.get_frame(0)
# Convert to png and save to BytesIO
image = Image.fromarray(frame).convert("RGBA")
thumbnail_file = BytesIO()
if max_size:
image.thumbnail(max_size, Image.ANTIALIAS)
image.save(thumbnail_file, frame_ext)
os.remove(temp_file)
w, h = image.size
return thumbnail_file.getvalue(), w, h
def extract_faces(path):
clip = VideoFileClip(path)
num_frames = len(list(clip.iter_frames()))
print(num_frames)
video_fps = 10.0
for frame_number in range(num_frames):
print(frame_number)
pipeline(clip.get_frame(frame_number / video_fps), frame_number)
class Demo(QWidget):
def __init__(self):
super().__init__()
self.video = VideoFileClip(
r'C:\Users\jklew\Videos\Music\Fractalia.MP4')
im_np = self.video.get_frame(0)
self.image = QImage(im_np, im_np.shape[1], im_np.shape[0],
QImage.Format_RGB888)
def preprocess(self, seq_len=30, target_resolution=(224, 224)):
"""
extract frames and audio from the video,
store the cropped frames and audio file in the output folders
seq_len: how many frames will be extracted from the video.
Considering all videos from this dataset have similar duration
video_duration = seq_len / fps
target_resolution: (desired_height, desired_width) of the facial frame extracted
"""
video = VideoFileClip(self.video_path,
audio=self.extract_audio,
target_resolution=target_resolution)
if self.extract_audio:
video.audio.write_audiofile(
os.path.join(self.audios_folder, "audio.wav"))
times = list(np.arange(0, video.duration, video.duration / seq_len))
if len(times) < seq_len:
times.append(video.duration)
times = times[:seq_len]
# extract 2D points from csv
data = np.genfromtxt(self.landmarks_path, delimiter=',')[1:]
lm_times = [
int(np.ceil(t))
for t in list(np.arange(0, len(data),
len(data) / seq_len))
]
if len(lm_times) < seq_len:
lm_times.append(len(data) - 1)
lm_times = lm_times[:seq_len]
index_x = (298, 366)
index_y = (366, 433)
landmarks_2d_x = [
data[t, index_x[0] - 1:index_x[1] - 1] * (1 / 1280)
for t in lm_times
]
landmarks_2d_y = [
data[t, index_y[0] - 1:index_y[1]] * (1 / 720) for t in lm_times
]
for i, t in enumerate(times):
img = cv2.cvtColor(video.get_frame(t), cv2.COLOR_BGR2RGB)
# extract roi from landmarks and crop
xs, ys = landmarks_2d_x[i], landmarks_2d_y[i]
bottom = int(max(ys) * img.shape[0])
right = int(max(xs) * img.shape[1])
top = int(min(ys) * img.shape[0])
left = int(min(xs) * img.shape[1])
cropped = cv2.resize(img[top:bottom, left:right, :],
target_resolution)
cv2.imwrite(
os.path.join(self.frames_folder,
"frame_{0:.2f}.jpg".format(t)), cropped)
print("Video duration {} seconds. Extracted {} frames".format(
video.duration, len(times)))
def CheckCropping(self):
''' Display frame at time "time" for video to check if cropping is fine.
Select ROI of interest by adjusting values in myconfig.py
USAGE for cropping:
clip.crop(x1=None, y1=None, x2=None, y2=None, width=None, height=None, x_center=None, y_center=None)
Returns a new clip in which just a rectangular subregion of the
original clip is conserved. x1,y1 indicates the top left corner and
x2,y2 is the lower right corner of the cropped region.
All coordinates are in pixels. Float numbers are accepted.
'''
from skimage import io
videosource = self.video_source
filename = self.filename
time = self.start
self.x1 = int(
self.cfg['video_sets'][videosource]['crop'].split(',')[0])
self.x2 = int(
self.cfg['video_sets'][videosource]['crop'].split(',')[1])
self.y1 = int(
self.cfg['video_sets'][videosource]['crop'].split(',')[2])
self.y2 = int(
self.cfg['video_sets'][videosource]['crop'].split(',')[3])
clip = VideoFileClip(videosource)
ny, nx = clip.size # dimensions of frame (width, height)
if self.cropping == True:
# Select ROI of interest by adjusting values in myconfig.py
clip = clip.crop(y1=self.y1, y2=self.y2, x1=self.x1, x2=self.x2)
# time = start
image = clip.get_frame(
time * clip.duration
) #frame is accessed by index *1./clip.fps (fps cancels)
fname = Path(filename)
output_path = Path(
self.config_path).parents[0] / 'labeled-data' / fname.stem
if output_path.exists():
saveimg = str(
Path(self.config_path).parents[0] / 'labeled-data'
) + '/IsCroppingOK_' + str(
fname
) + ".png" #str(self.currFrame).zfill(int(np.ceil(np.log10(self.numberFrames)))) + '.png'
io.imsave(saveimg, image)
print(
'Image cropped. Check the %s if cropping is ok, other wise change the parameters in the config file.'
% saveimg)
else:
print(
'The path %s does not exist in the config file. Use add function to add this video in the config file and retry.'
% output_path)
self.Close(True)
return image
def extract_frames(movie, times):
''' extract frames from video '''
clip = VideoFileClip(movie)
img_ls = []
for t in times:
img = clip.get_frame(t)
img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
img_ls.append(img)
return img_ls
def select_frames():
if start > 1.0 or stop > 1.0 or start < 0 or stop < 0 or start >= stop:
raise ValueError('Please change start & stop, they should form a '
'normalized interval with 0 <= start < stop <= 1.')
else:
base_folder = os.path.join(video_path, 'data-' + task + '/')
auxiliary_functions.attempt_to_make_folder(base_folder)
videos = auxiliary_functions.get_video_list(filename, video_path,
video_type)
for vindex, video in enumerate(videos):
print("Loading ", video, '# ', str(vindex + 1), ' of ',
str(len(videos)))
clip = VideoFileClip(os.path.join(video_path, video))
# print("Duration of video [s], ", clip.duration, "fps, ", clip.fps,
# "Cropped frame dimensions: ", clip.size)
# Create folder with experiment name and extract random frames
folder = 'selected'
v_name = video.split('.')[0]
auxiliary_functions.attempt_to_make_folder(
os.path.join(base_folder, folder))
index_length = int(np.ceil(np.log10(clip.duration * clip.fps)))
# extract first frame (uncropped) - useful for data augmentation
# index = 0
# image = img_as_ubyte(clip.get_frame(index * 1. / clip.fps))
# io.imsave(os.path.join(base_folder, folder, 'img' + v_name + '-'
# + str(index).zfill(index_length) + '.png'), image)
if cropping is True:
clip = clip.crop(y1=y1, y2=y2, x1=x1, x2=x2)
# print("Extracting frames")
if selection_algorithm == 'uniform':
frames_to_pick = frame_selection_tools.uniform_frames(
clip, num_frames_to_pick, start, stop)
elif selection_algorithm == 'kmeans':
frames_to_pick = frame_selection_tools.k_means_based_frame_selection(
clip, num_frames_to_pick, start, stop)
else:
print('not implemented')
frames_to_pick = []
index_length = int(np.ceil(np.log10(clip.duration * clip.fps)))
for index in frames_to_pick:
try:
image = img_as_ubyte(clip.get_frame(index * 1. / clip.fps))
io.imsave(
os.path.join(
base_folder, folder, 'img' + v_name + '-' +
str(index).zfill(index_length) + '.png'), image)
except FileExistsError:
print('Frame # ', index, ' does not exist.')
clip.close()
def get_video_array(video_path, label_path, set, video_name):
clip = VideoFileClip(video_path, target_resolution=(225, None))
clip_width = clip.get_frame(0).shape[1]
assert (clip_width > 224)
offset = int((clip_width - 224) / 2)
labels_video = loadmat(label_path)
try:
label_list = (labels_video['IF23'][0])
except:
label_list = (labels_video['IF'][0])
start_frame = 0
while True:
try:
print(start_frame)
frames = []
for frame in clip.iter_frames():
frames.append(frame)
if len(
frames
) == _FRAMES: # here you have 16 frames in your frames array
np_frames = np.array(frames)
np_frames = np_frames[:, :224, offset:224 + offset, :]
np_frames = np_frames.transpose((3, 0, 1, 2))
#print(np_frames.shape)
labels = label_list[int(start_frame):int(start_frame) +
_FRAMES]
label = Counter(labels).most_common(1)[0][0]
dict = {"frames": np_frames, 'label': label}
file_name = os.path.join(
set, video_name + str(start_frame) + ".pkl")
pickle.dump(dict, open(file_name, "wb"))
frames = [] # empty to start over
start_frame += _FRAMES
except Exception as e:
print(e)
for pair in enumerate(clip.iter_frames()):
if pair[0] in range(start_frame, -1):
frames.append(pair[1])
labels = label_list[int(start_frame):-1]
if labels != []:
label = Counter(labels).most_common(1)[0][0]
f = np.array(frames)
print(len(f))
f = pad_frames(f)
print(len(f))
dict = {"frames": np_frames, 'label': label}
file_name = os.path.join(
set, video_name + str(start_frame) + ".pkl")
pickle.dump(dict, open(file_name, "wb"))
break
else:
break
return print('got video blocks')
def videoPipeline(pathToInputVideoClip, pathToOutputVideoClip, linear_svc,
orientation, cells_per_block, pixels_per_cell,
convert_colorspace):
print(
"============================= Training Video ================================"
)
video_input = VideoFileClip(pathToInputVideoClip)
print(video_input.size) # [1280, 720]
image = video_input.get_frame(0)
x_start_stop = [0, video_input.size[0]]
print(x_start_stop)
y_start_stop = [
int(video_input.size[1] / 2),
int(video_input.size[1] - 80)
]
print(y_start_stop)
# xy_window_half = (32, 32)
# xy_overlap_half = (0.20, 0.20)
# windows_half = slide_window(image, x_start_stop, [400, 480],
# xy_window_half, xy_overlap_half)
xy_window = (64, 64)
xy_overlap = (0.15, 0.15)
windows_normal = sliding_window(image, x_start_stop, y_start_stop,
xy_window, xy_overlap)
xy_window_1_5 = (96, 96)
xy_window_1_5_overlap = (0.30, 0.30)
windows_1_5 = sliding_window(image, x_start_stop, y_start_stop,
xy_window_1_5, xy_window_1_5_overlap)
xy_window_twice_overlap = (0.50, 0.50)
xy_window_twice = (128, 128)
windows_twice = sliding_window(image, x_start_stop, y_start_stop,
xy_window_twice, xy_window_twice_overlap)
print(windows_normal)
print(windows_1_5)
print(windows_twice)
windows = windows_normal + windows_1_5 + windows_twice
print("No of Windows are ", len(windows))
processed_video = video_input.fl_image(lambda image: pipeline(
image, windows, linear_svc, orientation, cells_per_block,
pixels_per_cell, convert_colorspace))
processed_video.write_videofile(pathToOutputVideoClip,
threads=8,
audio=False,
fps=24)
video_input.reader.close()
video_input.audio.reader.close_proc()
def process_video(video_inp):
#.format(video_path_prefix)
output_video_name = "Video_Out/" + video_inp + "_proc.mp4"
input_video = VideoFileClip(video_inp + ".mp4")
print("Processing Video [" + input_video + "] and will write to [" +
output_video_name + "]")
calibrated = calibrated_camera(input_video.get_frame(0))
pipeline = Pipeline(calibrated)
output_video = input_video.fl_image(pipeline.run)
get_ipython().run_line_magic(
'time', 'output_video.write_videofile(output_video_name, audio=False)')
def average_video(filepath, outpath, start=None, end=None, sample_every=1):
"""Calculate average of video frames"""
# Load video
vid = VideoFileClip(filepath, audio=False)
width = vid.w
height = vid.h
if start is None and end is None:
frame_generator = vid.iter_frames(progress_bar=True, dtype=np.uint8)
else:
if start is None:
start = 0
if end is None:
end = vid.duration
# compute time increment for sampling by frames
sample_inc = sample_every / vid.fps
frame_generator = tqdm(
vid.get_frame(f) for f in frange(start, end, sample_inc))
# create starting matrix of zeros
sum_fs = np.zeros(shape=(height, width, 3), dtype=int)
ma_sum_fs = np.zeros(shape=(height, width, 3), dtype=int)
prev_f = np.zeros(shape=(height, width, 3), dtype=int)
sum_delta_fs = np.zeros(shape=(height, width, 3), dtype=int)
n_frames = 0
for f in frame_generator:
delta = f - prev_f
sum_delta_fs += delta
sum_fs += f
ma_sum_fs += f
if divmod(n_frames, 100)[1] == 0 and n_frames > 0:
ma_f = ma_sum_fs / 100
Image.fromarray(ma_f.astype(np.uint8))\
.save(os.path.join(outpath, 'movavg_{}.png'.format(n_frames)))
ma_sum_fs = np.zeros(shape=(height, width, 3), dtype=int)
n_frames += 1
prev_f = f
# average out the values for each frame
average_delta_f = sum_delta_fs / n_frames
average_f = sum_fs / n_frames
# Create images
delta_img = Image.fromarray(average_delta_f.astype(np.uint8))
delta_img.save(os.path.join(outpath, 'average_delta.png'))
final_img = Image.fromarray(average_f.astype(np.uint8))
final_img.save(os.path.join(outpath, 'average.png'))
def average_video(filepath, outpath, start=None, end=None, sample_every=1):
"""Calculate average of video frames"""
# Load video
vid = VideoFileClip(filepath, audio=False)
width = vid.w
height = vid.h
if start is None and end is None:
frame_generator = vid.iter_frames(progress_bar=True, dtype=np.uint8)
else:
if start is None:
start = 0
if end is None:
end = vid.duration
# compute time increment for sampling by frames
sample_inc = sample_every / vid.fps
frame_generator = tqdm(vid.get_frame(f) for f in frange(start, end, sample_inc))
# create starting matrix of zeros
sum_fs = np.zeros(shape=(height, width, 3), dtype=int)
ma_sum_fs = np.zeros(shape=(height, width, 3), dtype=int)
prev_f = np.zeros(shape=(height, width, 3), dtype=int)
sum_delta_fs = np.zeros(shape=(height, width, 3), dtype=int)
n_frames = 0
for f in frame_generator:
delta = f - prev_f
sum_delta_fs += delta
sum_fs += f
ma_sum_fs += f
if divmod(n_frames, 100)[1] == 0 and n_frames > 0:
ma_f = ma_sum_fs / 100
Image.fromarray(ma_f.astype(np.uint8))\
.save(os.path.join(outpath, 'movavg_{}.png'.format(n_frames)))
ma_sum_fs = np.zeros(shape=(height, width, 3), dtype=int)
n_frames += 1
prev_f = f
# average out the values for each frame
average_delta_f = sum_delta_fs / n_frames
average_f = sum_fs / n_frames
# Create images
delta_img = Image.fromarray(average_delta_f.astype(np.uint8))
delta_img.save(os.path.join(outpath, 'average_delta.png'))
final_img = Image.fromarray(average_f.astype(np.uint8))
final_img.save(os.path.join(outpath, 'average.png'))
def video2rollscan(videofile, focus, start=0, end=None, savefile=None):
"""
Makes a scan of the roll from the video.
Requires the pyton module MoviePy
Parameters
-----------
video
Any videofile that MoviePy (FFMPEG) can read.
focus
A function ( f(image)->rectangular image ). For instance
if the line of interest is defined by y=15 and x=10...230
>>> focus = lambda im : im[ [15], 10:230 ]
start,end
Where to start and stop, each one either in seconds, or in
format `(minutes, seconds)`. By default `start=0` and `end`
is the end of the video.
savefile
If provided, the scan image will be saved under this name.
Returns
--------
A W*H*3 RGB picture of the piano roll made by stacking the focus
lines of the different frames under one another.
"""
from moviepy.editor import VideoFileClip
if end is None:
end = video.duration
video = VideoFileClip(videofile, audio=False).subclip(start, end)
tt = np.arange(0, video.duration, 1.0 / video.fps)
result = np.vstack([focus(video.get_frame(t)) for t in tt])
if savefile:
import matplotlib.pyplot as plt
plt.imsave(savefile)
return result
def VideoInfo(inpath, outpath, sec=10):
inputv = VideoFileClip(inpath)
fps = inputv.fps
width, height = inputv.size
print("fps={}".format(fps))
print("width={}, height={}".format(width, height))
#get_frame return RGB ?
preframe = inputv.get_frame(sec)[:, :, [2, 1, 0]]
cv2.namedWindow("info")
def onMouse(evt, x, y, flags, param):
if evt == cv2.EVENT_LBUTTONDOWN:
param["drawing"] = True
param["start_pos"] = (x, y)
param["curr_pos"] = (x, y)
elif evt == cv2.EVENT_MOUSEMOVE and flags & cv2.EVENT_FLAG_LBUTTON:
param["curr_pos"] = (x, y)
if param["drawing"]:
frame = cv2.rectangle(preframe.copy(), param["start_pos"],
(x, y), (0, 255, 0), 0)
cv2.imshow("info", frame)
elif evt == cv2.EVENT_LBUTTONUP:
(x1, y1) = param["start_pos"]
(x2, y2) = param["curr_pos"]
X = min(x1, x2)
Y = min(y1, y2)
W = max(x1 - x2, x2 - x1)
H = max(y1 - y2, y2 - y1)
param["pos"] = (X, Y, W, H)
frame = cv2.rectangle(preframe.copy(), param["start_pos"],
param["curr_pos"], (0, 255, 0), 0)
cv2.imshow("info", frame)
kvalue = cv2.waitKey(0)
if kvalue & 0xFF == ord('q'):
cv2.destroyWindow("info")
elif kvalue & 0xFF == ord('s'):
cv2.imwrite(outpath + "_jpg.jpg", frame)
cv2.destroyWindow("info")
param = {}
param["pos"] = None
cv2.setMouseCallback("info", onMouse, param)
cv2.imshow("info", preframe)
cv2.waitKey(0)
print(param["pos"])
if param["pos"] is not None:
return param["pos"]
else:
return None
def create_video():
ir = ImageReader(read_mode='RGB')
cc = Camera(ir, None)
cc.calibrate()
ta = ThresholdApplier()
output_video_name = '../output_videos/project_video_result.mp4'
input_video = VideoFileClip("../project_video.mp4")
image = input_video.get_frame(0)
undistorted = cc.undistort(image)
llf = LaneLineFinder(ta, cc, (cc.get_region_of_interest(image)),
undistorted)
output_video = input_video.fl_image(llf.run)
output_video.write_videofile(output_video_name, audio=False)
def video2rollscan(videofile, focus, start=0, end=None, savefile=None):
"""
Makes a scan of the roll from the video.
Requires the pyton module MoviePy
Parameters
-----------
video
Any videofile that MoviePy (FFMPEG) can read.
focus
A function ( f(image)->rectangular image ). For instance
if the line of interest is defined by y=15 and x=10...230
>>> focus = lambda im : im[ [15], 10:230 ]
start,end
Where to start and stop, each one either in seconds, or in
format `(minutes, seconds)`. By default `start=0` and `end`
is the end of the video.
savefile
If provided, the scan image will be saved under this name.
Returns
--------
A W*H*3 RGB picture of the piano roll made by stacking the focus
lines of the different frames under one another.
"""
from moviepy.editor import VideoFileClip
if end is None:
end = video.duration
video = VideoFileClip(videofile, audio=False).subclip(start, end)
tt = np.arange(0, video.duration, 1.0 / video.fps)
result = np.vstack([focus(video.get_frame(t)) for t in tt])
if savefile:
import matplotlib.pyplot as plt
plt.imsave(savefile)
return result
def is_ingame_clip(self, clip: VideoFileClip) -> bool:
if self.model:
frames = []
# clip = VideoFileClip(clip_path)
for t in range(1, int(clip.duration)):
frame = clip.get_frame(t)
resized_frame = tf.keras.preprocessing.image.smart_resize(frame, (224, 224), interpolation="nearest")
frames.append(resized_frame)
# predictions[0] = game, predictions[1] = nogame
predictions = self.model.predict(np.array(frames))
percentage = np.average(predictions, axis=0)
clip.close()
return percentage[0] > 0.8
else:
logging.warning("No model for prediction available -> every clip is chosen as valid (ingame)")
return True
def main():
"""Start here..."""
# Create a frane iterator of the project video to run our pipeline on each frame.
project_video = VideoFileClip('./project_video.mp4')
# Determine dimensions of the video.
sample_img_shape = project_video.get_frame(0).shape
# Create the pipeline function.
vehicle_zone = VehicleCollisionZone()
lane_zone = LaneBoundaryZone(sample_img_shape[0], sample_img_shape[1])
pipeline_fn = lane_car_locate_pipeline(vehicle_zone, lane_zone)
# Pass the pipeline function to the iterator and fire it up saving the resulting stream to a video file.
project_video_pipeline = project_video.fl_image(pipeline_fn)
project_video_pipeline.write_videofile('./output_videos/project_video_pipeline.mp4', audio=False)
def visualize_errors(detected_shots, video_id='25010'):
# Get the errors
false_positives, false_negatives = get_f1(detected_shots,
video_id,
return_incorrect_shots=True)
v = VideoFileClip('%s/%s.mp4' % (DATASET_DIR, video_id))
for name, errors in zip(('FN', 'FP'), (false_negatives, false_positives)):
for count, trans in enumerate(errors):
plt.figure(figsize=(25, 80))
trans[0] = np.floor(trans[0])
trans[-1] = np.ceil(trans[-1])
for idx, frame_idx in enumerate(np.arange(trans[0], trans[1] + 1)):
plt.subplot(1, trans[1] - trans[0] + 1, idx + 1)
plt.imshow(v.get_frame(frame_idx / v.fps))
plt.title('%s; %.1f' % (name, frame_idx))
def extract_frames(csv_dir, video_dir, output_dir, save_format):
"""
Extracts frames from video using csv data. It then saves those frames in separate directories
inside `output_dir` with the names of the directories being the name of the videos and the
frames named time_x where x is time in seconds.
Args:
- csv_dir: str, path to directory containing the formatted csv files with columns Time and Labels.
- video_dir: str, path to directory containing the labeled flash videos.
- output_dir: str, path to directory where sub-directories containing frames will be saved. This will be created if it does not exist.
- save_format: str, file format for the frames.
Returns:
Saves images to directory, does not return a value.
"""
if not os.path.isdir(output_dir):
print(
"Destination directory {} does not exist, creating one now...".format(
output_dir
)
)
os.makedirs(output_dir)
csv_files = [file for file in os.listdir(csv_dir) if file.endswith(".csv")]
saveCount = 0
print("Found {} csv files in {}".format(len(csv_files), csv_dir))
print("Starting extraction of frames ...\n")
for csv in csv_files:
df = pd.read_csv(os.path.join(csv_dir, csv))
timelist = df["Time"].to_numpy(dtype="float")
# Name of sub-directory given by common characters in filenames shared by csv and video files.
subdir_name = os.path.splitext(csv)[0][:-6]
# create a directory inside output_dir if it doesn't already exist
if not os.path.isdir(os.path.join(output_dir, subdir_name)):
os.makedirs(os.path.join(output_dir, subdir_name))
# filename of the video has to correspond to the csv file.
video_filename = subdir_name + ".flv"
clip = VideoFileClip(os.path.join(video_dir, video_filename))
for timestep in timelist:
# extract a frame at the specified timestep
frame = clip.get_frame(timestep)
# save to file
save_frame(frame, output_dir, subdir_name, timestep, save_format)
saveCount += 1
print("Saved a total of {} images".format(saveCount))
def CheckCropping(videopath,
filename,
x1,
x2,
y1,
y2,
cropping,
videotype,
time=start):
''' Display frame at time "time" for video to check if cropping is fine.
Select ROI of interest by adjusting values in myconfig.py
USAGE for cropping:
clip.crop(x1=None, y1=None, x2=None, y2=None, width=None, height=None, x_center=None, y_center=None)
Returns a new clip in which just a rectangular subregion of the
original clip is conserved. x1,y1 indicates the top left corner and
x2,y2 is the lower right corner of the croped region.
All coordinates are in pixels. Float numbers are accepted.
'''
videos = auxiliaryfunctions.GetVideoList(filename, videopath, videotype)
if filename != 'all':
videotype = filename.split('.')[1]
for vindex, video in enumerate(videos):
clip = VideoFileClip(os.path.join(videopath, video))
print("Extracting ", video)
ny, nx = clip.size # dimensions of frame (width, height)
if cropping == True:
# Select ROI of interest by adjusting values in myconfig.py
clip = clip.crop(y1=y1, y2=y2, x1=x1, x2=x2)
image = clip.get_frame(
time * clip.duration
) #frame is accessed by index *1./clip.fps (fps cancels)
io.imsave("IsCroppingOK" + video.split('.')[0] + ".png", image)
if vindex == len(videos) - 1:
print(
"--> Open the CroppingOK-videofilename-.png file(s) to set the output range! <---"
)
print("--> Adjust shiftx, shifty, fx and fy accordingly! <---")
return image
def video_to_shortcuts(infile: str, outfile: str):
video_cap = VideoFileClip(infile)
frame_size = video_cap.size
video_basic_info = {
"frame_rate": video_cap.fps,
"size": {
"width": frame_size[0],
"height": frame_size[1],
},
"time": video_cap.duration
}
with open(outfile + ".json", "w") as fp:
json.dump(video_basic_info, fp)
vc = VideoClip(make_frame=lambda t: video_cap.get_frame(
(video_cap.duration - 3) * t / (img_count * duration)),
duration=img_count * duration)
vc = vc.set_fps(math.ceil(1 / duration))
vc.write_gif(outfile + ".gif")
def average_video(filepath, outpath, start=None, end=None, sample_every=1):
"""Calculate average of video frames"""
# Load video
vid = VideoFileClip(filepath, audio=False).resize(width=66)
width = vid.w
height = vid.h
if start is None and end is None:
frame_generator = vid.iter_frames(progress_bar=True, dtype=np.uint8)
else:
if start is None:
start = 0
if end is None:
end = vid.duration
# compute time increment for sampling by frames
sample_inc = sample_every / vid.fps
frame_generator = tqdm(vid.get_frame(f) for f in frange(start, end, sample_inc))
# create starting matrix of zeros
sum_fs = np.zeros(shape=(height, width, 3), dtype=int)
ma_sum_fs = np.zeros(shape=(height, width, 3), dtype=int)
prev_f = np.zeros(shape=(height, width, 3), dtype=int)
sum_delta_fs = np.zeros(shape=(height, width, 3), dtype=int)
n_frames = 0
for f in frame_generator:
#delta = f - prev_f
#sum_delta_fs += delta
#sum_fs += f
#ma_sum_fs += f
#if divmod(n_frames, 100)[1] == 0 and n_frames > 0:
# ma_f = ma_sum_fs / 100
# Image.fromarray(ma_f.astype(np.uint8))\
# .save(os.path.join(outpath, 'movavg_{}.png'.format(n_frames)))
# ma_sum_fs = np.zeros(shape=(height, width, 3), dtype=int)
#n_frames += 1
#prev_f = f
print len(f)
time.sleep(1.0/float(sample_every))
def run_moving_crash(args, target, outfile):
"""Runs a moving crash based on moving (gif/mp4) inputs"""
video = VideoFileClip(target)
img = video.get_frame(t=0) # first frame of the video
bounds = foreground.get_fg_bounds(img.shape[1], args.max_depth)
max_depth = bounds.max_depth
crash_params = crash.CrashParams(
max_depth, args.threshold, args.bg_value, args.rgb_select)
options = _options(args.reveal_foreground, args.reveal_background,
args.crash, args.reveal_quadrants, args.bg_value)
frames = video.iter_frames(fps=video.fps)
def make_frame(_):
frame = next(frames)
fg, bounds = foreground.find_foreground(frame, crash_params)
return _process_img(frame, fg, bounds, options)
output_video = VideoClip(
make_frame, duration=video.duration-(4/video.fps)) # trim last 4 frms
output_video.write_videofile(
outfile, preset=args.compression, fps=video.fps,
threads=args.in_parallel)
def average_video(filepath, outpath, start=None, end=None, sample_every=1):
global sb1
global sb2
global sb3
global sb4
global sb5
global sb6
global sb7
global sb8
global sb9
global sb10
global sb11
global sb12
global sb13
global sb14
global sb15
global sb16
global sb17
global sb18
global sb19
global sb20
global sb21
global sb22
global sb23
global sb24
global sb25
global sb26
global sb27
global sb28
global sb29
global sb30
global sb31
global sb32
global sb33
global sb34
global sb35
global sb36
global sb37
global sb38
global sb39
global sb40
global sb41
global sb42
global sb43
global sb44
global sb45
global sb46
global sb47
global sb48
global sb49
global sb50
global sb51
global sb52
global sb53
global sb54
global sb55
global sb56
global sb57
global sb58
global sb59
global sb60
global sb61
global sb62
global sb63
global sb64
global sb65
global sb66
"""Calculate average of video frames"""
# Load video
vid = VideoFileClip(filepath, audio=False).resize(width=66)
width = vid.w
height = vid.h
if start is None and end is None:
frame_generator = vid.iter_frames(progress_bar=True, dtype=np.uint8)
else:
if start is None:
start = 0
if end is None:
end = vid.duration
# compute time increment for sampling by frames
sample_inc = sample_every / vid.fps
frame_generator = tqdm(vid.get_frame(f) for f in frange(start, end, sample_inc))
# create starting matrix of zeros
sum_fs = np.zeros(shape=(height, width, 3), dtype=int)
ma_sum_fs = np.zeros(shape=(height, width, 3), dtype=int)
prev_f = np.zeros(shape=(height, width, 3), dtype=int)
sum_delta_fs = np.zeros(shape=(height, width, 3), dtype=int)
n_frames = 0
for f in frame_generator:
#delta = f - prev_f
#sum_delta_fs += delta
#sum_fs += f
#ma_sum_fs += f
#if divmod(n_frames, 100)[1] == 0 and n_frames > 0:
# ma_f = ma_sum_fs / 100
# Image.fromarray(ma_f.astype(np.uint8))\
# .save(os.path.join(outpath, 'movavg_{}.png'.format(n_frames)))
# ma_sum_fs = np.zeros(shape=(height, width, 3), dtype=int)
#n_frames += 1
#prev_f = f
#print len(f[0])
for x in range(1,len(f[0])+1):
for y in range(0,len(f)):
if y < 41:
r = f[y][x-1][0]
g = f[y][x-1][1]
b = f[y][x-1][2]
if x == 1:
sb1 += pack('BBBB', r, g, b, y)
elif x == 2:
sb2 += pack('BBBB', r, g, b, y)
elif x == 3:
sb3 += pack('BBBB', r, g, b, y)
elif x == 4:
sb4 += pack('BBBB', r, g, b, y)
elif x == 5:
sb5 += pack('BBBB', r, g, b, y)
elif x == 6:
sb6 += pack('BBBB', r, g, b, y)
elif x == 7:
sb7 += pack('BBBB', r, g, b, y)
elif x == 8:
sb8 += pack('BBBB', r, g, b, y)
elif x == 9:
sb9 += pack('BBBB', r, g, b, y)
elif x == 10:
sb10 += pack('BBBB', r, g, b, y)
elif x == 11:
sb11 += pack('BBBB', r, g, b, y)
elif x == 12:
sb12 += pack('BBBB', r, g, b, y)
elif x == 13:
sb13 += pack('BBBB', r, g, b, y)
elif x == 14:
sb14 += pack('BBBB', r, g, b, y)
elif x == 15:
sb15 += pack('BBBB', r, g, b, y)
elif x == 16:
sb16 += pack('BBBB', r, g, b, y)
elif x == 17:
sb17 += pack('BBBB', r, g, b, y)
elif x == 18:
sb18 += pack('BBBB', r, g, b, y)
elif x == 19:
sb19 += pack('BBBB', r, g, b, y)
elif x == 20:
sb20 += pack('BBBB', r, g, b, y)
elif x == 21:
sb21 += pack('BBBB', r, g, b, y)
elif x == 22:
sb22 += pack('BBBB', r, g, b, y)
elif x == 23:
sb23 += pack('BBBB', r, g, b, y)
elif x == 24:
sb24 += pack('BBBB', r, g, b, y)
elif x == 25:
sb25 += pack('BBBB', r, g, b, y)
elif x == 26:
sb26 += pack('BBBB', r, g, b, y)
elif x == 27:
sb27 += pack('BBBB', r, g, b, y)
elif x == 28:
sb28 += pack('BBBB', r, g, b, y)
elif x == 29:
sb29 += pack('BBBB', r, g, b, y)
elif x == 30:
sb30 += pack('BBBB', r, g, b, y)
elif x == 31:
sb31 += pack('BBBB', r, g, b, y)
elif x == 32:
sb32 += pack('BBBB', r, g, b, y)
elif x == 33:
sb33 += pack('BBBB', r, g, b, y)
elif x == 34:
sb34 += pack('BBBB', r, g, b, y)
elif x == 35:
sb35 += pack('BBBB', r, g, b, y)
elif x == 36:
sb36 += pack('BBBB', r, g, b, y)
elif x == 37:
sb37 += pack('BBBB', r, g, b, y)
elif x == 38:
sb38 += pack('BBBB', r, g, b, y)
elif x == 39:
sb39 += pack('BBBB', r, g, b, y)
elif x == 40:
sb40 += pack('BBBB', r, g, b, y)
elif x == 41:
sb41 += pack('BBBB', r, g, b, y)
elif x == 42:
sb42 += pack('BBBB', r, g, b, y)
elif x == 43:
sb43 += pack('BBBB', r, g, b, y)
elif x == 44:
sb44 += pack('BBBB', r, g, b, y)
elif x == 45:
sb45 += pack('BBBB', r, g, b, y)
elif x == 46:
sb46 += pack('BBBB', r, g, b, y)
elif x == 47:
sb47 += pack('BBBB', r, g, b, y)
elif x == 48:
sb48 += pack('BBBB', r, g, b, y)
elif x == 49:
sb49 += pack('BBBB', r, g, b, y)
elif x == 50:
sb50 += pack('BBBB', r, g, b, y)
elif x == 51:
sb51 += pack('BBBB', r, g, b, y)
elif x == 52:
sb52 += pack('BBBB', r, g, b, y)
elif x == 53:
sb53 += pack('BBBB', r, g, b, y)
elif x == 54:
sb54 += pack('BBBB', r, g, b, y)
elif x == 55:
sb55 += pack('BBBB', r, g, b, y)
elif x == 56:
sb56 += pack('BBBB', r, g, b, y)
elif x == 57:
sb57 += pack('BBBB', r, g, b, y)
elif x == 58:
sb58 += pack('BBBB', r, g, b, y)
elif x == 59:
sb59 += pack('BBBB', r, g, b, y)
elif x == 60:
sb60 += pack('BBBB', r, g, b, y)
elif x == 61:
sb61 += pack('BBBB', r, g, b, y)
elif x == 62:
sb62 += pack('BBBB', r, g, b, y)
elif x == 63:
sb63 += pack('BBBB', r, g, b, y)
elif x == 64:
sb64 += pack('BBBB', r, g, b, y)
elif x == 65:
sb65 += pack('BBBB', r, g, b, y)
elif x == 66:
sb66 += pack('BBBB', r, g, b, y)
time.sleep(1.0/float(sample_every))
class MyPaintWidget(Widget):
def __init__(self, **kwargs):
super(MyPaintWidget, self).__init__(**kwargs)
self._keyboard = Window.request_keyboard(self._keyboard_closed, self, 'text')
self._keyboard.bind(on_key_down=self._on_keyboard_down)
Window.size = (1366, 768)
self.size = Window.size
# if smoke true - user can draw rectangle
self.smoke = False
# if fire true - user can draw rectangle
self.fire = False
# list with points of fire rectangle
self.rectanglePoints = []
# number of current frame
self.numberOfFrame = 0
# if video open isVideoOpen = True
self.isVideoOpen = False
# video
self.video = None
# filename of result txt file
self.txtFilename = ""
# path to temp directory
self.dirPath = ""
# dictionary with points
self.dictionary = {}
self.Forest = ""
self.In = ""
self.Out = ""
self.start = 0
self.finish = 0
self.type = "None"
self.move = False
self.time = time.time()
def _keyboard_closed(self):
print('My keyboard have been closed!')
self._keyboard.unbind(on_key_down=self._on_keyboard_down)
self._keyboard = None
def _on_keyboard_down(self, keyboard, keycode, text, modifiers):
# Keycode is composed of an integer + a string
# If we hit escape, release the keyboard
if time.time() - self.time == 0:
print True
return True
else:
self.time = time.time()
if keycode[1] == 'p':
print 'p'
if keycode[1] == 'f':
print "t"
self.NextFrame()
if keycode[1] == 'a':
print "a"
self.DrawSmoke()
if keycode[1] == 'd':
self.DrawFire()
if keycode[1] == 'z':
self.PrevFrame()
# Return True to accept the key. Otherwise, it will be used by
# the system.
return True
# def __init__(self, **kwargs):
# super(MyPaintWidget1, self).__init__(**kwargs)
# self._keyboard = Window.request_keyboard(
# self._keyboard_closed, self, 'text')
# if self._keyboard.widget:
# # If it exists, this widget is a VKeyboard object which you can use
# # to change the keyboard layout.
# pass
# self._keyboard.bind(on_key_down=self._on_keyboard_down)
#
# def _keyboard_closed(self):
# print('My keyboard have been closed!')
# self._keyboard.unbind(on_key_down=self._on_keyboard_down)
# self._keyboard = None
#
# def _on_keyboard_down(self, keyboard, keycode, text, modifiers):
# print('The key', keycode, 'have been pressed')
# print(' - text is %r' % text)
# print(' - modifiers are %r' % modifiers)
#
# # Keycode is composed of an integer + a string
# # If we hit escape, release the keyboard
# if keycode[1] == 'escape':
# keyboard.release()
#
# # Return True to accept the key. Otherwise, it will be used by
# # the system.
# return True
def PrevFrame(self):
self.numberOfFrame -= 2 * speed
self.NextFrame()
def NextFrame(self):
for line in self.canvas.children:
if (type(line) == Line):
self.canvas.children.remove(line)
for obj in self.canvas.children:
if type(obj) == Rectangle:
self.rect = obj
filename = self.GetFrameFilename()
if (filename == None):
self.rect.size = (0, 0)
else:
self.rect.source = filename
def openVideoFile(self):
# open file explorer
root = Tkinter.Tk()
root.withdraw()
# get video filename
filename = tkFileDialog.askopenfilename(parent=root, title='Open file to encrypt')
try:
self.video = VideoFileClip(filename)
print self.video.fps
except Exception:
print "Error in opening file - " + filename
return None
# create default txt filename
self.txtFilename = filename[:filename.rfind(".")] + "_label.txt"
# display txt filename
self.ids.PathSaveFile.text = self.txtFilename
# create temp directory for frames from video
# self.dirPath = mkdtemp()
self.dirPath = "asdf"
makedirs("asdf")
print self.video.duration
# set number of frame
self.numberOfFrame = 0
# change winow size
Window.size = (self.video.size[0], self.video.size[1] + pad)
self.size = (self.video.size[0], self.video.size[1] + pad)
self.firstFrame = True
# find rectangle
for obj in self.canvas.children:
if type(obj) == Rectangle:
self.rect = obj
# set rectangle size
self.rect.size = (self.size[0], self.size[1] - pad)
# set frame to rectangle
self.rect.source = self.GetFrameFilename()
# return filename of frame from video
def GetFrameFilename(self):
# check if video open
if (self.video == None):
print "Error! Video doesn't open!"
return None
if (self.firstFrame):
imsave(self.dirPath + "/temp0.png", self.video.get_frame(self.numberOfFrame / self.video.fps))
self.firstFrame = False
self.dictionary[self.numberOfFrame] = {}
self.dictionary[self.numberOfFrame]["smoke"] = []
self.dictionary[self.numberOfFrame]["fire"] = []
return self.dirPath + "/temp0.png"
else:
# increase number of frame
self.numberOfFrame = int(self.numberOfFrame) + speed
if (self.numberOfFrame >= self.video.duration * self.video.fps):
self.numberOfFrame = int(self.numberOfFrame) - speed
self.Video = None
return None
self.dictionary[self.numberOfFrame] = {}
self.dictionary[self.numberOfFrame]["smoke"] = []
self.dictionary[self.numberOfFrame]["fire"] = []
# save frame from video
imsave(self.dirPath + "/temp" + str(self.numberOfFrame) + ".png",
self.video.get_frame(int(self.numberOfFrame / self.video.fps)))
print self.numberOfFrame / (self.video.fps * self.video.duration) * 100
return self.dirPath + "/temp" + str(self.numberOfFrame) + ".png"
def DrawSmoke(self):
# check if video open
if (self.video == None):
print "Error! Video doesn't open!"
return None
self.smoke = True
self.fire = False
def DrawFire(self):
# check if video open
if (self.video == None):
print "Error! Video doesn't open!"
return None
self.fire = True
self.smoke = False
def CleanSmoke(self):
points = self.dictionary.get(self.numberOfFrame)
if (points == None):
return None
pointsList = points.get("smoke")
if (points == None):
return None
else:
for points in pointsList:
# print "asdf"
for line in self.canvas.children:
if type(line) == Line:
for i in range(0, 4):
if line.points.count(points[i]) != 2:
break
else:
self.canvas.children.remove(line)
self.dictionary.get(self.numberOfFrame)["smoke"] = []
def CleanFire(self):
points = self.dictionary.get(self.numberOfFrame)
if (points == None):
return None
pointsList = points.get("fire")
# print "fire"
# print points
if (points == None):
return None
else:
for points in pointsList:
for line in self.canvas.children:
if type(line) == Line:
for i in range(0, 4):
if line.points.count(points[i]) != 2:
break
else:
self.canvas.children.remove(line)
self.dictionary.get(self.numberOfFrame)["fire"] = []
def FinishFire(self):
# check if video open
if (self.video == None):
print "Error! Video doesn't open!"
return None
self.finish = self.numberOfFrame
def StartFire(self):
# check if video open
if (self.video == None):
print "Error! Video doesn't open!"
return None
self.start = self.numberOfFrame
def In23(self):
# check if video open
if (self.video == None):
print "Error! Video doesn't open!"
return None
print "asdf"
self.type = "In"
self.ids.LInfo.text = self.type
def Out23(self):
# check if video open
if (self.video == None):
print "Error! Video doesn't open!"
return None
self.type = "Out"
self.ids.LInfo.text = self.type
def Forest23(self):
# check if video open
if (self.video == None):
print "Error! Video doesn't open!"
return None
self.type = "Forest"
self.ids.LInfo.text = self.type
def Quit(self):
print self.dirPath
if (isdir(self.dirPath)):
rmtree(self.dirPath)
App.get_running_app().stop()
def on_touch_down(self, touch):
super(MyPaintWidget, self).on_touch_down(touch)
color = (random(), 1, 1)
if (0 <= touch.y < self.size[1] - pad and 0 <= touch.x < self.size[0] and (self.smoke or self.fire)):
self.move = True
self.rectanglePoints.append(touch.x)
self.rectanglePoints.append(touch.y)
x = touch.x
y = touch.y
with self.canvas:
if (self.smoke):
Color(1, 0, 0)
else:
Color(0, 0, 1)
touch.ud['line'] = Line(rectangle=(x, y, 0, 0))
def on_touch_move(self, touch):
if (0 <= touch.y < self.size[1] - pad and 0 <= touch.x < self.size[0] and (
self.smoke or self.fire) and self.move):
x = self.rectanglePoints[0]
y = self.rectanglePoints[1]
touch.ud['line'].rectangle = (x, y, touch.x - x, touch.y - y)
def on_touch_up(self, touch):
if (0 <= touch.y < self.size[1] - pad and 0 <= touch.x < self.size[0] and (self.smoke or self.fire)):
self.move = False
self.rectanglePoints.append(touch.x)
self.rectanglePoints.append(touch.y)
if (self.smoke):
# self.dictionary[self.numberOfFrame]["smoke"] = self.rectanglePoints
self.dictionary[self.numberOfFrame]["smoke"].append(self.rectanglePoints)
# print "smoke dict"
# print self.dictionary[self.numberOfFrame]["smoke"]
else:
self.dictionary[self.numberOfFrame]["fire"].append(self.rectanglePoints)
# print "fire dict"
# print self.dictionary[self.numberOfFrame]["fire"]
self.smoke = False
self.fire = False
self.rectanglePoints = []
def SaveResult(self):
filename = self.ids.PathSaveFile.text
if (not (".txt" in filename)):
print "Error in text filename"
if isfile(filename):
i = 0
while (1):
filename = filename.replace(".txt", str(i) + ".txt")
if isfile(filename):
i += 1
continue
else:
break
f = open(filename, 'w')
f.write("type " + self.type + "\n")
f.write("start %s\n" % self.start)
f.write("finish %s\n" % self.finish)
self.dictionary = collections.OrderedDict(sorted(self.dictionary.items()))
for k, v in self.dictionary.iteritems():
f.write(str(k))
f.write(" smoke ")
if v.get("smoke") != None:
for item in v["smoke"]:
f.write("%s " % item)
else:
f.write(" 0 0 0 0 ")
f.write(" fire ")
if v.get("fire") != None:
for item in v["fire"]:
f.write("%s " % item)
else:
f.write("0 0 0 0")
f.write("\n")
f.close()
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
