def makeOutput(game): gameFile = 'games/%s.txt' % game seqFile = 'json/%s_sequences.json' % game dataFile = 'json/%s_datapoints.json' % game p1, p2 = parsing.processInfosets(gameFile) parsing.processSeqIDs(p1, p2, seqFile) parsing.getData(p1, p2, dataFile) ''' hm1 = hv.HoloMap({(i.player,name): genCurves(i) for p in (p1,p2) for name,i in p.items()}, kdims=['player','infoset']) ''' p1 = hv.HoloMap({name: genCurves(i) for name,i in p1.items()}, kdims=['infoset']) p2 = hv.HoloMap({name: genCurves(i) for name,i in p2.items()}, kdims=['infoset']) grid1 = hv.GridSpace(p1) grid2 = hv.GridSpace(p2) layout1 = hv.NdLayout(grid1).cols(2) layout2 = hv.NdLayout(grid2).cols(2) hv.output(layout1 + layout2, size=150, filename=game)
def new_game_of_life_grid(game_size, plot_size, x_grid, y_grid, shrink_factor): small_plot_size = round(plot_size / shrink_factor) graphs = [ new_game_of_life_graph(game_size, small_plot_size) for _ in range(x_grid * y_grid) ] gridspace = hv.GridSpace(group='Games', kdims=['i', 'j']) for i in range(x_grid): for j in range(y_grid): gridspace[i, j] = graphs[i + j] # put the dmap in the grid return gridspace, graphs
def modify_doc(doc): def sine_curve(phase, freq): xvals = [0.1 * i for i in range(100)] return hv.Curve((xvals, [np.sin(phase + freq * x) for x in xvals])) phases = [0, np.pi / 2, np.pi, 3 * np.pi / 2] frequencies = [0.5, 0.75, 1.0, 1.25] curve_dict_2D = {(p, f): sine_curve(p, f) for p in phases for f in frequencies} gridspace = hv.GridSpace(curve_dict_2D, kdims=['phase', 'frequency']) hv.output(size=50) hmap = hv.HoloMap(gridspace) final = hmap + hv.GridSpace(hmap) plot = renderer.get_plot(final) layout = row(plot.state) # renderer.server_doc(layout) doc.add_root(layout)
def assemble_patterns_image(data_holder, row_num, col_num, index, value_range, pattern_shape): """ After the program has obtained the index of the patterns in the selected region, this function randomly choose several of the patterns to show in a grid-space. Specifically, each pattern in this function is a holoview image object. :param data_holder: The holder containing all the data shown in the diagram :param row_num: The row number of the grid space :param col_num: The column number of the grid space :param index: The index of all the data in the selected region :param value_range: The range of values to show a numpy array as RGB image. :param pattern_shape: The pattern shape :return: hv.GridSpace """ index = np.array(index) index_num = index.shape[0] if index_num >= row_num * col_num: np.random.shuffle(index) sampled_index = index[:row_num * col_num] sampled_index = sampled_index.reshape((row_num, col_num)) image_holder = {(x, y): hv.Image( data_holder[sampled_index[x, y]]).redim.range(z=(value_range[0], value_range[1])) for x in range(row_num) for y in range(col_num)} else: # When we do not have so many patterns, first layout # all the patterns available and then fill the other # positions with patterns of zeros. index_list = [(x, y) for x in range(row_num) for y in range(col_num)] image_holder = { index_list[l]: hv.Image(data_holder[index[l]]).redim.range(z=(value_range[0], value_range[1])) for l in range(index_num) } image_holder.update({ index_list[l]: hv.Image(np.zeros(pattern_shape, dtype=np.float64)) for l in range(index_num, row_num * col_num) }) return hv.GridSpace(image_holder)
def plot_phase_exploration(d, phi0=-180, phi1=185): gridspace = hv.GridSpace(kdims=['type']) X_curves = {} Y_curves = {} sym_curves = {} for phi in range(-180, 185, 5): Xp_ph = d.Rp * np.cos(np.deg2rad(d.Tp + phi)) Xm_ph = d.Rm * np.cos(np.deg2rad(d.Tm + phi)) Yp_ph = d.Rp * np.sin(np.deg2rad(d.Tp + phi)) Ym_ph = d.Rm * np.sin(np.deg2rad(d.Tm + phi)) Xsym_ph = (Xp_ph + Xm_ph)/2 Xasym_ph = (Xp_ph - Xm_ph)/2 X_curves[phi] = hv.Curve((d.xum, Xp_ph), label='X+ ph') * hv.Curve((d.xum, Xm_ph), label='X- ph') Y_curves[phi] = hv.Curve((d.xum, Yp_ph), label='Y+ ph') * hv.Curve((d.xum, Ym_ph), label='Y- ph') sym_curves[phi] = hv.Curve((d.xum, Xsym_ph), label='+') * hv.Curve((d.xum, Xasym_ph), label='-') gridspace['X'] = hv.HoloMap(X_curves, kdims=['phi'], label='X') gridspace['Y'] = hv.HoloMap(Y_curves, kdims=['phi'], label='Y') gridspace['sym-asym'] = hv.HoloMap(sym_curves, kdims=['phi'], label='sym-asym') return gridspace(plot={'show_legend': True})
def new_game_of_life_grid(game_size=10, plot_size=100, x_grid=1, y_grid=1, shrink_factor=1.0, bgcolor=default_bgcolor, cmap=default_cmap, use_fixed_cell_sizes=default_use_fixed_cell_sizes, max_cell_age=default_max_cell_age): small_plot_size = round(plot_size / shrink_factor) graphs = [] for _ in range(x_grid * y_grid): graphs.append( new_game_of_life_graph(game_size, small_plot_size, bgcolor=bgcolor, cmap=cmap, use_fixed_cell_sizes=use_fixed_cell_sizes, max_cell_age=max_cell_age)) gridspace = hv.GridSpace(group='Games', kdims=['i', 'j']) for i in range(x_grid): for j in range(y_grid): gridspace[i, j] = graphs[i + j] # put the dmap in the grid return gridspace, graphs
def gather_plot(seismic_buttons, wiggle_buttons, seismic_iline, traces_iline, seismic_xline, traces_xline, time_slice, time_interval): """ NAME ---- gather_plot DESCRIPTION ----------- Constructs a grid of angle gathers. Collects angle gathers into one plot given a range of lines by using Holoviews and bokeh as backend. ARGUMENTS --------- Arguments are given by Panel's widgets through the panel's depend decorator: seismic_buttons : str Seismic direction to base the amplitude plotting. wiggle_buttons : str Desired amplitude's plot type. Can be given manually or by Panel's radio button widget. "Wavelet" will plot amplitudes using only a sine curve, "Black wiggle" will fill with black the area between the sin curve and time_axis and "Colored wiggle", will fill with blue/red the positive/negative area between the sin curve and time_axis. seismic_iline : int Inline number selection. traces_iline : tuple Range of crosslines to be intersected with seismic_iline. seismic_xline : int Crossline number selection. traces_xline : tuple Range of inlines to be intersected with seismic_xline. time_slice : list Time slice of interest. time_interval : int Chosen time interval. Survey.merge_path : str Path where the merge of the PAS is located. RETURN ------ GridSpace : Holviews element [GridSpace] Angle gathers. """ # f.gather[2405, 2664, :] array // f.gather[2405:2408, 2664:2667, :] generator!! Presents errores while giving atributes #When is not hardcoded #Opening seismic file (once) with segyio.open(Survey.merge_path) as segy: gather_dict = {} # Storing scaling fac WiggleModule.scaling_factor( self, segyio.tools.collect(segy.trace[:])) # Storing time array WiggleModule.time(self, time_interval) # Segyio gather Generator if seismic_buttons == "Inline": trace_counter = traces_iline[0] for gather in segy.gather[ seismic_iline, traces_iline[0]:traces_iline[-1] + 1, :]: gather_dict[ f"{seismic_iline}/{trace_counter}"] = WiggleModule.wiggle_plot( self, gather, time_slice, wiggle_buttons) trace_counter += 1 elif seismic_buttons == "Crossline": trace_counter = traces_xline[0] for gather in segy.gather[traces_xline[0]:traces_xline[1] + 1, seismic_xline, :]: gather_dict[ f"C{trace_counter}/{seismic_xline}"] = WiggleModule.wiggle_plot( self, gather, time_slice, wiggle_buttons) trace_counter += 1 # Gathers GridSpace = hv.GridSpace(gather_dict, kdims=['Trace']) return (GridSpace) column = pn.Column('# Column', w1, w2, background='WhiteSmoke')
def CreatePlot(ResultsNames, VerticalAxisLabel): "Create overlay plot of column names" def MyCycle(List, Enum): "Return a value from the list" RetVal = List[Enum % len(List)] return RetVal PlotList = [(holoviews.GridSpace( HoloviewsDataSet.to( holoviews.Scatter, ['Treatment Level'], PlotOutcome, label=VerticalAxisLabel, group=PlotOutcome).redim.label(**{ PlotOutcome: VerticalAxisLabel }).overlay(['Repetition']).options({ 'Scatter': { 'color': MyCycle(ColorList, Enum), 'marker': MyCycle(MarkerList, Enum), 'size': 2, 'legend_position': 'right', 'show_legend': True }, 'NdOverlay': { 'legend_position': 'right', 'show_legend': True }, 'Overlay': { 'legend_position': 'right', 'show_legend': True } })).options({ 'GridSpace': { 'shared_yaxis': True, 'shared_xaxis': True } })) for (Enum, PlotOutcome) in enumerate(ResultsNames)] PlotListAggregate = [(holoviews.GridSpace( HoloviewsAggregate.to( holoviews.Curve, ['Treatment Level'], PlotOutcome, label=VerticalAxisLabel, group=PlotOutcome).redim.label(**{ PlotOutcome: VerticalAxisLabel }).options({ 'Curve': { 'color': MyCycle(ColorList, Enum), 'show_legend': True }, 'NdOverlay': { 'legend_position': 'right', 'show_legend': True } })).options({ 'GridSpace': { 'shared_yaxis': True, 'shared_xaxis': True } })) for (Enum, PlotOutcome) in enumerate(ResultsNames)] HoloviewsText = [ holoviews.Text(0.5, (Enum + 1) / (len(ResultsNames) + 1) * 0.7, PlotOutcome).options({ 'Text': { 'color': MyCycle(ColorList, Enum), 'xaxis': None, 'yaxis': None, 'show_frame': False } }) for (Enum, PlotOutcome) in enumerate(ResultsNames) ] CreatedPlot = reduce(operator.mul, PlotList) CreatePlotAggregate = reduce(operator.mul, PlotListAggregate) CreatePlotTexts = reduce(operator.mul, HoloviewsText) return CreatedPlot, CreatePlotAggregate, CreatePlotTexts
def assemble_patterns_curve(y_data_array, y_range, x_data, x_range, row_num, col_num, index): """ After the program has obtained the index of the patterns in the selected region, this function randomly choose several of the patterns to show in a grid-space. Specifically, each pattern in this function is a holoview curve object. This function also assume that all curves share the same x-axis. :param y_data_array: 2D numpy array of the shape [n, curve_length] where n is the pattern number in total. :param y_range: The y range of the pattern. :param x_data: The x coordinate of the curve. :param x_range: The x range of the pattern. :param row_num: The row number of the grid space :param col_num: The column number of the grid space :param index: The index of all the data in the selected region :return: hv.GridSpace """ index = np.array(index) index_num = index.shape[0] # Get the span of x x_span = (x_data.max() - x_data.min()) if y_range == 'auto' and x_range == 'auto': if index_num >= row_num * col_num: # Extract some samples from all the selected ones. np.random.shuffle(index) sampled_index = index[:row_num * col_num] sampled_index = sampled_index.reshape((row_num, col_num)) # Assemble the patterns image_holder = {} for x in range(row_num): for y in range(col_num): # Get the span of the y values y_data = y_data_array[sampled_index[x, y]] y_span = y_data.max() - y_data.min() image_holder.update({ (x, y): hv.Curve((x_data, y_data)).redim.range( x=(x_data.min() - x_span * 0.05, x_data.max() + x_span * 0.05), y=(y_data.min() - y_span * 0.05, y_data.max() + y_span * 0.05)) }) else: # When we do not have so many patterns, first layout # all the patterns available and then fill the other # positions with patterns of zeros. index_list = [(x, y) for x in range(row_num) for y in range(col_num)] # Assemble the True patterns image_holder = {} for l in range(index_num): # Get the span of the y values y_data = y_data_array[index[l]] y_span = y_data.max() - y_data.min() image_holder.update({ index_list[l]: hv.Curve( (x_data, y_data)).redim.range(x=(x_data.min() - x_span * 0.05, x_data.max() + x_span * 0.05), y=(y_data.min() - y_span * 0.05, y_data.max() + y_span * 0.05)) }) # Assemble the psudo-image image_holder.update({ index_list[l]: hv.Curve( (x_data, np.zeros_like(x_data))).redim.range( x=(x_data.min() - x_span * 0.05, x_data.max() + x_span * 0.05), y=(0, 1)) for l in range(index_num, row_num * col_num) }) elif y_range == 'auto' and x_range != 'auto': # If y_range is auto while x is specified if index_num >= row_num * col_num: # Extract some samples from all the selected ones. np.random.shuffle(index) sampled_index = index[:row_num * col_num] sampled_index = sampled_index.reshape((row_num, col_num)) # Assemble the patterns image_holder = {} for x in range(row_num): for y in range(col_num): # Get the span of the y values y_data = y_data_array[sampled_index[x, y]] y_span = y_data.max() - y_data.min() image_holder.update({ (x, y): hv.Curve((x_data, y_data)).redim.range( x=(x_range[0], x_range[1]), y=(y_data.min() - y_span * 0.05, y_data.max() + y_span * 0.05)) }) else: # When we do not have so many patterns, first layout # all the patterns available and then fill the other # positions with patterns of zeros. index_list = [(x, y) for x in range(row_num) for y in range(col_num)] # Assemble the True patterns image_holder = {} for l in range(index_num): # Get the span of the y values y_data = y_data_array[index[l]] y_span = y_data.max() - y_data.min() image_holder.update({ index_list[l]: hv.Curve( (x_data, y_data)).redim.range(x=(x_range[0], x_range[1]), y=(y_data.min() - y_span * 0.05, y_data.max() + y_span * 0.05)) }) # Assemble the psudo-image image_holder.update({ index_list[l]: hv.Curve( (x_data, np.zeros_like(x_data))).redim.range(x=(x_range[0], x_range[1]), y=(0, 1)) for l in range(index_num, row_num * col_num) }) elif y_range != 'auto' and x_range == 'auto': if index_num >= row_num * col_num: # Extract some samples from all the selected ones. np.random.shuffle(index) sampled_index = index[:row_num * col_num] sampled_index = sampled_index.reshape((row_num, col_num)) # Assemble the patterns image_holder = {} for x in range(row_num): for y in range(col_num): # Get the span of the y values y_data = y_data_array[sampled_index[x, y]] image_holder.update({ (x, y): hv.Curve((x_data, y_data)).redim.range( x=(x_data.min() - x_span * 0.05, x_data.max() + x_span * 0.05), y=(y_range[0], y_range[1])) }) else: # When we do not have so many patterns, first layout # all the patterns available and then fill the other # positions with patterns of zeros. index_list = [(x, y) for x in range(row_num) for y in range(col_num)] # Assemble the True patterns image_holder = {} for l in range(index_num): # Get the span of the y values y_data = y_data_array[index[l]] image_holder.update({ index_list[l]: hv.Curve( (x_data, y_data)).redim.range(x=(x_data.min() - x_span * 0.05, x_data.max() + x_span * 0.05), y=(y_range[0], y_range[1])) }) # Assemble the psudo-image image_holder.update({ index_list[l]: hv.Curve( (x_data, np.zeros_like(x_data))).redim.range( x=(x_data.min() - x_span * 0.05, x_data.max() + x_span * 0.05), y=(y_range[0], y_range[1])) for l in range(index_num, row_num * col_num) }) else: # If neither x_range or y_range is specified if index_num >= row_num * col_num: # Extract some samples from all the selected ones. np.random.shuffle(index) sampled_index = index[:row_num * col_num] sampled_index = sampled_index.reshape((row_num, col_num)) # Assemble the patterns image_holder = {} for x in range(row_num): for y in range(col_num): # Get the span of the y values y_data = y_data_array[sampled_index[x, y]] image_holder.update({ (x, y): hv.Curve( (x_data, y_data)).redim.range(x=(x_range[0], x_range[1]), y=(y_range[0], y_range[1])) }) else: # When we do not have so many patterns, first layout # all the patterns available and then fill the other # positions with patterns of zeros. index_list = [(x, y) for x in range(row_num) for y in range(col_num)] # Assemble the True patterns image_holder = {} for l in range(index_num): # Get the span of the y values y_data = y_data_array[index[l]] image_holder.update({ index_list[l]: hv.Curve((x_data, y_data)).redim.range(x=(x_range[0], x_range[1]), y=(y_range[0], y_range[1])) }) # Assemble the psudo-image image_holder.update({ index_list[l]: hv.Curve( (x_data, np.zeros_like(x_data))).redim.range( x=(x_range[0], x_range[1]), y=(y_range[0], y_range[1])) for l in range(index_num, row_num * col_num) }) return hv.GridSpace(image_holder)
def covar_plot(x_var, y_var, x_range, y_range): cvs = ds.Canvas(plot_width=plot_width, plot_height=plot_height, x_range=x_range, y_range=y_range) agg = cvs.points(data, x_var, y_var, ds.count(y_var)) return hv.Image(agg).opts(colorbar=False, cmap='Blues', logz=True, width=int(plot_width * zoom_multiplier), height=int(plot_height * zoom_multiplier)) plot_dict = hv.OrderedDict([]) for yy in range(0, len(y_var)): # y_range = (np.nanmin(data.loc[:, yy]),np.nanmax(data.loc[:, yy])) y_range = (np.nanquantile(data.loc[:, y_var[yy]], .001), np.nanquantile(data.loc[:, y_var[yy]], .999)) for xx in range(yy, len(x_var)): # x_range = (np.nanmin(data.loc[:, x_var]),np.nanmax(data.loc[:, x_var])) x_range = (np.nanquantile(data.loc[:, x_var[xx]], .001), np.nanquantile(data.loc[:, x_var[xx]], .999)) plot_dict[(y_var[yy], x_var[xx])] = covar_plot(y_var[yy], x_var[xx], y_range, x_range) kdims = [hv.Dimension(('y_var', 'yy')), hv.Dimension(('x_var', 'xx'))] holomap = hv.HoloMap(plot_dict, kdims=kdims) # holomap.opts(opts.Curve(width=600)) grid = hv.GridSpace(holomap, sort=False) grid
def view(self, plane='axial', three_planes=False, image_size=300, dynamic=True, cmap='gray'): # imopts = {'tools': ['hover'], 'width': 400, 'height': 400, 'cmap': 'gray'} # imopts = {'tools': ['hover'], 'cmap': 'gray'} opts.defaults( opts.GridSpace( shared_xaxis=False, shared_yaxis=False, fontsize={ 'title': 16, 'labels': 16, 'xticks': 12, 'yticks': 12 }, ), # opts.Image(cmap='gray', tools=['hover'], xaxis=None, # yaxis=None, shared_axes=False), # opts.Overlay(tools=['hover']), # opts.NdOverlay(tools=['hover']), opts.Image(cmap=cmap, xaxis=None, yaxis=None, shared_axes=False), ) self.is2d = False if 'z' not in self.ds.dims: self.is2d = True self.set_size(image_size) if self.is2d: plane == '2d' a1, a2 = 'x', 'y' pane_width = self.pane_width pane_height = self.pane_height else: if plane == 'axial': a1, a2, a3 = 'x', 'y', 'z' # invert = True pane_width = self.axial_width pane_height = self.axial_height elif plane == 'coronal': a1, a2, a3 = 'x', 'z', 'y' pane_width = self.coronal_width pane_height = self.coronal_height # invert = False elif plane == 'sagittal': a1, a2, a3 = 'y', 'z', 'x' # invert = False pane_width = self.sagittal_width pane_height = self.sagittal_height contrast_start_min = np.asscalar( self.ds.isel(subject_id=0, ).image.quantile(0.01).values) - 1e-6 contrast_start_max = np.asscalar( self.ds.isel(subject_id=0, ).image.quantile(0.99).values) + 1e-6 contrast_min = np.asscalar( self.ds.isel(subject_id=0).image.min().values) contrast_max = np.asscalar( self.ds.isel(subject_id=0).image.max().values) ctotal = contrast_max - contrast_min contrast_min -= ctotal * 0.1 contrast_max += ctotal * 0.1 cslider = pn.widgets.RangeSlider(start=contrast_min, end=contrast_max, value=(contrast_start_min, contrast_start_max), name='contrast') if 'overlay' in self.ds.data_vars: hv_ds_image = hv.Dataset(self.ds[['image', 'overlay']]) # hv_ds_image = hv.Dataset(self.ds['image']) if self.verbose: print(hv_ds_image) hv_ds_overlay = hv.Dataset(self.ds['overlay']) if self.verbose: print(hv_ds_overlay) # tooltips = [ # ('(x,y)', '($x, $y)'), # ('image', '@image'), # ('overlay', '@overlay') # ] # hover = HoverTool(tooltips=tooltips) if self.verbose: print('overlay_max_calc') if self.is2d: first_subj_max = self.ds.isel(subject_id=0).overlay.max( dim=['x', 'y', 'label']).compute() first_subj_min = self.ds.isel(subject_id=0).overlay.min( dim=['x', 'y', 'label']).compute() else: first_subj_max = self.ds.isel(subject_id=0).overlay.max( dim=['x', 'y', 'z', 'label']).compute() first_subj_min = self.ds.isel(subject_id=0).overlay.min( dim=['x', 'y', 'z', 'label']).compute() if self.verbose: print('overlay_max_calc ready') print(first_subj_max) overlay_max = first_subj_max.max() alpha_slider = pn.widgets.FloatSlider(start=0, end=1, value=0.7, name='overlay transparency') cmap_select = pn.widgets.Select(name='Overlay Colormap', options=['Discrete', 'Continuous']) if self.verbose: print('max thresh calc') print(first_subj_max.max()) max_thresholds = first_subj_max.values if max_thresholds.size != 1: max_thresholds = sorted(set(max_thresholds)) else: max_thresholds = [np.asscalar(max_thresholds)] # max_thresholds = sorted(list(set([first_subj.overlay.sel(overlay_label=i).values.max() # for i in first_subj.overlay_label]))) if self.verbose: print('min thresh calc') min_thresholds = first_subj_min.values + 1e-6 if min_thresholds.size != 1: min_thresholds = sorted(set(min_thresholds)) else: min_thresholds = [np.asscalar(min_thresholds)] # min_thresholds = sorted(list(set(first_subj_min.min()))) # min_thresholds = sorted(list(set([first_subj.sel(overlay_label=i).min()+1e-6 for i in # first_subj.overlay_label]))) # ocslider = pn.widgets.DiscreteSlider(name='overlay max threshold', # options=max_thresholds, # value=max_thresholds[-1]) if len(min_thresholds) == 1 and len(max_thresholds) == 1: thresh_toggle = 0 oclim = (min_thresholds[0], max_thresholds[0]) elif len(min_thresholds) > 1 and len(max_thresholds) == 1: thresh_toggle = 1 ocslider_min = pn.widgets.DiscreteSlider( name='overlay min threshold', options=min_thresholds, value=min_thresholds[-1]) @pn.depends(ocslider_min) def oclim(value): return (value, max_thresholds[0]) elif len(min_thresholds) == 1 and len(max_thresholds) > 1: thresh_toggle = 2 ocslider_max = pn.widgets.DiscreteSlider( name='overlay max threshold', options=max_thresholds, value=max_thresholds[-1]) @pn.depends(ocslider_max) def oclim(value): return (min_thresholds[0], value) else: thresh_toggle = 3 ocslider_min = pn.widgets.DiscreteSlider( name='overlay min threshold', options=min_thresholds, value=min_thresholds[-1]) ocslider_max = pn.widgets.DiscreteSlider( name='overlay max threshold', options=max_thresholds, value=max_thresholds[-1]) @pn.depends(ocslider_min, ocslider_max) def oclim(value_min, value_max): return (value_min, value_max) if self.verbose: print(thresh_toggle) @pn.depends(cmap_select) def cmap_dict(value): d = {'Discrete': 'glasbey_hv', 'Continuous': 'viridis'} return d[value] # subj_viewer = SubjectViewer(ds=self.ds, # subject_id_sel=list(self.ds.subject_id.values)) if self.is2d: gridspace = hv_ds_image.to( hv.Image, [a1, a2], vdims=['image', 'overlay'], dynamic=dynamic).opts( frame_width=pane_width, frame_height=pane_height, tools=['hover'], ).apply.opts(clim=cslider.param.value) if self.verbose: print(gridspace) gridspace *= hv_ds_overlay.to( hv.Image, [a1, a2], vdims='overlay', dynamic=dynamic).opts( cmap='glasbey_hv', clipping_colors={ 'min': 'transparent', 'NaN': 'transparent' }, ).redim.range(overlay=(1e-6, overlay_max)).apply.opts( alpha=alpha_slider.param.value, cmap=cmap_dict, clim=oclim) # print(gridspace) # print(gridspace) # gridspace = hv.DynamicMap(subj_viewer.load_subject).grid('label') gridspace = gridspace.layout('label') elif three_planes: # squish_height = int(max(image_size*(len(self.ds.z)/len(self.ds.x)), image_size/2)) # gridspace = hv.GridSpace(kdims=['plane', 'label'], label=f'{self.subject_id}') gridspace = hv.GridSpace(kdims=['plane', 'label']) for mod in self.ds.label.values: gridspace['axial', mod] = hv_ds_image.select(label=mod).to( hv.Image, ['x', 'y'], groupby=['subject_id', 'z'], vdims='image', dynamic=dynamic).opts( frame_width=self.axial_width, frame_height=self.axial_height).apply.opts( clim=cslider.param.value) gridspace['coronal', mod] = hv_ds_image.select( label=mod).to( hv.Image, ['x', 'z'], groupby=['subject_id', 'y'], vdims='image', dynamic=dynamic).opts( frame_width=self.coronal_width, frame_height=self.coronal_height).apply.opts( clim=cslider.param.value) gridspace['sagittal', mod] = hv_ds_image.select( label=mod).to( hv.Image, ['y', 'z'], groupby=['subject_id', 'x'], vdims='image', dynamic=dynamic).opts( frame_width=self.sagittal_width, frame_height=self.sagittal_height).apply.opts( clim=cslider.param.value) gridspace['axial', mod] *= hv_ds_overlay.select(label=mod).to( hv.Image, ['x', 'y'], groupby=['subject_id', 'z', 'overlay_label'], vdims='overlay', dynamic=dynamic).opts( cmap='glasbey_hv', clipping_colors={ 'min': 'transparent', 'NaN': 'transparent' }, ).redim.range( overlay=(0.1, overlay_max)).apply.opts( alpha=alpha_slider.param.value, cmap=cmap_dict, clim=oclim) gridspace['coronal', mod] *= hv_ds_overlay.select(label=mod).to( hv.Image, ['x', 'z'], groupby=['subject_id', 'y', 'overlay_label'], vdims='overlay', dynamic=dynamic).opts( cmap='glasbey_hv', clipping_colors={ 'min': 'transparent', 'NaN': 'transparent' }, ).redim.range( overlay=(0.1, overlay_max)).apply.opts( alpha=alpha_slider.param.value, cmap=cmap_dict, clim=oclim) gridspace['sagittal', mod] *= hv_ds_overlay.select(label=mod).to( hv.Image, ['y', 'z'], groupby=['subject_id', 'x', 'overlay_label'], vdims='overlay', dynamic=dynamic).opts( cmap='glasbey_hv', clipping_colors={ 'min': 'transparent', 'NaN': 'transparent' }, ).redim.range( overlay=(0.1, overlay_max)).apply.opts( alpha=alpha_slider.param.value, cmap=cmap_dict, clim=oclim) else: # squish_height = int(max(image_size*(len(self.ds.z)/len(self.ds.x)), image_size/2)) # gridspace = hv.GridSpace(kdims=['label'], label=f'{self.subject_id}') if self.verbose: print('init gridspace') # gridspace = hv.GridSpace(kdims=['label']) # for mod in self.ds.label: # gridspace[mod] = hv_ds_image.select(label=mod).to( # hv.Image, [a1, a2], groupby=[a3], vdims='image', # dynamic=dynamic).opts(frame_width=image_size, frame_height=image_size, # ).apply.opts(clim=cslider.param.value) # gridspace[mod] *= hv_ds_overlay.select(label=mod).to( # hv.Image, [a1, a2], groupby=[a3, 'overlay_label'], vdims='overlay', # dynamic=dynamic).opts( # cmap='glasbey_hv', clipping_colors={'min': 'transparent'}, # ).redim.range(overlay=(1e-6, overlay_max)).apply.opts( # alpha=alpha_slider.param.value, cmap=cmap_dict, clim=oclim) # gridspace[mod] = gridspace[mod].opts(tools=['hover']) # print(gridspace[mod]) gridspace = hv_ds_image.to( hv.Image, [a1, a2], vdims=['image', 'overlay'], dynamic=dynamic).opts( frame_width=pane_width, frame_height=pane_height, tools=['hover'], ).apply.opts(clim=cslider.param.value) if self.verbose: print(gridspace) gridspace *= hv_ds_overlay.to( hv.Image, [a1, a2], vdims='overlay', dynamic=dynamic).opts( cmap='glasbey_hv', clipping_colors={ 'min': 'transparent', 'NaN': 'transparent' }, ).redim.range(overlay=(1e-6, overlay_max)).apply.opts( alpha=alpha_slider.param.value, cmap=cmap_dict, clim=oclim) # print(gridspace) # print(gridspace) # gridspace = hv.DynamicMap(subj_viewer.load_subject).grid('label') gridspace = gridspace.layout('label') else: tooltips = [ ('(x,y)', '($x, $y)'), ('image', '@image'), ] hover = HoverTool(tooltips=tooltips) hv_ds = hv.Dataset(self.ds['image']) if self.is2d: gridspace = hv.GridSpace(kdims=['label']) for mod in self.ds.label.values: gridspace[mod] = hv_ds.select(label=mod).to( hv.Image, [a1, a2], groupby=['subject_id'], vdims='image', dynamic=dynamic).opts( frame_width=pane_width, frame_height=pane_height, shared_axes=False, tools=[hover], axiswise=True, # ).apply.opts(clim=cslider.param.value) ) elif three_planes: # squish_height = int(max(image_size*(len(self.ds.z)/len(self.ds.x)), image_size/2)) # gridspace = hv.GridSpace(kdims=['plane', 'label'], label=f'{self.subject_id}') gridspace = hv.GridSpace(kdims=['plane', 'label']) for mod in self.ds.label.values: gridspace['axial', mod] = hv_ds.select(label=mod).to( hv.Image, ['x', 'y'], groupby=['subject_id', 'z'], vdims='image', dynamic=dynamic).opts(frame_width=self.axial_width, frame_height=self.axial_height, invert_yaxis=False).apply.opts( clim=cslider.param.value) gridspace['coronal', mod] = hv_ds.select(label=mod).to( hv.Image, ['x', 'z'], groupby=['subject_id', 'y'], vdims='image', dynamic=dynamic).opts( frame_width=self.coronal_width, frame_height=self.coronal_height).apply.opts( clim=cslider.param.value) gridspace['sagittal', mod] = hv_ds.select(label=mod).to( hv.Image, ['y', 'z'], groupby=['subject_id', 'x'], vdims='image', dynamic=dynamic).opts( frame_width=self.sagittal_width, frame_height=self.sagittal_height).apply.opts( clim=cslider.param.value) else: # squish_height = int(max(image_size*(len(self.ds.z)/len(self.ds.x)), image_size/2)) # gridspace = hv.GridSpace(kdims=['label'], label=f'{self.subject_id}') gridspace = hv.GridSpace(kdims=['label']) for mod in self.ds.label.values: gridspace[mod] = hv_ds.select(label=mod).to( hv.Image, [a1, a2], groupby=['subject_id', a3], vdims='image', dynamic=dynamic).opts( frame_width=pane_width, frame_height=pane_height, shared_axes=False, tools=[hover], ).apply.opts(clim=cslider.param.value) pn_layout = pn.pane.HoloViews(gridspace) wb = pn_layout.widget_box wb.append(cslider) if 'overlay' in self.ds.data_vars: wb.append(alpha_slider) wb.append(cmap_select) if thresh_toggle in [2, 3]: wb.append(ocslider_max) if thresh_toggle in [1, 3]: wb.append(ocslider_min) return pn.Row(wb, pn_layout)
def line_stuff(time_slice, seismic_buttons, iline_input, xline_input, checkbox): """ NAME ---- line_stuff. DESCRIPTION ----------- Plots a chosen seismic line. Inherited from WiggleModule class. The detected anomalies in the crossplot shall be compared with the amplitude display of a gather. ARGUMENTS --------- seismic_buttons : str Seismic direction to base the amplitude plotting. wiggle_buttons : str Hardcoded to "Colored wiggle". seismic_iline : int Inline number selection. traces_iline : tuple Range of crosslines to be intersected with seismic_iline. seismic_xline : int Crossline number selection. traces_xline : tuple Range of inlines to be intersected with seismic_iline. time_slice : list Time slice of interest. Survey.merge_path : str Path where the merge of the PAS is located. RETURN ------ GridSpace : Holviews element [GridSpace] A grid compounded by angle gathers. """ if checkbox: with segyio.open(Survey.merge_path) as segy: self.interpolation = False gather_dict = {} # Storing scaling fac self.scaling_factor = WiggleModule.scaling_factor( self, segyio.tools.collect(segy.trace[:])) # Storing time array WiggleModule.time( self, int( segy.attributes( segyio.TraceField.TRACE_SAMPLE_INTERVAL)[0] / 1000)) # Line visualization if seismic_buttons == "Inline": trace_counter = self.crosslines[0] for gather in segy.gather[int(iline_input), :, :]: gather_dict[ f"{int(iline_input)}/{trace_counter}"] = WiggleModule.wiggle_plot( self, gather, time_slice, "Colored wiggle") trace_counter += 1 else: trace_counter = self.inlines[0] for gather in segy.gather[:, int(xline_input), :]: gather_dict[ f"C{trace_counter}/{int(xline_input)}"] = WiggleModule.wiggle_plot( self, gather, time_slice, "Colored wiggle") trace_counter += 1 grid = hv.GridSpace(gather_dict, kdims=['Trace']) grid.opts(fontsize={ "title": 16, "labels": 14, "xticks": 8, "yticks": 8 }, plot_size=(60, 240)) return grid