def post_import_videos_job(dataset_name, path, method, logs_path=None, minutes=0): dataset_name = quote(dataset_name) if logs_path is None: logs_path = path # Since 'path' probably contains a query, like ending with '*.mkv', this should be removed if not (logs_path[-1] == '/'): logs_path = right_remove(logs_path, logs_path.split('/')[-1]) dc = DatasetConfig(dataset_name) if dc.exists: resolution = dc.get('video_resolution') fps = dc.get('video_fps') cmd = [python_path, "import_videos.py", "--query={}".format(path), "--dataset={}".format(dataset_name), "--resolution={}".format(resolution), "--method={}".format(method), "--fps={}".format(fps), "--logs={}".format(logs_path), "--minutes={}".format(minutes)] job_id = jm.run(cmd, "import_videos") if job_id: return (job_id, 202) else: return (NoContent, 503) else: return (NoContent, 404)
def post_train_detector_job(dataset_name, run_name, epochs, import_datasets=""): dataset_name = quote(dataset_name) run_name = quote(run_name) rc = RunConfig(dataset_name, run_name) dc = DatasetConfig(dataset_name) if rc.exists and dc.exists: cmd = [ python_path, "training_script.py", "--name={}".format(dataset_name), "--experiment={}".format(run_name), "--input_shape={}".format(rc.get('detector_resolution')), "--train_data_dir=fjlfbwjefrlbwelrfb_man_we_need_a_better_detector_codebase", "--batch_size={}".format(rc.get('detection_training_batch_size')), "--image_shape={}".format(dc.get('video_resolution')), "--epochs={}".format(epochs) ] if import_datasets: import_datasets = quote(import_datasets) cmd.append("--import_datasets={}".format(import_datasets)) job_id = jm.run(cmd, "train_detector") if job_id: return (job_id, 202) else: return (NoContent, 503) else: return (NoContent, 404)
def post_point_tracks_job(dataset_name, visualize, overwrite): assert (type(visualize) == bool) assert (type(overwrite) == bool) cmd = "findvids" if not overwrite: cmd = "continue" dataset_name = quote(dataset_name) dc = DatasetConfig(dataset_name) if dc.exists: cmd = [ python_path, "klt.py", "--cmd={}".format(cmd), "--dataset={}".format(dataset_name), "--imsize={}".format(dc.get('point_track_resolution')), "--visualize={}".format(visualize) ] job_id = jm.run(cmd, "point_tracks") if job_id: return (job_id, 202) else: return (NoContent, 503) else: return (NoContent, 404)
def post_autoannotate_job(dataset_name, import_datasets="", epochs=75, resolution="(640,480,3)"): dataset_name = quote(dataset_name) resolution = quote(resolution) dc = DatasetConfig(dataset_name) if dc.exists: cmd = [ python_path, "autoannotate.py", "--dataset={}".format(dataset_name), "--input_shape={}".format(resolution), "--image_shape={}".format(dc.get('video_resolution')), "--epochs={}".format(epochs) ] if import_datasets: import_datasets = quote(import_datasets) cmd.append("--import_datasets={}".format(import_datasets)) job_id = jm.run(cmd, "autoannotate") if job_id: return (job_id, 202) else: return (NoContent, 503) else: return (NoContent, 404)
def post_prepare_annotations_job(dataset_name, less_night=True): assert(type(less_night) == bool) dataset_name = quote(dataset_name) dc = DatasetConfig(dataset_name) if dc.exists: cmd = [python_path, "annotation_preparation.py", "--dataset={}".format(dataset_name), "--num_ims={}".format(dc.get('images_to_annotate')), "--ims_per_vid={}".format(dc.get('images_to_annotate_per_video')), "--train_amount={}".format(dc.get('annotation_train_split')), "--night={}".format(less_night)] job_id = jm.run(cmd, "prepare_annotations") if job_id: return (job_id, 202) else: return (NoContent, 503) else: return (NoContent, 404)
def post_detections_to_world_coordinates_job(dataset_name, run_name, make_videos): dataset_name = quote(dataset_name) run_name = quote(run_name) rc = RunConfig(dataset_name, run_name) dc = DatasetConfig(dataset_name) if rc.exists and dc.exists: cmd = [ python_path, "detections_world.py", "--cmd=findvids", "--dataset={}".format(dataset_name), "--run={}".format(run_name), "--make_videos={}".format(make_videos), "--ssdres={}".format(rc.get("detector_resolution")), "--vidres={}".format(dc.get('video_resolution')), "--kltres={}".format(dc.get('point_track_resolution')) ] job_id = jm.run(cmd, "detections_to_world") if job_id: return (job_id, 202) else: return (NoContent, 503) else: return (NoContent, 404)
def get_annotation_slideshow(dataset_name): dataset_name = quote(dataset_name) dc = DatasetConfig(dataset_name) if dc.exists: imsize = dc.get('video_resolution') outpath = datasets_path / dataset_name / "slideshow.mp4" res = slideshow(dataset_name, outpath) if not res: return ("Failed to make slideshow", 404) else: vid = send_file(str(outpath), mimetype='video/mp4') return (vid, 200) else: return ("Dataset does not exist", 404)
def post_visualize_detections_job(dataset_name, run_name, confidence_threshold, coords): dataset_name = quote(dataset_name) run_name = quote(run_name) rc = RunConfig(dataset_name, run_name) dc = DatasetConfig(dataset_name) if rc.exists and dc.exists: cmd = [python_path, "visualize_detections.py", "--cmd=findvids", "--dataset={}".format(dataset_name), "--run={}".format(run_name), "--res={}".format(rc.get("detector_resolution")), "--conf={}".format(confidence_threshold), "--fps={}".format(dc.get('video_fps')), "--coords={}".format(coords)] job_id = jm.run(cmd, "visualize_detections") if job_id: return (job_id, 202) else: return (NoContent, 503) else: return (NoContent, 404)
def post_rare_class_mining_job(dataset_name, class_name, confidence, time_distance, time_sampling, import_datasets="", epochs=75, resolution="(300,300,3)"): dataset_name = quote(dataset_name) class_name = quote(class_name) resolution = quote(resolution) dc = DatasetConfig(dataset_name) if dc.exists: cmd = [ python_path, "rare_class_mining.py", "--dataset={}".format(dataset_name), "--class_name={}".format(class_name), "--confidence={}".format(confidence), "--time_dist={}".format(time_distance), "--sampling_rate={}".format(time_sampling), "--epochs={}".format(epochs), "--input_shape={}".format(resolution), "--image_shape={}".format(dc.get('video_resolution')) ] if import_datasets: import_datasets = quote(import_datasets) cmd.append("--import_datasets={}".format(import_datasets)) job_id = jm.run(cmd, "rare_class_mining") if job_id: return (job_id, 202) else: return (NoContent, 503) else: return ("Dataset does not exists or is not configured", 404)
def main(dataset, run, date, gt_csv, det_id, gt_class_name_conversion, visualize, patience, per_iteration): dc = DatasetConfig(dataset) vidres = dc.get('video_resolution') width, height, _ = vidres if width > height: stack_axis = 'v' else: stack_axis = 'h' if gt_class_name_conversion is None: print_flush("Not converting class names") else: print_flush("Using class conversion:") print_flush(gt_class_name_conversion) gt_class_name_conversion = json.loads(gt_class_name_conversion) assert (type(gt_class_name_conversion) == dict) print_flush("Interpreting ground truth...") gt = interpret_tracks_gt(dataset, date, det_id, gt_csv) print_flush("Optimizing...") config_min = { 'time_drop_thresh': 0.1, # in seconds 'time_region_check_thresh': 0.1, # in seconds 'creation_too_close_thresh': 1, # in meters 'is_too_close_thresh': { 'default': 0.2, 'bicycle_bicycle': 0.1 }, # in metres 'incorrect_class_cost': { 'default': 100, 'bicycle_person': 3, 'person_bicycle': 3 }, # unitless? Compared with WorldTrack.cost output 'cost_thresh': { 'default': 5, 'bicycle': 5 }, # unitless? Compared with WorldTrack.cost output 'mask_margin': 0, # in pixels, how close to the borders of the interesting region a track can be 'cost_dist_weight': 0.5, 'cost_dir_weight': 0.5, } config_max = { 'time_drop_thresh': 7.0, # in seconds 'time_region_check_thresh': 2.0, # in seconds 'creation_too_close_thresh': 10, # in meters 'is_too_close_thresh': { 'default': 3.0, 'bicycle_bicycle': 2.0 }, # in metres 'incorrect_class_cost': { 'default': 123456789123456789, 'bicycle_person': 30, 'person_bicycle': 30 }, # unitless? Compared with WorldTrack.cost output 'cost_thresh': { 'default': 25, 'bicycle': 35 }, # unitless? Compared with WorldTrack.cost output 'mask_margin': 15, # in pixels, how close to the borders of the interesting region a track can be 'cost_dist_weight': 2.0, 'cost_dir_weight': 2.0, } config_min, config_max = map(WorldTrackingConfig, (config_min, config_max)) base_path = runs_path / "{}_{}".format(dataset, run) plot_path = base_path / 'world_tracking_optimization.png' config, tracks = optimize_tracking(config_min, config_max, dataset, run, gt, gt_class_name_conversion, plot_path=plot_path, patience=patience, n=per_iteration) save(config, base_path / 'world_tracking_optimization.pklz') if visualize: print_flush("Visualizing...") visualize_tracks(base_path / 'world_tracking_optimization.mp4', dataset, gt, tracks, stack_axis=stack_axis) print_flush("Done!")
def visualize_tracks(outvidpath, dataset, gts, tracks=None, stack_axis='v'): import imageio as iio from visualize_tracking import _draw_world, draw_world from visualize import class_colors from apply_mask import Masker from config import DatasetConfig if not (tracks is None): calib = Calibration(dataset) # Reset IDs tracks = sorted(tracks, key=lambda x: x.history[0][0]) for track in tracks: track.id = i i += 1 dc = DatasetConfig(dataset) gts_by_vid = split_lambda(gts, lambda x: x[0]) assert (len(gts_by_vid) == 1) vid = list(gts_by_vid.keys())[0] n_colors = 50 colors = class_colors(n_colors) mask = Masker(dataset) with iio.get_writer(outvidpath, fps=dc.get('video_fps')) as outvid: with iio.get_reader(datasets_path / dataset / "videos" / (vid + '.mkv')) as invid: gt_by_frame = split_lambda(gts, lambda x: x[1]) fns = list(gt_by_frame.keys()) fns.sort() for fn in fns: gts_frame = gt_by_frame[fn] frame = invid.get_data(fn) frame = mask.mask(frame, alpha=0.5) if not (tracks is None): tracks_frame = frame.copy() for gt in gts_frame: vid, fn, t, x, y, i, c, px, py = gt text = "{} {}".format(c, i) col = colors[i % n_colors] frame = _draw_world(frame, text, px, py, col) if not (tracks is None): for track in tracks: draw_world(tracks_frame, track, fn, colors[track.id % n_colors], calib) if stack_axis == 'h': frame = np.hstack((frame, tracks_frame)) elif stack_axis == 'v': frame = np.vstack((frame, tracks_frame)) else: raise (ValueError( "Incorrect stack axis {}, try 'h' or 'v'".format( stack_axis))) outvid.append_data(frame)
def main(dataset, run, videos): # Note: This main function only works for world coordinate tracks! calib = Calibration(dataset) dc = DatasetConfig(dataset) masker = Masker(dataset) if videos == 'all': from glob import glob files = glob('{rp}{ds}_{r}/tracks_world/*_tracks.pklz'.format( rp=runs_path, ds=dataset, r=run)) video_names = [ right_remove(x.split('/')[-1], '_tracks.pklz') for x in files ] elif videos.startswith('random:'): num = int(left_remove(videos, 'random:')) from glob import glob files = glob('{rp}{ds}_{r}/tracks_world/*_tracks.pklz'.format( rp=runs_path, ds=dataset, r=run)) all_video_names = [ right_remove(x.split('/')[-1], '_tracks.pklz') for x in files ] video_names = [] while len(video_names) < num: video_name = choice(all_video_names) if not video_name in video_names: video_names.append(video_name) # Just in case user wants more videos than there are if len(video_names) == len(all_video_names): break else: # Assumes the user types one or more videos, separated by commas with no spaces video_names = videos.split(',') # In case user includes endings video_names = [right_remove(x.rstrip, '.mkv') for x in video_names] # In case user includes spaces video_names = [x.strip(' ') for x in video_names] print_flush("Chosen videos: ") print_flush(str(video_names)) for video_name in video_names: print_flush(video_name) print_flush("Loading...") tracks = load('{rp}{ds}_{r}/tracks_world/{v}_tracks.pklz'.format( rp=runs_path, ds=dataset, r=run, v=video_name)) vidpath = "{dsp}{ds}/videos/{v}.mkv".format(dsp=datasets_path, ds=dataset, v=video_name) if not isfile(vidpath): raise (ValueError("Incorrect input {}".format(videos))) outvidpath = '{rp}{ds}_{r}/tracks_world/{v}_tracks.mp4'.format( rp=runs_path, ds=dataset, r=run, v=video_name) print_flush("Rendering...") render_video(tracks, vidpath, outvidpath, mask=masker, id_mode="global", calib=calib, fps=dc.get('video_fps')) print_flush("Done!")
def main(cmd, dataset, run, vidres, ssdres, kltres, make_videos): vidres = parse_resolution(vidres) ssdres = parse_resolution(ssdres) kltres = parse_resolution(kltres) x_factor = float(vidres[0]) / ssdres[0] y_factor = float(vidres[1]) / ssdres[1] det_dims = ('xmin', 'xmax', 'ymin', 'ymax') det_factors = (x_factor, x_factor, y_factor, y_factor) calib = Calibration(dataset) ts = Timestamps(dataset) class_data = get_class_data(dataset) class_heights = {d['name']: d['height'] for d in class_data} class KLTConfig(object): klt_x_factor = 0 klt_y_factor = 0 klt_config = KLTConfig() klt_config.klt_x_factor = vidres[0] / kltres[0] klt_config.klt_y_factor = vidres[1] / kltres[1] if cmd == "findvids": vidnames = list((datasets_path / dataset / "videos").glob('*.mkv')) vidnames = [x.stem for x in vidnames] vidnames.sort() outfolder = runs_path / '{}_{}'.format(dataset, run) / 'detections_world' mkdir(outfolder) else: vidnames = [cmd] outfolder = Path('.') mkdir(outfolder) if make_videos: classnames = get_classnames(dataset) dc = DatasetConfig(dataset) fps = dc.get('video_fps') for v in vidnames: print_flush(v) detections = pd.read_csv(runs_path / '{}_{}'.format(dataset, run) / 'csv' / (v + '.csv')) # Convert pixel coordinate positions from SSD resolution to video resolution # because Calibration assumes video resolution coordinates for dim, factor in zip(det_dims, det_factors): detections[dim] = round(detections[dim] * factor).astype(int) print_flush("Converting point tracks...") klt = load(datasets_path / dataset / 'klt' / (v + '.pklz')) klt, klt_frames = convert_klt(klt, klt_config) pts = PointTrackStructure(klt, klt_frames, vidres[0], vidres[1]) outpath = outfolder / '{v}_world.csv'.format(v=v) print_flush("Converting to world coordinates...") detections3D = detections_to_3D( detections, pts, calib, ts, v, klt_save_path=outpath.with_name(outpath.stem + '_klt.pklz'), class_heights=class_heights) detections3D.to_csv(outpath, float_format='%.4f') if make_videos: from visualize_detections import detections_video vidpath = datasets_path / dataset / "videos" / "{}.mkv".format(v) print_flush("Rendering video...") detections_video(detections3D, vidpath, outpath.with_suffix('.mp4'), classnames, dataset, vidres, fps=fps, conf_thresh=0.0, coords='world') print_flush("Done!")
def main(dataset, times, images_per_time, interval): times = times.strip( "'" ) # These are added around it by the quote function in server.py, to make sure it is a single argument instead of being split by the spaces ts = Timestamps(dataset) dc = DatasetConfig(dataset) fps = dc.get('video_fps') half_interval = int((fps * interval) / 2) # in frames timestrings = times.split(',') for timestring in timestrings: print_flush(timestring) # Intepret the requested times, can look like '2017-05-16 00:49:04.954000' splot = timestring.split(' ') date = splot[0].split('-') time = splot[1].replace('.', ':').split(':') year, month, day = map(int, date) hour, minute, second, microsecond = map(int, time) timestamp = datetime(year, month, day, hour, minute, second, microsecond) vid_name, frame_num = ts.get_frame_number(timestamp) print_flush("Time found to be {}, frame {}".format( vid_name, frame_num)) if vid_name is None: raise (ValueError( "This timestamp was incorrect: {} Could it be before the first video?" .format(timestring))) video_path = datasets_path / dataset / "videos" / (vid_name + '.mkv') annot_folder = datasets_path / dataset / "objects" / "train" / vid_name log_path = annot_folder / 'frames.log' if not log_path.is_file(): with log_path.open('w') as f: f.write("{}.mkv\n".format(vid_name)) # See which frames were already annotated, to start at the right index already_ims = list(annot_folder.glob('*.jpg')) if already_ims: already_nums = [int(x.stem) for x in already_ims] i = max(already_nums) + 1 else: i = 1 with iio.get_reader(video_path) as vid: # Find start and end time, in frames start = frame_num - half_interval if start < 0: start = 0 stop = frame_num + half_interval if stop >= len(vid): stop = len(vid) - 1 with open(log_path, 'a') as log: # Choose frames to extract frame_nums = np.linspace(start, stop, images_per_time).astype(int).tolist() frame_nums = sorted(list(set(frame_nums))) # Remove duplicates for frame_num in frame_nums: frame = vid.get_data(frame_num) log.write("{} ".format(frame_num)) impath = annot_folder / "{}.jpg".format(i) imsave(impath, frame) i += 1 print_flush("> Written {}".format(impath)) print_flush("Done!")
def main(cmd, dataset, run, conf, make_videos): from pathlib import Path if make_videos: from visualize_tracking import render_video from config import DatasetConfig from apply_mask import Masker mask = Masker(dataset) dc = DatasetConfig(dataset) config_path = runs_path / "{}_{}".format(dataset,run) / "world_tracking_optimization.pklz" if config_path.is_file(): config = load(config_path) else: #raise(ValueError("No world tracking optimized configuration exists at {}".format(config_path))) config = WorldTrackingConfig(default_config) calib = Calibration(dataset) munkres = Munkres() ts = Timestamps(dataset) start_stop = None if cmd == "findvids": vidnames = (datasets_path / dataset / "videos").glob('*.mkv') vidnames = [x.stem for x in vidnames] vidnames.sort() outfolder = runs_path / "{}_{}".format(dataset,run) / "tracks_world" mkdir(outfolder) else: vidnames = [cmd] outfolder = Path('./') start_stop = (0,500) for v in vidnames: print_flush(v) out_path = outfolder / (v+'_tracks.pklz') print_flush("Loading data...") det_path = runs_path / "{}_{}".format(dataset,run) / "detections_world" / (v+'_world.csv') detections3D = pd.read_csv(det_path) klt_path = det_path.with_name(det_path.stem + '_klt.pklz') klts = load(klt_path) print_flush("Tracking...") tracks = make_tracks(dataset, v, detections3D, klts, munkres, ts, calib, config, start_stop=start_stop) print_flush("Saving tracks...") save(tracks, out_path) if make_videos: vidpath = datasets_path / dataset / "videos" / (v+'.mkv') print_flush("Rendering video...") render_video(tracks, vidpath, out_path.with_suffix('.mp4'), calib=calib, mask=mask, fps=dc.get('video_fps')) print_flush("Done!")
def main(cmd, dataset, run, conf, make_videos): if make_videos: from visualize_tracking import render_video from config import DatasetConfig from apply_mask import Masker mask = Masker(dataset) dc = DatasetConfig(dataset) config_path = "{rp}{ds}_{rn}/world_tracking_optimization.pklz".format(rp=runs_path, ds=dataset, rn=run) if isfile(config_path): config = load(config_path) else: #raise(ValueError("No world tracking optimized configuration exists at {}".format(config_path))) config = WorldTrackingConfig(default_config) calib = Calibration(dataset) munkres = Munkres() ts = Timestamps(dataset) start_stop = None if cmd == "findvids": from glob import glob vidnames = glob('{dsp}{ds}/videos/*.mkv'.format(dsp=datasets_path, ds=dataset)) vidnames = [right_remove(x.split('/')[-1], '.mkv') for x in vidnames] vidnames.sort() outfolder = '{}{}_{}/tracks_world/'.format(runs_path, dataset, run) mkdir(outfolder) else: vidnames = [cmd] outfolder = './' start_stop = (0,500) for v in vidnames: print_flush(v) out_path = "{of}{v}_tracks.pklz".format(of=outfolder, v=v) print_flush("Loading data...") det_path = "{rp}{ds}_{rn}/detections_world/{v}_world.csv".format(rp=runs_path, ds=dataset, rn=run, v=v) detections3D = pd.read_csv(det_path) klt_path = det_path.replace('.csv', '_klt.pklz') klts = load(klt_path) print_flush("Tracking...") tracks = make_tracks(dataset, v, detections3D, klts, munkres, ts, calib, config, start_stop=start_stop) print_flush("Saving tracks...") save(tracks, out_path) if make_videos: vidpath = "{dsp}{ds}/videos/{v}.mkv".format(dsp=datasets_path, ds=dataset, v=v) print_flush("Rendering video...") render_video(tracks, vidpath, out_path.replace('.pklz','.mp4'), calib=calib, mask=mask, fps=dc.get('video_fps')) print_flush("Done!")
def main(dataset, run, n_clips, clip_length): dc = DatasetConfig(dataset) rc = RunConfig(dataset, run) mask = Masker(dataset) classes = get_classnames(dataset) num_classes = len(classes) + 1 calib = Calibration(dataset) dataset_path = "{dsp}{ds}/".format(dsp=datasets_path, ds=dataset) run_path = "{rp}{ds}_{r}/".format(rp=runs_path, ds=dataset, r=run) # Grab a bunch of videos vids_query = "{dsp}videos/*.mkv".format(dsp=dataset_path) all_vids = glob(vids_query) all_vids = [right_remove(x.split('/')[-1], '.mkv') for x in all_vids] all_vids.sort() vids = [] if n_clips > len(all_vids): n_clips = len(all_vids) if n_clips == len(all_vids): vids = all_vids else: while len(vids) < n_clips: vid = choice(all_vids) if not vid in vids: vids.append(vid) print_flush(vids) # Find out what has been run on all of these videos, what to include include_klt = True include_pixeldets = True include_worlddets = True include_worldtracks = True klts = [] pixeldets = [] worlddets = [] worldtracks = [] # Point tracks need to be converted for faster access vidres = dc.get('video_resolution') kltres = dc.get('point_track_resolution') class KLTConfig(object): klt_x_factor = 0 klt_y_factor = 0 klt_config = KLTConfig() klt_config.klt_x_factor = vidres[0] / kltres[0] klt_config.klt_y_factor = vidres[1] / kltres[1] ssdres = rc.get('detector_resolution') x_scale = vidres[0] / ssdres[0] y_scale = vidres[1] / ssdres[1] colors = class_colors(num_classes) for vid in vids: f = get_klt_path(dataset_path, vid) if not isfile(f): include_klt = False else: klt = load(f) klt, klt_frames = convert_klt(klt, klt_config) pts = (klt, klt_frames, class_colors(n_cols_klts)) klts.append(pts) f = get_pixeldet_path(run_path, vid) if not isfile(f): include_pixeldets = False else: dets = pd.read_csv(f) pixeldets.append((dets, colors, x_scale, y_scale)) f = get_worlddet_path(run_path, vid) if not isfile(f): include_worlddets = False else: dets = pd.read_csv(f) worlddets.append((dets, colors, calib)) f = get_worldtracks_path(run_path, vid) if not isfile(f): include_worldtracks = False else: tracks = load(f) worldtracks.append((tracks, class_colors(n_cols_tracks), calib)) print_flush("Point tracks: {}".format(include_klt)) print_flush("Pixel coordinate detections: {}".format(include_pixeldets)) print_flush("World coordinate detections: {}".format(include_worlddets)) print_flush("World coordinate tracks: {}".format(include_worldtracks)) # Decide where to start and stop in the videos clip_length = clip_length * dc.get( 'video_fps') # convert from seconds to frames print_flush("Clip length in frames: {}".format(clip_length)) clips = [] for vid in vids: start, stop = make_clip(vid, clip_length, dataset_path) clips.append((start, stop)) incs = [ include_klt, include_pixeldets, include_worlddets, include_worldtracks ] funs = [klt_frame, pixeldet_frame, worlddet_frame, worldtracks_frame] dats = [klts, pixeldets, worlddets, worldtracks] nams = [ "Point tracks", "Detections in pixel coordinates", "Detections in world coordinates", "Tracks in world coordinates" ] print_flush(clips) with iio.get_writer("{trp}summary.mp4".format(trp=run_path), fps=dc.get('video_fps')) as outvid: for i_vid, vid in enumerate(vids): print_flush(vid) old_prog = 0 with iio.get_reader("{dsp}videos/{v}.mkv".format(dsp=dataset_path, v=vid)) as invid: start, stop = clips[i_vid] for i_frame in range(start, stop): frame = invid.get_data(i_frame) pieces = [] for inc, fun, dat, nam in zip(incs, funs, dats, nams): if inc: piece = fun(dat[i_vid], mask.mask(frame.copy(), alpha=0.5), i_frame) draw_text(piece, vid, i_frame, nam) pieces.append(piece) outvid.append_data(join(pieces)) prog = float(i_frame - start) / (stop - start) if prog - old_prog > 0.1: print_flush("{}%".format(round(prog * 100))) old_prog = prog print_flush("Done!")
def main(cmd, dataset, run, vidres, ssdres, kltres, make_videos): vidres = parse_resolution(vidres) ssdres = parse_resolution(ssdres) kltres = parse_resolution(kltres) x_factor = float(vidres[0]) / ssdres[0] y_factor = float(vidres[1]) / ssdres[1] det_dims = ('xmin', 'xmax', 'ymin', 'ymax') det_factors = (x_factor, x_factor, y_factor, y_factor) calib = Calibration(dataset) ts = Timestamps(dataset) class_data = get_class_data(dataset) class_heights = {d['name']: d['height'] for d in class_data} class KLTConfig(object): klt_x_factor = 0 klt_y_factor = 0 klt_config = KLTConfig() klt_config.klt_x_factor = vidres[0] / kltres[0] klt_config.klt_y_factor = vidres[1] / kltres[1] if cmd == "findvids": from glob import glob vidnames = glob('{dsp}{ds}/videos/*.mkv'.format(dsp=datasets_path, ds=dataset)) vidnames = [right_remove(x.split('/')[-1], '.mkv') for x in vidnames] vidnames.sort() outfolder = '{}{}_{}/detections_world/'.format(runs_path, dataset, run) mkdir(outfolder) else: vidnames = [cmd] outfolder = './' mkdir(outfolder) if make_videos: classnames = get_classnames(dataset) dc = DatasetConfig(dataset) fps = dc.get('video_fps') for v in vidnames: print_flush(v) detections = pd.read_csv('{}{}_{}/csv/{}.csv'.format( runs_path, dataset, run, v)) # Convert pixel coordinate positions from SSD resolution to video resolution # because Calibration assumes video resolution coordinates for dim, factor in zip(det_dims, det_factors): detections[dim] = round(detections[dim] * factor).astype(int) print_flush("Converting point tracks...") klt = load('{}{}/klt/{}.pklz'.format(datasets_path, dataset, v)) klt, klt_frames = convert_klt(klt, klt_config) pts = PointTrackStructure(klt, klt_frames, vidres[0], vidres[1]) outpath = '{of}{v}_world.csv'.format(of=outfolder, v=v) print_flush("Converting to world coordinates...") detections3D = detections_to_3D(detections, pts, calib, ts, v, klt_save_path=outpath.replace( '.csv', '_klt.pklz'), class_heights=class_heights) detections3D.to_csv(outpath, float_format='%.4f') if make_videos: from visualize_detections import detections_video vidpath = "{dsp}{ds}/videos/{v}.mkv".format(dsp=datasets_path, ds=dataset, v=v) print_flush("Rendering video...") detections_video(detections3D, vidpath, outpath.replace('.csv', '.mp4'), classnames, dataset, vidres, fps=fps, conf_thresh=0.0, coords='world') print_flush("Done!")