def create_aggregate(self, plot_width, plot_height, x_range, y_range, star_age, aperture, agg_field, x_field, y_field, agg_func, glyph): # this may not be the best place for it, but before we recreate the aggregation # we need to edit the df according to the current slider settings, which are # available here as "self.aperture", "self.age", etc. self.prepare_dataframe() canvas = ds.Canvas(plot_width=plot_width,plot_height=plot_height, x_range=x_range,y_range=y_range) method = getattr(canvas, glyph) # handle categorical field if agg_field in self.categorical_fields: print("Categorical aggregate is about to do its thing with :", agg_field) agg = method(self.df, x_field, y_field, ds.count_cat(agg_field)) # handle ordinal field elif agg_field in self.ordinal_fields: func = self.aggregate_functions[agg_func] print("Ordinal aggregate is about to do its thing with :", agg_field) agg = method(self.df[(self.df['LOGAGE'] == star_age) ], x_field, y_field, func(agg_field)) else: print("Ordinal aggregate is about to do its thing with :", agg_field) agg = method(self.df, x_field, y_field) return agg
def view_datashade(self): """ Use of datashade for performance and line for hover tool capabilities :return: Panel of this combination """ # Select only sufficient data if self.x in self.y: self.y.remove(self.x) if self.y == []: return self.gif df = self.dataframe[[self.x] + self.y].copy() plot_opts = { 'Scatter': { 'color': self.color_key, 'marker': self.marker_keys, 'size': 10 }, 'Curve': { 'color': self.color_key } } lines_overlay = df.hvplot.scatter( **self.plot_options).options(plot_opts) def hover_curve(x_range=[df.index.min(), df.index.max()]): # , y_range): # Compute dataframe = df.copy() if x_range is not None: dataframe = dataframe[(dataframe[self.x] > x_range[0]) & (dataframe[self.x] < x_range[1])] data_length = len(dataframe) * len(dataframe.columns) step = 1 if data_length < self.max_step else data_length // self.max_step plot_df = dataframe[::step].hvplot.line(**self.plot_options) * \ dataframe[::step*60].hvplot.scatter(**self.plot_options) plot_opts = { 'Scatter': { 'color': 'k', 'marker': self.marker_keys, 'size': 10 }, 'Curve': { 'color': self.color_key } } if len(self.y) != 1: plot_opts['Scatter']['color'] = self.color_key return plot_df.options(plot_opts) # Define a RangeXY stream linked to the image rangex = hv.streams.RangeX(source=lines_overlay) data_shade_plot = hv.DynamicMap(hover_curve, streams=[rangex]) if len(self.y) == 1: data_shade_plot *= datashade(lines_overlay) else: data_shade_plot *= datashade(lines_overlay, aggregator=ds.count_cat('Variable')) return pn.panel(data_shade_plot)
def test_aggregate_ndoverlay_count_cat_datetimes_microsecond_timebase( self): dates = pd.date_range(start="2016-01-01", end="2016-01-03", freq='1D') xstart = np.datetime64('2015-12-31T23:59:59.723518000', 'us') xend = np.datetime64('2016-01-03T00:00:00.276482000', 'us') curve = Curve((dates, [1, 2, 3])) curve2 = Curve((dates, [3, 2, 1])) ndoverlay = NdOverlay({0: curve, 1: curve2}, 'Cat') imgs = aggregate(ndoverlay, aggregator=ds.count_cat('Cat'), width=2, height=2, x_range=(xstart, xend), dynamic=False) bounds = (np.datetime64('2015-12-31T23:59:59.723518'), 1.0, np.datetime64('2016-01-03T00:00:00.276482'), 3.0) dates = [ np.datetime64('2016-01-01T11:59:59.861759000', ), np.datetime64('2016-01-02T12:00:00.138241000') ] expected = Image((dates, [1.5, 2.5], [[1, 0], [0, 2]]), datatype=['xarray'], bounds=bounds, vdims='Count') expected2 = Image((dates, [1.5, 2.5], [[0, 1], [1, 1]]), datatype=['xarray'], bounds=bounds, vdims='Count') self.assertEqual(imgs[0], expected) self.assertEqual(imgs[1], expected2)
def compute_range_created_radio_hist(client): """ Use Datashader to compute a 3D histogram of cell_towers_ddf, binned by the created, log10_range, and radio dimensions """ cell_towers_ddf = client.get_dataset("cell_towers_ddf") created_bin_edges = client.get_dataset("created_bin_edges") created_bin_centers = client.get_dataset("created_bin_centers") min_log10_range = client.get_dataset("min_log10_range") max_log10_range = client.get_dataset("max_log10_range") created_bins = created_bin_edges.astype("int") cvs2 = ds.Canvas( # Specify created bins plot_width=len(created_bins) - 1, x_range=[min(created_bins), max(created_bins)], # Specify log10_range bins plot_height=20, y_range=[min_log10_range, max_log10_range], ) agg = cvs2.points( cell_towers_ddf, x="created", y="log10_range", agg=ds.count_cat("radio") ) # Set created index back to datetime values agg = agg.assign_coords(created=created_bin_centers) return agg
def pl(lbls,key,data): dataset = pd.DataFrame({'Column1': data[:, 0], 'Column2': data[:, 1], 'Column3': lbls}) dataset['Column3'] = dataset['Column3'].astype('category') cvs = ds.Canvas(plot_width = 900, plot_height = 500) aggs = cvs.points(dataset,'Column1','Column2',ds.count_cat('Column3')) img = ds.transfer_functions.shade(aggs, color_key=key) return img
def color_code_dm(dsname): ds = yt.load(dsname) box = ds.r[0:1, 0:1, 0:1] particle_df, used_particles, halo_catalog = create_particle_df(box) particle_df['position_x'] = particle_df['position_x'] * ( 1. + ds.current_redshift) particle_df['position_y'] = particle_df['position_y'] * ( 1. + ds.current_redshift) particle_df['position_z'] = particle_df['position_z'] * ( 1. + ds.current_redshift) particle_df['level'] = 'LX' particle_df.loc[particle_df.mass > 1e5, 'level'] = 'L3' particle_df.loc[particle_df.mass > 1e6, 'level'] = 'L2' particle_df.loc[particle_df.mass > 1e7, 'level'] = 'L1' particle_df.loc[particle_df.mass > 1e8, 'level'] = 'L0' particle_df.level = particle_df.level.astype('category') agg = aggregate_particles(particle_df, 'position_y', 'position_z', 800) color_key = collections.OrderedDict([('L0', '#666666'), ('L1', '#FF0000'), ('L2', '#00FF00'), ('L3', '#0000FF')]) cvs = dshader.Canvas(plot_width=1000, plot_height=1000, x_range=[0, 25000], y_range=[0, 25000]) agg = cvs.points(particle_df, 'position_y', 'position_z', dshader.count_cat('level')) img = tf.shade(agg, color_key=color_key, how='log') export = partial(export_image, background='white', export_path="./") export(img, dsname[7:] + '_particles_yz') return img
def agg_count_cat( data, x, y, z, scale_paras, clip_max=0, reduce=False, sharp_boundary=True, ): """count categorical data """ # collect aggdata and ps agg = ds.count_cat(z) aggdata, ps = agg_data_ps(data, x, y, agg, scale_paras) zlabels = aggdata[z].values if clip_max: aggdata = aggdata.clip(max=clip_max) if reduce: aggdata = aggdata.argmax(z) if sharp_boundary: # normalize by any (set no cells to nan) agg = ds.any() aggdata_any = agg_data(data, x, y, ps.npxlx, ps.npxly, agg) aggdata_any = aggdata_any.astype(int) aggdata = aggdata/aggdata_any return aggdata, ps, zlabels
def _compute_datashader_assets(data, x, aggregate_col, aggregate_fn, color_palette): aggregator = None cmap = {"cmap": color_palette} if isinstance(data[x].dtype, cudf.core.dtypes.CategoricalDtype): if ds_version >= "0.11": aggregator = ds.by( x, getattr(ds, aggregate_fn)(aggregate_col), ) else: print("only count_cat supported by datashader <=0.10") aggregator = ds.count_cat(x) cmap = { "color_key": { k: v for k, v in zip( list(data[x].cat.categories), color_palette, ) } } else: if aggregate_fn: aggregator = getattr(ds, aggregate_fn)(aggregate_col) return aggregator, cmap
def create_image(x_range, y_range, w=plot_width, h=plot_height): cvs = dshader.Canvas(plot_width=w, plot_height=h, x_range=x_range, y_range=y_range) agg = cvs.points(df, 'x', 'z', dshader.count_cat('phase')) img = tf.colorize(agg, phase_color_key, how='eq_hist') return tf.dynspread(img, threshold=0.3, max_px=4)
def test_count_cat(): agg = c.points(df, 'x', 'y', ds.count_cat('cat')) sol = np.array([[[5, 0, 0, 0], [0, 0, 5, 0]], [[0, 5, 0, 0], [0, 0, 0, 5]]]) assert (nd.as_numpy(agg._data) == sol).all() assert agg._cats == ('a', 'b', 'c', 'd')
def create_image(frame, x_range, y_range, w=plot_width, h=plot_height): cvs = dshader.Canvas(plot_width=w, plot_height=h, x_range=x_range, y_range=y_range) agg = cvs.points(frame, 'x', 'y', dshader.count_cat('phase')) img = tf.shade(agg, color_key=phase_color_key, how='eq_hist') return img
def test_count_cat(): sol = np.array([[[5, 0, 0, 0], [0, 0, 5, 0]], [[0, 5, 0, 0], [0, 0, 0, 5]]]) out = xr.DataArray(sol, coords=(coords + [['a', 'b', 'c', 'd']]), dims=(dims + ['cat'])) agg = c.points(df, 'x', 'y', ds.count_cat('cat')) assert_eq(agg, out)
def create_image3(x_range, y_range, w=plot_width, h=plot_height): cvs = dshader.Canvas(plot_width=w, plot_height=h, x_range=x_range, y_range=y_range) agg = cvs.points(df, 'dens', 'temp', dshader.count_cat('phase')) img = tf.colorize(agg, phase_color_key, how='eq_hist') return img
def create_image2(x_range, y_range, w=plot_width, h=plot_height): cvs = dshader.Canvas(plot_width=w, plot_height=h, x_range=x_range, y_range=y_range) agg = cvs.points(df, 'x', 'mass', dshader.count_cat('phase')) raw = tf.shade(agg, color_key=phase_color_key, how='eq_hist') img = tf.spread(raw, px=2, shape='square') return img
def nodes_plot(nodes, name=None, canvas=None, cat=None, kwargs=cvsopts): ''' Plot nodes using datashader Canvas functions and returns datashader.transfer_functions.spread(). ''' canvas = ds.Canvas(**kwargs) if canvas is None else canvas aggregator = None if cat is None else ds.count_cat(cat) agg = canvas.points(nodes, 'x', 'y', aggregator) return tf.spread(tf.shade(agg, cmap=["#FF3333"]), px=3, name=name)
def create_image(longitude_range, latitude_range, w=plot_width, h=plot_height): x_range, y_range = webm(longitude_range, latitude_range) cvs = ds.Canvas(plot_width=w, plot_height=h, x_range=x_range, y_range=y_range) agg = cvs.points(df, 'easting', 'northing', ds.count_cat('race')) img = tf.shade(agg, color_key=color_key, how='eq_hist') return img
def test_count_cat(): sol = np.array([[[5, 0, 0, 0], [0, 0, 5, 0]], [[0, 5, 0, 0], [0, 0, 0, 5]]]) out = xr.DataArray(sol, coords=(coords + [['a', 'b', 'c', 'd']]), dims=(dims + ['cat'])) agg = c.points(ddf, 'x', 'y', ds.count_cat('cat')) assert_eq(agg, out)
def my_nodesplot(nodes, name=None, canvas=None, cat=None): canvas = ds.Canvas(**cvsopts) if canvas is None else canvas aggregator = None if cat is None else ds.count_cat(cat) agg = canvas.points(nodes, 'x', 'y', aggregator) return tf.spread(tf.shade(agg, cmap=["#333333"], color_key=colors, min_alpha=255), px=3, name=name)
def test_aggregate_points_categorical(self): points = Points([(0.2, 0.3, 'A'), (0.4, 0.7, 'B'), (0, 0.99, 'C')], vdims='z') img = aggregate(points, dynamic=False, x_range=(0, 1), y_range=(0, 1), width=2, height=2, aggregator=ds.count_cat('z')) xs, ys = [0.25, 0.75], [0.25, 0.75] expected = NdOverlay({'A': Image((xs, ys, [[1, 0], [0, 0]]), vdims='z Count'), 'B': Image((xs, ys, [[0, 0], [1, 0]]), vdims='z Count'), 'C': Image((xs, ys, [[0, 0], [1, 0]]), vdims='z Count')}, kdims=['z']) self.assertEqual(img, expected)
def test_aggregate_points_categorical_zero_range(self): points = Points([(0.2, 0.3, 'A'), (0.4, 0.7, 'B'), (0, 0.99, 'C')], vdims='z') img = aggregate(points, dynamic=False, x_range=(0, 0), y_range=(0, 1), aggregator=ds.count_cat('z')) xs, ys = [], [0.25, 0.75] params = dict(bounds=(0, 0, 0, 1), xdensity=1) expected = NdOverlay({'A': Image((xs, ys, np.zeros((2, 0))), vdims='z Count', **params), 'B': Image((xs, ys, np.zeros((2, 0))), vdims='z Count', **params), 'C': Image((xs, ys, np.zeros((2, 0))), vdims='z Count', **params)}, kdims=['z']) self.assertEqual(img, expected)
def feat_reduction_umap(type=None, filename='data.csv', random_state=42): print("UMAP with random_state {}".format(random_state)) if type is not None: ext = '_{}'.format(type) else: ext = '' filename = RESULTS_DIR + filename source_df = pd.read_csv(filename) data = source_df.iloc[:, :224].values.astype(np.float32) target = source_df['emotion'].values pal = [ '#0000FF', '#FF0000' # red # '#FFFF00' # yellow ] color_key = {str(d): c for d, c in enumerate(pal)} reducer = umap.UMAP(random_state=random_state) embedding = reducer.fit_transform(data) df = pd.DataFrame(embedding, columns=('x', 'y')) df['class'] = pd.Series([str(int(x)) for x in target], dtype="category") # for k, v in df.iteritems(): # print("k: {}, v: {}".format(k, v)) # cvs = ds.Canvas(plot_width=400, plot_height=400) cvs = ds.Canvas() agg = cvs.points(df, 'x', 'y', ds.count_cat('class')) img = tf.shade(agg, color_key=color_key, how='eq_hist') ds_utils.export_image(img, filename='cognimuse_{}'.format(random_state), export_path=RESULTS_DIR, background='white') image = plt.imread(RESULTS_DIR + 'cognimuse_{}.png'.format(random_state)) fig, ax = plt.subplots(figsize=(6, 6)) plt.imshow(image) plt.setp(ax, xticks=[], yticks=[]) plt.xlabel('Dimension 1') plt.ylabel('Dimension 2') plt.title( "COGNIMUS data data embedded\n" "into two dimensions by UMAP\n" "visualised with Datashader", fontsize=12) plt.savefig(RESULTS_DIR + 'cognimuse_{}_labels.png'.format(random_state))
def ds_to_img(heatmap, split_val, color_key=None): if color_key is None: color_key = {'1': "#FF6A00", '0': "#009951"} # for value in heatmap: # ['mmsi', 'longitude', 'latitude', 'distshore_f', 'ourlabel'] df = pd.DataFrame(heatmap, columns=["mmsi", "X", "Y", "distshore_f", "ourlabel"]) df.ourlabel = df.ourlabel.astype(int) df.ourlabel = df.ourlabel.astype(str) df.X = df.X.astype(float) df.Y = df.Y.astype(float) df.distshore_f = df.distshore_f.astype(float) cvs = ds.Canvas(plot_width=int(360 * split_val), plot_height=int(180 * split_val), x_range=(-180, 180), y_range=(-90, 90)) df.ourlabel = df.ourlabel.astype('category') # now make the image agg = cvs.points(df, 'X', 'Y', ds.count_cat('ourlabel')) images = tf.shade(agg, color_key=color_key, how='log', min_alpha=0) img = images.data.tolist() image = [] # change alpha=0 to 0, no need to send these values for x in img: i = [] for y in x: if y != 0: alpha = (y >> 24) & 255 # blue = (y >> 16) & 255 # green = (y >> 8) & 255 # red = y & 255 if alpha > 0: i.append(y) else: i.append(0) image.append(i) try: vals_arr, min_val, max_val = summarize_aggregate_values(agg, how='log') # print '%s %s %s' % (vals_arr, min_val, max_val) except ValueError: min_val = 0 max_val = 0 # return json.dumps(img) return image, min_val, max_val
def plot_catalog_overlap(catalog_a, catalog_b, legend): a_coords = catalog_a[['ra', 'dec']] a_coords['catalog'] = legend[0] b_coords = catalog_b[['ra', 'dec']] b_coords['catalog'] = legend[1] df_to_plot = pd.concat([a_coords, b_coords]) df_to_plot['catalog'] = df_to_plot['catalog'].astype('category') canvas = ds.Canvas(plot_width=400, plot_height=400) aggc = canvas.points(df_to_plot, 'ra', 'dec', ds.count_cat('catalog')) img = tf.shade(aggc) export_image(img, 'catalog_overlap')
def plot_df(df_list): renderer = hv.renderer('bokeh').instance(mode='server') print(df_list) lines = { i: hv.Curve(df_list[i], kdims=['x'], vdims=['y']) for i in range(len(df_list)) } linespread = dynspread(datashade(hv.NdOverlay(lines, kdims='k')), aggregator=ds.count_cat('k')).opts( **{'plot': { 'height': 400, 'width': 1400 }}) return renderer.get_plot(linespread).state
def plot_datashader_as_base64(df, param): cat = param['target_variables'][0] dfr = df.astype({cat: 'category'}) cvs = ds.Canvas(plot_width=300, plot_height=300) agg = cvs.points(dfr, 'UMAP1', 'UMAP2', ds.count_cat(cat)) color_key_dga = {'dga': 'red', 'legit': 'blue'} #img = tf.shade(agg, cmap='darkblue', how='log') #, cmap=color_key_dga, how="eq_hist") img = tf.shade(agg, cmap=color_key_dga, how="eq_hist") img.plot() pic_IObytes = img.to_bytesio() pic_IObytes.seek(0) pic_hash = base64.b64encode(pic_IObytes.read()) return str(pic_hash)
def querygraph(gene, set): if (set == "microglia"): categorical_points = hv.Points( (df3["UMAP_1"], df3["UMAP_2"], getVals_microglia(gene)), ['UMAP_1', 'UMAP_2'], vdims='Category') else: categorical_points = hv.Points( (df["UMAP_1"], df["UMAP_2"], getVals(gene)), ['UMAP_1', 'UMAP_2'], vdims='Category') return dynspread( datashade(categorical_points, aggregator=ds.count_cat('Category'), color_key=['#c9c9c9', '#00008a'], dynamic=False).opts(plot=dict(width=600, height=450)))
def create_aggregate(self, plot_width, plot_height, x_range, y_range, agg_field, x_field, y_field, agg_func): canvas = ds.Canvas(plot_width=plot_width, plot_height=plot_height, x_range=x_range, y_range=y_range) # handle categorical field if agg_field in self.categorical_fields: agg = canvas.points(self.df, x_field, y_field, ds.count_cat(agg_field)) # handle ordinal field elif agg_field in self.ordinal_fields: func = self.aggregate_functions[agg_func] agg = canvas.points(self.df, x_field, y_field, func(agg_field)) else: agg = canvas.points(self.df, x_field, y_field) return agg
def clustersgraph(set): if (set == "microglia"): categorical_points = hv.Points( (df3["UMAP_1"], df3["UMAP_2"], df4["SCT_snn_res.0.2"]), ['UMAP_1', 'UMAP_2'], vdims='Category') else: categorical_points = hv.Points( (df["UMAP_1"], df["UMAP_2"], df2["SCT_snn_res.0.2"]), ['UMAP_1', 'UMAP_2'], vdims='Category') return dynspread( datashade(categorical_points, aggregator=ds.count_cat('Category'), color_key=Sets1to3, dynamic=False).opts(plot=dict(width=600, height=450)))
def datashading_plot(*args, **kwargs): self = args[0] plot = method(*args, **kwargs) if not self.datashade: return plot try: from holoviews.operation.datashader import datashade from datashader import count_cat except: raise ImportError('Datashading is not available') opts = dict(width=self._plot_opts['width'], height=self._plot_opts['height']) if 'cmap' in self._style_opts: opts['cmap'] = self._style_opts['cmap'] if self.by: opts['aggregator'] = count_cat(self.by) return datashade(plot, **opts).opts(plot=self._plot_opts)
def test_count_cat(ddf): sol = np.array([[[5, 0, 0, 0], [0, 0, 5, 0]], [[0, 5, 0, 0], [0, 0, 0, 5]]]) out = xr.DataArray(sol, coords=(coords + [['a', 'b', 'c', 'd']]), dims=(dims + ['cat'])) agg = c.points(ddf, 'x', 'y', ds.count_cat('cat')) assert_eq_xr(agg, out) # categorizing by (cat_int-10)%4 ought to give the same result out = xr.DataArray(sol, coords=(coords + [range(4)]), dims=(dims + ['cat_int'])) agg = c.points( ddf, 'x', 'y', ds.by(ds.category_modulo('cat_int', modulo=4, offset=10), ds.count())) assert_eq_xr(agg, out) # easier to write these tests in here, since we expect the same result with only slight tweaks # add an extra category (this will count nans and out of bounds) sol = np.append(sol, [[[0], [0]], [[0], [0]]], axis=2) # categorizing by binning the integer arange columns using [0,20] into 4 bins. Same result as for count_cat for col in 'i32', 'i64': out = xr.DataArray(sol, coords=(coords + [range(5)]), dims=(dims + [col])) agg = c.points(ddf, 'x', 'y', ds.by(ds.category_binning(col, 0, 20, 4), ds.count())) assert_eq_xr(agg, out) # as above, but for the float arange columns. Element 2 has a nan, so the first bin is one short, and the nan bin is +1 sol[0, 0, 0] = 4 sol[0, 0, 4] = 1 for col in 'f32', 'f64': out = xr.DataArray(sol, coords=(coords + [range(5)]), dims=(dims + [col])) agg = c.points(ddf, 'x', 'y', ds.by(ds.category_binning(col, 0, 20, 4), ds.count())) assert_eq_xr(agg, out)
def test_aggregate_ndoverlay_count_cat_datetimes_microsecond_timebase(self): dates = pd.date_range(start="2016-01-01", end="2016-01-03", freq='1D') xstart = np.datetime64('2015-12-31T23:59:59.723518000', 'us') xend = np.datetime64('2016-01-03T00:00:00.276482000', 'us') curve = Curve((dates, [1, 2, 3])) curve2 = Curve((dates, [3, 2, 1])) ndoverlay = NdOverlay({0: curve, 1: curve2}, 'Cat') imgs = aggregate(ndoverlay, aggregator=ds.count_cat('Cat'), width=2, height=2, x_range=(xstart, xend), dynamic=False) bounds = (np.datetime64('2015-12-31T23:59:59.723518'), 1.0, np.datetime64('2016-01-03T00:00:00.276482'), 3.0) dates = [np.datetime64('2016-01-01T11:59:59.861759000',), np.datetime64('2016-01-02T12:00:00.138241000')] expected = Image((dates, [1.5, 2.5], [[1, 0], [0, 2]]), datatype=['xarray'], bounds=bounds, vdims='Count') expected2 = Image((dates, [1.5, 2.5], [[0, 1], [1, 1]]), datatype=['xarray'], bounds=bounds, vdims='Count') self.assertEqual(imgs[0], expected) self.assertEqual(imgs[1], expected2)
def plot_ds_bespoke(ax, mdf, cats, explicit_colors): import datashader as ds from datashader import transfer_functions as tf from datashader.colors import Sets1to3 cvs = ds.Canvas(plot_width=960, plot_height=640) agg = cvs.points(mdf, 'x', 'y', ds.count_cat('cat')) color_key = dict(zip(cats, Sets1to3)) color_key.update(explicit_colors) img = tf.shade(agg, min_alpha=128, color_key=color_key) img = tf.dynspread(img, threshold=0.5, max_px=1000) img = img.data.view(np.uint8).reshape(*img.shape, 4)[::-1, :, :] ax.imshow(img) from matplotlib.lines import Line2D ax.legend([Line2D([0], [0], color=color_key[c], lw=4) for c in cats], cats, loc='upper left', markerscale=5)
def plot_ds(ax, mdf, col, title): import datashader as ds from datashader import transfer_functions as tf from datashader.colors import Sets1to3 mdf[col] = mdf[col].astype('category') cvs = ds.Canvas(plot_width=960, plot_height=540) agg = cvs.points(mdf, 'x', 'y', ds.count_cat(col)) color_key = dict(zip(mdf[col].cat.categories, Sets1to3)) img = tf.shade(agg, name=title, min_alpha=64, color_key=color_key) img = tf.dynspread(img) img = img.data.view(np.uint8).reshape(*img.shape, 4)[::-1, :, :] ax.imshow(img) from matplotlib.lines import Line2D ax.legend([Line2D([0], [0], color=c, lw=4) for c in color_key.values()], color_key.keys(), loc='upper left', markerscale=5)
def callback_InteractiveImage(self, x_range, y_range, plot_width, plot_height, name=None): cvs = ds.Canvas( plot_width=plot_width, plot_height=plot_height, x_range=x_range, y_range=y_range, ) agg = cvs.points( self.result, 'x', 'y', agg=ds.count_cat('c'), ) img = tf.shade(agg, min_alpha=255, color_key=self.color_key) return img
def nodesplot(nodes, name=None, canvas=None, cat=None): canvas = ds.Canvas(**cvsopts) if canvas is None else canvas aggregator=None if cat is None else ds.count_cat(cat) agg=canvas.points(nodes,'x','y',aggregator) return tf.spread(tf.shade(agg, cmap=["#FF3333"]), px=3, name=name)
def get_events(tdb): query = [('title', 'Prince (musician)')] for i in range(len(tdb)): events = list(tdb.trail(i, event_filter=query)) if events: yield events[0].time, events def get_dataframe(): tdb = TrailDB('pydata-tutorial.tdb') base = tdb.min_timestamp() types = [] xs = [] ys = [] #try this: #for y, (first_ts, events) in enumerate(sorted(get_events(tdb), reverse=True)): for y, (first_ts, events) in enumerate(get_events(tdb)): for event in events: xs.append(int(event.time - base) / (24 * 3600)) ys.append(y) types.append('user' if event.user else 'anon') data = pd.DataFrame({'x': xs, 'y': ys}) data['type'] = pd.Series(types, dtype='category') return data cnv = ds.Canvas(400, 300) agg = cnv.points(get_dataframe(), 'x', 'y', ds.count_cat('type')) colors = {'anon': 'red', 'user': '******'} img=tf.set_background(tf.colorize(agg, colors, how='eq_hist'), 'white') with open('prince.png', 'w') as f: f.write(img.to_bytesio().getvalue())