def __init__(self, *args, **kwargs): Visualiser.__init__(self, *args, **kwargs) fin = NetCDFFile(self.vis_source, 'r') self.xPoints = array(fin.variables['x'], Float) self.yPoints = array(fin.variables['y'], Float) self.quantityCache = {} fin.close()
def __init__(self, source, frameDelay=100, frameStep=1): """The source parameter is assumed to be a NetCDF sww file. The frameDelay parameter is the number of milliseconds waited between frames. """ Visualiser.__init__(self, source) self.frameNumber = 0 fin = NetCDFFile(self.source, 'r') self.maxFrameNumber = fin.variables['time'].shape[0] - 1 fin.close() #self.frameNumberTkVariable = StringVar() #self.frameNumberTkVariable.set('Frame - %05g'%self.framNumber) self.frameDelay = frameDelay self.xmin = None self.xmax = None self.ymin = None self.ymax = None self.zmin = None self.zmax = None self.frameStep = frameStep self.vtk_heightQuantityCache = [] for i in range(self.maxFrameNumber + 1): # maxFrameNumber is zero indexed. self.vtk_heightQuantityCache.append({}) self.paused = False self.movie = False
def __init__(self, source, frameDelay=100, frameStep=1): """The source parameter is assumed to be a NetCDF sww file. The frameDelay parameter is the number of milliseconds waited between frames. """ Visualiser.__init__(self, source) self.frameNumber = 0 fin = NetCDFFile(self.source, 'r') self.maxFrameNumber = fin.variables['time'].shape[0] - 1 fin.close() #self.frameNumberTkVariable = StringVar() #self.frameNumberTkVariable.set('Frame - %05g'%self.framNumber) self.frameDelay = frameDelay self.xmin = None self.xmax = None self.ymin = None self.ymax = None self.zmin = None self.zmax = None self.frameStep= frameStep self.vtk_heightQuantityCache = [] for i in range(self.maxFrameNumber + 1): # maxFrameNumber is zero indexed. self.vtk_heightQuantityCache.append({}) self.paused = False self.movie = False
def setup_gui(self): Visualiser.setup_gui(self) self.tk_quit.grid(row=0, column=0, sticky=W+E) self.tk_movie_toggle = Button(self.tk_controlFrame, text="Movie off", command=self.movie_toggle) self.tk_movie_toggle.grid(row=0, column=6, sticky=W+E) self.tk_restart = Button(self.tk_controlFrame, text="<<<", command=self.restart, width=5) self.tk_restart.grid(row=1, column=0, sticky=W+E) self.tk_back10 = Button(self.tk_controlFrame, text="<<", command=self.back10, width=5) self.tk_back10.grid(row=1, column=1, sticky=W+E) self.tk_back = Button(self.tk_controlFrame, text="<", command=self.back, width=5) self.tk_back.grid(row=1, column=2, sticky=W+E) self.tk_pauseResume = Button(self.tk_controlFrame, text="Pause", command=self.pauseResume, width=15) self.tk_pauseResume.grid(row=1, column=3, sticky=W+E) self.tk_forward = Button(self.tk_controlFrame, text=">", command=self.forward, width=5) self.tk_forward.grid(row=1, column=4, sticky=W+E) self.tk_forward10 = Button(self.tk_controlFrame, text=">>", command=self.forward10, width=5) self.tk_forward10.grid(row=1, column=5, sticky=W+E) self.tk_forwardEnd = Button(self.tk_controlFrame, text=">>>", command=self.forwardEnd, width=5) self.tk_forwardEnd.grid(row=1, column=6, sticky=W+E) self.tk_frameNumber = Label(self.tk_controlFrame, text='Frame') self.tk_frameNumber.grid(row=2, column=0, sticky=W+E) self.tk_gotoFrame = Scale(self.tk_controlFrame, from_=0, to=self.maxFrameNumber, orient=HORIZONTAL) self.tk_gotoFrame.grid(row=2, column=1, columnspan=2, sticky=W+E) self.tk_stepLabel = Label(self.tk_controlFrame, text='Step') self.tk_stepLabel.grid(row=2, column=4, sticky=W+E) self.tk_frameStep = Scale(self.tk_controlFrame, from_=0, to=self.maxFrameNumber, orient=HORIZONTAL) self.tk_frameStep.grid(row=2, column=5, columnspan=2, sticky=W+E) # Make the buttons stretch to fill all available space for i in range(7): self.tk_controlFrame.grid_columnconfigure(i, weight=1)
def redraw(self): if self.running and self.sync_unpaused.isSet(): self.sync_redrawReady.wait() self.sync_redrawReady.clear() self.redraw_quantities() self.sync_idle.set() Visualiser.redraw(self)
def main(): # def main(arglist): file = './testcases/4g1_m1.txt' outfile = 'out/4g1_m1_output.txt' # file = arglist[0] # outfile = arglist[1] prm = EST(file) # config = prm.sampling(1000) # robot = prm.get_init_state(); f = open("tmp_output.txt", "w") f.write("") f.close() prm.run_EST(outfile) # D = [1e-3,1e-3] # sampleRobot = prm.sampling_withinD(robot,D,100) # robot = prm.assign_config(config.tolist(),0) # print(sampleRobot) # print(config.tolist()) # config = config[:,:-1] # prm.write_config('test.txt',config.tolist()) aa = test_robot(prm) qq = aa.load_output('output.txt') vis = Visualiser(prm, qq)
def create_widgets(self): self.code_text = CodeText(self) self.visualiser = Visualiser(self) self.code_runner = wx.Panel(self) # self.aui_manager = wx.aui.AuiManager(self, wx.aui.AUI_MGR_DEFAULT | wx.aui.AUI_MGR_LIVE_RESIZE) self.aui_manager = wx.aui.AuiManager( self, wx.aui.AUI_MGR_ALLOW_FLOATING | wx.aui.AUI_MGR_TRANSPARENT_HINT | wx.aui.AUI_MGR_LIVE_RESIZE) # self.aui_manager = wx.lib.agw.aui.AuiManager(self, wx.aui.AUI_MGR_ALLOW_FLOATING | wx.aui.AUI_MGR_TRANSPARENT_HINT # | wx.aui.AUI_MGR_LIVE_RESIZE) self.aui_manager.AddPane(self.code_text, wx.CENTRE, 'Code Text') self.aui_manager.AddPane(self.visualiser, wx.TOP, 'Visualiser') self.aui_manager.AddPane(self.code_runner, wx.BOTTOM, 'Code Runner') self.aui_manager.Update()
def __init__(self, current_season: int): self.current_season = current_season self.data = Data(current_season) self.visualiser = Visualiser() # Import environment variables __file__ = 'data.py' dotenv_path = join(dirname(__file__), '.env') load_dotenv(dotenv_path) self.url = os.getenv('URL') self.headers = {'X-Auth-Token': os.getenv('X_AUTH_TOKEN')} # Number of games played in a season for season data to be used self.games_threshold = 4 self.home_games_threshold = 6 self.star_team_threshold = 0.75 # Rating over 75% to be a star team # Store for new requested API data or old data from memory self.json_data = {'fixtures': {}, 'standings': {}} self.last_updated = None # type: str
def setUp(self): self.parser = DataParser() self.cmd_view = CmdView() self.file_view = FileView() self.validator = Validator() self.db = DatabaseView("test.db") self.vis = Visualiser() # self.val = Validator() self.controller = Controller(self.cmd_view, self.file_view, self.parser, self.validator, self.db, self.vis)
def run_optimal(): vis = Visualiser(env, 80) numActions = env.n_actions playerA = QLearn(actions=list(range(numActions))) playerA.load_Qtable("saved_players/QR") playerB = QLearn(actions=list(range(numActions))) playerB.load_Qtable("saved_players/QR_base") for episode in range(500): observation = env.reset() vis.update_canvas(env) while(True): actionA = playerA.choose_action(str(observation)) actionB = playerB.choose_action(str(observation)) observation_, reward, done = env.step(actionA, actionB) observation = observation_ vis.update_canvas(env) if done: vis.reset() break print("Games won: " + str(env.win_count)) vis.destroy()
def __init__(self, source): """The source parameter is assumed to be a Domain. """ Visualiser.__init__(self, source) self.running = True self.xmin = None self.xmax = None self.ymin = None self.ymax = None self.zmin = None self.zmax = None # Synchronisation Constructs self.sync_idle = Event() self.sync_idle.clear() self.sync_unpaused = Event() self.sync_unpaused.set() self.sync_redrawReady = Event() self.sync_redrawReady.clear()
def setUp(self): self.parser = DataParser() self.cmd_view = CmdView() self.file_reader = FileReader() self.validator = Validator() self.db = Database("test.db") self.vis = Visualiser() self.val = Validator() self.serial = Serializer() self.controller = Controller(self.cmd_view, self.file_reader, self.parser, self.validator, self.db, self.vis, self.serial) self.init()
def print_top(self, sentiments=[], n=10): ''' :param sentiments: :param n: :return: ''' if not self._scored : self.score_tweets() if len(set(sentiments).difference(self._data.columns)) != 0 or not isinstance(sentiments, list) or len( sentiments) == 0: raise Exception("Use a valid sentiment list {}".format([sentiment for sentiment in self.models_ar])) Visualiser(self._data).print_top(sentiments=sentiments, n=n)
def run_optimalB(): numActions = env.n_actions drawProbability = 0.1 decay = 10**(-2. / N_EPISODES * 0.05) vis = Visualiser(env, 80) numActions = env.n_actions playerB = MinimaxQPlayer(numActions, numActions, decay=decay, expl=0.00, gamma=1-drawProbability) playerB.load_Qtable("MR") playerA = QLearn(actions=list(range(numActions))) playerA.load_Qtable("saved_players/MR_base") for episode in range(20): observation = env.reset() vis.update_canvas(env) while(True): actionA = playerA.choose_action(str(observation)) actionB = playerB.choose_action(str(observation)) observation_, reward, done = env.step(actionA, actionB) observation = observation_ vis.update_canvas(env) if done: vis.reset() break print("Games won: " + str(env.win_count)) vis.destroy()
def bubble_chart(self, rounding=2, positive_sentiments=['joy', 'love'], negative_sentiments=['anger', 'sadness']): ''' :param rounding: :param positive_sentiments: :param negative_sentiments: :return: ''' if not self._scored : self.score_tweets() Visualiser(self._data).bubble_chart( rounding=rounding, positive_sentiments=positive_sentiments, negative_sentiments=negative_sentiments)
def sample(spec): samples = [] samples += sample_double_grappled(spec) samples += uniform_sample(spec) double_samples = [] for s in samples: angles = s.ee1_angles.copy() lengths = s.lengths.copy() lengths.reverse() double_samples.append( make_robot_config_from_ee2(s.points[0][0], s.points[0][1], angles, lengths, ee1_grappled=s.ee2_grappled, ee2_grappled=s.ee1_grappled)) samples += double_samples Visualiser(spec, samples) return samples
def pie_chart(self, treshold_pos=0.7, treshold_neg=0.3, positive_sentiments=['joy', 'love'], negative_sentiments=['anger', 'sadness']): ''' :param treshold_pos: :param treshold_neg: :param positive_sentiments: :param negative_sentiments: :return: ''' if not self._scored : self.score_tweets() Visualiser(self._data).pie_chart( treshold_pos=treshold_pos, treshold_neg=treshold_neg, positive_sentiments=positive_sentiments, negative_sentiments=negative_sentiments)
def ql_vs_minmax(visualise): print("ql vs minmax ql") numActions = env.n_actions drawProbability = 0.1 decay = 10**(-2. / N_EPISODES * 0.05) if(visualise): vis = Visualiser(env, 80) numActions = env.n_actions start_time = time.time() ql_wins = 0 minmax_wins = 0 playerA = QLearn(actions=list(range(numActions)), reward_decay=0.7) playerB = MinimaxQPlayer(numActions, numActions, decay=decay, expl=0.01, gamma=1-drawProbability) playerA.load_Qtable('saved_players/QR') playerB.load_Qtable("MR") # no explore iterations = 5000 for episode in range(iterations): # initial observation observation = env.reset() # print(str(episode)) if(episode % 100 == 0): print(str(float(episode) / iterations * 100) + "%") # if(episode > iterations - 100): # vis.update_canvas(env) while True: # RL choose action based on observation actionA = playerA.choose_action(str(observation)) actionB = playerB.choose_action(str(observation)) # RL take action and get next observation and reward observation_, reward, done = env.step(actionA, actionB) if reward == 1: ql_wins += 1 elif reward == -1: minmax_wins += 1 observation = observation_ if(visualise): vis.update_canvas(env) if done: if(visualise): vis.reset() break return (ql_wins, minmax_wins)
def main(): # input data inputDataFileName = '/home/dane/repos/oops/datasets/small.in' print("Input Dataset: ", inputDataFileName) smallData = InputData(inputDataFileName) # assume the slices piece is valid # magic code goes here slicedSmallPizza = [ 7, [[0, 0, 1, 1], [0, 3, 1, 4], [0, 5, 1, 6], [2, 0, 3, 1], [2, 2, 3, 3], [2, 4, 3, 5], [4, 5, 5, 6]] ] # visualise slices Visualiser(smallData, slicedSmallPizza[1]) # calculate the score print('Score: ', ScoreCalc(slicedSmallPizza[1]).score) # output the the file outputDataFileName = '/home/dane/repos/oops/output/small.out' print("Output file: ", outputDataFileName) GenerateOutput(slicedSmallPizza, outputDataFileName)
def main(arglist): # input_file = arglist[0] # output_file = arglist[1] input_file = "testcases/3g1_m2.txt" output_file = "testcases/output.txt" spec = ProblemSpec(input_file) init_node = GraphNode(spec, spec.initial) goal_node = GraphNode(spec, spec.goal) g = GraphNode(spec, spec.goal) # path_plan = [] # # for i in range(200): # c = g.generate_sample() # path_plan.append(c) steps = [] path_plan = g.PRM(init_node, goal_node) # write_robot_config_list_to_file(output_file, path_plan) # Code for your main method can go here. # # Your code should find a sequence of RobotConfig objects such that all configurations are collision free, the # distance between 2 successive configurations is less than 1 primitive step, the first configuration is the initial # state and the last configuration is the goal state. # # # if len(arglist) > 1: # # You may uncomment this line to launch visualiser once a solution has been found. This may be useful for debugging. # *** Make sure this line is commented out when you submit to Gradescope *** # v = Visualiser(spec, path_plan)
def main(arglist): input_file = arglist[0] output_file = arglist[1] spec = ProblemSpec(input_file) init_node = GraphNode(spec, spec.initial) goal_node = GraphNode(spec, spec.goal) num_grapple_points = spec.num_grapple_points if num_grapple_points == 1: graph_nodes = [[init_node, goal_node]] else: graph_nodes = [[] for i in range(num_grapple_points)] graph_nodes[0].append(init_node) graph_nodes[-1].append(goal_node) steps = [] # Solution # Note on solution: if there are multiple grapple points, samples are collected separately for each grapple point # Then, the closest node to a grapple point in the sample for an ADJACENT grapple point is taken as the goal node. # steps = generate_steps(spec, 5000 * spec.num_grapple_points, graph_nodes, init_node, goal_node, spec.num_grapple_points) if len(arglist) > 1: write_robot_config_list_to_file(output_file, steps) # # You may uncomment this line to launch visualiser once a solution has been found. This may be useful for debugging. # *** Make sure this line is commented out when you submit to Gradescope *** # v = Visualiser(spec, steps)
import pygame import sys import random from map import Map from visualiser import Visualiser from pathfinder import Pathfinder map = Map() map.loadData() visualiser = Visualiser("Inlupp 2 - Visualiser", map.getWidth(), map.getHeight()) visualiser.setMap(map) pathfinder = Pathfinder(visualiser, map) pathfinder.findCheapestPath() visualiser.runLoop()
vis.update_canvas(env.actor, env.enemy) if done: break print("Games won: " + str(env.win_count)) vis.destroy() if __name__ == '__main__': parser = argparse.ArgumentParser(description='QMaze options') parser.add_argument('--test', dest='test', action='store_true', help='if you wish to re-train') parser.add_argument('--vis', dest='vis', action='store_true', help='if you wish to see the GUI') args = parser.parse_args() print(args) if (args.test): env = Maze() RL = QLearn(actions=list(range(env.n_actions))) if (args.vis): vis = Visualiser(4, 4, 80, env.hell_blocks, env.goal, env.enemy) test(args.vis) else: env = Maze() vis = Visualiser(4, 4, 80, env.hell_blocks, env.goal, env.enemy) RL = QLearn(actions=list(range(env.n_actions)), e_greedy=1.0) run_optimal()
from controller import Controller from cmdview import CmdView from file_reader import FileReader from data_parser import DataParser from validator import Validator from database import Database from visualiser import Visualiser from serializer import Serializer if __name__ == "__main__": parser = DataParser() cmd_view = CmdView() file_reader = FileReader() validator = Validator() db = Database("test.db") vis = Visualiser() serial = Serializer() con = Controller(cmd_view, file_reader, parser, validator, db, vis, serial) cmd_view.set_controller(con) # run program cmd_view.cmdloop()
def shutdown(self): Visualiser.shutdown(self) self.running = False self.sync_idle.set() self.sync_unpaused.set()
def setup_gui(self): Visualiser.setup_gui(self) self.tk_quit.grid(row=0, column=0, sticky=W + E) self.tk_movie_toggle = Button(self.tk_controlFrame, text="Movie off", command=self.movie_toggle) self.tk_movie_toggle.grid(row=0, column=6, sticky=W + E) self.tk_restart = Button(self.tk_controlFrame, text="<<<", command=self.restart, width=5) self.tk_restart.grid(row=1, column=0, sticky=W + E) self.tk_back10 = Button(self.tk_controlFrame, text="<<", command=self.back10, width=5) self.tk_back10.grid(row=1, column=1, sticky=W + E) self.tk_back = Button(self.tk_controlFrame, text="<", command=self.back, width=5) self.tk_back.grid(row=1, column=2, sticky=W + E) self.tk_pauseResume = Button(self.tk_controlFrame, text="Pause", command=self.pauseResume, width=15) self.tk_pauseResume.grid(row=1, column=3, sticky=W + E) self.tk_forward = Button(self.tk_controlFrame, text=">", command=self.forward, width=5) self.tk_forward.grid(row=1, column=4, sticky=W + E) self.tk_forward10 = Button(self.tk_controlFrame, text=">>", command=self.forward10, width=5) self.tk_forward10.grid(row=1, column=5, sticky=W + E) self.tk_forwardEnd = Button(self.tk_controlFrame, text=">>>", command=self.forwardEnd, width=5) self.tk_forwardEnd.grid(row=1, column=6, sticky=W + E) self.tk_frameNumber = Label(self.tk_controlFrame, text='Frame') self.tk_frameNumber.grid(row=2, column=0, sticky=W + E) self.tk_gotoFrame = Scale(self.tk_controlFrame, from_=0, to=self.maxFrameNumber, orient=HORIZONTAL) self.tk_gotoFrame.grid(row=2, column=1, columnspan=2, sticky=W + E) self.tk_stepLabel = Label(self.tk_controlFrame, text='Step') self.tk_stepLabel.grid(row=2, column=4, sticky=W + E) self.tk_frameStep = Scale(self.tk_controlFrame, from_=0, to=self.maxFrameNumber, orient=HORIZONTAL) self.tk_frameStep.grid(row=2, column=5, columnspan=2, sticky=W + E) # Make the buttons stretch to fill all available space for i in range(7): self.tk_controlFrame.grid_columnconfigure(i, weight=1)
def run(self): self.alter_tkroot(Tk.after, (self.frameDelay, self.animateForward)) Visualiser.run(self)
def setup_gui(self): Visualiser.setup_gui(self) self.tk_pauseResume = Button(self.tk_controlFrame, text="Pause", command=self.pauseResume) self.tk_pauseResume.grid(row=1, column=0, sticky=E+W)
sky_type += "-rgb" step = .1 # 10 cm tau_phi = np.pi # 60 deg condition = Hybrid(tau_x=step, tau_phi=tau_phi) agent_name = create_agent_name(date, sky_type, step, fov[0], fov[1]) print agent_name world = load_world() world.enable_pol_filters(enable_pol) world.uniform_sky = uniform_sky routes = load_routes() world.add_route(routes[0]) agent = MBAgent(condition=condition, live_sky=update_sky, visualiser=Visualiser(), rgb=rgb, fov=fov, name=agent_name) agent.set_world(world) print agent.homing_routes[0] agent.visualiser.set_mode("panorama") for route in agent.start_learning_walk(): print "Learned route:", route agent.visualiser.set_mode("top") route = agent.start_homing() print route if route is not None: save_route(route, agent_name)
def overview_chart(self): if not self._scored : self.score_tweets() sentiments = [sentiment for sentiment in self.models_ar] Visualiser(self._data).overview(sentiments=sentiments)
class Updater: def __init__(self, current_season: int): self.current_season = current_season self.data = Data(current_season) self.visualiser = Visualiser() # Import environment variables __file__ = 'data.py' dotenv_path = join(dirname(__file__), '.env') load_dotenv(dotenv_path) self.url = os.getenv('URL') self.headers = {'X-Auth-Token': os.getenv('X_AUTH_TOKEN')} # Number of games played in a season for season data to be used self.games_threshold = 4 self.home_games_threshold = 6 self.star_team_threshold = 0.75 # Rating over 75% to be a star team # Store for new requested API data or old data from memory self.json_data = {'fixtures': {}, 'standings': {}} self.last_updated = None # type: str # ----------------------------- DATA API ----------------------------------- def fixtures_data(self, season: int, request_new: bool = True) -> dict: if request_new and self.url is not None: response = requests.get( self.url + 'competitions/PL/matches/?season={}'.format(season), headers=self.headers) code = response.status_code if code == 429 or code == 403: print('❌ Status:', code) raise ValueError('❌ ERROR: Data request failed') else: print('✔️ Status:', code) return response.json()['matches'] else: # Read saved fixtures data with open(f'data/fixtures_{season}.json', 'r') as json_file: return json.load(json_file) def standings_data(self, season: int, request_new: bool = True) -> dict: if request_new and self.url is not None: response = requests.get( self.url + 'competitions/PL/standings/?season={}'.format(season), headers=self.headers) code = response.status_code if code == 429 or code == 403: print('❌ Status:', code) raise ValueError('❌ ERROR: Data request failed') else: print('✔️ Status:', code) return response.json()['standings'][0]['table'] else: # Read standings data with open(f'data/standings_{season}.json', 'r') as json_file: return json.load(json_file) def fetch_current_season(self, request_new: bool): # Fetch data from API (max this season and last season) self.json_data['fixtures'][self.current_season] = self.fixtures_data( self.current_season, request_new) self.json_data['standings'][self.current_season] = self.standings_data( self.current_season, request_new) def load_previous_fixtures(self, n_seasons: int): for i in range(1, n_seasons): season = self.current_season - i self.json_data['fixtures'][season] = self.fixtures_data( season, request_new=False) self.json_data['standings'][season] = self.standings_data( season, request_new=False) def fetch_json_data(self, n_seasons: int, request_new: bool = True): self.fetch_current_season(request_new) self.load_previous_fixtures(n_seasons) if request_new: self.last_updated = datetime.now().strftime( 'Last updated: %Y-%m-%d %H:%M:%S') def save_data(self): """ Save current season fixtures and standings data in self.json_data to json files. """ for type in ('fixtures', 'standings'): with open(f'data/{type}_{self.current_season}.json', 'w') as f: json.dump(self.json_data[type][self.current_season], f) def get_logo_urls(self) -> dict[str, str]: data = self.json_data['standings'][self.current_season] logo_urls = {} for standings_row in data: team_name = standings_row['team']['name'].replace('&', 'and') crest_url = standings_row['team']['crestUrl'] logo_urls[team_name] = crest_url return logo_urls def update_dataframes(self, n_seasons: int, display_tables: bool = False): # Standings for the last [n_seasons] seasons self.data.standings.update(self.json_data, self.data.team_names, self.current_season, n_seasons, display=display_tables) # Fixtures for the whole season for each team self.data.fixtures.update(self.json_data, self.current_season, display=display_tables) # Ratings for each team, based on last <no_seasons> seasons standings table self.data.team_ratings.update(self.data.standings, self.current_season, self.games_threshold, n_seasons, display=display_tables) # Calculated values to represent the personalised advantage each team has at home self.data.home_advantages.update(self.json_data, self.current_season, self.home_games_threshold, n_seasons, display=display_tables) # Calculated form values for each team for each matchday played so far self.data.form.update(self.data.fixtures, self.data.standings, self.data.team_ratings, self.star_team_threshold, display=display_tables) # Season metrics self.data.season_stats.update(self.data.form, display=display_tables) # Data about the opponent in each team's next game self.data.upcoming.update(self.json_data, self.data.fixtures, self.data.form, self.data.home_advantages, self.data.team_names, self.current_season, n_seasons, display=display_tables) def save_tables(self): self.data.standings._save_to_html() self.data.fixtures._save_to_html() self.data.team_ratings._save_to_html() self.data.home_advantages._save_to_html() self.data.form._save_to_html() self.data.upcoming._save_to_html() self.data.season_stats._save_to_html() def update_data(self, n_seasons, display_tables): self.data.logo_urls = self.get_logo_urls() self.data.team_names = self.data.logo_urls.keys() # Using stored data in self.json_data self.update_dataframes(n_seasons, display_tables) @timebudget def update_all(self, n_seasons: int = 4, team_name: str = None, display_tables: bool = False, display_graphs: bool = False, request_new: bool = True): try: self.fetch_json_data(n_seasons, request_new) except ValueError as e: print(e) print('🔁 Retrying with saved data...') request_new = False self.fetch_json_data(n_seasons, request_new) self.update_data(n_seasons, display_tables) if request_new: print('💾 Saving new data as JSON files...') self.save_data() print('💾 Saving tables as HTML files...') self.save_tables() # Use dataframes to update all graph HTML files self.visualiser.update(self.data.fixtures, self.data.team_ratings, self.data.home_advantages, self.data.form, display_graphs=display_graphs, team=team_name)
body_luminosity=7, body_object_area=5000, body_hole_area=5000, edge_luminosity=7, edge_object_area=6, edge_hole_area=5000) segmentor_nuc = ConfocalNucleusSegmentor(img_retriever=skimage_img_retriever) masker_cell = ConfocalCellAreaMasker(img_retriever=skimage_img_retriever, body_luminosity=7, body_object_area=100, body_hole_area=100) segmentor_cell = ConfocalCellSegmentor(img_retriever=skimage_img_retriever) shaper_cell = ImageShapeMaker(img_retriever=skimage_img_retriever) viz = Visualiser(cmap='gray', cmap_set_under='green') df_labels = parse_labels('./data_tmp/train.csv') for cell_id, data_path_collection in local_imgs.items(): if not '0020ad' in cell_id: continue img_nuc = data_path_collection['nuclei'] img_er = data_path_collection['ER'] img_tube = data_path_collection['microtubule'] img_prot = data_path_collection['green'] masker_nuc.make_mask_(img_nuc) segmentor_nuc.make_segments_(img_nuc, masker_nuc.mask)