def __init__(self, width=5, height=5, render_type='cubes', num_objects=5, seed=None, immovable=False, immovable_fixed=False, opposite_direction=False, background=BACKGROUND_WHITE, num_colors=5, same_shape_and_color=False): self.width = width self.height = height self.render_type = render_type self.immovable = immovable self.immovable_fixed = immovable_fixed self.opposite_direction = opposite_direction self.same_shape_and_color = same_shape_and_color self.num_objects = num_objects self.num_actions = 4 * self.num_objects # Move NESW self.num_colors = num_colors self.colors = utils.get_colors(num_colors=max(9, self.num_objects)) self.background = background # used only if background != BACKGROUND_WHITE self.background_colors = utils.get_colors(cmap="Set2", num_colors=num_colors) # used only if background in [BACKGROUND_RANDOM_SAME_EP, BACKGROUND_DETERMINISTIC] self.background_index = 0 self.np_random = None self.game = None self.target = None # Initialize to pos outside of env for easier collision resolution. self.objects = [[-1, -1] for _ in range(self.num_objects)] # If True, then check for collisions and don't allow two # objects to occupy the same position. self.collisions = True self.action_space = spaces.Discrete(self.num_actions) self.observation_space = spaces.Box(low=0, high=1, shape=(3, self.width, self.height), dtype=np.float32) self.seed(seed) self.reset()
def __init__(self, width=5, height=5, render_type='cubes', num_objects=5, seed=None): self.width = width self.height = height self.render_type = render_type self.num_objects = num_objects self.num_actions = 4 * self.num_objects # Move NESW self.colors = utils.get_colors(num_colors=max(9, self.num_objects)) self.np_random = None self.game = None self.target = None # Initialize to pos outside of env for easier collision resolution. self.objects = [[-1, -1] for _ in range(self.num_objects)] # If True, then check for collisions and don't allow two # objects to occupy the same position. self.collisions = True self.action_space = spaces.Discrete(self.num_actions) self.observation_space = spaces.Box(low=0, high=1, shape=(3, self.width, self.height), dtype=np.float32) self.seed(seed) self.reset()
def __init__(self, width=5, height=5, render_type='cubes', num_objects=5, seed=None, immovable=False, same_shape_and_color=False): super(BlockPushingCursor, self).__init__(width=width, height=height, render_type=render_type, num_objects=num_objects, seed=seed, immovable=immovable, same_shape_and_color=same_shape_and_color) # overwrite action space self.num_actions = 8 self.action_space = spaces.Discrete(self.num_actions) # get color for cursor self.colors = utils.get_colors(num_colors=max(9, self.num_objects + 1)) # initialize cursor outside of the env self.cursor = [-1, -1]
def get_image(): tile_size = 40 cars = [ Boxy(get_colors(4)), Midsize(get_colors(4)), Race(get_colors(4)), OldSchool(get_colors(2, False)) ] car = Car(random.choice(cars).picture, tile_size) output = BytesIO() car.result.save(output, 'PNG') output.seek(0) return send_file(io.BytesIO(output.read()), mimetype='image/png')
def __init__(self, n_clusters=8, beta=16, distance_func=euclidean_distance): self.n_clusters = n_clusters self.beta = beta self.d = distance_func self.labels = {} # maps a point to the id of the cluster it belongs to self.centers = list() # the list of centers such that the pairwise distances > 2β self.collection = list() # the collection of disjoint clusters self.unclustered_points = set() # the set of unclustered points self.colors = get_colors(n_clusters) # the colors used to visualize the clusters
def monthlyhourlyplot(metdat, catinfo, category=None, basecolor='span'): """**Get Monthly Hourly Averaged Profile**. Plot the monthly hourly averaged profile of a given variable (or category of variables) grouped by a given condition (or set of conditions). Parameters: 1. metdat (Pandas DataFrame): The desired input data (Met Mast). 2. catinfo (dictionary): Categorization information for the desired input data. Holds column names, labels, units, and save names. 3. category (string) [default: None]: Specifies the category of information that is desired for plotting. 4. basecolor (string) [default: 'span']: Provides the color code information to get from "utils.py". Returns: 1. fig (Matplotlib Figure): The figure object for the desired input data and categories. 2. ax (Matplotlib Axes): The axes object for the desired input data and categories. """ if category is None: print('not sure what to plot...') pass months = utils.monthnames() colors = utils.get_colors(len(catinfo['columns'][category]), basecolor=basecolor, reverse=True) colnames, vertlocs, ind = utils.get_vertical_locations( catinfo['columns'][category], reverse=True) plotdat = metdat[colnames].groupby( [metdat.index.month.rename('month'), metdat.index.hour.rename('hour')]).mean() fig, ax = plt.subplots(4, 3, figsize=(9, 11), sharex=True, sharey=True) for iax in range(len(months)): for catitem in range(len(colnames)): ax.flatten()[iax].plot(plotdat[colnames[catitem]].xs(iax + 1), color=colors[catitem]) ax.flatten()[iax].set_title(months[iax], fontsize=12) fig.text(0.5, 0.2, 'Time of Day [hour]', ha='center', va='center') leg = fig.legend([str(v) + ' m' for v in vertlocs], loc='upper center', bbox_to_anchor=(0, -0.825, 1, 1), bbox_transform=plt.gcf().transFigure, frameon=False, ncol=2) fig.tight_layout() fig.subplots_adjust(bottom=0.25) fig.text(0, 0.6125, catinfo['labels'][category], ha='center', va='center', rotation='vertical') return fig, ax
def normalized_hist_by_stability(metdat, catinfo, vertloc=80): """**Get Normalized Stability Grouped Histogram Figure**. Plot the normalized stability grouped histogram of a given variable (or category of variables) grouped by a given condition (or set of conditions). Parameters: 1. metdat (Pandas DataFrame): The desired input data (Met Mast). 2. catinfo (dictionary): Categorization information for the desired input data. Holds column names, labels, units, and save names. 3. vertloc (integer, float) [default: 80]: Describes the desired vertical location alond the tower for analysis. Returns: 1. fig (Matplotlib Figure): The figure object for the desired input data and categories. 2. ax (Matplotlib Axes): The axes object for the desired input data and categories. """ stabconds = utils.get_stabconds() stabcol, _, _ = utils.get_vertical_locations( catinfo['columns']['stability flag'], location=vertloc) colors = utils.get_colors(len(stabconds), basecolor='span') temp = metdat[stabcol].dropna() garb = temp.groupby(temp.index.hour).value_counts(normalize=True) garb.index.names = ['hour', 'stabclass'] garb = garb.reorder_levels(['stabclass', 'hour']) hours = np.arange(24) newbottom = np.zeros(24) fig, ax = plt.subplots() for jj, cond in enumerate(stabconds): # Use this for missing data, also works for full data a = garb.loc[cond] b = a.index.tolist() c = a.values.tolist() for i in range(len(hours)): if (hours[i]) in b: pass else: b.insert(i, hours[i]) c.insert(i, 0) d = pd.Series(data=c, index=b) ax.bar(hours, d, color=colors[jj], bottom=newbottom) newbottom += c #<-- for if missing data, also works for full data #ax.bar(hours, garb.loc[cond], color=colors[jj], bottom=newbottom) #newbottom += garb.loc[cond] ax.set_ylabel('Probability [%]') ax.set_xlabel('Time of Day [Hour]') fig.legend(stabconds) #fig.legend(stabconds, loc=6, bbox_to_anchor=(1,0.5),framealpha=0) fig.tight_layout() return fig, ax
def hist_by_stability(metdat, catinfo, category, vertloc=80, basecolor='span'): ########################################### """ make histograms separating the variable (colname) by stability class. stability is the list of column names containing stability flags Parameters: metdat: Pandas dataframe containing met mast data catinfo: dict containing categorization info for the metmast data. Fore each category, catinfo holds column names, labels, units, and save names category: string specifying category of information to plot (e.g. 'speed', 'stability', etc.) vertloc: int or float describing the exact or approximate height of interest along the tower basecolor: string with the color code info to get from utils. """ stabconds = utils.get_stabconds() stabcol, _, _ = utils.get_vertical_locations( catinfo['columns']['stability flag'], location=vertloc) varcol, vertloc, _ = utils.get_vertical_locations( catinfo['columns'][category], location=vertloc) colors = utils.get_colors(len(stabconds), basecolor=basecolor) metdat = metdat.groupby(stabcol) fig, ax = plt.subplots(len(stabconds), 1, figsize=(4, 6), sharex=True, sharey=True) for ii, stab in enumerate(stabconds): data = metdat[varcol].get_group(stab).dropna() ax.flatten()[ii].hist(data, facecolor=colors[ii], edgecolor='k', bins=50, weights=np.ones(len(data)) / len(data), density=False) ax.flatten()[ii].legend([stab], fontsize=10, frameon=False) ax.flatten()[0].set_title(r'$z={}$m'.format(vertloc)) fig.text(-0.03, 0.5, 'Frequency [%]', rotation='vertical', ha='center', va='center') fig.text(0.5, 0, catinfo['labels'][category], ha='center', va='center') fig.tight_layout() return fig, ax
def main(draw_faces=False): try: simg = get_image(get_random_searchtag()) except ConnectionError: logging.warning("Retried since couldn't get source...") return main() if id_is_blacklisted(simg.id): logging.info("Retried, already posted image...") return main() if check_pixiv_404(fix_source_url(simg.source)): logging.warning("Skipping since pixiv linked 404'd") return main() append_blacklisted(simg.id) with DownloadedImage(simg.imurl) as impath: img = cv2.imread(impath) cascade = cascade = cv2.CascadeClassifier( os.path.join("lbpcascade_animeface", "lbpcascade_animeface.xml")) gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) gray = cv2.equalizeHist(gray) faces = cascade.detectMultiScale( gray, # detector options scaleFactor=1.1, minNeighbors=5, minSize=(24, 24)) if draw_faces: for (x, y, w, h) in faces: cv2.rectangle(img, (x, y), (x + w, y + h), (0, 0, 255), 2) logging.info("Found image %i faces, id: %i" % (len(faces), simg.id)) pilimg = Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2RGB)) text = utils.get_quote(CONFIG["texts"]) logging.info(text) font = utils.set_font(pilimg, text) draw = ImageDraw.Draw(pilimg) lines = utils.messages_multiline(text, font, pilimg) colours = utils.get_colors(impath) (x, y, faces) = utils.randomize_location(pilimg, lines, font, faces) for line in lines: height = font.getsize(line[1])[1] utils.draw_with_border(x, y, line, colours[0], colours[1], font, draw) y = y + height pilimg.save("img.png") return "img.png", fix_source_url(simg.source), text
def hist_by_stability(metdat, catinfo, category, vertloc=80, basecolor='span'): """**Get Stability Grouped Histogram Figure**. Plot the stability grouped histogram of a given variable (or category of variables) grouped by a given condition (or set of conditions). Parameters: 1. metdat (Pandas DataFrame): The desired input data (Met Mast). 2. catinfo (dictionary): Categorization information for the desired input data. Holds column names, labels, units, and save names. 3. category (string): Specifies the category of information that is desired for plotting. 4. vertloc (integer, float) [default: 80]: Describes the desired vertical location alond the tower for analysis. 5. basecolor (string) [default: 'span']: Provides the color code information to get from "utils.py". Returns: 1. fig (Matplotlib Figure): The figure object for the desired input data and categories. 2. ax (Matplotlib Axes): The axes object for the desired input data and categories. """ stabconds = utils.get_stabconds() stabcol, _, _ = utils.get_vertical_locations( catinfo['columns']['stability flag'], location=vertloc) varcol, vertloc, _ = utils.get_vertical_locations( catinfo['columns'][category], location=vertloc) colors = utils.get_colors(len(stabconds), basecolor=basecolor) metdat = metdat.groupby(stabcol) fig, ax = plt.subplots(len(stabconds), 1, figsize=(4, 6), sharex=True, sharey=True) for ii, stab in enumerate(stabconds): data = metdat[varcol].get_group(stab).dropna() ax.flatten()[ii].hist(data, facecolor=colors[ii], edgecolor='k', bins=50, weights=np.ones(len(data)) / len(data), density=False) ax.flatten()[ii].legend([stab], fontsize=10, frameon=False) ax.flatten()[0].set_title(r'$z={}$m'.format(vertloc)) fig.text(-0.03, 0.5, 'Frequency [%]', rotation='vertical', ha='center', va='center') fig.text(0.5, 0, catinfo['labels'][category], ha='center', va='center') fig.tight_layout() return fig, ax
def figs_hyperparameters_rej_abc(): df = get_df( path=f"{basepath_dfs}/supplement_hyperparameters_rej_abc.csv", ) for tasks in tqdm(all_tasks): for metric in ["C2ST"]: plot_task_metric( df, tasks, metric, subfolder="hyperparameters_rej_abc", default_color=get_colors(df=df, include_defaults=True)["REJ"], ) plot_task_metric( df, tasks, metric, subfolder="hyperparameters_rej_abc", labels=False, default_color=get_colors(df=df, include_defaults=True)["REJ"], )
def figs_abc_lra_sass(): df = get_df(path=f"{basepath_dfs}/supplement_abc_lra_sass.csv", ) for tasks in tqdm(all_tasks): for metric in ["C2ST"]: plot_task_metric( df, tasks, metric, subfolder="abc_lra_sass", default_color=get_colors(df=df), ) plot_task_metric( df, tasks, metric, subfolder="abc_lra_sass", labels=False, default_color=get_colors(df=df), )
def monthlyhourlyplot(metdat, catinfo, category=None, basecolor='span'): ########################################### """ Plot monthly average profiles against one another. Parameters: metdat: Pandas dataframe containing met mast data catinfo: dict containing categorization info for the metmast data. Fore each category, catinfo holds column names, labels, units, and save names category: string specifying category of information to plot (e.g. 'speed', 'stability', etc.) basecolor: string with the color code info to get from utils. """ if category is None: print('not sure what to plot...') pass months = utils.monthnames() colors = utils.get_colors(len(catinfo['columns'][category]), basecolor=basecolor, reverse=True) colnames, vertlocs, ind = utils.get_vertical_locations( catinfo['columns'][category], reverse=True) plotdat = metdat[colnames].groupby([metdat.index.month, metdat.index.hour]).mean() fig, ax = plt.subplots(4, 3, figsize=(9, 11), sharex=True, sharey=True) for iax in range(len(months)): for catitem in range(len(colnames)): ax.flatten()[iax].plot(plotdat[colnames[catitem]].xs(iax + 1), color=colors[catitem]) ax.flatten()[iax].set_title(months[iax], fontsize=12) fig.text(0.5, 0.2, 'Time of Day [hour]', ha='center', va='center') leg = fig.legend([str(v) + ' m' for v in vertlocs], loc='upper center', bbox_to_anchor=(0, -0.825, 1, 1), bbox_transform=plt.gcf().transFigure, frameon=False, ncol=2) fig.tight_layout() fig.subplots_adjust(bottom=0.25) fig.text(0, 0.6125, catinfo['labels'][category], ha='center', va='center', rotation='vertical') return fig, ax
def figs_mmd(): subfolder = "mmd" if not os.path.exists(basepath_figs / subfolder): os.makedirs(basepath_figs / subfolder) chart = fig_posterior( task_name="two_moons", width=200, height=200, samples_path= "runs/8ad671f1-1e7b-4af8-b0e9-ec35a99d354f/posterior_samples.csv.bz2", samples_name="REJ", title="REJ-ABC on Two Moons", legend=False, colors_dict=get_colors(include_defaults=True), config="manuscript", ) path = str(basepath_figs / subfolder / f"rej_abc.svg") chart.save(path) for ff in ["pdf", "png"]: den.convert_file(path, to=ff, debug=0) chart = fig_posterior( task_name="two_moons", width=200, height=200, samples_path= "runs/e37c16cf-3dda-4e26-ac3e-781fd27971a8/posterior_samples.csv.bz2", samples_name="SNLE", title="SNLE on Two Moons", legend=False, colors_dict=get_colors(include_defaults=True), config="manuscript", ) path = str(basepath_figs / subfolder / f"snle.svg") chart.save(path) for ff in ["pdf", "png"]: den.convert_file(path, to=ff, debug=0)
def stability_profile(metdat, catinfo, category=None, vertloc=80, basecolor='span'): ########################################### """ Plot cumulative average profiles sorted by stability. Parameters: metdat: Pandas dataframe containing met mast data catinfo: dict containing categorization info for the metmast data. Fore each category, catinfo holds column names, labels, units, and save names category: string specifying category of information to plot (e.g. 'speed', 'stability', etc.) vertloc: int or float describing the exact or approximate height of interest along the tower basecolor: string with the color code info to get from utils. """ if category is None: print('not sure what to plot...') pass stab, stabloc, ind = utils.get_vertical_locations( catinfo['columns']['stability flag'], location=vertloc) colors = utils.get_colors(5, basecolor=basecolor) stabconds = utils.get_stabconds() # extract vertical locations of data from variable names _, vertlocs, ind = utils.get_vertical_locations( catinfo['columns'][category]) plotdat = metdat.groupby(stab).mean() pdat = plotdat[catinfo['columns'][category]].T.iloc[ind] fig, ax = plt.subplots(figsize=(3.5, 5)) for ii, cond in enumerate(stabconds): ax.plot(pdat[cond], vertlocs, color=colors[ii], label=cond) ax.set_ylabel('Probe Height [m]') ax.set_xlabel(catinfo['labels'][category]) fig.legend(stabconds, loc=6, bbox_to_anchor=(1, 0.5), frameon=False) fig.tight_layout() return fig, ax
def stability_profile(metdat, catinfo, category=None, vertloc=80, basecolor='cycle'): """**Get Stability Profile**. Plot the stability profile of a given variable (or category of variables) grouped by a given condition (or set of conditions). Parameters: 1. metdat (Pandas DataFrame): The desired input data (Met Mast). 2. catinfo (dictionary): Categorization information for the desired input data. Holds column names, labels, units, and save names. 3. category (string) [default: None]: Specifies the category of information that is desired for plotting. 4. vertloc (integer, float) [default: 80]: Describes the desired vertical location alond the tower for analysis. 5. basecolor (string) [default: 'cycle]: Provides the color code information to get from "utils.py". Returns: 1. fig (Matplotlib Figure): The figure object for the desired input data and categories. 2. ax (Matplotlib Axes): The axes object for the desired input data and categories. """ if category is None: print('not sure what to plot...') pass stab, stabloc, ind = utils.get_vertical_locations( catinfo['columns']['stability flag'], location=vertloc) colors = utils.get_colors(5, basecolor=basecolor) stabconds = utils.get_stabconds() plotdat = metdat.groupby(stab).mean() pdat = plotdat[catinfo['columns'][category]].get_values() # Extract vertical locations of data from variable names _, vertlocs, ind = utils.get_vertical_locations( catinfo['columns'][category]) fig, ax = plt.subplots(figsize=(3.5, 5)) for ii, cond in enumerate(stabconds): ax.plot(pdat[ii, ind], vertlocs, color=colors[ii]) ax.set_ylabel('Probe Height [m]') ax.set_xlabel(catinfo['labels'][category]) fig.legend(stabconds, loc=6, bbox_to_anchor=(1, 0.5), frameon=False) fig.tight_layout() return fig, ax
def stacked_hist_by_stability(metdat, catinfo, category, vertloc=80): """**Get Stacked Stability Grouped Histogram Figure**. Plot the stacked stability grouped histogram of a given variable (or category of variables) grouped by a given condition (or set of conditions). Parameters: 1. metdat (Pandas DataFrame): The desired input data (Met Mast). 2. catinfo (dictionary): Categorization information for the desired input data. Holds column names, labels, units, and save names. 3. category (string): Specifies the category of information that is desired for plotting. 4. vertloc (integer, float): Describes the desired vertical location alond the tower for analysis. Returns: 1. fig (Matplotlib Figure): The figure object for the desired input data and categories. 2. ax (Matplotlib Axes): The axes object for the desired input data and categories. """ stabconds = utils.get_stabconds() stabcol, _, _ = utils.get_vertical_locations( catinfo['columns']['stability flag'], location=vertloc) varcol, vertloc, _ = utils.get_vertical_locations( catinfo['columns'][category], location=vertloc) colors = utils.get_colors(len(stabconds), basecolor='span') plotdat = metdat.groupby(stabcol) fig, ax = plt.subplots() temp = pd.DataFrame( {cond: plotdat[varcol].get_group(cond) for cond in stabconds}) temp.plot.hist( ax=ax, stacked=True, color=colors, bins=35, edgecolor='k', legend=False, # weights = np.ones(temp.shape) / len(temp.index), density=True) ax.set_xlabel(catinfo['labels'][category]) ax.set_title(r'$z={}$m'.format(vertloc)) fig.legend(stabconds, loc=6, bbox_to_anchor=(1, 0.5), frameon=False) fig.tight_layout() return fig, ax
def stacked_hist_by_stability(metdat, catinfo, category, vertloc=80): ########################################### """ make a stacked histogram of data separated by stability class. Parameters: metdat: Pandas dataframe containing met mast data catinfo: dict containing categorization info for the metmast data. Fore each category, catinfo holds column names, labels, units, and save names category: string specifying category of information to plot (e.g. 'speed', 'stability', etc.) vertloc: int or float describing the exact or approximate height of interest along the tower """ stabconds = utils.get_stabconds() stabcol, _, _ = utils.get_vertical_locations( catinfo['columns']['stability flag'], location=vertloc) varcol, vertloc, _ = utils.get_vertical_locations( catinfo['columns'][category], location=vertloc) colors = utils.get_colors(len(stabconds), basecolor='span') plotdat = metdat.groupby(stabcol) fig, ax = plt.subplots(figsize=(5, 3)) temp = pd.DataFrame( {cond: plotdat[varcol].get_group(cond) for cond in stabconds}) temp.plot.hist( ax=ax, stacked=True, color=colors, bins=35, edgecolor='k', legend=False, # weights = np.ones(temp.shape) / len(temp.index), density=True) ax.set_xlabel(catinfo['labels'][category]) # ax.set_title(r'$z={}$m'.format(vertloc)) fig.legend(stabconds, loc=6, bbox_to_anchor=(1, 0.5), frameon=False) fig.tight_layout() return fig, ax
def hourlyplot(metdat, catinfo, category=None, basecolor='span'): """**Get Hourly Averaged Profile**. Plot the hourly averaged profile of a given variable (or category of variables) grouped by a given condition (or set of conditions). Parameters: 1. metdat (Pandas DataFrame): The desired input data (Met Mast). 2. catinfo (dictionary): Categorization information for the desired input data. Holds column names, labels, units, and save names. 3. category (string): Specifies the category of information that is desired for plotting. 4. basecolor (string): Provides the color code information to get from "utils.py". Returns: 1. fig (Matplotlib Figure): The figure object for the desired input data and categories. 2. ax (Matplotlib Axes): The axes object for the desired input data and categories. """ if category is None: print('not sure what to plot...') pass colors = utils.get_colors(len(catinfo['columns'][category]), basecolor=basecolor, reverse=True) colnames, vertlocs, ind = utils.get_vertical_locations( catinfo['columns'][category], reverse=True) plotdat = metdat[colnames].groupby(metdat.index.hour).mean() fig, ax = plt.subplots(figsize=(5, 3.5), sharex=True, sharey=True) for iax in range(len(colnames)): ax.plot(plotdat[colnames[iax]], color=colors[iax]) leg = ax.legend([str(v) + ' m' for v in vertlocs], loc=6, bbox_to_anchor=(1, 0.5), frameon=False) ax.set_xlabel('Time [hour]') ax.set_ylabel(catinfo['labels'][category]) fig.tight_layout() return fig, ax
def hourlyplot(metdat, catinfo, category=None, basecolor='span'): ########################################### """ Plot monthly average profiles against one another. Parameters: metdat: Pandas dataframe containing met mast data catinfo: dict containing categorization info for the metmast data. Fore each category, catinfo holds column names, labels, units, and save names category: string specifying category of information to plot (e.g. 'speed', 'stability', etc.) basecolor: string with the color code info to get from utils. """ if category is None: print('not sure what to plot...') pass colors = utils.get_colors(len(catinfo['columns'][category]), basecolor=basecolor, reverse=True) colnames, vertlocs, ind = utils.get_vertical_locations( catinfo['columns'][category], reverse=True) plotdat = metdat[colnames].groupby(metdat.index.hour).mean() fig, ax = plt.subplots(figsize=(5, 3), sharex=True, sharey=True) for iax in range(len(colnames)): ax.plot(plotdat[colnames[iax]], color=colors[iax]) leg = ax.legend([str(v) + ' m' for v in vertlocs], loc=6, bbox_to_anchor=(1, 0.5), frameon=False) ax.set_xlabel('Time [hour]') ax.set_ylabel(catinfo['labels'][category]) fig.tight_layout() return fig, ax
def normalized_hist_by_stability(metdat, catinfo, vertloc=80): ########################################### """ make a normlizec histogram of data separated by stability class. Parameters: metdat: Pandas dataframe containing met mast data catinfo: dict containing categorization info for the metmast data. Fore each category, catinfo holds column names, labels, units, and save names vertloc: int or float describing the exact or approximate height of interest along the tower """ stabconds = utils.get_stabconds() stabcol, _, _ = utils.get_vertical_locations( catinfo['columns']['stability flag'], location=vertloc) colors = utils.get_colors(len(stabconds), basecolor='span') temp = metdat[stabcol].dropna() garb = temp.groupby(temp.index.hour).value_counts(normalize=True) garb.index.names = ['hour', 'stabclass'] garb = garb.reorder_levels(['stabclass', 'hour']) hours = np.arange(24) newbottom = np.zeros(24) fig, ax = plt.subplots(figsize=(5, 3)) for jj, cond in enumerate(stabconds): ax.bar(hours, garb.loc[cond], color=colors[jj], bottom=newbottom) newbottom += garb.loc[cond] ax.set_ylabel('Probability [%]') ax.set_xlabel('Time of Day [Hour]') fig.legend(stabconds, loc=6, bbox_to_anchor=(1, 0.5), framealpha=0) fig.tight_layout() return fig, ax
def monthly_profile(metdat, catinfo, category=None, basecolor='cycle'): ########################################### """ Plot monthly average profiles against one another. Parameters: metdat: Pandas dataframe containing met mast data catinfo: dict containing categorization info for the metmast data. Fore each category, catinfo holds column names, labels, units, and save names category: string specifying category of information to plot (e.g. 'speed', 'stability', etc.) basecolor: string with the color code info to get from utils. """ if category is None: print('not sure what to plot...') pass months = utils.monthnames() colors = utils.get_colors(len(months), basecolor=basecolor) colnames, vertlocs, ind = utils.get_vertical_locations( catinfo['columns'][category]) plotdat = metdat[colnames].groupby(metdat.index.month).mean() fig, ax = plt.subplots(figsize=(3.5, 5), sharex=True, sharey=True) for iax in range(len(months)): ax.plot(plotdat.xs(iax + 1), vertlocs, color=colors[iax]) leg = ax.legend(months, loc=7, bbox_to_anchor=(1.75, 0.5), edgecolor='w') ax.set_ylabel('Probe Height [m]') ax.set_xlabel(catinfo['labels'][category]) fig.tight_layout() return fig, ax
def monthly_profile(metdat, catinfo, category=None, basecolor='cycle'): """**Get Monthly Profile**. Plot the monthly profile of a given variable (or category of variables) grouped by a given condition (or set of conditions). Parameters: 1. metdat (Pandas DataFrame): The desired input data (Met Mast). 2. catinfo (dictionary): Categorization information for the desired input data. Holds column names, labels, units, and save names. 3. category (string) [default: None]: Specifies the category of information that is desired for plotting. 4. basecolor (string) [default: 'cycle']: Provides the color code information to get from "utils.py". Returns: 1. fig (Matplotlib Figure): The figure object for the desired input data and categories. 2. ax (Matplotlib Axes): The axes object for the desired input data and categories. """ if category is None: print('not sure what to plot...') pass months = utils.monthnames() colors = utils.get_colors(len(months), basecolor=basecolor) colnames, vertlocs, ind = utils.get_vertical_locations( catinfo['columns'][category]) plotdat = metdat[colnames].groupby(metdat.index.month).mean() fig, ax = plt.subplots(figsize=(3.5, 5), sharex=True, sharey=True) for iax in range(len(months)): ax.plot(plotdat.xs(iax + 1), vertlocs, color=colors[iax]) leg = ax.legend(months, loc=7, bbox_to_anchor=(1.75, 0.5), edgecolor='w') ax.set_ylabel('Probe Height [m]') ax.set_xlabel(catinfo['labels'][category]) fig.tight_layout() return fig, ax
def post(): with open("files.csv") as f: reader = csv.reader(f) chosen_row = random.choice(list(reader)) source = chosen_row[1] file_extension = chosen_row[2].split(".")[1] filename = "pics/" + chosen_row[2] text = get_quote("texts/quotes.txt") image = Image.open(filename) font = set_font(image, text) # get font size based on image size draw = ImageDraw.Draw(image) lines = messages_multiline(text, font, image) # split up lines for text wrapping colors = get_colors(image.filename) # get colors (x, y, faces) = randomize_location( image, lines, font ) # where to start drawing text for line in lines: height = font.getsize(line[1])[1] draw_with_border(x, y, line, colors[0], colors[1], font, draw) y = y + height image.save(f"to_tweet.{file_extension}") photo = open(f"to_tweet.{file_extension}", "rb") response = twitter.upload_media(media=photo) message = f"{text} ({source})" print(filename, message) twitter.update_status(status=message, media_ids=[response["media_id"]]) photo.close() os.remove(photo.name) with open("log", "a") as f: f.write( f"{datetime.now().strftime('%d-%m-%Y %H:%M:%S')}\t{filename}\t({image.size[0]} {image.size[1]})\t{font.size} ({max((font.size // 25), 2)})\t{text}\n" )
fill_value=0.0) df_err = df.pivot_table(index=['site', 'date'], columns='trt', values=dat, aggfunc=np.std, fill_value=0.0) df_pvt.reset_index(inplace=True) df_err.reset_index(inplace=True) df_pvt.to_csv(constants.base_dir + constants.soil_dir + 'df_pvt.csv') # Determine maximum value on y axis y_max = utils.roundup(df[dat].max(), 10.0) # Start plotting utils.set_matplotlib_params() colors = utils.get_colors() # Set up the axes and figure fig, axis = plt.subplots(nrows=nrow, ncols=ncol, figsize=(5 * ncol, 5 * nrow)) ctr = [(x, y) for x in np.arange(nrow) for y in np.arange(ncol)] site_ctr = 0 for i in ctr: if (nrow > 1): ax = axis[i[0], i[1]] else: ax = axis[site_ctr]
def main(): ### Main definitions ROOT.gROOT.SetBatch() ### canvas, c_top, c_bottom = utils.create_double_pad('plot_3lcr_2l2v') ### root_file = ROOT.TFile('inputs/MTW_all_met_tst.root') stack = utils.re_style_top( root_file.Get('c1').GetPrimitive('pad1').GetPrimitive('hs1')) stack.GetXaxis().SetTitle('#it{E}_{T}^{miss} [GeV]') stack.GetYaxis().SetTitle('Events / 30 GeV') hists = {} merging_scheme = utils.complex_merging full_stack = stack.GetStack().Last() for hist in stack.GetHists(): prev_color = hist.GetFillColor() sample_name = None for key, vals in utils.original_colors_2l2v.iteritems(): if prev_color in vals: sample_name = key if not sample_name: 'Sample Name Not Found' else: ''' for merging_key, merging_list in merging_scheme.iteritems(): if sample_name in merging_list: print sample_name, ' is supposed to be merged into ', merging_key ''' hists[sample_name] = utils.re_shape_tail(hist) ''' a = hist.GetXaxis() print print a.GetNbins() print a.GetXmin() print a.GetXmax() ''' ### Getting complicated here... loop_over_this = hists.keys() to_be_removed = utils.wjets_removal for key in loop_over_this: for merging_key, merging_list in merging_scheme.iteritems(): if key in merging_list: to_be_removed.add(key) if merging_key in hists: hists[merging_key].Add(hists[key]) else: hists[merging_key] = hists[key].Clone('another_clone_' + hists[key].GetName()) to_be_used = [] for k in hists: hist = hists[k] hist.SetFillColor(utils.get_colors(k)) hist.SetLineColor(ROOT.kBlack) hist.SetLineWidth(1) hist.SetTitle(utils.titles[k]) if not k in to_be_removed: to_be_used.append((k, hist.Integral())) sample_list = sorted(to_be_used, key=lambda x: x[1]) sample_list_r = sorted(to_be_used, key=lambda x: x[1], reverse=True) new_stack = ROOT.THStack(stack.GetName() + '_clone', '') for name, integral in sample_list: new_stack.Add(hists[name]) ### data = utils.re_style_top( utils.th1_to_tgraph( root_file.Get('c1').GetPrimitive('pad1').GetPrimitive( 'met_tst_MTW_all_Nominal'), True)) prev_error, last_bin_ratio = utils.re_shape_tail( root_file.Get('c1').GetPrimitive('pad1').GetPrimitive('h0'), True) error = utils.re_style_top(utils.th1_to_tgraph(prev_error)) error.SetMarkerStyle(1) error.SetFillColor(ROOT.kBlack) error.SetFillStyle(3345) ### ratio_axis = utils.re_style_bot( root_file.Get('c1').GetPrimitive('pad2').GetPrimitive('h3')) ratio = utils.re_style_bot( utils.th1_to_tgraph( root_file.Get('c1').GetPrimitive('pad2').GetPrimitive('h3'), True)) ratio_axis.GetXaxis().SetTitle('#it{E}_{T}^{miss} [GeV]') ratio_axis.GetYaxis().SetTitle('#frac{Data}{Prediction}') syst_band = utils.re_style_bot( utils.th1_to_tgraph( utils.change_last_bin( root_file.Get('c1').GetPrimitive('pad2').GetPrimitive('h0'), last_bin_ratio))) #ratio = utils.re_style_bot( root_file.Get( 'c1' ).GetPrimitive( 'pad2' ).GetPrimitive( 'h3' ) ) #ratio.GetXaxis().SetTitle( '#it{E}_{T}^{miss} [GeV]' ) #ratio.GetYaxis().SetTitle( '#frac{Data}{Prediction}' ) ##syst_band = utils.re_style_bot( utils.re_shape_tail( root_file.Get( 'c1' ).GetPrimitive( 'pad2' ).GetPrimitive( 'h0' ), full_stack ) ) #syst_band = utils.re_style_bot( utils.change_last_bin( root_file.Get( 'c1' ).GetPrimitive( 'pad2' ).GetPrimitive( 'h0' ), last_bin_ratio ) ) syst_band.SetMarkerStyle(1) syst_band.SetFillColor(ROOT.kBlack) syst_band.SetFillStyle(3345) ### c_top.cd() new_stack.SetMaximum(1000000) new_stack.SetMinimum(0.001) new_stack.Draw('hist') new_stack = utils.re_style_top(new_stack) new_stack.Draw('hist') new_stack.GetXaxis().SetTitle('#it{E}_{T}^{miss} [GeV]') new_stack.GetYaxis().SetTitle('Events / 30 GeV') new_stack.GetXaxis().SetRangeUser(0, 600) error.Draw('e2 same') data.Draw('pe') x_l1, y_l1, latex1 = utils.draw_latex(utils.lumi, True) latex1.DrawLatex( x_l1, y_l1 - 0.12, utils.h_to_zz_to + utils.lepp + utils.lepm + utils.nu + utils.nubar + utils.void_char + utils.inv_prime) latex1.DrawLatex(x_l1, y_l1 - 0.18, '3#it{l} Control Region') leg = utils.create_legend(len(sample_list_r), 0.3, 1) leg.AddEntry(data, 'Data', 'pe') for name, integral in sample_list_r: leg.AddEntry(hists[name], hists[name].GetTitle(), 'f') leg.AddEntry(error, 'Uncertainty', 'f') leg.Draw() #utils.patch_bar( 229. / 566., 234. / 566., 322. / 407., 322. / 407., True ) c_top.SetLogy() c_bottom.cd() ratio_axis.Draw('axis') ratio_axis.GetXaxis().SetRangeUser(0, 600) syst_band.Draw('e2 same') ratio.Draw('pe0 same') c_bottom.Update() for arrow in utils.get_arrows(ROOT.gPad.GetUymin(), ROOT.gPad.GetUymax(), ratio): arrow.Draw() Line = ROOT.TLine(ROOT.gPad.GetUxmin(), 1, ROOT.gPad.GetUxmax(), 1) Line.SetLineColor(ROOT.kBlack) Line.SetLineWidth(2) Line.SetLineStyle(2) Line.Draw() #canvas.SaveAs( canvas.GetName() + '.pdf' ) utils.save(canvas)
def main(argv): parser = argparse.ArgumentParser( description="Do the forward pass and estimate a set of primitives") parser.add_argument("dataset_directory", help="Path to the directory containing the dataset") parser.add_argument( "primitives_directory", help= "Path to the directory containing the superquadrics of the instance") parser.add_argument("output_directory", help="Save the output files in that directory") parser.add_argument( "--weight_file", default=None, help="The path to the previously trainined model to be used") parser.add_argument("--save_prediction_as_mesh", action="store_true", help="When true store prediction as a mesh") parser.add_argument("--run_on_gpu", action="store_true", help="Use GPU") parser.add_argument("--prob_threshold", type=float, default=0.5, help="Probability threshold") # Parse args add_nn_parameters(parser) add_dataset_parameters(parser) add_datatype_parameters(parser) add_training_parameters(parser) args = parser.parse_args(argv) # Check if output directory exists and if it doesn't create it if not os.path.exists(args.output_directory): os.makedirs(args.output_directory) if args.run_on_gpu and torch.cuda.is_available(): device = torch.device("cuda:0") else: device = torch.device("cpu") # device = torch.device("cuda:0") print("Running code on ", device) # TODO M = 11 data_output_shape = (M, 7) # Create a factory that returns the appropriate data type based on the # input argument data_factory = DataFactory( args.data_type, tuple([data_input_shape(args), data_output_shape])) # Create a dataset instance to generate the samples for training dataset = get_dataset_type("matrix_loss")( (DatasetBuilder().with_dataset(args.dataset_type).build( args.dataset_directory)), data_factory, transform=compose_transformations(args.data_type)) # TODO: Change batch_size in dataloader dataloader = DataLoader(dataset, batch_size=1, num_workers=4) network_params = NetworkParameters(args.architecture, M, False) model = network_params.network(network_params) # Move model to device to be used model.to(device) if args.weight_file is not None: # Load the model parameters of the previously trained model model.load_state_dict(torch.load(args.weight_file)) model.eval() # Keep track of the files containing the parameters of each primitive primitives = load_all_primitive_parameters(args.primitives_directory, args.prob_threshold) gt_primitives = list(primitives) colors = get_colors(M) # Prepare matlab figs # mlab.view(azimuth=0.0, elevation=0.0, distance=2) # Iterate thru the data total_runs = 0 total = 0 r_loss_total = 0 t_loss_total = 0 # fp = open(os.path.join(args.output_directory, "stats.csv"), "w") # fp.write("loss_total\trot_loss\ttrans_loss\t\n") for sample in dataloader: primitive_list = [] total_runs += 1 X, y_target = sample # Show input image # img = X.numpy()[0] # img = np.transpose(img, (1,2,0)) # img = img.reshape((224, 224, 3)) # imgplot = plt.imshow(img) # plt.show() X, y_target = X.to(device), y_target.to(device) # Declare some variables B = y_target.shape[0] # batch size M = y_target.shape[1] # number of primitives poses_target = y_target.view(B, M, 7).detach().cpu().numpy() rotations_target = poses_target[:, :, :4].reshape(B, M, 4)[0] translations_target = poses_target[:, :, 4:].reshape(B, M, 3)[0] # # Do the forward pass y_hat = model(X) translations = y_hat[0].detach().cpu().numpy().reshape(B, M, 3)[0] rotations = y_hat[1].detach().cpu().numpy().reshape(B, M, 4)[0] # Loss computations # options = dict() # options["device"] = device # loss, extra = matrix_loss(y_hat, y_target, options) # total += (extra["r_loss"] + extra["t_loss"]) # r_loss_total += extra["r_loss"] # t_loss_total += extra["t_loss"] # fp.write(str(total / total_runs)) # fp.write("\t") # fp.write(str(r_loss_total / total_runs)) # fp.write("\t") # fp.write(str(t_loss_total / total_runs)) # fp.write("\t") # fp.write("\n") # if total_runs % 50 == 0: # print(total / total_runs ) i = 0 # fig1 = mlab.figure(size=(400, 400), bgcolor=(1, 1, 1)) # fig2 = mlab.figure(size=(400, 400), bgcolor=(1, 1, 1)) for p in primitives: # primitives[i]["rotation"] = rotations[i] # primitives[i]["location"] = translations[i] # gt_primitives[i]["rotation"] = rotations_target[i] # gt_primitives[i]["location"] = translations_target[i] print("using GT...") x_tr, y_tr, z_tr, prim_pts =\ points_on_sq_surface( p["size"][0], p["size"][1], p["size"][2], p["shape"][0], p["shape"][1], # Quaternion(rotations_target[i]).rotation_matrix.reshape(3, 3), # np.array(translations_target[i]).reshape(3, 1), Quaternion(rotations[i]).rotation_matrix.reshape(3, 3), np.array(translations[i]).reshape(3, 1), p["tapering"][0], p["tapering"][1], None, None ) primitive_list.append((prim_pts, p['color'])) i += 1 print("-------- GT ---------") print(rotations_target) print(translations_target) print("--------- Pred ---------") print(rotations) print(translations) display_primitives(primitive_list)
df = df[df.site.isin(constants.SITE_NAMES.values())] for dat in constants.DATA_COLS: print dat df_pvt = df.pivot_table(index=['site','date'],columns='trt',values=dat,aggfunc='mean',fill_value=0.0) df_err = df.pivot_table(index=['site','date'],columns='trt',values=dat,aggfunc=np.std,fill_value=0.0) df_pvt.reset_index(inplace=True) df_err.reset_index(inplace=True) df_pvt.to_csv(constants.base_dir+constants.soil_dir+'df_pvt.csv') # Determine maximum value on y axis y_max = utils.roundup(df[dat].max(),10.0) # Start plotting utils.set_matplotlib_params() colors = utils.get_colors() # Set up the axes and figure fig, axis = plt.subplots(nrows=nrow, ncols=ncol, figsize=(5*ncol,5*nrow)) ctr = [(x, y) for x in np.arange(nrow) for y in np.arange(ncol)] site_ctr = 0 for i in ctr: if(nrow > 1): ax = axis[i[0],i[1]] else: ax = axis[site_ctr] if(site_ctr >= len(constants.SITE_NAMES)): ax.axis('off')
def main(argv): parser = argparse.ArgumentParser( description="Do the forward pass and estimate a set of primitives" ) parser.add_argument( "dataset_directory", help="Path to the directory containing the dataset" ) parser.add_argument( "output_directory", help="Save the output files in that directory" ) parser.add_argument( "--tsdf_directory", default="", help="Path to the directory containing the precomputed tsdf files" ) parser.add_argument( "--weight_file", default=None, help="The path to the previously trainined model to be used" ) parser.add_argument( "--n_primitives", type=int, default=32, help="Number of primitives" ) parser.add_argument( "--prob_threshold", type=float, default=0.5, help="Probability threshold" ) parser.add_argument( "--use_deformations", action="store_true", help="Use Superquadrics with deformations as the shape configuration" ) parser.add_argument( "--save_prediction_as_mesh", action="store_true", help="When true store prediction as a mesh" ) parser.add_argument( "--run_on_gpu", action="store_true", help="Use GPU" ) parser.add_argument( "--with_animation", action="store_true", help="Add animation" ) add_dataset_parameters(parser) add_nn_parameters(parser) add_voxelizer_parameters(parser) add_gaussian_noise_layer_parameters(parser) add_loss_parameters(parser) add_loss_options_parameters(parser) args = parser.parse_args(argv) # A sampler instance e = EqualDistanceSamplerSQ(200) # Check if output directory exists and if it doesn't create it if not os.path.exists(args.output_directory): os.makedirs(args.output_directory) if args.run_on_gpu and torch.cuda.is_available(): device = torch.device("cuda:0") else: device = torch.device("cpu") print ("Running code on {}".format(device)) # Create a factory that returns the appropriate voxelizer based on the # input argument voxelizer_factory = VoxelizerFactory( args.voxelizer_factory, np.array(voxelizer_shape(args)), args.save_voxels_to ) # Create a dataset instance to generate the samples for training dataset = get_dataset_type("euclidean_dual_loss")( (DatasetBuilder() .with_dataset(args.dataset_type) .filter_tags(args.model_tags) .build(args.dataset_directory)), voxelizer_factory, args.n_points_from_mesh, transform=compose_transformations(voxelizer_factory) ) model_tags = dataset._dataset_object._tags # TODO: Change batch_size in dataloader dataloader = DataLoader(dataset, batch_size=1, num_workers=4) network_params = NetworkParameters.from_options(args) # Build the model to be used for testing model = network_params.network(network_params) # Move model to device to be used model.to(device) if args.weight_file is not None: # Load the model parameters of the previously trained model model.load_state_dict( torch.load(args.weight_file, map_location=device) ) model.eval() colors = get_colors(args.n_primitives) for sample_idx, sample in enumerate(dataloader): model_tag = model_tags[sample_idx] X, y_target = sample X, y_target = X.to(device), y_target.to(device) # Do the forward pass and estimate the primitive parameters y_hat = model(X) M = args.n_primitives # number of primitives probs = y_hat[0].to("cpu").detach().numpy() # Transform the Euler angles to rotation matrices if y_hat[2].shape[1] == 3: R = euler_angles_to_rotation_matrices( y_hat[2].view(-1, 3) ).to("cpu").detach() else: R = quaternions_to_rotation_matrices( y_hat[2].view(-1, 4) ).to("cpu").detach() # get also the raw quaternions quats = y_hat[2].view(-1, 4).to("cpu").detach().numpy() translations = y_hat[1].to("cpu").view(args.n_primitives, 3) translations = translations.detach().numpy() shapes = y_hat[3].to("cpu").view(args.n_primitives, 3).detach().numpy() epsilons = y_hat[4].to("cpu").view( args.n_primitives, 2 ).detach().numpy() taperings = y_hat[5].to("cpu").view( args.n_primitives, 2 ).detach().numpy() pts = y_target[:, :, :3].to("cpu") pts_labels = y_target[:, :, -1].to("cpu").squeeze().numpy() pts = pts.squeeze().detach().numpy().T on_prims = 0 # XXX: UNTIL I FIX THE MLAB ISSUE # fig = mlab.figure(size=(400, 400), bgcolor=(1, 1, 1)) # mlab.view(azimuth=0.0, elevation=0.0, distance=2) # Uncomment to visualize the points sampled from the target mesh # t = np.array([1.2, 0, 0]).reshape(3, -1) # pts_n = pts + t # mlab.points3d( # # pts_n[0], pts_n[1], pts_n[2], # pts[0], pts[1], pts[2], # scale_factor=0.03, color=(0.8, 0.8, 0.8) # ) save_dir = os.path.join(args.output_directory, os.path.basename(os.path.dirname(args.dataset_directory)), model_tag) if not os.path.exists(save_dir): os.makedirs(save_dir) # args.output_directory/class/model_id/primitive_%d.p # args.output_directory/class/model_id/reconstruction # Keep track of the files containing the parameters of each primitive primitive_files = [] for i in range(args.n_primitives): x_tr, y_tr, z_tr, prim_pts =\ get_shape_configuration(args.use_cuboids)( shapes[i, 0], shapes[i, 1], shapes[i, 2], epsilons[i, 0], epsilons[i, 1], R[i].numpy(), translations[i].reshape(-1, 1), taperings[i, 0], taperings[i, 1] ) # Dump the parameters of each primitive as a dictionary # TODO: change filepath store_primitive_parameters( size=tuple(shapes[i]), shape=tuple(epsilons[i]), rotation=tuple(quats[i]), location=tuple(translations[i]), tapering=tuple(taperings[i]), probability=(probs[0, i],), color=(colors[i % len(colors)]) + (1.0,), filepath=os.path.join( save_dir, "primitive_%d.p" %(i,) ) ) if probs[0, i] >= args.prob_threshold: on_prims += 1 # mlab.mesh( # x_tr, # y_tr, # z_tr, # color=tuple(colors[i % len(colors)]), # opacity=1.0 # ) primitive_files.append( os.path.join(save_dir, "primitive_%d.p" % (i,)) ) if args.with_animation: cnt = 0 for az in range(0, 360, 1): cnt += 1 # XXX UNTIL I FIX THE MLAB ISSUE # mlab.view(azimuth=az, elevation=0.0, distance=2) # mlab.savefig( # os.path.join( # args.output_directory, # "img_%04d.png" % (cnt,) # ) # ) for i in range(args.n_primitives): print("{} {}".format(i, probs[0, i])) print ("Using %d primitives out of %d" % (on_prims, args.n_primitives)) # XXX UNTIL I FIX THE MLAB ISSUE # mlab.show() # TODO: from_primitive_parms_to_mesh() # TODO: get parts for this chair. # TODO: push the parts and superquadric meshes through the metric function # TODO: record metrics if args.save_prediction_as_mesh: # TODO: save with model information, class information ...etc print ("Saving prediction as mesh....") save_prediction_as_ply( primitive_files, os.path.join(save_dir, "reconstruction.ply") ) print("Saved prediction as ply file in {}".format( os.path.join(save_dir, "reconstruction.ply") ))
path_flexce_top = os.path.abspath(join(path_plot, '../..')) path_output = join(path_flexce_top, 'output') path_fileio = join(path_flexce_top, 'flexCE', 'fileio') path_plots_top = join(path_flexce_top, 'plots') path_config = join(path_plots_top, 'config') path_plots = join(path_plots_top, 'plots') # --------------------- sys.path.append(path_fileio) import txt_io import cfg_io # Read config file fin = utils.get_filename(sys.argv, path_config) cfg = cfg_io.read_plot_config(join(path_config, fin)) colors = utils.get_colors(cfg) abund = cfg['General']['abundance'] labels = cfg['General']['labels'] # Read in simulation results sims = [] for sim_id in cfg['General']['sim_ids']: sims.append(txt_io.load_dataframe(path_output, sim_id)) # Make plot for i, (sim, color) in enumerate(zip(sims, colors)): marg_kws = dict(norm_hist=True, hist_kws=dict(weights=sim.Survivors.values)) if i == 0: fig = sns.jointplot('[Fe/H]', abund, data=sim, stat_func=None, color=color, marginal_kws=marg_kws)
network_params = NetworkParameters(architecture, M, False) model = network_params.network(network_params) # Move model to device to be used model.to(device) if weight_file is not None: # Load the model parameters of the previously trained model model.load_state_dict(torch.load(weight_file)) print("Loading...", weight_file) model.eval() # Keep track of the files containing the parameters of each primitive primitives = load_all_primitive_parameters(primitives_directory, prob_threshold) gt_primitives = list(primitives) colors = get_colors(M) parser = argparse.ArgumentParser( description="Do the forward pass and estimate a set of primitives") add_nn_parameters(parser) add_dataset_parameters(parser) add_datatype_parameters(parser) add_training_parameters(parser) args = parser.parse_args("") print(args) data_type = "image" data_factory = DataFactory(data_type, tuple([data_input_shape(args), data_output_shape])) dataset = get_dataset_type("matrix_loss")( (DatasetBuilder().with_dataset(
def image_scatter(csv, color_by, x, y, dpi, channel): #./main.py image_scatter --csv ResultTable\ -\ 2\ wells\,\ 1\ fields\,\ thresh\ 160_with_Traces_full_curated.csv -x tsne1 -y tsne2 --color-by CellLine --dpi 650 df = utils.read_csv(csv) print('Found number of cells: %s' % df.shape[0]) #image_dir = './images/cropped_images/Ron/' image_dir = './images/cropped_images/' cell_imgs = [] colors = [] xx = np.array([]) yy = np.array([]) cmap = 'gist_rainbow' color_list = utils.get_colors(len(np.unique(df[color_by])), cmap=cmap) # blue is better when there are only 3 colours if len(color_list) == 3 and cmap == 'gist_rainbow': color_list[2] = (0.05, 0.529, 1, 1.0) for row_id, row in df.iterrows(): cell_id = row.CellID image_filename = image_dir + 'ch' + str( channel) + '-' + cell_id + '.jpg' if not os.path.exists(image_filename): print('[WARN] no image found %s' % image_filename) continue print('Loading image %s' % image_filename) image = skimage.io.imread(image_filename) image = utils.gray_to_color(image) cell_imgs.append(image) xx = np.append(xx, row[x]) yy = np.append(yy, row[y]) color_id = np.where(np.unique(df[color_by]) == row[color_by])[0][ 0] # find position where this value appears c = color_list[color_id] c = (int(c[0] * 255), int(c[1] * 255), int(c[2] * 255) ) # convert value range, ex. 1.0 -> 255 or 0.0 -> 0 colors.append(c) if len(cell_imgs) == 0: print('[ERROR] 0 cropped single cell images found.') return canvas = plot.image_scatter(yy, xx, cell_imgs, colors, min_canvas_size=4000) plt.imshow(canvas, origin='lower') plt.title('%s vs %s' % (x, y)) plt.xlabel('%s' % x) plt.ylabel('%s' % y) plt.xticks([]) plt.yticks([]) patches = [] for i in range(len(np.unique(df[color_by]))): label = '%s %s' % (color_by, np.unique(df[color_by])[i]) if color_by == 'Dend.cat': label = 'Detected Category %s' % (i + 1) # Plot additional data that can't be in the main csv # extra_datafile = 'PCaxes.csv' # if os.path.exists(extra_datafile): # df_extra = utils.read_csv(extra_datafile) # from IPython import embed # embed() # drop into an IPython session # plt.scatter(avg_x, avg_y,c=color,marker='*') patch = mpatches.Patch(color=color_list[i], label=label) patches.append(patch) plt.legend(handles=patches, bbox_to_anchor=(1.04, 0.5), loc="center left", borderaxespad=0, frameon=False) save_location = './images/%s_image_scatter_by_%s_dpi%s.jpg' % ( csv, color_by, dpi) plt.savefig(save_location, dpi=dpi, pad_inches=1, bbox_inches='tight') # plt.show() print('Saved image scatter to %s' % save_location)