class ProgBar(object): def __init__(self,max_epoch): self.leaf_values = [Value(0) for i in range(1)] self.max_epoch = max_epoch self.epoch = 0 self.test_d = { 'Training Processing:': BarDescriptor(value=self.leaf_values[0], type=Bar, kwargs=dict(max_value=self.max_epoch)) } self.t = Terminal() self.n = ProgressTree(term=self.t) self.n.make_room(self.test_d) def incr_value(self): if self.epoch < self.max_epoch: self.leaf_values[0].value +=1 self.epoch +=1 def we_done(self): if self.epoch == self.max_epoch: return True else: return False def show_progbar(self): self.n.cursor.restore() self.incr_value() self.n.draw(self.test_d)
class TaskGraphics: def __init__(self,data,num=__DEFAULT_NUM__): self.bind_data=[Value(0) for i in range(num)] #self.bind_data=data self.terminal=False self.bd_defaults=dict(type=Bar,kwargs=dict(max_value=100)) self.indicator={} self.graph_data={} for i in range(0,num): task_name='task_%d'%i self.indicator[i]=task_name self.graph_data[task_name]=BarDescriptor(value=self.bind_data[i],**self.bd_defaults) self.__init_tree__() threading.Thread(target=self.invalidate,args=()).start() def __init_tree__(self): t=Terminal() self.n=ProgressTree(term=t) self.n.make_room(self.graph_data) def updateTask(self,id,task_name): old_task_name=self.indicator[id] if task_name == old_task_name: return self.graph_data[task_name]=self.graph_data[old_task_name] self.indicator[id]=task_name del self.graph_data[old_task_name] def updateValue(self,id,value): self.bind_data[id].value=value def invalidate(self): while not self.terminal: time.sleep(0.1) self.n.cursor.restore() self.n.draw(self.graph_data,BarDescriptor(self.bd_defaults)) def stop(self): self.terminal=True
tymin = dbt.cols.y[dbt.colindexes['y'][0]].astype(np.int64) tymax = dbt.cols.y[dbt.colindexes['y'][-1]].astype(np.int64) xbounds = (txmin, txmax) ybounds = (tymin, tymax) print(xbounds) print(ybounds) xb, yb = neoextent.pad_grid(xbounds, ybounds) f2l_mat = np.array([125E3, 250E3, 500E3, 1E6]) n_img_feat = np.array([1E3, 5E3, 10E3, 20E3]) # Create blessings.Terminal instance leaf_values, test_d = build_progress(f2l_mat, n_img_feat, img_times) tt = Terminal() prog_tree = ProgressTree(term=tt) prog_tree.make_room(test_d) # Full aggregate tile id tid, tidcount = np.unique(dbt.cols.pair_id, return_counts=True) extent = neoextent.SearchExtent(15, xb, yb, tid, tidcount) zoom_depth = 14 # Ok do whatever filters = tb.Filters(complevel=5, complib='blosc') atom = tb.Float64Atom() neogeo_shape = (img_times.nrows, 64, 64) times_shape = (img_times.nrows, ) leaf_ii = 0 for f2l in f2l_mat: f2l_group = out_tb.createGroup(out_tb.root, 'loaded_%d' % int(f2l))
def tree(): """Example showing tree progress view""" ############# # Test data # ############# # For this example, we're obviously going to be feeding fictitious data # to ProgressTree, so here it is leaf_values = [Value(0) for i in range(6)] bd_defaults = dict(type=Bar, kwargs=dict(max_value=10)) test_d = { "Warp Jump": { "1) Prepare fuel": { "Load Tanks": { "Tank 1": BarDescriptor(value=leaf_values[0], **bd_defaults), "Tank 2": BarDescriptor(value=leaf_values[1], **bd_defaults), }, "Refine tylium ore": BarDescriptor(value=leaf_values[2], **bd_defaults), }, "2) Calculate jump co-ordinates": { "Resolve common name to co-ordinates": { "Querying resolution from baseship": BarDescriptor(value=leaf_values[3], **bd_defaults), }, }, "3) Perform jump": { "Check FTL drive readiness": BarDescriptor(value=leaf_values[4], **bd_defaults), "Juuuuuump!": BarDescriptor(value=leaf_values[5], **bd_defaults) } } } # We'll use this function to bump up the leaf values def incr_value(obj): for val in leaf_values: if val.value < 10: val.value += 1 break # And this to check if we're to stop drawing def are_we_done(obj): return all(val.value == 10 for val in leaf_values) ################### # The actual code # ################### # Create blessings.Terminal instance t = Terminal() # Initialize a ProgressTree instance n = ProgressTree(term=t) # We'll use the make_room method to make sure the terminal # is filled out with all the room we need n.make_room(test_d) while not are_we_done(test_d): sleep(0.2 * random.random()) # After the cursor position is first saved (in the first draw call) # this will restore the cursor back to the top so we can draw again n.cursor.restore() # We use our incr_value method to bump the fake numbers incr_value(test_d) # Actually draw out the bars n.draw(test_d, BarDescriptor(bd_defaults))
bd_files = dict(type=Bar, kwargs=dict(max_value=file_count, width='50%')) bd_defaults = dict(type=Bar, kwargs=dict(max_value=100, width='50%', num_rep='percentage')) test_d = { 'Analyze files in %s' % scan_dir: { "Directories": BarDescriptor(value=leaf_values[0], **bd_directories), "Files": BarDescriptor(value=leaf_values[1], **bd_files) } } t = Terminal() n = ProgressTree(term=t) n.make_room(test_d) def are_we_done(): return files_analyzed == file_count while not are_we_done(): for root, dirs, files in os.walk(scan_dir, followlinks=False, topdown=True): dirs[:] = [d for d in dirs if d not in exclude] for directory_name in dirs: directory_name = os.path.join(root, directory_name) file_hash = analyze(directory_name).hexdigest() upsert_md5_hash(directory_name, file_hash) dirs_analyzed += 1
def pretty(delete=False): import random from time import sleep from blessings import Terminal from progressive.bar import Bar from progressive.tree import ProgressTree, Value, BarDescriptor leaf_values = [Value(0) for i in range(1)] bd_defaults = dict(type=Bar, kwargs=dict(max_value=900)) test_d = { "Verifying [kubeflow]": BarDescriptor(value=leaf_values[0], **bd_defaults), "Verifying [dkube]": BarDescriptor(value=leaf_values[0], **bd_defaults), "Verifying [dkube-ui]": BarDescriptor(value=leaf_values[0], **bd_defaults), "Verifying [argo]": BarDescriptor(value=leaf_values[0], **bd_defaults), "Verifying [minio]": BarDescriptor(value=leaf_values[0], **bd_defaults), "Verifying [efk]": BarDescriptor(value=leaf_values[0], **bd_defaults) } # We'll use this function to bump up the leaf values def incr_value(obj): for val in leaf_values: if val.value < 900: val.value += 10 break # And this to check if we're to stop drawing def are_we_done(obj): return all(val.value == 900 for val in leaf_values) ################### # The actual code # ################### # Create blessings.Terminal instance t = Terminal() # Initialize a ProgressTree instance n = ProgressTree(term=t) # We'll use the make_room method to make sure the terminal # is filled out with all the room we need n.make_room(test_d) monitor_freq = 0 status = False while not status and not are_we_done(test_d): if monitor_freq >= 60: if not delete: status = monitorOnCreation() else: status = monitorOnDeletion() monitor_freq = 0 # After the cursor position is first saved (in the first draw call) # this will restore the cursor back to the top so we can draw again n.cursor.restore() # We use our incr_value method to bump the fake numbers incr_value(test_d) # Actually draw out the bars n.draw(test_d, BarDescriptor(bd_defaults)) sleep(10) monitor_freq += 10 return status
def tree(): """Example showing tree progress view""" ############# # Test data # ############# # For this example, we're obviously going to be feeding fictitious data # to ProgressTree, so here it is leaf_values = [Value(0) for i in range(6)] bd_defaults = dict(type=Bar, kwargs=dict(max_value=10)) test_d = { "Warp Jump": { "1) Prepare fuel": { "Load Tanks": { "Tank 1": BarDescriptor(value=leaf_values[0], **bd_defaults), "Tank 2": BarDescriptor(value=leaf_values[1], **bd_defaults), }, "Refine tylium ore": BarDescriptor( value=leaf_values[2], **bd_defaults ), }, "2) Calculate jump co-ordinates": { "Resolve common name to co-ordinates": { "Querying resolution from baseship": BarDescriptor( value=leaf_values[3], **bd_defaults ), }, }, "3) Perform jump": { "Check FTL drive readiness": BarDescriptor( value=leaf_values[4], **bd_defaults ), "Juuuuuump!": BarDescriptor(value=leaf_values[5], **bd_defaults) } } } # We'll use this function to bump up the leaf values def incr_value(obj): for val in leaf_values: if val.value < 10: val.value += 1 break # And this to check if we're to stop drawing def are_we_done(obj): return all(val.value == 10 for val in leaf_values) ################### # The actual code # ################### # Create blessings.Terminal instance t = Terminal() # Initialize a ProgressTree instance n = ProgressTree(term=t) # We'll use the make_room method to make sure the terminal # is filled out with all the room we need n.make_room(test_d) while not are_we_done(test_d): sleep(0.2 * random.random()) # After the cursor position is first saved (in the first draw call) # this will restore the cursor back to the top so we can draw again n.cursor.restore() # We use our incr_value method to bump the fake numbers incr_value(test_d) # Actually draw out the bars n.draw(test_d, BarDescriptor(bd_defaults))
def FMOTF( f5, f5featmeta, dted_path, geoid_file, frame_yaml, cam_yaml, dbf, out_path, ): # f5 = tb.open_file('/media/sean/D2F2E7B2F2E798CD/Users/student/neo_data/fc2_f5.hdf', 'r') # f5featmeta = pd.read_hdf('/media/sean/D2F2E7B2F2E798CD/Users/student/AIEoutput2/feat/feat_meta.hdf') img_times = f5.root.camera.image_raw.compressed.metadata.col('t_valid') feat_path = f5featmeta.iloc[:, 3] descripath = f5featmeta.iloc[:, 4] # Get a truth finder # dted_path = '/media/sean/D2F2E7B2F2E798CD/Users/student/neo_data/srtm' # geoid_file = '/media/sean/D2F2E7B2F2E798CD/Users/student/neo_data/egm96-15.tif' # frame_yaml = '/home/sean/ImageAidedNav/pypnp/data/fc2_pod_frames.yaml' # cam_yaml = '/home/sean/ImageAidedNav/pypnp/data/fc2_cam_model.yaml' finder = pnputils.DEMTileFinder(dted_path, geoid_file) finder.load_cam_and_vehicle_frames(frame_yaml) finder.load_camera_cal(cam_yaml) # Get the Feature Database # dbf = tb.open_file('/media/sean/D2F2E7B2F2E798CD/Users/student/neo_data/pytables_db.hdf', 'r') dbt = dbf.get_node('/sift_db/sift_features_sorted') # Set up the output file # out_path = '/media/sean/D2F2E7B2F2E798CD/Users/student/neo_data/obs_out_mat7.hdf' out_tb = tb.open_file(out_path, 'w') # You need boundaries txmin = dbt.cols.x[dbt.colindexes['x'][0]].astype(np.int64) txmax = dbt.cols.x[dbt.colindexes['x'][-1]].astype(np.int64) tymin = dbt.cols.y[dbt.colindexes['y'][0]].astype(np.int64) tymax = dbt.cols.y[dbt.colindexes['y'][-1]].astype(np.int64) xbounds = (txmin, txmax) ybounds = (tymin, tymax) print(xbounds) print(ybounds) xb, yb = neoextent.pad_grid(xbounds, ybounds) # TODO Redefine xb and yb to be the tiles that encompassed the area defined by the particles and/or confidence ellipse f2l_mat = np.array([1E6]) n_img_feat = np.array([10E3]) # Create blessings.Terminal instance leaf_values, test_d = build_progress(f2l_mat, n_img_feat, img_times) tt = Terminal() prog_tree = ProgressTree(term=tt) prog_tree.make_room(test_d) # Full aggregate tile id tid, tidcount = np.unique(dbt.cols.pair_id, return_counts=True) extent = neoextent.SearchExtent(15, xb, yb, tid, tidcount) zoom_depth = 15 # orginal value was 14 # Ok do whatever filters = tb.Filters(complevel=5, complib='blosc') atom = tb.Float64Atom() neogeo_shape = (img_times.size, 64, 64) times_shape = (img_times.size, ) leaf_ii = 0 for f2l in f2l_mat: f2l_group = out_tb.create_group(out_tb.root, 'loaded_%d' % int(f2l)) f2l_group.num_feat_loaded = f2l db_rows, N = load_all_features(dbt, extent, zoom_depth, f2l) flann, t_build_db = build_flann_db(db_rows) f2l_group.time_to_build_flann = t_build_db obs_shape = (img_times.size, db_rows.shape[0], 4) for n_img in n_img_feat: n_group = out_tb.create_group(f2l_group, 'feat_%d' % int(n_img)) n_group.img_feat = n_img neogeo_out = out_tb.create_carray(n_group, 'neogeo_out', atom=atom, shape=neogeo_shape, filters=filters) obs_out = out_tb.create_carray(n_group, 'obs_out', atom=atom, shape=obs_shape, filters=filters) # print(neogeo_out) flann_time = out_tb.create_carray(n_group, 'flann_time', atom=atom, shape=times_shape, filters=filters) # dbloc = out_tb.create_carray(n_group,'dbloc',atom=atom, shape=dbloc_shape, filters=filters) for img_num in np.arange(img_times.size): if f5featmeta.num_feat[img_num] > 0: generate_obs(img_num, n_img, db_rows, obs_out, neogeo_out, flann_time, flann) leaf_values[leaf_ii].value += 1 # if np.mod(leaf_values[leaf_ii].value, 5) == 0: # prog_tree.cursor.restore() # prog_tree.draw(test_d) leaf_ii += 1 out_tb.flush() out_tb.close() dbf.close() f5.close()