def drop(self, firstFrametoDrop, lastFrametoDrop, framesToAdd, flows, matches):
super(StratAudioSep, self).drop(firstFrametoDrop, lastFrametoDrop, framesToAdd, flows, matches)
st = tool_set.getMilliSecondsAndFrameCount(int(firstFrametoDrop), self.fps)[0]
en = tool_set.getMilliSecondsAndFrameCount(int(lastFrametoDrop), self.fps)[0]
audio_file = maskgen_audio.cut_n_stitch(self.sp.original, [int(st), int(en)], 100)
maskgen_audio.export_audio(audio_file, os.path.splitext(self.out_file)[0] + '.wav')
return firstFrametoDrop, lastFrametoDrop, framesToAdd
def transformAdd(img,source,target,**kwargs):
start_time = getMilliSecondsAndFrameCount(kwargs['Start Time']) if 'Start Time' in kwargs else (0, 1)
end_time = getMilliSecondsAndFrameCount(kwargs['End Time']) if 'End Time' in kwargs else None
frames_add = int(kwargs['Frames to Add']) if 'Frames to Add' in kwargs else None
if frames_add is not None:
end_time = (start_time[0], start_time[1] + frames_add - 1)
codec = (kwargs['codec']) if 'codec' in kwargs else 'XVID'
add_frames, end_time_millis = maskgen.algorithms.optical_flow.smartAddFrames(source, target,
start_time,
end_time,
codec=codec,
direction=kwargs['Direction'] if 'Direction' in kwargs else 'forward')
if start_time[0] > 0:
et = getDurationStringFromMilliseconds(end_time_millis)
else:
et = str(int(start_time[1]) + int(add_frames))
return {'Start Time': str(kwargs['Start Time']),
'End Time': et,
'Frames to Add': int(add_frames),
'Method': 'Pixel Motion',
'Algorithm': 'Farneback',
'scale': 0.8,
'levels': 7,
'winsize': 15,
'iterations': 3,
'poly_n': 7,
'poly_sigma': 1.5,
'Vector Detail': 100}, None
def create(self, arguments={}, invert=False):
from maskgen.zip_tools import AudioPositions
from maskgen.tool_set import getMilliSecondsAndFrameCount
from maskgen.video_tools import FileMetaDataLocator, \
create_segment
fps = float(getValue(arguments, 'sample rate', 0))
# use AudioPostions to determine duration and rate
positions = AudioPositions(FileMetaDataLocator(
self.startFileName).get_filename(),
fps=fps)
duration = positions.get_total_duration()
rate = positions.fps
end_time_tuple = getMilliSecondsAndFrameCount(
getValue(arguments, 'End Time', "00:00:00"))
start_time_tuple = getMilliSecondsAndFrameCount(
getValue(arguments, 'Start Time', '00:00:00'))
if end_time_tuple[0] <= start_time_tuple[0]:
end_time_tuple = (duration, 0)
return [
create_segment(
starttime=float(start_time_tuple[0]),
startframe=int(start_time_tuple[0] * rate / 1000.0) + 1,
endtime=float(end_time_tuple[0]),
endframe=int(end_time_tuple[0] * rate / 1000.0) + 1,
type='audio',
rate=rate)
]
def transform(img, source, target, **kwargs):
start_time = getMilliSecondsAndFrameCount(str(
kwargs['Start Time'])) if 'Start Time' in kwargs else (0, 1)
end_time = getMilliSecondsAndFrameCount(str(
kwargs['End Time'])) if 'End Time' in kwargs else None
seconds_to_drop = float(
kwargs['seconds to drop']) if 'seconds to drop' in kwargs else 1.0
save_histograms = (kwargs['save histograms']
== 'yes') if 'save histograms' in kwargs else False
drop = (kwargs['drop']
== 'yes') if 'drop at start time' in kwargs else True
audio = (kwargs['Audio'] == 'yes') if 'Audio' in kwargs else False
codec = (kwargs['codec']) if 'codec' in kwargs else 'XVID'
start, stop, frames_to_add = smartDropFrames(
source,
target,
start_time,
end_time,
seconds_to_drop,
savehistograms=save_histograms,
codec=codec,
audio=audio)
return {
'Start Time': str(start),
'End Time': str(stop),
'Frames Dropped': str(stop - start + 1),
'Frames to Add': frames_to_add
}, None
def value(self, frame1, frame2):
st = tool_set.getMilliSecondsAndFrameCount(self.offset + frame1,
self.fps)[0]
en = tool_set.getMilliSecondsAndFrameCount(self.offset + frame2,
self.fps)[0]
if int(st) < self.vlen and int(en) < self.vlen and \
self.visualsilence[int(st)] == 1 and self.visualsilence[int(en) + 1] == 1:
return 1
return 1000000
def test_timeparse(self):
t, f = tool_set.getMilliSecondsAndFrameCount('00:00:00')
self.assertEqual(1, f)
self.assertEqual(0, t)
t, f = tool_set.getMilliSecondsAndFrameCount('1')
self.assertEqual(1, f)
self.assertEqual(0, t)
self.assertTrue(tool_set.validateTimeString('03:10:10.434'))
t, f = tool_set.getMilliSecondsAndFrameCount('03:10:10.434')
self.assertEqual(0, f)
self.assertEqual(1690434, t)
t, f = tool_set.getMilliSecondsAndFrameCount('03:10:10:23')
self.assertFalse(tool_set.validateTimeString('03:10:10:23'))
self.assertEqual(23, f)
self.assertEqual(1690000, t)
t, f = tool_set.getMilliSecondsAndFrameCount('03:10:10:A',
defaultValue=(0, 0))
self.assertFalse(tool_set.validateTimeString('03:10:10:A'))
self.assertEqual((0, 0), (t, f))
time_manager = tool_set.VidTimeManager(startTimeandFrame=(1000, 2),
stopTimeandFrame=(1003, 4))
time_manager.updateToNow(999)
self.assertTrue(time_manager.isBeforeTime())
time_manager.updateToNow(1000)
self.assertTrue(time_manager.isBeforeTime())
time_manager.updateToNow(1001)
self.assertTrue(time_manager.isBeforeTime())
time_manager.updateToNow(1002)
self.assertFalse(time_manager.isBeforeTime())
self.assertFalse(time_manager.isPastTime())
time_manager.updateToNow(1003)
self.assertFalse(time_manager.isPastTime())
time_manager.updateToNow(1004)
self.assertFalse(time_manager.isPastTime())
time_manager.updateToNow(1005)
self.assertFalse(time_manager.isPastTime())
time_manager.updateToNow(1006)
self.assertFalse(time_manager.isPastTime())
time_manager.updateToNow(1007)
self.assertFalse(time_manager.isPastTime())
time_manager.updateToNow(1008)
self.assertTrue(time_manager.isPastTime())
self.assertEqual(9, time_manager.getEndFrame())
self.assertEqual(4, time_manager.getStartFrame())
time_manager = tool_set.VidTimeManager(startTimeandFrame=(999, 2),
stopTimeandFrame=None)
time_manager.updateToNow(999)
self.assertTrue(time_manager.isBeforeTime())
time_manager.updateToNow(1000)
self.assertTrue(time_manager.isBeforeTime())
time_manager.updateToNow(1001)
self.assertFalse(time_manager.isBeforeTime())
self.assertEqual(3, time_manager.getEndFrame())
self.assertEqual(3, time_manager.getStartFrame())
def create(self, arguments={}, invert=False):
from maskgen.video_tools import getMaskSetForEntireVideoForTuples, FileMetaDataLocator
from maskgen.tool_set import getMilliSecondsAndFrameCount
end_time_tuple = getMilliSecondsAndFrameCount(
getValue(arguments, 'End Time', "00:00:00"))
start_time_tuple = getMilliSecondsAndFrameCount(
getValue(arguments, 'Start Time', '00:00:00'))
return getMaskSetForEntireVideoForTuples(
FileMetaDataLocator(self.startFileName),
start_time_tuple=start_time_tuple,
end_time_tuple=end_time_tuple if end_time_tuple[0] > 0 else None,
media_types=self.media_types())
def transform(img, source, target, **kwargs):
start_time = getMilliSecondsAndFrameCount(str(kwargs['Start Time'])) if 'Start Time' in kwargs else (0, 1)
end_time = getMilliSecondsAndFrameCount(str(kwargs['End Time'])) if 'End Time' in kwargs else None
codec = (kwargs['codec']) if 'codec' in kwargs else 'XVID'
start, stop, frames_dropped = dropFrames(source,
target,
start_time,
end_time,
codec=codec)
return {'Start Time': str(start),
'End Time': str(stop),
'Frames Dropped': frames_dropped}, None
def transform(img, source, target, **kwargs):
start_time = getMilliSecondsAndFrameCount(
kwargs['Select Start Time']) if 'Select Start Time' in kwargs else (0,
1)
end_time = addFrame(start_time, int(kwargs['Number of Frames']) - 1)
paste_time = getMilliSecondsAndFrameCount(kwargs['Dest Paste Time'])
codec = (kwargs['codec']) if 'codec' in kwargs else 'XVID'
start_frame = copyFrames(
source, target, start_time, end_time, paste_time, codec=codec) + 1
return {
'Start Time': str(start_frame),
'End Time': str(start_frame + int(kwargs['Number of Frames']) - 1),
'add type': 'insert'
}, None
def transformDrop(img,source,target,**kwargs):
start_time = getMilliSecondsAndFrameCount(str(kwargs['Start Time'])) if 'Start Time' in kwargs else (0, 1)
end_time = getMilliSecondsAndFrameCount(str(kwargs['End Time'])) if 'End Time' in kwargs else None
seconds_to_drop = float(kwargs['seconds to drop']) if 'seconds to drop' in kwargs else 1.0
save_histograms = (kwargs['save histograms'] == 'yes') if 'save histograms' in kwargs else False
drop = (kwargs['drop']) if 'drop' in kwargs else True
codec = (kwargs['codec']) if 'codec' in kwargs else 'XVID'
audio = (kwargs['audio']) if 'audio' in kwargs else False
if drop:
start, stop, frames_to_add = smartDropFrames(source, target,
start_time,
end_time,
seconds_to_drop,
savehistograms=save_histograms,
codec=codec,
audio=audio)
# start = 1235
# stop = 1245
# frames_to_add=7
return {'Start Time': str(start),
'End Time': str(stop),
'Frames Dropped': stop - start + 1,
'Frames to Add': frames_to_add}, None
if audio:
frame_data = get_best_frame_pairs(source, target,
start_time,
end_time,
seconds_to_drop,
savehistograms=save_histograms,
codec=codec,
strategy=dropStrats.StratTopFrames)
else:
start, stop, frames_to_add = get_best_frame_pairs(source, target,
start_time,
end_time,
seconds_to_drop,
savehistograms=save_histograms,
codec=codec,
strategy=dropStrats.StratTopFramesVideo)
return {'Start Time': str(start),
'End Time': str(stop),
'Frames Dropped': stop - start + 1,
'Frames to Add': frames_to_add}, None
# start = 1235
# stop = 1245
# frames_to_add=7
return frame_data
def transform(img, source, target, **kwargs):
end_time = getMilliSecondsAndFrameCount(
kwargs['Select Start Time']) if 'Select Start Time' in kwargs else (0,
1)
return {
'Select Start Time':
str(end_time[1] - int(kwargs['Number of Frames'])),
'Number of Frames': kwargs['Number of Frames'],
'Dest Paste Time': kwargs['Dest Paste Time']
}, None
def getMasksFromEdge(self,
source,
target,
media_types,
channel=0,
startTime=None,
endTime=None):
"""
Currently prioritizes masks over entered. This seems appropriate. Adjust the software to
produce masks consistent with recorded change.
:param filename:q
:param edge:
:param media_types:
:param channel:
:param startTime:
:param endTime:
:return:
"""
edge = self.graph.get_edge(source, target)
if 'videomasks' in edge and \
edge['videomasks'] is not None and \
len(edge['videomasks']) > 0:
return [
mask for mask in edge['videomasks']
if mask['type'] in media_types
]
else:
st = getMilliSecondsAndFrameCount(getValue(
edge, 'arguments.Start Time', defaultValue='00:00:00.000'),
defaultValue=(0, 1))
et = getValue(edge, 'arguments.End Time', None)
et = getMilliSecondsAndFrameCount(et) if et not in [None, '0'
] else None
result = self.getMetaDataLocator(
source).getMaskSetForEntireVideoForTuples(
start_time_tuple=st if startTime is None else startTime,
end_time_tuple=et if endTime is None else endTime,
media_types=media_types,
channel=channel)
if result is None or len(result) == 0:
return None
return result
def test_zip(self):
import os
filename = self.locateFile('tests/zips/raw.zip')
self.addFileToRemove(os.path.join(os.path.dirname(filename), 'raw.png'))
img = tool_set.openImage(filename,tool_set.getMilliSecondsAndFrameCount('2'),preserveSnapshot=True)
self.assertEqual((5796, 3870),img.size)
tool_set.condenseZip(filename,keep=1)
self.addFileToRemove(os.path.join(os.path.dirname(filename),'raw_c.zip'))
contents = tool_set.getContentsOfZip(os.path.join(os.path.dirname(filename),'raw_c.zip'))
self.assertTrue('59487443539401a4d83512edaab3c1b2.cr2' in contents)
self.assertTrue('7d1800a38ca7a22021bd94e71b6e0f42.cr2' in contents)
self.assertTrue(len(contents) == 2)
def selectSilence(matches, fps, sp, offset):
audio_matches = []
silences = sp.detect_silence(sp.processed,
min_silence_len=sp.fade_length,
silence_thresh=-21,
seek_step=1)
visualsilence = np.zeros(silences[-1][1])
for s in silences:
visualsilence[s[0]:s[1]] = 1
if matches is not None:
for m in matches:
st = tool_set.getMilliSecondsAndFrameCount(offset + int(m[0]),
fps)[0]
en = tool_set.getMilliSecondsAndFrameCount(offset + int(m[1]),
fps)[0]
if int(st)<len(visualsilence) and int(en) < len(visualsilence) and \
visualsilence[int(st)] == 1 and visualsilence[int(en) + 1] == 1:
audio_matches.append(m)
return np.asarray(audio_matches)
def create(self, arguments={}, invert=False):
from maskgen.tool_set import getMilliSecondsAndFrameCount
media_types = ['video', 'audio'] if getValue(
arguments, 'include audio', 'no') == 'yes' else ['video']
from maskgen.video_tools import FileMetaDataLocator
end_time_tuple = getMilliSecondsAndFrameCount(
getValue(arguments, 'End Time', "00:00:00"))
start_time_tuple = getMilliSecondsAndFrameCount(
getValue(arguments, 'Start Time', '00:00:00'))
video_set = FileMetaDataLocator(
self.startFileName).getMaskSetForEntireVideoForTuples(
start_time_tuple=start_time_tuple,
end_time_tuple=end_time_tuple
if end_time_tuple[1] > start_time_tuple[1] else None,
media_types=media_types)
audio_segments = [
x for x in video_set if get_type_of_segment(x) == 'audio'
]
video_segments = [
x for x in video_set if get_type_of_segment(x) == 'video'
]
if getValue(arguments, 'include audio', 'no') == 'yes':
for audio_segment in audio_segments:
video_segment = video_segments[0] if len(
video_segments) > 0 else audio_segment
update_segment(
audio_segment,
type='audio',
starttime=get_start_time_from_segment(video_segment),
endtime=get_end_time_from_segment(video_segment),
startframe=int(
get_start_time_from_segment(video_segment) *
get_rate_from_segment(audio_segment) / 1000.0),
endframe=int(
get_end_time_from_segment(video_segment) *
get_rate_from_segment(audio_segment) / 1000.0) + 1)
return video_set
def test_gray_writing(self):
import os
import sys
import time
s = time.clock()
writer = tool_set.GrayBlockWriter('test_ts_gw', 29.97002997)
mask_set = list()
for i in range(255):
mask = np.random.randint(255, size=(1090, 1920)).astype('uint8')
mask_set.append(mask)
writer.write(mask, 33.3666666667 * i, i + 1)
for i in range(300, 350):
mask = np.random.randint(255, size=(1090, 1920)).astype('uint8')
mask_set.append(mask)
writer.write(mask, 33.3666666667 * i, i + 1)
writer.close()
fn = writer.get_file_name()
reader = tool_set.GrayBlockReader(fn, end_frame=305)
pos = 0
while True:
mask = reader.read()
if mask is None:
break
compare = mask == mask_set[pos]
self.assertEqual(mask.size, sum(sum(compare)))
if pos == 255:
self.assertEqual(301, reader.current_frame() - 1)
pos += 1
reader.close()
self.assertEqual(305, pos)
print time.clock() - s
suffix = 'm4v'
if sys.platform.startswith('win'):
suffix = 'avi'
filename = tool_set.convertToVideo(fn)
self.assertEquals('test_ts_gw_mask_0.0.' + suffix, filename)
self.assertTrue(os.path.exists(filename))
size = tool_set.openImage(
filename, tool_set.getMilliSecondsAndFrameCount('00:00:01')).size
self.assertTrue(size == (1920, 1090))
os.remove(filename)
os.remove(fn)
def drop(self, firstFrametoDrop, lastFrametoDrop, framesToAdd, flows, matches):
st = tool_set.getMilliSecondsAndFrameCount(int(firstFrametoDrop), self.fps)[0]
en = tool_set.getMilliSecondsAndFrameCount(int(lastFrametoDrop), self.fps)[0]
return firstFrametoDrop, st, lastFrametoDrop, en, framesToAdd
