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,
)
