def test_link_subsitite_masks(self): import os def imageName(x): return None, x createMovie( 'test_link1.m4v', lambda: np.random.randint(0, 255, (720, 480, 3), dtype='uint8'), 40) self.addFileToRemove('test_link1.m4v') createMovie( 'test_link2.m4v', lambda: np.random.randint(0, 255, (720, 480, 3), dtype='uint8'), 40) self.addFileToRemove('test_link2.m4v') masks = video_tools.formMaskDiff('test_link1.m4v', 'test_link2.m4v', 'link_1_2_cmp', '-') createMovie( 'test_link3.m4v', lambda: np.random.randint(0, 255, (720, 480, 3), dtype='uint8'), 30) self.addFileToRemove('test_link3.m4v') link_tool = scenario_model.VideoVideoLinkTool() model = Mock() model.getImageAndName = imageName model.G = Mock() model.G.dir = '.' subs = link_tool.addSubstituteMasks('test_link1.m4v', 'test_link2.m4v', model, '-', arguments={'Start Time': '11'}, filename='test_link3.m4v') self.assertEqual(1, len(subs)) self.assertEqual(30, video_tools.get_frames_from_segment(subs[0])) self.assertEqual(11, video_tools.get_start_frame_from_segment(subs[0])) self.assertTrue( os.path.exists(video_tools.get_file_from_segment(subs[0]))) self.addFileToRemove(video_tools.get_file_from_segment(subs[0]))
def cleanup_temporary_files(probes=[], scModel=None): files_to_remove = [] used_hdf5 = [''] used_masks = [''] for frm, to in scModel.G.get_edges(): edge = scModel.G.get_edge(frm, to) input_mask = getValue(edge, 'inputmaskname', '') video_input_mask = getValue(edge, 'arguments.videomaskname', '') subs = getValue(edge, 'substitute videomasks', []) for sub in subs: hdf5 = get_file_from_segment(sub) used_hdf5.append(hdf5) mask = getValue(edge, 'maskname', '') used_masks.append(input_mask) used_masks.append(video_input_mask) used_masks.append(mask) videomasks = getValue(edge, 'videomasks', []) for mask in videomasks: hdf5 = get_file_from_segment(mask) used_hdf5.append(hdf5) used_hdf5 = set(used_hdf5) used_masks = set(used_masks) for probe in probes: mask = probe.targetMaskFileName if probe.targetMaskFileName != None else '' if os.path.basename(mask) not in used_masks: files_to_remove.append(mask) if probe.targetVideoSegments != None: for segment in probe.targetVideoSegments: hdf5 = segment.filename if segment.filename != None else '' if os.path.basename(hdf5) not in used_hdf5: files_to_remove.append(hdf5) files_to_remove = set(files_to_remove) for _file in files_to_remove: try: os.remove(os.path.join(scModel.get_dir(), _file)) except OSError: pass
def read_masks(self, mask_set): from maskgen import tool_set r = [] for segment in mask_set: reader = tool_set.GrayBlockReader( video_tools.get_file_from_segment(segment)) r.append({ 'start_time': reader.current_frame_time(), 'start_frame': reader.current_frame(), 'frames': reader.length() }) return r
def test_video_video_link_tool(self): from maskgen.scenario_model import VideoVideoLinkTool from maskgen.software_loader import Operation from maskgen.video_tools import get_end_frame_from_segment, get_file_from_segment from maskgen.image_wrap import ImageWrapper import os import numpy as np def create_zero(h, w): return ImageWrapper(np.zeros((h, w), dtype='uint8')) vida = self.locateFile('videos/sample1.mov') vidb = self.locateFile('videos/sample1_swap.mov') image_values = { 'a': (create_zero(300, 300), vida), 'b': (create_zero(300, 300), vidb) } def get_image(arg): return image_values[arg] tool = VideoVideoLinkTool() scModel = Mock() scModel.gopLoader = Mock() scModel.G.dir = '.' scModel.gopLoader.getOperationWithGroups = Mock( return_value=Operation(name='test', category='test')) scModel.getImageAndName = get_image mask, analysis, errors = tool.compareImages('a', 'b', scModel, 'Normalization', arguments={ 'aggregate': 'sum', 'minimum threshold': 1 }, analysis_params={}) self.assertEqual(0, len(errors)) self.assertEqual((640, 480), mask.size) self.assertEqual(1, len(analysis['videomasks'])) self.assertEqual(803, get_end_frame_from_segment(analysis['videomasks'][0])) self.assertTrue( os.path.exists(get_file_from_segment(analysis['videomasks'][0])))
def test_zip_zip_link_tool(self): from maskgen.scenario_model import ZipZipLinkTool from maskgen.software_loader import Operation from maskgen.video_tools import get_end_frame_from_segment, get_file_from_segment from maskgen.tool_set import ZipWriter from maskgen.image_wrap import ImageWrapper import os import numpy as np def create_zero(h, w): return ImageWrapper(np.zeros((h, w), dtype='uint8')) w = ZipWriter('v1.zip') for i in range(2): w.write(np.random.randint(0, 255, (300, 300, 3))) w.release() self.addFileToRemove('v1.zip') w = ZipWriter('v2.zip') for i in range(2): w.write(np.random.randint(0, 255, (300, 300, 3))) w.release() self.addFileToRemove('v2.zip') image_values = { 'a': (create_zero(300, 300), 'v1.zip'), 'b': (create_zero(300, 300), 'v2.zip') } def get_image(arg): return image_values[arg] tool = ZipZipLinkTool() scModel = Mock() scModel.gopLoader = Mock() scModel.G.dir = '.' scModel.gopLoader.getOperationWithGroups = Mock( return_value=Operation(name='test', category='test')) scModel.getImageAndName = get_image mask, analysis, errors = tool.compareImages('a', 'b', scModel, 'Normalization', arguments={}, analysis_params={}) self.assertEqual(0, len(errors)) self.assertEqual((300, 300), mask.size) self.assertEqual(1, len(analysis['videomasks'])) self.assertEqual(2, get_end_frame_from_segment(analysis['videomasks'][0])) self.assertTrue( os.path.exists(get_file_from_segment(analysis['videomasks'][0]))) w = ZipWriter('v1.zip') for i in range(2): w.write(np.random.randint(0, 255, (300, 300, 3))) w.release() self.addFileToRemove('v1.zip') w = ZipWriter('v2.zip') for i in range(2): w.write(np.random.randint(0, 255, (400, 400, 3))) w.release() self.addFileToRemove('v2.zip') image_values = { 'a': (create_zero(300, 300), 'v1.zip'), 'b': (create_zero(400, 400), 'v2.zip') } def get_image(arg): return image_values[arg] tool = ZipZipLinkTool() scModel = Mock() scModel.gopLoader = Mock() scModel.G.dir = '.' scModel.gopLoader.getOperationWithGroups = Mock( return_value=Operation(name='test', category='test')) scModel.getImageAndName = get_image mask, analysis, errors = tool.compareImages('a', 'b', scModel, 'TransformResize', arguments={}, analysis_params={}) self.assertEqual(0, len(errors)) self.assertEqual('(100, 100)', analysis['shape change']) self.assertEqual(1, len(analysis['videomasks'])) self.assertEqual(2, get_end_frame_from_segment(analysis['videomasks'][0]))
def warpMask(self, video_masks, source, target, expectedType='video', inverse=False, useFFMPEG=False): """ Tranform masks when the frame rate has changed. :param video_masks: ithe set of video masks to walk through and transform :param expectedType: :param video_masks: :return: new set of video masks """ edge = self.graph.get_edge(source, target) meta_i, frames_i = self.getVideoMeta(source, show_streams=True, media_types=[expectedType]) meta_o, frames_o = self.getVideoMeta(target, show_streams=True, media_types=[expectedType]) indices_i = ffmpeg_api.get_stream_indices_of_type(meta_i, expectedType) indices_o = ffmpeg_api.get_stream_indices_of_type(meta_o, expectedType) if not indices_i or not indices_o: return video_masks index_i = indices_i[0] index_o = indices_o[0] isVFR = ffmpeg_api.is_vfr(meta_i[index_i]) or ffmpeg_api.is_vfr( meta_o[index_o]) result = self.getChangeInFrames(edge, meta_i[index_i], meta_o[index_o], source, target, expectedType=expectedType) if result is None: return video_masks sourceFrames, sourceTime, targetFrames, targetTime, sourceRate, targetRate = result if sourceFrames == targetFrames and int(sourceTime * 100) == int( targetTime * 100): return video_masks dropRate = sourceFrames / float( sourceFrames - targetFrames) if sourceFrames != targetFrames else sourceFrames + 1 #if sourceFrames > targetFrames else targetFrames / float(sourceFrames - targetFrames) def apply_change(existing_value, orig_rate, final_rate, inverse=False, round_value=True, min_value=0, upper_bound=False): # if round_value, return a tuple of value plus rounding error import math multiplier = -1.0 if inverse else 1.0 adjustment = existing_value * math.pow(final_rate / orig_rate, multiplier) if round_value: v = max( min(round(adjustment), final_rate) if upper_bound else round(adjustment), min_value) e = abs(adjustment - v) return int(v), e return max( min(adjustment, final_rate) if upper_bound else adjustment, min_value) def adjustPositionsFFMPEG(meta, video_frames, hits): rate = ffmpeg_api.get_video_frame_rate_from_meta([meta], [video_frames]) aptime = 0 lasttime = 0 hitspos = 0 start_mask = None for pos in range(0, len(video_frames)): aptime = get_frame_time(video_frames[pos], aptime, rate) while hitspos < len(hits) and aptime > hits[hitspos][0]: mask = hits[hitspos][2] element = hits[hitspos][1] error = abs(aptime - hits[hitspos][0]) if element == 'starttime': update_segment(mask, starttime=lasttime, startframe=pos, error=error + get_error_from_segment(mask)) start_mask = mask else: # for error, only record the error if not recorded update_segment( mask, endtime=lasttime, endframe=pos, error=(error if start_mask != mask else 0) + get_error_from_segment(mask)) hitspos += 1 lasttime = aptime return mask def adjustPositions(video_file, hits): # used if variable frame rate frmcnt = 0 hitspos = 0 last = 0 cap = cv2api_delegate.videoCapture(video_file) try: while cap.grab() and hitspos < len(hits): frmcnt += 1 aptime = cap.get(cv2api_delegate.prop_pos_msec) while hitspos < len(hits) and aptime > hits[hitspos][0]: mask = hits[hitspos][2] element = hits[hitspos][1] error = max(abs(last - hits[hitspos][0]), abs(aptime - hits[hitspos][0])) if element == 'starttime': update_segment(mask, starttime=last, startframe=frmcnt, error=error) else: update_segment(mask, endtime=last, endframe=frmcnt, error=max( error, get_error_from_segment(mask))) hitspos += 1 last = aptime finally: cap.release() return mask new_mask_set = [] hits = [] # First adjust all the frame and time references by the total change in the video. # In most cases, the length of the video in time changes by a small amount which is distributed # across all the masks for mask_set in video_masks: if 'type' in mask_set and mask_set['type'] != expectedType: new_mask_set.append(mask_set) continue #these are initial estimates startframe, error_start = apply_change( get_start_frame_from_segment(mask_set), float(sourceFrames), float(targetFrames), inverse=inverse, round_value=True, min_value=1) endframe, error_end = apply_change( get_end_frame_from_segment(mask_set), float(sourceFrames), float(targetFrames), inverse=inverse, min_value=1, round_value=True, upper_bound=True) endtime = apply_change(get_end_time_from_segment(mask_set), float(sourceTime), targetTime, inverse=inverse, round_value=False) starttime = apply_change(get_start_time_from_segment(mask_set), sourceTime, targetTime, inverse=inverse, round_value=False, upper_bound=True) try: if endframe == int(getValue(meta_o[index_o], 'nb_frames', 0)) and \ float(getValue(meta_o[index_o], 'duration', 0)) > 0: endtime = float(getValue(meta_o[index_o], 'duration', 0)) * 1000.0 - (1000.0 / targetRate) elif endtime > targetTime and endframe > targetFrames: message = '{} exceeded target time of {} for {}'.format( sourceTime, target, targetTime) if (endtime - targetTime) > 300: logging.getLogger('maskgen').error(message) else: logging.getLogger('maskgen').warn(message) endtime = targetTime - (1000.0 / targetRate) endframe = targetFrames except: pass change = create_segment( rate=sourceRate if inverse else targetRate, type=get_type_of_segment(mask_set), starttime=starttime, startframe=startframe, error=get_error_from_segment(mask_set) + (max(error_start, error_end) / targetRate * 1000.0), endtime=endtime, endframe=endframe, videosegment=get_file_from_segment(mask_set)) if not isVFR: # in this case, we trust the time invariance, updating frames recalculate_frames_for_segment(change) # then we reupdate time to match the frames recalculate_times_for_segment(change) new_mask_set.append(change) hits.append( (get_start_time_from_segment(change), 'starttime', change)) hits.append((get_end_time_from_segment(change), 'endime', change)) # only required when one of the two videos is variable rate hits = sorted(hits) if isVFR: if useFFMPEG: meta_r, frames_r = self.getVideoMeta( source if inverse else target, show_streams=True, with_frames=True, media_types=[expectedType]) index_r = ffmpeg_api.get_stream_indices_of_type( meta_o, expectedType)[0] adjustPositionsFFMPEG(meta_r[index_r], frames_r[index_r], hits) else: adjustPositions( self.getNodeFile(source) if inverse else self.getNodeFile(target), hits) transfer_masks(video_masks, new_mask_set, dropRate, frame_time_function=lambda x, y: y + (1000.0 / targetRate), frame_count_function=lambda x, y: y + 1) return new_mask_set