def edges_plot(self, canvas, nodes, name=None): """ plot edges(lines) """ aggregator, cmap = _compute_datashader_assets( self.connected_edges, self.node_x, self.edge_aggregate_col, self.edge_aggregate_fn, self.edge_color_palette, ) agg = canvas.line(self.connected_edges, self.node_x, self.node_y, aggregator) if (self.constant_limit_edges is None or self.edge_aggregate_fn == "count"): self.constant_limit_edges = [ float(cp.nanmin(agg.data)), float(cp.nanmax(agg.data)), ] span = {"span": self.constant_limit_nodes} return getattr(tf, self.node_pixel_spread)( tf.shade( agg, name=name, how="linear", alpha=255 - 255 * self.edge_transparency, **cmap, **span, ), max_px=1, )
def __init__(self, xx, yy, minimum=xp.nan, maximum=xp.nan, name=None, latex_label=None, unit=None, boundary=None): self.xx = xp.asarray(xx) self.min_limit = float(xp.amin(self.xx)) self.max_limit = float(xp.amax(self.xx)) # In order to use np/cp.interp, we need to make sure that xx is ordered sorted_idxs = xp.argsort(self.xx) self.xx = self.xx[sorted_idxs] self._yy = xp.asarray(yy)[sorted_idxs] if self._yy.ndim != 1: raise TypeError("yy must be 1D. A {}-D array given.".format( self.yy.dim)) self.YY = None self.probability_density = None self.cumulative_distribution = None self.inverse_cumulative_distribution = None self.__all_interpolated = Interp(self.xx, self._yy) minimum = float(xp.nanmax(xp.array([self.min_limit, minimum]))) maximum = float(xp.nanmin(xp.array([self.max_limit, maximum]))) bilby.core.prior.Prior.__init__(self, name=name, latex_label=latex_label, unit=unit, minimum=minimum, maximum=maximum, boundary=boundary) self._update_instance()
def _run_cupy_equal_interval(data, k): max_data = cupy.nanmax(data) min_data = cupy.nanmin(data) width = (max_data - min_data) / k cuts = cupy.arange(min_data.get() + width.get(), max_data.get() + width.get(), width.get()) l_cuts = cuts.shape[0] if l_cuts > k: # handle overshooting cuts = cuts[0:k] cuts[-1] = max_data out = _bin(data, cuts, cupy.arange(l_cuts)) return out
def viewInteractiveImage(x_range, y_range, w, h, data_source, **kwargs): dd = data_source[[self.x, self.y, self.aggregate_col]] dd[self.x] = self._to_xaxis_type(dd[self.x]) dd[self.y] = self._to_yaxis_type(dd[self.y]) x_range = self._to_xaxis_type(x_range) y_range = self._to_yaxis_type(y_range) cvs = ds.Canvas(plot_width=w, plot_height=h, x_range=x_range, y_range=y_range) aggregator, cmap = _compute_datashader_assets( dd, self.x, self.aggregate_col, self.aggregate_fn, self.color_palette, ) agg = cvs.points( dd, self.x, self.y, aggregator, ) if self.constant_limit is None or self.aggregate_fn == "count": self.constant_limit = [ float(cp.nanmin(agg.data)), float(cp.nanmax(agg.data)), ] self.render_legend() span = {"span": self.constant_limit} if self.pixel_shade_type == "eq_hist": span = {} img = tf.shade(agg, how=self.pixel_shade_type, **cmap, **span) if self.pixel_spread == "dynspread": return tf.dynspread( img, threshold=self.pixel_density, max_px=self.point_size, shape=self.point_shape, ) else: return tf.spread(img, px=self.point_size, shape=self.point_shape)
def nodes_plot(self, canvas, nodes, name=None): """ plot nodes(scatter) """ aggregator, cmap = _compute_datashader_assets( nodes, self.node_id, self.node_aggregate_col, self.node_aggregate_fn, self.node_color_palette, ) agg = canvas.points(nodes.sort_index(), self.node_x, self.node_y, aggregator) if (self.constant_limit_nodes is None or self.node_aggregate_fn == "count"): self.constant_limit_nodes = [ float(cp.nanmin(agg.data)), float(cp.nanmax(agg.data)), ] self.render_legend() span = {"span": self.constant_limit_nodes} if self.node_pixel_shade_type == "eq_hist": span = {} return getattr(tf, self.node_pixel_spread)( tf.shade(agg, how=self.node_pixel_shade_type, name=name, **cmap, **span), threshold=self.node_pixel_density, max_px=self.node_point_size, shape=self.node_point_shape, )