def fig(self, ix, raw=False, alt_df=None): """Generate interactive plot of a specified target. alt_df: df to use for fig; None if using self.pbb ix: index of the dataframe to plot raw: slider for raw image """ if alt_df is None: df = self.pbbs else: df = alt_df row = df.loc[ix] print row pid, z, y, x, d = row['pid'], row['z'],\ row['y'],row['x'],row['d'] import IPython.html.widgets as w if not raw: img = np.load(os.path.join(self.PREP, pid + '_clean.npy')) else: img, origin, spacing = utils.load_itk_image(os.path.join(self.RAW,pid + '.mhd')) # convert z,y,x,d to raw voxel coordinates v = np.array([z,y,x]) ebox_origin = np.load(os.path.join(self.PREP,pid+'_ebox_origin.npy')) v = v + ebox_origin prep_spacing = np.load(os.path.join(self.PREP,pid+'_spacing.npy')) v = utils.voxelToWorldCoord(v, origin, prep_spacing) v = utils.worldToVoxelCoord(v, origin, spacing) z, y, x = v[0], v[1], v[2] d = d * prep_spacing[1] / spacing[1] # convert title row = row.copy() row['z'] = z row['y'] = y row['x'] = x row['d'] = d def fz(k): utils.showTargetImgComp(img, [k,y,x], plt, d=d, t=str(row)) def fy(k): utils.showTargetImgComp(np.swapaxes(img,0,1), [k,z,x], plt, d=d, t=str(row)) def fx(k): utils.showTargetImgComp(np.swapaxes(img,0,2), [k,y,z], plt, d=d, t=str(row)) w.interact(fz, k=w.IntSlider(min=0,max=img.shape[0]-1,step=1,value=z)) w.interact(fy, k=w.IntSlider(min=0,max=img.shape[1]-1,step=1,value=y)) w.interact(fx, k=w.IntSlider(min=0,max=img.shape[2]-1,step=1,value=x))
def show_image_and_mask(img): """ Given CT img, produce interactive jupyter notebook slider across axial slice img: [D,H,W] or [D,H,W,3] """ def fz(k): plt.imshow(img[k], vmin=img.min(), vmax=img.max() + 1) plt.show() w.interact(fz, k=w.IntSlider(min=0, max=img.shape[0] - 1, step=1, value=0))
def show3Dimg(image, *imgs): n_img = 1 + sum([not img is None for img in imgs]) def fz(k): plt.subplot(1, n_img, 1) colorbar(plt.imshow(image[k])) for i in range(len(imgs)): plt.subplot(1, n_img, 2 + i) colorbar(plt.imshow(imgs[i][k], vmin=0, vmax=30)) plt.show() w.interact(fz, k=w.IntSlider(min=0, max=image.shape[0] - 1, step=1, value=0))
def create_linewidth_slider(desc, *args, **kwargs): """ Creates a slider for linewidth-type settings in `matplotlib.rcParams`. :param desc: The description label of the widget. :returns: The configured slider. """ from_rc = mpl.rcParams[desc] val = 0 # TODO deal with strings if not isinstance(from_rc, str): val = from_rc return widgets.IntSlider(min=0, max=9, value=val, description=desc, *args, **kwargs)
def simulate(transitions, input='10101', unary=False, input_unary=12, pause=0.05, step_from=0, step_to=100, step_slack=100): """loads widget to simulate a given TM""" # widgets to specify the range of steps to simulate from_w = widgets.IntText(value=step_from, description="simulate from step") to_w = widgets.IntText(value=step_to, description="simulate to step") pause_w = widgets.FloatText(value=pause, description="pause between steps") # widget to indicate current step steps_w = widgets.IntSlider(min=0, max=step_to + step_slack, value=0, description="current step") # subroutine to animate the simulation def animate(x): steps_w.max = to_w.value + step_slack for steps in range(from_w.value, to_w.value + 1): steps_w.value = steps sleep(pause_w.value) # button to start animated simulation simulate_w = widgets.Button(description='simulate') simulate_w.on_click(animate) input_w = widgets.Text(value=input, description="input") unary_w = widgets.Checkbox(value=unary, description='unary?') input_unary_w = widgets.IntText(value=input_unary, description='input number') def update(): if unary_w.value: input_w.disabled = True input_unary_w.visible = True input_w.value = '1' * input_unary_w.value else: input_w.disabled = False input_unary_w.visible = False update() unary_w.on_trait_change(update) input_unary_w.on_trait_change(update) # display control widgets box = widgets.VBox( children=[simulate_w, from_w, to_w, pause_w, unary_w, input_unary_w]) display(box) # widgets to display simulation interact(display_wrap(run), transitions=fixed(transitions), input=input_w, steps=steps_w)
Fs = 2.**12 options = { "sine": 0, "cosine": 1, "sinc": 2, "block": 3, "impulse": 4, "blocktrain": 5, "damped oscillation": 6, "carrier + signal": 7 } # Extra options for sine select_sine_amplitude = widgets.IntSlider(min=1, max=5, description="Amplitude:") select_sine_frequency = widgets.IntSlider(min=1., max=200., step=20., description="Frequency:") box_sine = widgets.Box(children=[select_sine_amplitude, select_sine_frequency], visible=True) # Extra options for cosine select_cosine_amplitude = widgets.IntSlider(min=1, max=5, description="Amplitude:") select_cosine_frequency = widgets.IntSlider(min=1.0, max=200.0, step=20.0, description="Frequency:")
def start_explorer(global_namespace, manual_data_select=False, dir="./"): frame = framework.framework() frame.set_default_display_style(padding="0.25em", background_color="white", border_color="LightGrey", border_radius="0.5em") frame.set_default_io_style(padding="0.25em", margin="0.25em", border_color="LightGrey", border_radius="0.5em") group_style = { "border_style": "none", "border_radius": "0em", "width": "100%" } text_box_style = {"width": "10em"} button_style = {"font_size": "1.25em", "font_weight": "bold"} first_tab_style = {"border_radius": "0em 0.5em 0.5em 0.5em"} states_movie = ["movie", "movie_iso_abund", "movie_abu_chart"] states_nugrid = [ "nugrid", "nugrid_w_data", "nugrid_get_data", "iso_abund", "abu_chart", "nugrid_plot" ] + states_movie states_mesa = [ "mesa", "mesa_w_data", "get_data", "hrd", "plot", "kip_cont", "kippenhahn", "tcrhoc" ] states_plotting = states_nugrid[3:] + states_mesa[3:] frame.add_state(states_nugrid) frame.add_state(states_mesa) if manual_data_select: frame.set_state_data("model_data", (None, None)) else: frame.set_state_data("model_data", (None, None, None)) frame.set_state_data("variable_name_timer", None) frame.set_state_data("dir", os.path.abspath(dir)) def update_dir_bar_list(): dir = frame.get_state_data("dir") dirs = [".", ".."] + os.listdir(dir) frame.set_state_attribute("address_bar", value=dir) frame.set_state_attribute("directory_list", options=dirs) frame.add_display_object("window") frame.add_io_object("Title") frame.add_display_object("widget") ###Data page### frame.add_display_object("page_data") frame.add_io_object("mass") frame.add_io_object("Z") frame.add_io_object("select_nugrid_mesa") frame.add_io_object("address_bar") frame.add_io_object("directory_list") frame.add_display_object("contain_module_load") frame.add_io_object("select_module") frame.add_display_object("contain_model_select") frame.add_io_object("model_select") frame.add_io_object("load_data") frame.set_state_children("window", ["Title", "widget"]) frame.set_state_children("widget", ["page_data"], titles=["Data"]) frame.set_state_children("page_data", [ "mass", "Z", "address_bar", "directory_list", "select_nugrid_mesa", "contain_module_load" ]) frame.set_state_children( "contain_module_load", ["select_module", "contain_model_select", "load_data"]) frame.set_state_children("contain_model_select", ["model_select"]) ###Plotting page### frame.add_display_object("page_plotting") frame.add_io_object("select_plot") frame.add_io_object("warning_msg") frame.add_io_object("plot_name") frame.add_display_object("cycle_sparsity_group") frame.add_io_object("cycle") frame.add_io_object("cycle_range") frame.add_io_object("sparsity") frame.add_io_object("movie_type") frame.add_display_object("xax") frame.add_io_object("xaxis") frame.add_io_object("logx") frame.add_display_object("yax") frame.add_io_object("yaxis") frame.add_io_object("logy") frame.add_display_object("mass_settings") frame.add_io_object("set_amass") frame.add_io_object("amass_range") frame.add_io_object("set_mass") frame.add_io_object("mass_range") frame.add_io_object("lbound") frame.add_display_object("kipp_settings") frame.add_io_object("plot_star_mass") frame.add_io_object("plot_c12border") frame.add_io_object("plot_engminus") frame.add_io_object("plot_engplus") frame.add_io_object("ixaxis") frame.add_display_object("lim_settings") frame.add_io_object("set_lims") frame.add_io_object("ylim") frame.add_io_object("xlim") frame.add_io_object("yres") frame.add_io_object("xres") frame.add_io_object("stable") frame.add_display_object("abu_settings") frame.add_io_object("ilabel") frame.add_io_object("imlabel") frame.add_io_object("imagic") frame.add_io_object("variable_name") frame.add_io_object("generate_plot") frame.set_state_children("widget", ["page_plotting"], titles=["Plotting"]) frame.set_state_children("page_plotting", [ "select_plot", "warning_msg", "plot_name", "movie_type", "variable_name", "cycle_sparsity_group", "xax", "yax", "stable", "mass_settings", "kipp_settings", "lim_settings", "abu_settings", "stable", "generate_plot" ]) frame.set_state_children("cycle_sparsity_group", ["cycle", "cycle_range", "sparsity"]) frame.set_state_children("xax", ["xaxis", "logx"]) frame.set_state_children("yax", ["yaxis", "logy"]) frame.set_state_children( "mass_settings", ["set_amass", "amass_range", "set_mass", "mass_range", "lbound"]) frame.set_state_children( "lim_settings", ["ixaxis", "set_lims", "xlim", "ylim", "xres", "yres"]) frame.set_state_children("abu_settings", ["ilabel", "imlabel", "imagic"]) frame.set_state_children( "kipp_settings", ["plot_star_mass", "plot_c12border", "plot_engminus", "plot_engplus"]) ###DEFAULT### frame.set_state_data("class_instance", None) frame.set_state_attribute('window', visible=True, **group_style) frame.set_state_attribute( 'Title', visible=True, value= "<center><h1>NuGrid Set explorer</h1></center><p><center>This explorer allows you to investigate NuGrid stellar evolution and yields data sets.</center></p>" ) frame.set_state_attribute('widget', visible=True, **group_style) frame.set_state_attribute("page_data", visible=True, **first_tab_style) frame.set_state_attribute('mass', visible=not manual_data_select, description="Mass: ", options=[ "1.0", "1.65", "2.0", "3.0", "4.0", "5.0", "6.0", "7.0", "12.0", "15.0", "20.0", "25.0", "32.0", "60.0" ], selected_label="2.0") frame.set_state_attribute('Z', visible=not manual_data_select, description="Z: ", options=["1E-4", "1E-3", "6E-3", "1E-2", "2E-2"]) frame.set_state_attribute("address_bar", visible=manual_data_select) frame.set_state_attribute("directory_list", visible=manual_data_select) frame.set_state_attribute("select_nugrid_mesa", visible=True, description="Select NuGrid or Mesa: ", options=["", "NuGrid", "Mesa"]) frame.set_state_attribute("contain_module_load", visible=True, **group_style) frame.set_state_attribute("select_module", visible=True, description="Select data type: ", disabled=True) frame.set_state_attribute("contain_model_select", border_style="none", padding="0px", margin="0px", width="18em") frame.set_state_attribute("model_select", visible=True, description="Select model: ", placeholder="1", **text_box_style) frame.set_state_attribute("load_data", visible=True, description="Load Data", disabled=True, **button_style) ###NUGRID### frame.set_state_attribute("select_module", states_nugrid, options=["", "H5 out"], disabled=False) frame.set_state_attribute("load_data", states_nugrid, disabled=False) ###MESA### frame.set_state_attribute("select_module", states_mesa, options=["", "History", "Profile"], disabled=False) frame.set_state_attribute("load_data", states_mesa, disabled=False) ###CALLBACKS### def model_select_handler(name, value): frame.set_attributes("model_select", value=int_text(value)) def mass_Z_handler(name, value): if frame.get_attribute("contain_model_select", "visible"): mass = float(frame.get_attribute("mass", "value")) Z = float(frame.get_attribute("Z", "value")) dir = frame.get_attribute("address_bar", "value") if manual_data_select: mdir, mmodel = frame.get_state_data("model_data") if (mdir != dir) or (mmodel == None): clear_output() pre_data = ms.mesa_profile(dir) frame.set_state_data("model_data", (dir, pre_data.model)) else: mmass, mZ, mmodel = frame.get_state_data("model_data") if (mmass != mass) or (mZ != Z) or (mmodel == None): clear_output() pre_data = ms.mesa_profile(mass=mass, Z=Z) frame.set_state_data("model_data", (mass, Z, pre_data.model)) def address_bar_handler(widget): dir = frame.get_attribute("address_bar", "value") if os.path.isdir(dir): dir = os.path.abspath(dir) frame.set_state_data("dir", dir) update_dir_bar_list() frame.update() frame.set_attributes("address_bar", value=dir) frame.set_attributes("directory_list", value=".", selected_label=u".") def directory_list_handler(name, value): dir = frame.get_state_data("dir") dir = dir + "/" + frame.get_attribute("directory_list", "value") if os.path.isdir(dir): dir = os.path.abspath(dir) frame.set_state_data("dir", dir) update_dir_bar_list() frame.update() frame.set_attributes("address_bar", value=dir) frame.set_attributes("directory_list", value=".", selected_label=u".") def sel_nugrid_mesa(name, value): if value == "NuGrid": frame.set_state("nugrid") elif value == "Mesa": frame.set_state("mesa") elif value == "": frame.set_state("default") def load(widget): clear_output() data = None mass = float(frame.get_attribute("mass", "value")) Z = float(frame.get_attribute("Z", "value")) dir = frame.get_attribute("address_bar", "value") if frame.get_attribute("model_select", "value") != "": model = int(frame.get_attribute("model_select", "value")) else: model = 1 module = frame.get_attribute("select_module", "value") if module == "H5 out": if manual_data_select: data = mp.se(dir) else: data = mp.se(mass=mass, Z=Z) frame.set_state("nugrid_w_data") properties = ["mass", "radius", "rho", "temperature"] frame.set_attributes("xaxis", options=properties + data.se.isotopes) frame.set_attributes("yaxis", options=properties + data.se.isotopes) elif module == "History": if manual_data_select: data = ms.history_data(dir) else: data = ms.history_data(mass=mass, Z=Z) frame.set_state("mesa_w_data") frame.set_attributes("xaxis", options=sorted(data.cols.keys())) frame.set_attributes("yaxis", options=sorted(data.cols.keys())) elif module == "Profile": if manual_data_select: data = ms.mesa_profile(dir, num=model) else: data = ms.mesa_profile(mass=mass, Z=Z, num=model) frame.set_state("mesa_w_data") frame.set_attributes("xaxis", options=sorted(data.cols.keys())) frame.set_attributes("yaxis", options=sorted(data.cols.keys())) else: nugrid_or_mesa = frame.get_attribute("select_nugrid_mesa", 'value') if nugrid_or_mesa == "NuGrid": frame.set_state("nugrid") elif nugrid_or_mesa == "Mesa": frame.set_state("mesa") frame.set_state_data("class_instance", data) frame.set_attributes("select_plot", selected_label="") def change_module(widget, value): if value == "History": frame.set_state_attribute("select_plot", states_mesa[1:], options={ "": "mesa_w_data", "HR-Diagram": "hrd", "Plot": "plot", "Kippenhahn": "kippenhahn", "Kippenhahan contour": "kip_cont", "TCRhoC plot": "tcrhoc", "Get data": "get_data" }) frame.set_state_attribute("contain_model_select", states_mesa, visible=False) frame.set_attributes("contain_model_select", visible=False) elif value == "Profile": frame.set_attributes("load_data", disabled=True) frame.set_state_attribute("select_plot", states_mesa[1:], options={ "": "mesa_w_data", "Plot": "plot", "Get data": "get_data" }) mass = float(frame.get_attribute("mass", "value")) Z = float(frame.get_attribute("Z", "value")) dir = frame.get_attribute("address_bar", "value") if manual_data_select: mdir, mmodel = frame.get_state_data("model_data") if (mdir != dir) or (mmodel == None): clear_output() pre_data = ms.mesa_profile(dir) mmodel = pre_data.model frame.set_state_data("model_data", (dir, mmodel)) else: mmass, mZ, mmodel = frame.get_state_data("model_data") if (mmass != mass) or (mZ != Z) or (mmodel == None): clear_output() pre_data = ms.mesa_profile(mass=mass, Z=Z) mmodel = pre_data.model frame.set_state_data("model_data", (mass, Z, mmodel)) frame.set_state_attribute("contain_model_select", states_mesa, visible=True) frame.set_attributes("contain_model_select", visible=True) frame.set_attributes("model_select", value=str(mmodel[-1])) frame.set_attributes("load_data", disabled=False) else: frame.set_state_attribute("contain_model_select", states_mesa, visible=False) frame.set_attributes("contain_model_select", visible=False) frame.set_state_callbacks("model_select", model_select_handler) frame.set_state_callbacks("mass", mass_Z_handler) frame.set_state_callbacks("Z", mass_Z_handler) frame.set_state_callbacks("address_bar", address_bar_handler, attribute=None, type="on_submit") frame.set_state_callbacks("directory_list", directory_list_handler) frame.set_state_callbacks("select_nugrid_mesa", sel_nugrid_mesa) frame.set_state_callbacks("select_module", change_module) frame.set_state_callbacks("load_data", load, attribute=None, type="on_click") frame.set_object("window", widgets.Box()) frame.set_object("Title", widgets.HTML()) frame.set_object("widget", widgets.Tab()) frame.set_object("page_data", widgets.VBox()) frame.set_object("mass", widgets.Dropdown()) frame.set_object("Z", widgets.ToggleButtons()) frame.set_object("address_bar", widgets.Text()) frame.set_object("directory_list", widgets.Select()) frame.set_object("select_nugrid_mesa", widgets.Dropdown()) frame.set_object("contain_module_load", widgets.HBox()) frame.set_object("select_module", widgets.Dropdown()) frame.set_object("contain_model_select", widgets.HBox()) frame.set_object("model_select", widgets.Text()) frame.set_object("load_data", widgets.Button()) ###Plotting page### frame.set_state_attribute('page_plotting', visible=True) frame.set_state_attribute("select_plot", visible=True, description="Select plot type: ", disabled=True) frame.set_state_attribute("select_plot", states_nugrid[1:], options={ "": "nugrid_w_data", "Isotope abundance": "iso_abund", "Abundance chart": "abu_chart", "Movie": "movie", "Plot": "nugrid_plot", "Get data": "nugrid_get_data" }, disabled=False) frame.set_state_attribute("select_plot", states_mesa[1:], options={ "": "mesa_w_data", "HR-Diagram": "hrd", "Plot": "plot", "Kippenhahn": "kippenhahn", "Kippenhahan contour": "kip_cont", "TCRhoC": "tcrhoc", "Get data": "nugrid_get_data" }, disabled=False) frame.set_state_attribute('warning_msg', visible=True, value="<h3>Error: No data loaded!</h3>", **group_style) frame.set_state_attribute("warning_msg", ["nugrid_w_data", "mesa_w_data"], value="<h2>Select plot.</h2>") frame.set_state_attribute("warning_msg", states_plotting + ["get_data", "nugrid_get_data"], visible=False) frame.set_state_attribute("plot_name", **group_style) frame.set_state_attribute('plot_name', "iso_abund", visible=True, value="<h2>Isotope abundance</h2>") frame.set_state_attribute('plot_name', "abu_chart", visible=True, value="<h2>Abundance chart</h2>") frame.set_state_attribute('plot_name', states_movie, visible=True, value="<h2>Movie</h2>") frame.set_state_attribute('plot_name', "hrd", visible=True, value="<h2>HR-Diagram</h2>") frame.set_state_attribute('plot_name', ["plot", "nugrid_plot"], visible=True, value="<h2>Plot</h2>") frame.set_state_attribute('plot_name', "kippenhahn", visible=True, value="<h2>Kippenhahn</h2>") frame.set_state_attribute('plot_name', "kip_cont", visible=True, value="<h2>Kippenhahn contour</h2>") frame.set_state_attribute( 'plot_name', "tcrhoc", visible=True, value="<h2>Central temperature vs central density</h2>") frame.set_state_attribute('plot_name', ["get_data", "nugrid_get_data"], visible=True, value="<h2>Get data</h2>") frame.set_state_attribute("variable_name", ["get_data", "nugrid_get_data"], visible=True, description="Variable name: ", placeholder="Enter name.", **text_box_style) frame.set_state_attribute('movie_type', states_movie, visible=True, description="Movie Type: ", options={ "": "movie", "Isotope abundance": "movie_iso_abund", "Abundance chart": "movie_abu_chart" }) frame.set_state_attribute('cycle_sparsity_group', states_nugrid[1:] + states_mesa[1:] + states_movie, visible=True, **group_style) frame.set_state_attribute( 'cycle', ["iso_abund", "abu_chart", "nugrid_plot", "nugrid_get_data"], visible=True, description="cycle: ") frame.set_state_attribute('cycle_range', states_movie[1:], visible=True) frame.set_state_attribute('sparsity', states_movie[1:], visible=True, description="Sparsity: ", value="1", **text_box_style) frame.set_state_attribute( 'xax', ["plot", "nugrid_plot", "get_data", "nugrid_get_data"], visible=True, **group_style) frame.set_state_attribute('xaxis', visible=True, description="select X-axis: ") frame.set_state_attribute('xaxis', ["get_data", "nugrid_get_data"], description="select data: ") frame.set_state_attribute('logx', visible=True, description="log X-axis: ") frame.set_state_attribute('logx', ["get_data", "nugrid_get_data"], visible=False) frame.set_state_attribute('yax', ["plot", "nugrid_plot"], visible=True, **group_style) frame.set_state_attribute('yaxis', visible=True, description="select Y-axis: ") frame.set_state_attribute('logy', visible=True, description="log Y-axis: ") frame.set_state_attribute("mass_settings", ["iso_abund", "abu_chart"] + states_movie[1:], visible=True, **group_style) frame.set_state_attribute("set_amass", ["iso_abund", "movie_iso_abund"], visible=True, description="Set atomic mass: ") frame.set_state_attribute("amass_range", ["iso_abund", "movie_iso_abund"], description="Atomi mass range: ", min=0, max=211, value=(0, 211)) frame.set_state_attribute("set_mass", ["iso_abund", "abu_chart"] + states_movie[1:], visible=True, description="Set mass: ") frame.set_state_attribute("mass_range", ["iso_abund", "abu_chart"] + states_movie[1:], description="Mass range: ") frame.set_state_attribute("lbound", "abu_chart", visible=True, description="lbound", min=-12, max=0, step=0.05, value=(-12, 0)) frame.set_state_links("amass_link", [("set_amass", "value"), ("amass_range", "visible")], ["iso_abund", "movie_iso_abund"], True) frame.set_state_links("mass_link", [("set_mass", "value"), ("mass_range", "visible")], ["iso_abund", "abu_chart"] + states_movie[1:], True) frame.set_state_attribute( "lim_settings", ["iso_abund", "abu_chart", "kip_cont", "tcrhoc"] + states_movie[1:], visible=True, **group_style) frame.set_state_attribute( "set_lims", ["iso_abund", "abu_chart", "kip_cont", "tcrhoc"] + states_movie[1:], visible=True, description="Set axis limits: ") frame.set_state_attribute("xlim", ["abu_chart", "movie_abu_chart", "kip_cont"], description="x-axis limits: ", min=0, max=130, value=(0, 130), step=0.5) frame.set_state_attribute("xlim", "tcrhoc", description="x-axis limits: ", min=3.0, max=10.0, value=(3.0, 10.0), step=0.5) frame.set_state_attribute( "ylim", ["iso_abund", "abu_chart", "kip_cont", "tcrhoc"] + states_movie[1:], description="y-axis limits: ") frame.set_state_attribute("ylim", ["iso_abund", "movie_iso_abund"], min=-13, max=0, step=0.05, value=(-13, 0)) frame.set_state_attribute("ylim", ["abu_chart", "movie_abu_chart"], min=0, max=130, value=(0, 130), step=0.5) frame.set_state_attribute("ylim", "kip_cont", min=0, max=1, value=(0, 1), step=0.005) #mass frame.set_state_attribute("ylim", "tcrhoc", min=8.0, max=10.0, value=(8.0, 10.0), step=0.5) frame.set_state_attribute("ixaxis", "kip_cont", visible=True, description="X axis format: ", options={ "Log time": "log_time_left", "Age": "age", "Model number": "model_number" }, value="model_number") frame.set_state_links( "xlims_link", [("set_lims", "value"), ("xlim", "visible")], ["abu_chart", "movie_abu_chart", "kip_cont", "tcrhoc"], True) frame.set_state_links("ylims_link", [("set_lims", "value"), ("ylim", "visible")], ["iso_abund", "abu_chart", "kip_cont", "tcrhoc"] + states_movie[1:], True) frame.set_state_attribute("xres", "kip_cont", visible=True, description="x resolution: ", placeholder="1000", **text_box_style) frame.set_state_attribute("yres", "kip_cont", visible=True, description="y resolution: ", placeholder="1000", **text_box_style) frame.set_state_links("xres_link", [("set_lims", "value"), ("xres", "visible")], "kip_cont", True) frame.set_state_links("yres_link", [("set_lims", "value"), ("yres", "visible")], "kip_cont", True) frame.set_state_attribute("abu_settings", ["abu_chart", "movie_abu_chart"], visible=True, **group_style) frame.set_state_attribute("ilabel", ["abu_chart", "movie_abu_chart"], visible=True, description="Element label") frame.set_state_attribute("imlabel", ["abu_chart", "movie_abu_chart"], visible=True, description="Isotope label") frame.set_state_attribute("imagic", ["abu_chart", "movie_abu_chart"], visible=True, description="Magic numbers") frame.set_state_attribute("kipp_settings", ["kippenhahn", "kip_cont"], visible=True, **group_style) frame.set_state_attribute("plot_star_mass", "kippenhahn", visible=True, description="Plot star mass: ") frame.set_state_attribute("plot_c12border", ["kippenhahn", "kip_cont"], visible=True, description="Show C-12 Border: ") frame.set_state_attribute( "plot_engminus", "kip_cont", visible=True, description="Energy generation contours (eps_nuc>0): ") frame.set_state_attribute( "plot_engplus", "kip_cont", visible=True, description="Energy generation contours (eos_nuc<0): ") frame.set_state_attribute("stable", "iso_abund", visible=True, description="stable: ") frame.set_state_attribute('generate_plot', states_plotting, visible=True, description="Generate Plot", **button_style) frame.set_state_attribute('generate_plot', ["get_data", "nugrid_get_data"], visible=True, description="Get Data", **button_style) def variable_name_full_validation(value): frame.set_attributes("variable_name", value=token_text(value, strict=True)) frame.set_state_data("variable_name_timer", None) def variable_name_handler(name, value): value = token_text(value) frame.set_attributes("variable_name", value=value) timer = frame.get_state_data("variable_name_timer") if (value != token_text(value, strict=True)): if timer != None: timer.cancel() timer = threading.Timer(1.0, variable_name_full_validation, kwargs={"value": value}) timer.start() else: if timer != None: timer.cancel() timer = None frame.set_state_data("variable_name_timer", timer) def yres_handler(name, value): frame.set_attributes("yres", value=int_text(value)) def xres_handler(name, value): frame.set_attributes("xres", value=int_text(value)) def sel_plot(widget, value): data = frame.get_state_data("class_instance") if value in ["iso_abund", "abu_chart"]: cycle_list = data.se.cycles step = int(cycle_list[1]) - int(cycle_list[0]) min = int(cycle_list[0]) max = int(cycle_list[-1]) mass_list = data.se.get(min, "mass") mass_min, mass_max = mass_list[0], mass_list[-1] mass_step = (mass_max - mass_min) / 200.0 frame.set_state_attribute("mass_range", ["iso_abund", "abu_chart"], min=mass_min, max=mass_max, value=(mass_min, mass_max), step=mass_step) frame.set_state_attribute('cycle', ["iso_abund", "abu_chart"], min=min, max=max, step=step) if value == "kip_cont": min = 0 max = len(data.data) mass = data.header_attr["initial_mass"] frame.set_state_attribute("xlim", "kip_cont", min=min, max=max, step=1, value=(min, max)) frame.set_state_attribute("ylim", "kip_cont", min=0.0, max=mass, step=mass / 200.0, value=(0.0, mass)) if value in ["nugrid_plot", "nugrid_get_data"]: cycle_list = data.se.cycles step = int(cycle_list[1]) - int(cycle_list[0]) min = int(cycle_list[0]) max = int(cycle_list[-1]) frame.set_state_attribute('cycle', ["nugrid_plot", "nugrid_get_data"], min=min, max=max, step=step) frame.set_state(value) def sel_movie_plot(widget, value): data = frame.get_state_data("class_instance") if value in ["movie_iso_abund", "movie_abu_chart"]: cycle_list = data.se.cycles step = int(cycle_list[1]) - int(cycle_list[0]) min = int(cycle_list[0]) max = int(cycle_list[-1]) mass_list = data.se.get(min, "mass") mass_min, mass_max = mass_list[0], mass_list[-1] mass_step = (mass_max - mass_min) / 200.0 frame.set_state_attribute("mass_range", ["movie_iso_abund", "movie_abu_chart"], min=mass_min, max=mass_max, value=(mass_min, mass_max), step=mass_step) frame.set_state_attribute('cycle_range', ["movie_iso_abund", "movie_abu_chart"], min=min, max=max, step=step, value=(min, max)) frame.set_state(value) def make_plot(widget): clear_output() pyplot.close("all") state = frame.get_state() data = frame.get_state_data("class_instance") variable_name = frame.get_attribute("variable_name", "value") cycle = frame.get_attribute("cycle", "value") cycle_range = frame.get_attribute("cycle_range", "value") if state in states_movie: sparsity = int(frame.get_attribute("sparsity", "value")) xax = frame.get_attribute("xaxis", "value") logx = frame.get_attribute("logx", "value") yax = frame.get_attribute("yaxis", "value") logy = frame.get_attribute("logy", "value") if frame.get_attribute("set_amass", "value"): amass = frame.get_attribute("amass_range", "value") amass = [amass[0], amass[1]] else: amass = None if frame.get_attribute("set_mass", "value"): mass = frame.get_attribute("mass_range", "value") mass = [mass[0], mass[1]] else: mass = None lbound = frame.get_attribute("lbound", "value") if frame.get_attribute("set_lims", "value"): xlim = frame.get_attribute("xlim", "value") ylim = frame.get_attribute("ylim", "value") else: xlim = [0, 0] ylim = [0, 0] xres = frame.get_attribute("xres", "value") if xres == "": xres = "1000" yres = frame.get_attribute("yres", "value") if yres == "": yres = "1000" xres = int(xres) yres = int(yres) ixaxis = frame.get_attribute("ixaxis", "value") stable = frame.get_attribute("stable", "value") ilabel = frame.get_attribute("ilabel", "value") imlabel = frame.get_attribute("imlabel", "value") imagic = frame.get_attribute("imagic", "value") plot_star_mass = frame.get_attribute("plot_star_mass", "value") plot_c12border = frame.get_attribute("plot_c12border", "value") plot_engminus = frame.get_attribute("plot_engminus", "value") plot_engplus = frame.get_attribute("plot_engplus", "value") if state == "iso_abund": data.iso_abund(cycle, stable, amass, mass, ylim) elif state == "abu_chart": plotaxis = [xlim[0], xlim[1], ylim[0], ylim[1]] data.abu_chart(cycle, mass, ilabel, imlabel, imagic=imagic, lbound=lbound, plotaxis=plotaxis, ifig=1) elif state == "plot": if isinstance(yax, basestring): yax = [yax] for yaxis in yax: data.plot(xax, yaxis, logx=logx, logy=logy, shape="-") elif state == "nugrid_plot": if isinstance(yax, basestring): yax = [yax] for yaxis in yax: data.plot(xax, yaxis, logx=logx, logy=logy, shape="-", fname=cycle, numtype="time") elif state == "hrd": data.hrd_new() elif state == "kippenhahn": data.kippenhahn(0, "model", plot_star_mass=plot_star_mass, c12_bm=plot_c12border) elif state == "kip_cont": xlims = [xlim[0], xlim[1]] ylims = [ylim[0], ylim[1]] if (xlims == [0, 0]) and (ylims == [0, 0]): xlim = frame.get_attribute("xlim", "value") ylim = frame.get_attribute("ylim", "value") xlims = [xlim[0], xlim[1]] ylims = [ylim[0], ylim[1]] data.kip_cont(modstart=xlims[0], modstop=xlims[1], ylims=ylims, xres=xres, yres=yres, engenPlus=plot_engplus, engenMinus=plot_engminus, c12_boundary=plot_c12border, ixaxis=ixaxis) elif state == "tcrhoc": lims = [xlim[0], xlim[1], ylim[0], ylim[1]] if lims == [0, 0, 0, 0]: lims = [3.0, 10.0, 8.0, 10.0] data.tcrhoc(lims=lims) elif state == "movie_iso_abund": cycles = data.se.cycles cyc_min = cycles.index("%010d" % (cycle_range[0], )) cyc_max = cycles.index("%010d" % (cycle_range[1], )) cycles = cycles[cyc_min:cyc_max:sparsity] display( data.movie(cycles, "iso_abund", amass_range=amass, mass_range=mass, ylim=ylim)) elif state == "movie_abu_chart": cycles = data.se.cycles cyc_min = cycles.index("%010d" % (cycle_range[0], )) cyc_max = cycles.index("%010d" % (cycle_range[1], )) cycles = cycles[cyc_min:cyc_max:sparsity] plotaxis = [xlim[0], xlim[1], ylim[0], ylim[1]] display( data.movie(cycles, "abu_chart", mass_range=mass, ilabel=ilabel, imlabel=imlabel, imagic=imagic, plotaxis=plotaxis)) elif state == "get_data": if variable_name == "": print("No variable name.") else: global_namespace[variable_name] = data.get(xax) print( "\nThe data " + str(xax) + " is loaded into the global namespace under the variable name \"" + str(variable_name) + "\".") elif state == "nugrid_get_data": if variable_name == "": print("No variable name.") else: global_namespace[variable_name] = data.se.get(cycle, xax) print( "\nThe data " + str(xax) + " is loaded into the global namespace under the variable name \"" + str(variable_name) + "\".") frame.set_state_callbacks("variable_name", variable_name_handler) frame.set_state_callbacks("yres", yres_handler) frame.set_state_callbacks("xres", xres_handler) frame.set_state_callbacks("select_plot", sel_plot) frame.set_state_callbacks("movie_type", sel_movie_plot) frame.set_state_callbacks("generate_plot", make_plot, attribute=None, type="on_click") frame.set_object("page_plotting", widgets.VBox()) frame.set_object("select_plot", widgets.Dropdown()) frame.set_object("warning_msg", widgets.HTML()) frame.set_object("plot_name", widgets.HTML()) frame.set_object("movie_type", widgets.Dropdown()) frame.set_object("variable_name", widgets.Text()) frame.set_object("cycle_sparsity_group", widgets.HBox()) frame.set_object("cycle", widgets.IntSlider()) frame.set_object("cycle_range", widgets.IntRangeSlider()) frame.set_object("sparsity", widgets.Text()) frame.set_object("xax", widgets.HBox()) frame.set_object("xaxis", widgets.Select()) frame.set_object("logx", widgets.Checkbox()) frame.set_object("yax", widgets.HBox()) frame.set_object("yaxis", widgets.SelectMultiple()) frame.set_object("logy", widgets.Checkbox()) frame.set_object("mass_settings", widgets.VBox()) frame.set_object("set_amass", widgets.Checkbox()) frame.set_object("amass_range", widgets.IntRangeSlider()) frame.set_object("set_mass", widgets.Checkbox()) frame.set_object("mass_range", widgets.FloatRangeSlider()) frame.set_object("lbound", widgets.FloatRangeSlider()) frame.set_object("lim_settings", widgets.VBox()) frame.set_object("set_lims", widgets.Checkbox()) frame.set_object("ixaxis", widgets.Dropdown()) frame.set_object("ylim", widgets.FloatRangeSlider()) frame.set_object("xlim", widgets.FloatRangeSlider()) frame.set_object("yres", widgets.Text()) frame.set_object("xres", widgets.Text()) frame.set_object("stable", widgets.Checkbox()) frame.set_object("abu_settings", widgets.HBox()) frame.set_object("ilabel", widgets.Checkbox()) frame.set_object("imlabel", widgets.Checkbox()) frame.set_object("imagic", widgets.Checkbox()) frame.set_object("kipp_settings", widgets.HBox()) frame.set_object("plot_star_mass", widgets.Checkbox()) frame.set_object("plot_c12border", widgets.Checkbox()) frame.set_object("plot_engminus", widgets.Checkbox()) frame.set_object("plot_engplus", widgets.Checkbox()) frame.set_object("generate_plot", widgets.Button()) update_dir_bar_list() frame.display_object("window")
# Graph object g = GraphWidget(foodmap(1961)) # Definition of a class that will update the graph object class z_data: def __init__(self): self.z = food[str(int(1961))] def on_z_change(self, name, old_value, new_value): self.z = food[str(int(new_value))] self.title = "Food Supply (kcal per capita) in " + str(new_value) self.replot() def replot(self): g.restyle({'z': [self.z]}) g.relayout({'title': self.title}) # Interactive object edu_slider = widgets.IntSlider(min=1961, max=2011, value=1961, step=1) edu_slider.description = 'Year' edu_slider.value = 1961 z_state = z_data() edu_slider.on_trait_change(z_state.on_z_change, 'value') display(edu_slider) display(g)
def show3D_comparison(image, gt, pred, bbox, save_dir='paper_figs/', show_all_legend=True): ''' show 3d comparison plot of ground truth and prediction. Four views: original CT image with zoomed in bbox, ground truth overlay on the image, prediction overlay on the image, gt and pred contour outline comparison image: CT image of dimension 3 gt: a list of 2 elements, the first is ground truth mask and the second is ground truth contour pred: a list of 2 elements, the first is predicted mask and the second is predicted contour bbox: [start, end], plot zoomed in region (defined by this param) for view 2 - 4 ''' continuous_update = False # n_img = 1 + sum([not img is None for img in masks]) start, end = bbox params = { 'z': 0, 'level': 0, 'width': 1000, 'show_mask': True, 'start': start, 'end': end } z_slider = w.IntSlider(min=0, max=image.shape[0] - 1, step=1, value=params['z'], continuous_update=continuous_update, description="z") level_slider = w.IntSlider(min=-1024, max=1000, step=1, value=params['level'], continuous_update=continuous_update, description="level") width_slider = w.IntSlider(min=-1024, max=2000, step=1, value=params['width'], continuous_update=continuous_update, description="width") mask_checkbox = w.Checkbox(value=True, description='show mask', disabled=False) N = 3 plt.rcParams['legend.markerscale'] = 0.2 fig, axes = plt.subplots(1, N) plt.subplots_adjust(hspace=0) for i in range(N): axes[i].set_axis_off() def on_z_value_change(change): params['z'] = change.new plot_compare_figure(image, gt, pred, params, save_dir, show_all_legend) def on_level_value_change(change): params['level'] = change.new plot_compare_figure(image, gt, pred, params, save_dir, show_all_legend) def on_width_value_change(change): params['width'] = change.new plot_compare_figure(image, gt, pred, params, save_dir, show_all_legend) def on_mask_value_change(change): params['show_mask'] = change.new plot_compare_figure(image, gt, pred, params, save_dir, show_all_legend) display(z_slider, level_slider, width_slider, mask_checkbox) z_slider.observe(on_z_value_change, names='value') level_slider.observe(on_level_value_change, names='value') width_slider.observe(on_width_value_change, names='value') mask_checkbox.observe(on_mask_value_change, names='value') plot_compare_figure(image, gt, pred, params, save_dir, show_all_legend)
def show3Dimg2(image, *masks): ''' Plot contour and mask on original CT image using matplotlib image: CT image of dimension 3. *masks: usually consists of [mask, contour], then contour would be plot using alpha=1 and mask using alpha 0.5. ''' continuous_update = False n_img = 1 + sum([not img is None for img in masks]) params = {'z': 0, 'level': 0, 'width': 1000, 'show_mask': True} z_slider = w.IntSlider(min=0, max=image.shape[0] - 1, step=1, value=params['z'], continuous_update=continuous_update, description="z") level_slider = w.IntSlider(min=-1024, max=1000, step=1, value=params['level'], continuous_update=continuous_update, description="level") width_slider = w.IntSlider(min=-1024, max=2000, step=1, value=params['width'], continuous_update=continuous_update, description="width") mask_checkbox = w.Checkbox(value=True, description='show mask', disabled=False) def plot_figure(): z = params['z'] level = params['level'] width = params['width'] show_mask = params['show_mask'] plt.imshow(image[z], cmap='gray', vmin=level - width / 2, vmax=level + width / 2) if show_mask: for i in range(len(masks)): mask = masks[i].astype(np.float32) mask[mask == 0] = np.nan plt.imshow(mask[z], cmap=custom_cmap, alpha=0.5 * (i + 1), vmin=1, vmax=28) plt.axis('off') plt.legend(handles=patches1, bbox_to_anchor=(1.01, 1), loc=2, borderaxespad=0.) plt.show() def on_z_value_change(change): params['z'] = change.new plot_figure() def on_level_value_change(change): params['level'] = change.new plot_figure() def on_width_value_change(change): params['width'] = change.new plot_figure() def on_mask_value_change(change): params['show_mask'] = change.new plot_figure() display(z_slider, level_slider, width_slider, mask_checkbox) z_slider.observe(on_z_value_change, names='value') level_slider.observe(on_level_value_change, names='value') width_slider.observe(on_width_value_change, names='value') mask_checkbox.observe(on_mask_value_change, names='value') plot_figure()
def plot_pulse_files(fileNames, firstSeqNum=0): ''' plot_pulse_files(fileNames, firstSeqNum=0) Helper function to plot a list of AWG files. In an iPython notebook the plots will be in line with dynamic updating. For iPython consoles a static html file will be generated with the firstSeqNum. ''' #If we only go one filename turn it into a list if isinstance(fileNames, str): fileNames = [fileNames] wfs = {} dataDict = {} lineNames = [] title = "" for fileName in sorted(fileNames): #Assume a naming convention path/to/file/SequenceName-AWGName.h5 AWGName = (os.path.split( os.path.splitext(fileName)[0])[1]).split('-')[1] #Strip any _ suffix if '_' in AWGName: AWGName = AWGName[:AWGName.index('_')] title += os.path.split(os.path.splitext(fileName)[0])[1] + "; " wfs[AWGName] = read_sequence_file(Libraries.instrumentLib[AWGName], fileName) for (k, seqs) in sorted(wfs[AWGName].items()): if not all_zero_seqs(seqs): lineNames.append(AWGName + '-' + k) dataDict[lineNames[-1] + "_x"] = np.arange( len(seqs[firstSeqNum])) dataDict[lineNames[-1]] = seqs[firstSeqNum] + 2 * ( len(lineNames) - 1) #Remove trailing semicolon from title title = title[:-2] source = bk.ColumnDataSource(data=dataDict) figH = bk.figure(title=title, plot_width=1000, y_range=(-1, len(dataDict) + 1)) #Colorbrewer2 qualitative Set3 (http://colorbrewer2.org) colours = [ "#8dd3c7", "#ffffb3", "#bebada", "#fb8072", "#80b1d3", "#fdb462", "#b3de69", "#fccde5", "#d9d9d9", "#bc80bd", "#ccebc5", "#ffed6f" ] for ct, k in enumerate(lineNames): figH.line(k + "_x", k, source=source, color=colours[ct % len(colours)], line_width=2, legend=k) if in_ipynb(): #Setup inline plotting with slider updating of data def update_plot(_, seqNum): for ct, k in enumerate(lineNames): AWGName, chName = k.split('-') source.data[k + "_x"] = np.arange( len(wfs[AWGName][chName][seqNum - 1])) source.data[k] = wfs[AWGName][chName][seqNum - 1] + 2 * ct source.push_notebook() #widgets.interact(update_plot, seqNum=(1, len(wfs[AWGName]["ch1"])), div=widgets.HTMLWidget(value=notebook_div(figH))) slider = widgets.IntSlider(value=firstSeqNum + 1, min=1, max=len(wfs[AWGName]["ch1"]), step=1, description="Sequence (of {}):".format( len(seqs))) slider.on_trait_change(update_plot, 'value') plotBox = widgets.HTML(value=notebook_div(figH)) appBox = widgets.Box() appBox.children = [slider, plotBox] display(appBox) else: #Otherwise dump to a static file bk.show(figH)
def four_panel_horizontal(var, src_dir=WORK_DIR, extract=True, extr_kwargs={}, load=True, load_kwargs={}, debug=False): var_name = var.varname # Extract the variables we want to plot, if necessary if extract: var.extract(src_dir, act_cases=CASES_ACT, aer_cases=CASES_AER, **extr_kwargs) else: if debug: print("skipping extraction") # Load into memory if load: var.load_datasets(src_dir, act_cases=CASES_ACT, aer_cases=CASES_AER) else: if debug: print("skipping loading") # Coerce to DataArray sample = var.data[CASES_ACT[0], CASES_AER[0]] if isinstance(sample, Dataset): var.apply(lambda ds: ds[var.varname]) if debug: print("converted to dataarray from %r" % type(sample)) data_dict = var.data # Set up area grid for weighted global averages ds = data_dict[CASES_ACT[0], CASES_AER[0]] area = area_grid(ds.lon, ds.lat) total_area = np.sum(area.data) # Compute PD-PI difference max_diff = 0. max_level = 0. if debug: print("Reading...") for act in CASES_ACT: if debug: print(" ", act) exp_pd = data_dict[act, "F2000"] exp_pi = data_dict[act, "F1850"] abs_diff = exp_pi - exp_pd case_max_diff = np.max(abs_diff.data) if debug: print(" max diff", case_max_diff) if case_max_diff > max_diff: max_diff = case_max_diff _, case_max_level = min_max_cubes(exp_pd, exp_pi) if debug: print(" max level", case_max_level) if np.abs(case_max_level) > max_level: max_level = case_max_level if debug: print("Final max diff/level -", max_diff, max_level) ################################################################# act_control = widgets.Dropdown(description="Activation Case", options=CASES_ACT) proj_control = widgets.Dropdown(description="Map Projection", options=["PlateCarree", "Robinson"]) max_level_trunc = widgets.FloatText(description="Trunc level", value=max_level) abs_top = np.ceil(1.5 * max_diff) step = 0.01 if abs_top <= 1. else 0.1 if debug: print("absolute slider range - ", 0., abs_top) print(" step - ", step) abs_control = widgets.FloatSlider(description="Max Abs. Difference", value=abs_top, min=0., max=abs_top, width=150., step=step) rel_control = widgets.IntSlider(description="Max Rel. Difference", value=50, min=0, max=150, width=150.) reverse_cmap = widgets.Checkbox(description="Reverse colormap", value=False, width=150.) colormap_text = widgets.Text(description="Colormap on PD/PI", value="cubehelix_r") plot_button = widgets.Button(description="Make Plot") save_quality = widgets.Dropdown(description="Save quality", options=["quick", "production", "vector"]) save_filename = widgets.Text(description="Save filename", value="%s_horiz_PD-PI" % var_name) save_button = widgets.Button(description="Save Figure") form = widgets.VBox(width=1000) hbox_make = widgets.HBox() hbox_make.children = [act_control, proj_control, plot_button] hbox_diff = widgets.HBox() hbox_diff.children = [abs_control, rel_control] hbox_cmap = widgets.HBox() hbox_cmap.children = [max_level_trunc, reverse_cmap, colormap_text] hbox_save = widgets.HBox() hbox_save.children = [save_quality, save_filename, save_button] form.children = [hbox_make, hbox_diff, hbox_cmap, hbox_save] def _driver(*args, **kwargs): if not debug: clear_output() # Save the fig for later reference global fig fig = plt.figure("4panel_PD-PI", figsize=(12, 8)) fig.clf() fig.set_rasterized(True) exp_pd = data_dict[act_control.value, "F2000"] exp_pi = data_dict[act_control.value, "F1850"] pd_vs_pi_summary(exp_pd, exp_pi, area, max_level_trunc.value, abs_control.value, rel_control.value, reverse_cmap.value, colormap_text.value, proj_control.value, fig) def _savefig(*args, **kwargs): global fig save_figure(save_filename.value + ".4panel", fig=fig, qual=save_quality.value) plot_button.on_click(_driver) save_button.on_click(_savefig) return display(form)
def start_PPM(global_namespace, local_dir="./"): frame = framework.framework() frame.set_default_display_style(padding="0.25em", background_color="white", border_color="LightGrey", border_radius="0.5em") frame.set_default_io_style(padding="0.25em", margin="0.25em", border_color="LightGrey", border_radius="0.5em") group_style = { "border_style": "none", "border_radius": "0em", "width": "100%" } text_box_style = {"width": "10em"} button_style = {"font_size": "1.25em", "font_weight": "bold"} first_tab_style = {"border_radius": "0em 0.5em 0.5em 0.5em"} states_plotting = ["plot_prof_time", "plot_tEkmax", "plot_vprofs", "get"] states_loaded = ["data_loaded"] + states_plotting states = states_loaded frame.add_state(states) frame.set_state_data("data_sets", []) frame.set_state_data("data_set_count", 0) frame.set_state_data("dir", os.path.abspath(local_dir)) frame.set_state_data("yaxis_options", [""], "plot_prof_time") frame.set_state_data("yaxis_options", [""], "get") frame.set_state_data("cycles", []) frame.set_state_data("variable_name_timer", None) def add_data_set(data, name): data_set_count = frame.get_state_data("data_set_count") data_sets = frame.get_state_data("data_sets") widget_name = "data_set_widget_#" + str(data_set_count) frame.add_io_object(widget_name) frame.set_state_attribute(widget_name, visible=True, description=name) frame.set_object(widget_name, widgets.Checkbox()) data_sets.append((data, name, widget_name)) frame.set_state_children("data_sets", [widget_name]) frame.set_state_data("data_sets", data_sets) data_set_count += 1 frame.set_state_data("data_set_count", data_set_count) def remove_data_set(): data_sets = frame.get_state_data("data_sets") children = ["data_sets_title"] tmp_data_sets = [] for i in xrange(len(data_sets)): widget_name = data_sets[i][2] if frame.get_attribute(widget_name, "value"): frame.remove_object(widget_name) else: children.append(widget_name) tmp_data_sets.append(data_sets[i]) data_sets = tmp_data_sets frame.set_state_children("data_sets", children, append=False) frame.set_state_data("data_sets", data_sets) if data_sets == []: frame.set_state() def update_dir_bar_list(): dir = frame.get_state_data("dir") dirs = [".", ".."] + os.listdir(dir) frame.set_state_attribute("address_bar", value=dir) frame.set_state_attribute("directory_list", options=dirs) frame.add_display_object("window") frame.add_io_object("Title") frame.add_display_object("widget_data_set_group") frame.add_display_object("widget") frame.add_display_object("data_sets") frame.add_io_object("data_sets_title") ##data page frame.add_display_object("data_page") frame.add_display_object("file_system_group") frame.add_io_object("address_bar") frame.add_io_object("directory_list") frame.add_display_object("name_load_remove_group") frame.add_io_object("data_set_name") frame.add_io_object("data_set_load") frame.add_io_object("data_set_remove") ##plotting page frame.add_display_object("plotting_page") frame.add_io_object("select_plot") frame.add_io_object("plot_title") frame.add_io_object("warning_msg") frame.add_display_object("cycle_range_group") frame.add_io_object("cycle") frame.add_io_object("cycle_range") frame.add_io_object("cycle_sparsity") frame.add_io_object("variable_name") frame.add_display_object("yaxis_group") frame.add_io_object("yaxis") frame.add_io_object("logy") frame.add_io_object("plot") frame.set_state_children("window", ["Title", "widget_data_set_group"]) frame.set_state_children("widget_data_set_group", ["widget", "data_sets"]) frame.set_state_children("data_sets", ["data_sets_title"]) frame.set_state_children("widget", ["data_page", "plotting_page"], titles=["Data", "Plotting"]) frame.set_state_children("data_page", ["file_system_group", "name_load_remove_group"]) frame.set_state_children("file_system_group", ["address_bar", "directory_list"]) frame.set_state_children( "name_load_remove_group", ["data_set_load", "data_set_remove", "data_set_name"]) frame.set_state_children("plotting_page", [ "select_plot", "warning_msg", "plot_title", "variable_name", "cycle_range_group", "yaxis_group", "plot" ]) frame.set_state_children("cycle_range_group", ["cycle", "cycle_range", "cycle_sparsity"]) frame.set_state_children("yaxis_group", ["yaxis", "logy"]) frame.set_state_attribute("window", visible=True, **group_style) frame.set_state_attribute("Title", visible=True, value="<center><h1>PPM explorer</h1></center>") frame.set_state_attribute("widget_data_set_group", visible=True, **group_style) frame.set_state_attribute("data_sets", visible=True, margin="3.15em 0em 0em 0em") frame.set_state_attribute("data_sets_title", visible=True, value="<center><h2>Data Sets</h2></center>", **group_style) frame.set_state_attribute("widget", visible=True, **group_style) frame.set_state_attribute("data_page", visible=True, **first_tab_style) frame.set_state_attribute("file_system_group", visible=True, **group_style) frame.set_state_attribute("address_bar", visible=True) frame.set_state_attribute("directory_list", visible=True) frame.set_state_attribute("name_load_remove_group", visible=True, **group_style) frame.set_state_attribute("data_set_name", visible=True, description="Data set name:", placeholder="Enter name", **text_box_style) frame.set_state_attribute("data_set_load", visible=True, description="Load data set", **button_style) frame.set_state_attribute("data_set_remove", visible=True, description="Remove data set", **button_style) def address_bar_handler(widget): dir = frame.get_attribute("address_bar", "value") if os.path.isdir(dir): dir = os.path.abspath(dir) frame.set_state_data("dir", dir) update_dir_bar_list() frame.update() frame.set_attributes("address_bar", value=dir) frame.set_attributes("directory_list", value=".", selected_label=u".") def directory_list_handler(name, value): dir = frame.get_state_data("dir") dir = dir + "/" + frame.get_attribute("directory_list", "value") if os.path.isdir(dir): dir = os.path.abspath(dir) frame.set_state_data("dir", dir) update_dir_bar_list() frame.update() frame.set_attributes("address_bar", value=dir) frame.set_attributes("directory_list", value=".", selected_label=u".") def data_set_load_handler(widget): clear_output() pyplot.close("all") dir = frame.get_attribute("address_bar", "value") data_set_count = frame.get_state_data("data_set_count") name = frame.get_attribute("data_set_name", "value") if name == "": name = "Data set - " + "%03d" % (data_set_count + 1, ) data = ppm.yprofile(dir) if data.files != []: frame.set_state("data_loaded") old_cycs = frame.get_state_data("cycles") cycs = data.cycles cycs = list(set(cycs) | set(old_cycs)) cycs.sort() frame.set_state_data("cycles", cycs) frame.set_state_data("yaxis_options", data.dcols, "plot_prof_time") frame.set_state_data("yaxis_options", data.dcols + data.cattrs, "get") frame.set_state_attribute("cycle", min=cycs[0], max=cycs[-1], value=cycs[-1]) frame.set_state_attribute("cycle_range", min=cycs[0], max=cycs[-1], value=(cycs[0], cycs[-1])) add_data_set(data, name) frame.update() def data_set_remove_handler(widget): remove_data_set() frame.update() frame.set_state_callbacks("address_bar", address_bar_handler, attribute=None, type="on_submit") frame.set_state_callbacks("directory_list", directory_list_handler) frame.set_state_callbacks("data_set_load", data_set_load_handler, attribute=None, type="on_click") frame.set_state_callbacks("data_set_remove", data_set_remove_handler, attribute=None, type="on_click") frame.set_object("window", widgets.Box()) frame.set_object("Title", widgets.HTML()) frame.set_object("widget_data_set_group", widgets.HBox()) frame.set_object("widget", widgets.Tab()) frame.set_object("data_sets", widgets.VBox()) frame.set_object("data_sets_title", widgets.HTML()) frame.set_object("data_page", widgets.VBox()) frame.set_object("file_system_group", widgets.VBox()) frame.set_object("address_bar", widgets.Text()) frame.set_object("directory_list", widgets.Select()) frame.set_object("name_load_remove_group", widgets.HBox()) frame.set_object("data_set_name", widgets.Text()) frame.set_object("data_set_load", widgets.Button()) frame.set_object("data_set_remove", widgets.Button()) frame.set_state_attribute("plotting_page", visible=True) frame.set_state_attribute("select_plot", states_loaded, visible=True, options={ "": "data_loaded", "Profile time": "plot_prof_time", "Velocity Profile": "plot_vprofs", "tEkmax": "plot_tEkmax", "Get Data": "get" }) frame.set_state_attribute("warning_msg", visible=True, value="<h3>No data sets loaded!</h3>", **group_style) frame.set_state_attribute("warning_msg", "data_loaded", value="<h3>Select plot.</h3>") frame.set_state_attribute("warning_msg", states_plotting, visible=False) frame.set_state_attribute("plot_title", visible=False, **group_style) frame.set_state_attribute("plot_title", "plot_prof_time", visible=True, value="<h3>Prof_time</h3>") frame.set_state_attribute("plot_title", "plot_vprofs", visible=True, value="<h3>Plot Velocity Profiles</h3>") frame.set_state_attribute("plot_title", "plot_tEkmax", visible=True, value="<h3>tEkmax</h3>") frame.set_state_attribute("plot_title", "get", visible=True, value="<h3>Get Data</h3>") frame.set_state_attribute("variable_name", "get", visible=True, description="Variable name:", placeholder="Enter name.", **text_box_style) frame.set_state_attribute("cycle_range_group", ["plot_prof_time", "plot_vprofs", "get"], visible=True, **group_style) frame.set_state_attribute("cycle", "get", visible=True, description="Cycle:") frame.set_state_attribute("cycle_range", ["plot_prof_time", "plot_vprofs"], visible=True, description="Cycle range:") frame.set_state_attribute("cycle_sparsity", ["plot_prof_time", "plot_vprofs"], visible=True, description="Cycle sparsity", value=1) frame.set_state_attribute("yaxis_group", ["plot_prof_time", "plot_vprofs", "get"], visible=True, **group_style) frame.set_state_attribute("yaxis", ["plot_prof_time", "get"], visible=True, description="Yaxis:", options=[""]) frame.set_state_attribute("logy", ["plot_prof_time", "plot_vprofs"], visible=True, description="Log Y axis:") frame.set_state_attribute("plot", states_loaded, visible=True, description="Generate Plot", **button_style) frame.set_state_attribute("plot", "get", description="Get Data") def variable_name_full_validation(value): frame.set_attributes("variable_name", value=token_text(value, strict=True)) frame.set_state_data("variable_name_timer", None) def variable_name_handler(name, value): value = token_text(value) frame.set_attributes("variable_name", value=value) timer = frame.get_state_data("variable_name_timer") if (value != token_text(value, strict=True)): if timer != None: timer.cancel() timer = threading.Timer(1.0, variable_name_full_validation, kwargs={"value": value}) timer.start() else: if timer != None: timer.cancel() timer = None frame.set_state_data("variable_name_timer", timer) def select_plot_handler(name, value): if value in ["plot_prof_time", "get"]: frame.set_state_attribute("yaxis", value, options=frame.get_state_data( "yaxis_options", value)) frame.set_state(value) def plot_handler(widget): clear_output() pyplot.close("all") state = frame.get_state() data_sets = frame.get_state_data("data_sets") variable_name = frame.get_attribute("variable_name", "value") cycle = frame.get_attribute("cycle", "value") cycle_min, cycle_max = frame.get_attribute("cycle_range", "value") cycle_sparsity = int(frame.get_attribute("cycle_sparsity", "value")) if state in ["plot_prof_time", "plot_vprofs"]: cycles = range(cycle_min, cycle_max, cycle_sparsity) yaxis = frame.get_attribute("yaxis", "value") logy = frame.get_attribute("logy", "value") no_runs = True if state == "plot_prof_time": for data, name, widget_name in data_sets: if frame.get_attribute(widget_name, "value"): cycs = data.cycles cycs = list(set(cycs) & set(cycles)) cycs.sort() no_runs = False data.prof_time(cycs, yaxis_thing=yaxis, logy=logy) elif state == "plot_vprofs": for data, name, widget_name in data_sets: if frame.get_attribute(widget_name, "value"): cycs = data.cycles cycs = list(set(cycs) & set(cycles)) cycs.sort() no_runs = False data.vprofs(cycs, log_logic=logy) elif state == "plot_tEkmax": i = 0 for data, name, widget_name in data_sets: if frame.get_attribute(widget_name, "value"): no_runs = False data.tEkmax(ifig=1, label=name, id=i) i += 1 elif state == "get": data_out = [] i = 0 for data, name, widget_name in data_sets: if frame.get_attribute(widget_name, "value"): if cycle in data.cycles: i += 1 no_runs = False if yaxis in data.cattrs: data_out.append(data.get(attri=yaxis)) else: data_out.append(data.get(attri=yaxis, fname=cycle)) else: print("cycle out of range for " + name) if data_out != []: if i == 1: data_out = data_out[0] if variable_name == "": print("No variable name.") else: global_namespace[variable_name] = data_out print( "\nThe selected data is now loaded into the global namespace under the variable name \"" + variable_name + "\".") if no_runs: print "No data sets selected." frame.set_state_callbacks("variable_name", variable_name_handler) frame.set_state_callbacks("select_plot", select_plot_handler) frame.set_state_callbacks("plot", plot_handler, attribute=None, type="on_click") frame.set_object("plotting_page", widgets.VBox()) frame.set_object("select_plot", widgets.Dropdown()) frame.set_object("warning_msg", widgets.HTML()) frame.set_object("plot_title", widgets.HTML()) frame.set_object("variable_name", widgets.Text()) frame.set_object("cycle_range_group", widgets.HBox()) frame.set_object("cycle", widgets.IntSlider()) frame.set_object("cycle_range", widgets.IntRangeSlider()) frame.set_object("cycle_sparsity", widgets.IntText()) frame.set_object("yaxis_group", widgets.HBox()) frame.set_object("yaxis", widgets.Select()) frame.set_object("logy", widgets.Checkbox()) frame.set_object("plot", widgets.Button()) update_dir_bar_list() frame.display_object("window")