def run_benchmark(): import ubelt as ub data_dim = 128 num_dpts = 1000000 num_qpts = 25000 num_neighbs = 5 random_seed = 42 rng = np.random.RandomState(0) dataset = rand_vecs(num_dpts, data_dim, rng) testset = rand_vecs(num_qpts, data_dim, rng) # Build determenistic flann object flann = pyflann.FLANN() print('building datset for %d vecs' % (len(dataset))) with ub.Timer(label='building kdtrees', verbose=True) as t: params = flann.build_index( dataset, algorithm='kdtree', trees=6, random_seed=random_seed, cores=6, ) print(params) qvec_chunks = list(ub.chunks(testset, 1000)) times = [] for qvecs in ub.ProgIter(qvec_chunks, label='find nn'): with ub.Timer(verbose=0) as t: _ = flann.nn_index(testset, num_neighbs) # NOQA times.append(t.ellapsed) print(np.mean(times))
def check_performance_versus_tqdm(): import progiter import tqdm import ubelt as ub self = iterable = LongIterable(duration=3) progkw = dict( leave=True, mininterval=2.0, ) with ub.Timer('tqdm') as timer1: Progress = tqdm.tqdm prog = Progress(iterable, **progkw) for idx in prog: pass with ub.Timer('progiter.progiter') as timer2: Progress = progiter.ProgIter prog = Progress(iterable, **progkw) for idx in prog: pass with ub.Timer('ub progiter') as timer3: Progress = ub.ProgIter prog = Progress(iterable, **progkw) for idx in prog: pass print('timer1.elapsed = {!r}'.format(timer1.elapsed)) print('timer2.elapsed = {!r}'.format(timer2.elapsed)) print('timer3.elapsed = {!r}'.format(timer3.elapsed))
def _devcheck_sample_full_image(): """ """ import kwimage import numpy as np sampler = grab_camvid_sampler() cid_to_cidx = sampler.catgraph.id_to_idx classes = sampler.catgraph # Try loading an entire image img, annots = sampler.load_image_with_annots(1) file = img['imdata'] imdata = file[:] aids = [ann['id'] for ann in annots] _annots = sampler.dset.annots(aids) sseg_list = [] for s in _annots.lookup('segmentation'): m = kwimage.MultiPolygon.coerce(s) sseg_list.append(m) aids = _annots.aids cids = _annots.cids boxes = _annots.boxes segmentations = kwimage.PolygonList(sseg_list) class_idxs = np.array([cid_to_cidx[cid] for cid in cids]) dets = kwimage.Detections( aids=aids, boxes=boxes, class_idxs=class_idxs, segmentations=segmentations, classes=classes, datakeys=['aids'], ) if 1: print('dets = {!r}'.format(dets)) print('dets.data = {!r}'.format(dets.data)) print('dets.meta = {!r}'.format(dets.meta)) if ub.argflag('--show'): import kwplot with ub.Timer('dets.draw_on'): canvas = imdata.copy() canvas = dets.draw_on(canvas) kwplot.imshow(canvas, pnum=(1, 2, 1), title='dets.draw_on') with ub.Timer('dets.draw'): kwplot.imshow(imdata, pnum=(1, 2, 2), docla=True, title='dets.draw') dets.draw()
def test_timer_default_verbosity(): with CaptureStdout() as cap: ub.Timer('').tic().toc() assert cap.text == '', 'should be quiet by default when label is not given' with CaptureStdout() as cap: ub.Timer('a label').tic().toc() assert cap.text != '', 'should be verbose by default when label is given'
def _ensure_coco(coco): # Map a file path or an in-memory dataset to a CocoDataset import kwcoco import six from os.path import exists if coco is None: return None elif isinstance(coco, six.string_types): fpath = _rectify_fpath(coco) if exists(fpath): with ub.Timer( 'read kwcoco dataset: fpath = {!r}'.format(fpath)): coco = kwcoco.CocoDataset(fpath, autobuild=False) print('building kwcoco index') coco._build_index() else: if not coco.lower().startswith('special:'): import warnings warnings.warn('warning start dataset codes with special:') code = coco else: code = coco.lower()[len('special:'):] coco = kwcoco.CocoDataset.demo(code) else: # print('live dataset') assert isinstance(coco, kwcoco.CocoDataset) return coco
def test_timer_nonewline(): from xdoctest.utils import CaptureStdout with CaptureStdout() as cap: timer = ub.Timer(newline=False) timer.tic() timer.toc() assert cap.text.replace('u', '').startswith("\ntic('')...toc('')")
def test_timer_error(): try: with ub.Timer() as timer: raise Exception() except Exception as ex: pass assert timer.elapsed > 0
def check_fsspec(): import ubelt as ub from os.path import join dpath = ub.ensure_app_cache_dir('ubelt/simple_server') info = ub.cmd(['python', '-m', 'http.server', '--directory', dpath], detatch=True) fnames = ['file_{}.txt'.format(i) for i in range(100)] for fname in fnames: ub.writeto(join(dpath, fname), ub.hash_data(fname)) # info = ub.cmd('python -m http.server --directory "{}"'.format(dpath), verbose=3) # proc = info['proc'] # TODO: ub.cmd return with some object that can tee the output on demand? # _proc_iteroutput = ub.util_cmd._proc_iteroutput_thread(proc) # line = next(_proc_iteroutput) urls = ['http://localhost:8000/{}'.format(fname) for fname in fnames] import fsspec file = fsspec.open(urls[0]).open().read() with ub.Timer(label='fsspec.cat', verbose=1): fs = fsspec.filesystem("http") out = fs.cat(urls) # fetches data concurrently with ub.Timer(label='ub.DownloadManager', verbose=1): dpath = ub.ensure_app_cache_dir('ubelt/simple_download_root') dman = ub.DownloadManager(dpath) for url in urls: dman.submit(url) results = [] for future in dman.as_completed(prog=True): fpath = future.result() results.append(fpath) # print('fpath = {!r}'.format(fpath)) proc.terminate()
def main_selenium(): from selenium import webdriver ensure_selenium_chromedriver() # url = 'https://stackoverflow.com/questions/1732348/regex-match-open-tags-except-xhtml-self-contained-tags/' # url = 'https://www.reddit.com/r/TheSilphArena/comments/jr2ee9/season_5_little_cup_meta_moves_infographic/' # url = 'https://en.wikipedia.org/wiki/Prime_number' # url = 'https://networkx.org/documentation/networkx-1.10/reference/generated/networkx.algorithms.simple_paths.all_simple_paths.html' url = 'https://pypi.org/project/networkx/' with ub.Timer() as timer: driver = webdriver.Chrome() driver.get(url) driver.execute_script("window.scrollTo(0, document.body.scrollHeight);") driver.implicitly_wait(30) print('timer.elapsed = {!r}'.format(timer.elapsed))
def main_requests(): urls = [ 'https://google.com', 'https://whitehouse.gov', 'https://cmake.org', 'https://stackoverflow.com/', 'https://reddit.com', 'https://github.com/ipfs/go-ipfs', ] times = {} for url in urls: with ub.Timer() as timer: resp = requests.get(url) print(resp.text) times[url] = timer.elapsed print('times = {}'.format(ub.repr2(times, nl=1))) total = sum(times.values()) print('total = {!r}'.format(total))
def after_initialize(harn, **kw): harn.draw_timer = ub.Timer().tic()
def grab_coco_camvid(): """ Example: >>> # xdoctest: +REQUIRES(--download) >>> dset = grab_coco_camvid() >>> print('dset = {!r}'.format(dset)) >>> # xdoctest: +REQUIRES(--show) >>> import kwplot >>> plt = kwplot.autoplt() >>> plt.clf() >>> dset.show_image(gid=1) Ignore: import xdev gid_list = list(dset.imgs) for gid in xdev.InteractiveIter(gid_list): dset.show_image(gid) xdev.InteractiveIter.draw() """ import kwcoco cache_dpath = ub.ensure_app_cache_dir('kwcoco', 'camvid') coco_fpath = join(cache_dpath, 'camvid.mscoco.json') # Need to manually bump this if you make a change to loading SCRIPT_VERSION = 'v4' # Ubelt's stamp-based caches are super cheap and let you take control of # the data format. stamp = ub.CacheStamp('camvid_coco', cfgstr=SCRIPT_VERSION, dpath=cache_dpath, product=coco_fpath, hasher='sha1', verbose=3) if stamp.expired(): camvid_raw_info = grab_raw_camvid() dset = convert_camvid_raw_to_coco(camvid_raw_info) with ub.Timer('dumping MS-COCO dset to: {}'.format(coco_fpath)): dset.dump(coco_fpath) # Mark this process as completed by saving a small file containing the # hash of the "product" you are stamping. stamp.renew() # We can also cache the index build step independently. This uses # ubelt.Cacher, which is pickle based, and writes the actual object to # disk. Each type of caching has its own uses and tradeoffs. cacher = ub.Cacher('prebuilt-coco', cfgstr=SCRIPT_VERSION, dpath=cache_dpath, verbose=3) dset = cacher.tryload() if dset is None: print('Reading coco_fpath = {!r}'.format(coco_fpath)) dset = kwcoco.CocoDataset(coco_fpath, tag='camvid') # Directly save the file to disk. dset._build_index() dset._build_hashid() cacher.save(dset) camvid_dset = dset print('Loaded camvid_dset = {!r}'.format(camvid_dset)) return camvid_dset
def test_timer_nonewline(): with CaptureStdout() as cap: timer = ub.Timer(newline=False, verbose=1) timer.tic() timer.toc() assert cap.text.replace('u', '').startswith("\ntic('')...toc('')")
import ubelt as ub import sys import time from datetime import timedelta timer = ub.Timer().tic() print('Welcome to stopwatch') try: while True: total_sec = timer.toc() total_min, sec_rem = divmod(total_sec, 60) total_hour, min_part = divmod(total_min, 60) hour_part = total_hour sec_part = int(sec_rem) subsec = str(sec_rem - sec_part).split('.')[-1][0:4] x = f'{int(total_hour):02d}:{int(min_part):02d}:{sec_part:02d}.{subsec}' # delta = timedelta(seconds=sec) sys.stdout.write(str(x)) time.sleep(0.001) sys.stdout.write('\r') except KeyboardInterrupt: print('') print(timer.toc()) """ python ~/misc/learn/stopwatch.py """
def after_initialize(harn, **kw): harn.draw_timer = ub.Timer().tic() # hack: for k, v in harn.datasets.items(): v.raw_model = harn.xpu.raw(harn.model)
def random_negatives(self, num, anchors=None, window_size=None, gids=None, thresh=0.0, exact=True, rng=None, patience=None): """ Finds random boxes that don't have a large overlap with positive instances. Args: num (int): number of negative boxes to generate (actual number of boxes returned may be less unless `exact=True`) anchors (ndarray): prior normalized aspect ratios for negative boxes. Mutually exclusive with `window_size`. window_size (ndarray): absolute (W, H) sizes to use for negative boxes. Mutually exclusive with `anchors`. gids (List[int]): image-ids to generate negatives for, if not specified generates for all images. thresh (float): overlap area threshold as a percentage of the negative box size. When thresh=0.0, that means negatives cannot overlap any positive, when threh=1.0, there are no constrains on negative placement. exact (bool): if True, ensure that we generate exactly `num` boxes rng (RandomState): random number generator Example: >>> from ndsampler.isect_indexer import * >>> import ndsampler >>> import kwcoco >>> dset = kwcoco.CocoDataset.demo('shapes8') >>> self = FrameIntersectionIndex.from_coco(dset) >>> anchors = np.array([[.35, .15], [.2, .2], [.1, .1]]) >>> #num = 25 >>> num = 5 >>> rng = kwarray.ensure_rng(None) >>> neg_gids, neg_boxes = self.random_negatives( >>> num, anchors, gids=[1], rng=rng, thresh=0.01, exact=1) >>> # xdoc: +REQUIRES(--show) >>> gid = sorted(set(neg_gids))[0] >>> boxes = neg_boxes.compress(neg_gids == gid) >>> import kwplot >>> kwplot.autompl() >>> img = kwimage.imread(dset.imgs[gid]['file_name']) >>> kwplot.imshow(img, doclf=True, fnum=1, colorspace='bgr') >>> support = self._support(gid) >>> kwplot.draw_boxes(support, color='blue') >>> kwplot.draw_boxes(boxes, color='orange') Example: >>> from ndsampler.isect_indexer import * >>> import kwcoco >>> dset = kwcoco.CocoDataset.demo('shapes8') >>> self = FrameIntersectionIndex.from_coco(dset) >>> #num = 25 >>> num = 5 >>> rng = kwarray.ensure_rng(None) >>> window_size = (50, 50) >>> neg_gids, neg_boxes = self.random_negatives( >>> num, window_size=window_size, gids=[1], rng=rng, >>> thresh=0.01, exact=1) >>> # xdoc: +REQUIRES(--show) >>> import kwplot >>> kwplot.autompl() >>> gid = sorted(set(neg_gids))[0] >>> boxes = neg_boxes.compress(neg_gids == gid) >>> img = kwimage.imread(dset.imgs[gid]['file_name']) >>> kwplot.imshow(img, doclf=True, fnum=1, colorspace='bgr') >>> support = self._support(gid) >>> support.draw(color='blue') >>> boxes.draw(color='orange') """ if not ((window_size is None) ^ (anchors is None)): raise ValueError('window_size and anchors are mutually exclusive') rng = kwarray.ensure_rng(rng) all_gids = self.all_gids if gids is None else gids def _generate_rel(n): # Generate n candidate boxes in the normalized 0-1 domain cand_boxes = kwimage.Boxes.random(num=n, scale=1.0, format='tlbr', anchors=anchors, anchor_std=0, rng=rng) chosen_gids = np.array(sorted(rng.choice(all_gids, size=n))) gid_to_boxes = kwarray.group_items(cand_boxes, chosen_gids, axis=0) neg_gids = [] neg_boxes = [] for gid, img_boxes in gid_to_boxes.items(): qtree = self.qtrees[gid] # scale from normalized coordinates to image coordinates img_boxes = img_boxes.scale((qtree.width, qtree.height)) for box in img_boxes: # isect_aids, overlaps = self.ious(gid, box) isect_aids, overlaps = self.iooas(gid, box) if len(overlaps) == 0 or overlaps.max() < thresh: neg_gids.append(gid) neg_boxes.append(box.data) return neg_gids, neg_boxes def _generate_abs(n): # Randomly choose images to generate boxes for chosen_gids = np.array(sorted(rng.choice(all_gids, size=n))) gid_to_nboxes = ub.dict_hist(chosen_gids) neg_gids = [] neg_boxes = [] for gid, nboxes in gid_to_nboxes.items(): qtree = self.qtrees[gid] scale = (qtree.width, qtree.height) anchors_ = np.array([window_size]) / np.array(scale) if np.any(anchors_ > 1.0): continue img_boxes = kwimage.Boxes.random(num=nboxes, scale=1.0, format='tlbr', anchors=anchors_, anchor_std=0, rng=rng) img_boxes = img_boxes.scale(scale) for box in img_boxes: # isect_aids, overlaps = self.ious(gid, box) isect_aids, overlaps = self.iooas(gid, box) if len(overlaps) == 0 or overlaps.max() < thresh: neg_gids.append(gid) neg_boxes.append(box.data) return neg_gids, neg_boxes if window_size is not None: _generate = _generate_abs elif anchors is not None: _generate = _generate_rel else: raise ValueError( 'must specify at least one window_size or anchors') if exact: # TODO: Dont attempt to sample negatives from images where the # positives cover more than a threshold percent. (Handle the case # of chip detections) factor = 2 # oversample factor if patience is None: patience = int(np.sqrt(num * 10) + 1) remaining_patience = patience timer = ub.Timer().tic() # Generate boxes until we have enough neg_gids, neg_boxes = _generate(n=int(num * factor)) n_tries = 1 for n_tries in it.count(n_tries): want = num - len(neg_boxes) if want <= 0: break extra_gids, extra_boxes = _generate(n=int(want * factor)) neg_gids.extend(extra_gids) neg_boxes.extend(extra_boxes) if len(neg_boxes) < num: # If we haven't found a significant number of boxes our # patience decreases (if the wall time is getting large) if len(extra_boxes) <= (num // 10) and timer.toc() > 1.0: remaining_patience -= 1 if remaining_patience == 0: break if len(neg_boxes) < num: # but throw an error if we don't make any progress message = ('Cannot make a negative sample with thresh={} ' 'in under {} tries. Found {} but need {}'.format( thresh, n_tries, len(neg_boxes), num)) if exact == 'warn': warnings.warn(message) else: raise Exception(message) print('n_tries = {!r}'.format(n_tries)) neg_gids = neg_gids[:num] neg_boxes = neg_boxes[:num] else: neg_gids, neg_boxes = _generate(n=num) neg_gids = np.array(neg_gids) neg_boxes = kwimage.Boxes(np.array(neg_boxes), 'tlbr') return neg_gids, neg_boxes
def expected_samples(self, target, method='approx'): """ Args: target (float): fraction of events between 0 and 1 method (str): can be 'approx' or 'montecarlo'. Example: >>> probs = np.ones(4) >>> probs = np.random.rand(int(10000)) >>> probs = probs / probs.sum() >>> self = CouponCollector(probs) >>> ev_exact = self.expected_samples(target=1.0, method='exact') >>> print('ev_exact = {!r}'.format(ev_exact)) >>> ev_approx = self.expected_samples(target=1.0, method='approx') >>> print('ev_approx = {!r}'.format(ev_approx)) >>> ev_monte = self.expected_samples(target=1.0, method='montecarlo') >>> print('ev_monte = {!r}'.format(ev_monte)) """ probs = self.probs if method == 'exact': if target != 1.0: raise NotImplementedError( 'exact method only implemented for target=1') ev = coupon_collector_expected_samples(self.probs) if method == 'approx': # Theoretical approximation (this is not exactly right) def _integrand(t): return self.prob_sampled_in(target, t, method=method) ev, abserr = integrate.quad( func=_integrand, a=len(self.probs), # These bounds are dubious b=len(self.probs)**2) # def func(t): # return (self.prob_sampled_in(target, t) - 0.5) ** 2 # x0 = len(probs) * np.log(len(probs)) # import scipy # scipy.optimize.newton(func, x0) elif method == 'montecarlo': ntrials = 100 timeout = 30 trails = [] with ub.Timer() as timer: for _ in range(ntrials): remain = set(range(len(probs))) all_items = np.arange(len(probs)) n_seen = 0 while len(remain): got = np.random.choice(all_items, p=probs) if got in remain: remain.remove(got) n_seen += 1 if timer.toc() > timeout: # Limit attempts break trails.append(n_seen) if timer.toc() > 2: # Limit attempts break expected_number_samples = np.mean(trails) ev = expected_number_samples return ev
def simple_pipeline(): """ Processing_with_species_id.m is their main file OpenCV2: cd ~/code/VIAME/plugins/camtrawl/python workon_py2 source ~/code/VIAME/build/install/setup_viame.sh # Ensure python and sprokit knows about our module export PYTHONPATH=$(pwd):$PYTHONPATH export KWIVER_DEFAULT_LOG_LEVEL=info export SPROKIT_PYTHON_MODULES=kwiver.processes:viame.processes:camtrawl_processes python ~/code/VIAME/plugins/camtrawl/python/run_camtrawl.py --dataset=demo OpenCV3: cd ~/code/VIAME/plugins/camtrawl/python workon_py2 source ~/code/VIAME/build-cv3-py2/install/setup_viame.sh # Ensure python and sprokit knows about our module export PYTHONPATH=$(pwd):$PYTHONPATH export KWIVER_DEFAULT_LOG_LEVEL=info export SPROKIT_PYTHON_MODULES=kwiver.processes:viame.processes:camtrawl_processes python ~/code/VIAME/plugins/camtrawl/python/run_camtrawl.py --dataset=demo /home/joncrall/code/VIAME/build-cv3-py2/install/bin/pipeline_runner -p /home/joncrall/.cache/sprokit/temp_pipelines/temp_pipeline_file.pipe -S pythread_per_process """ # Setup the input files import ubelt as ub dataset = ub.argval('--dataset', default='demo') if dataset == 'demo': import zipfile from os.path import commonprefix dpath = ub.ensure_app_cache_dir('camtrawl') try: demodata_zip = ub.grabdata( 'http://acidalia:8000/data/camtrawl_demodata.zip', dpath=dpath) except Exception: raise ValueError( 'Demo data is currently only available on Kitware VPN') with zipfile.ZipFile(demodata_zip) as zfile: dname = commonprefix(zfile.namelist()) data_fpath = join(dpath, dname) if not exists(data_fpath): zfile.extractall(dpath) print('data_fpath = {!r}'.format(data_fpath)) cal_fpath = join(data_fpath, 'cal.npz') datakw = { 'data_fpath': data_fpath, 'img_path1': join(data_fpath, 'left'), 'img_path2': join(data_fpath, 'right'), } print('datakw = {!r}'.format(datakw)) elif dataset == 'test': data_fpath = expanduser('~/data/autoprocess_test_set') cal_fpath = join(data_fpath, 'cal_201608.mat') datakw = { 'data_fpath': data_fpath, 'img_path1': join(data_fpath, 'image_data/left'), 'img_path2': join(data_fpath, 'image_data/right'), } elif dataset == 'haul83-small': data_fpath = expanduser('~/data/camtrawl_stereo_sample_data_small') cal_fpath = join(data_fpath, '201608_calibration_data/selected/Camtrawl_2016.npz') datakw = { 'data_fpath': data_fpath, 'img_path1': join(data_fpath, 'Haul_83/left'), 'img_path2': join(data_fpath, 'Haul_83/right'), } elif dataset == 'haul83': data_fpath = expanduser('~/data/camtrawl_stereo_sample_data/') cal_fpath = join(data_fpath, '201608_calibration_data/selected/Camtrawl_2016.npz') datakw = { 'data_fpath': data_fpath, 'img_path1': join( data_fpath, 'Haul_83/D20160709-T021759/images/AB-800GE_00-0C-DF-06-40-BF' ), # left 'img_path2': join( data_fpath, 'Haul_83/D20160709-T021759/images/AM-800GE_00-0C-DF-06-20-47' ), # right 'start_frame': 2000, 'end_frame': 5000, } else: import argparse import os parser = argparse.ArgumentParser(description='Camtrawl pipline demo') parser.add_argument( '--cal', help='path to matlab or numpy stereo calibration file', default='cal.npz') parser.add_argument('--left', help='path to directory containing left images', default='left') parser.add_argument('--right', help='path to directory containing right images', default='right') args = parser.parse_args() config = args.__dict__.copy() img_path1, img_path2, cal_fpath = ub.take(config, ['left', 'right', 'cal']) data_fpath = os.path.dirname(img_path1) datakw = { 'data_fpath': data_fpath, 'img_path1': img_path1, 'img_path2': img_path2, } if not exists(img_path1): raise IOError( 'left image path {!r} does not exist'.format(img_path1)) if not exists(img_path2): raise IOError( 'right image path {!r} does not exist'.format(img_path2)) if not exists(cal_fpath): raise IOError( 'calibration file path {!r} does not exist'.format(cal_fpath)) # raise KeyError('Unknown dataset {}'.format(dataset)) make_image_input_files(**datakw) def add_stereo_camera_branch(pipe, prefix): """ Helper that defines a single branch, so it can easilly be duplicated. """ image_list_file = join(data_fpath, prefix + 'images.txt') cam = {} # --- Node --- cam['imread'] = imread = pipe.add_process(name=prefix + 'imread', type='frame_list_input', config={ 'image_list_file': image_list_file, 'frame_time': 0.03333333, 'image_reader:type': 'ocv', }) # ------------ # --- Node --- cam['detect'] = detect = pipe.add_process(name=prefix + 'detect', type='camtrawl_detect_fish', config={}) detect.iports.connect({ 'image': imread.oports['image'], # 'image_file_name': imread.oports['image_file_name'], }) # ------------ return cam pipe = define_pipeline.Pipeline() cam1 = add_stereo_camera_branch(pipe, 'cam1_') cam2 = add_stereo_camera_branch(pipe, 'cam2_') # stereo_cameras = pipe.add_process( # name='stereo_cameras', type='stereo_calibration_camera_reader', # config={ # # 'cal_fpath': cal_fpath, # }) # ------ pipe.add_process(name='measure', type='camtrawl_measure', config={ 'cal_fpath': cal_fpath, 'output_fpath': './camtrawl_out.csv', }) pipe['measure'].iports.connect({ # 'camera1': stereo_cameras.oports['camera1'], # 'camera2': stereo_cameras.oports['camera2'], 'detected_object_set1': cam1['detect'].oports['detected_object_set'], 'detected_object_set2': cam2['detect'].oports['detected_object_set'], 'image_file_name1': cam1['imread'].oports['image_file_name'], 'image_file_name2': cam2['imread'].oports['image_file_name'], }) # ------ pipe.config['_pipeline:_edge']['capacity'] = 1 pipe.config['_scheduler']['type'] = 'pythread_per_process' # pipe.draw_graph('pipeline.png') # import ubelt as ub # ub.startfile('pipeline.png') print(' --- RUN PIPELINE ---') import ubelt as ub with ub.Timer('Running Pipeline'): pipe.run() return pipe
def _devcheck_load_sub_image(): import kwimage import numpy as np sampler = grab_camvid_sampler() cid_to_cidx = sampler.catgraph.id_to_idx classes = sampler.catgraph # Try loading a subregion of an image sample = sampler.load_positive(2) imdata = sample['im'] annots = sample['annots'] aids = annots['aids'] cids = annots['cids'] boxes = annots['rel_boxes'] class_idxs = np.array([cid_to_cidx[cid] for cid in cids]) segmentations = annots['rel_ssegs'] raw_dets = kwimage.Detections( aids=aids, boxes=boxes, class_idxs=class_idxs, segmentations=segmentations, classes=classes, datakeys=['aids'], ) # Clip boxes to the image boundary input_dims = imdata.shape[0:2] raw_dets.data['boxes'] = raw_dets.boxes.clip(0, 0, input_dims[1], input_dims[0]) keep = [] for i, s in enumerate(raw_dets.data['segmentations']): # TODO: clip polygons m = s.to_mask(input_dims) if m.area > 0: keep.append(i) dets = raw_dets.take(keep) heatmap = dets.rasterize(bg_size=(1, 1), input_dims=input_dims) if 1: print('dets = {!r}'.format(dets)) print('dets.data = {!r}'.format(dets.data)) print('dets.meta = {!r}'.format(dets.meta)) if ub.argflag('--show'): import kwplot kwplot.autompl() heatmap.draw() draw_boxes = 1 kwplot.figure(doclf=True) with ub.Timer('dets.draw_on'): canvas = imdata.copy() # TODO: add logic to color by class canvas = dets.draw_on(canvas, boxes=draw_boxes, color='random') kwplot.imshow(canvas, pnum=(1, 2, 1), title='dets.draw_on') with ub.Timer('dets.draw'): kwplot.imshow(imdata, pnum=(1, 2, 2), docla=True, title='dets.draw') dets.draw(boxes=draw_boxes, color='random')