def test_colormapper_color_levels(self):
cmap = process_cmap('viridis', provider='bokeh')
img = Image(np.array([[0, 1], [2, 3]])).options(color_levels=5, cmap=cmap)
plot = bokeh_renderer.get_plot(img)
cmapper = plot.handles['color_mapper']
self.assertEqual(len(cmapper.palette), 5)
self.assertEqual(cmapper.palette, ['#440154', '#440255', '#440357', '#450558', '#45065A'])
def test_colormapper_color_levels(self):
cmap = process_cmap('viridis', provider='bokeh')
img = Image(np.array([[0, 1], [2, 3]])).options(color_levels=5, cmap=cmap)
plot = bokeh_renderer.get_plot(img)
cmapper = plot.handles['color_mapper']
self.assertEqual(len(cmapper.palette), 5)
self.assertEqual(cmapper.palette, ['#440154', '#440255', '#440357', '#450558', '#45065A'])
def __init__(self, **params):
super(AdhView, self).__init__(**params)
# initialize the boundary condition ui
self.bc_ui = BoundaryConditionsUI(
bound_cond=self.adh_mod.simulation.boundary_conditions)
self.meshes = None
if len(self.adh_mod.simulation.results.data_vars) != 0:
# set default values
self.param.selected_result.objects = self.adh_mod.simulation.results.data_vars
try:
self.selected_result = 'Depth'
except:
self.selected_result = set(
self.adh_mod.simulation.results.data_vars).pop()
self.param.selected_times.objects = self.adh_mod.mesh.current_sim.results[
self.selected_result].times.data
self.selected_times = set(self.adh_mod.mesh.current_sim.results[
self.selected_result].times.data).pop()
# set default colormap
self.cmap_opts.colormap = process_cmap('rainbow_r')
# set default wmts
self.adh_mod.wmts.source = gvts.tile_sources['EsriImagery']
def test_process_cmap_instance_mpl(self):
try:
from matplotlib.cm import get_cmap
except:
raise SkipError(
"Matplotlib needed to test matplotlib colormap instances")
cmap = get_cmap('Greys')
colors = process_cmap(cmap, 3)
self.assertEqual(colors, ['#ffffff', '#959595', '#000000'])
class ColormapOpts(param.Parameterized):
colormap = param.ObjectSelector(default=cc.coolwarm,
objects={
'Rainbow':
cc.rainbow,
'Rainbow Reverse':
process_cmap('rainbow_r'),
'Fire':
cc.fire,
'Fire Reverse':
process_cmap('fire_r'),
'Gray':
cc.gray,
'Gray Reverse':
process_cmap('gray_r'),
'CoolWarm':
cc.coolwarm,
'WarmCool':
process_cmap('coolwarm_r')
})
def test_hex_tiles_opts(self):
from holoviews.plotting.util import process_cmap
tiles = HexTiles([(0, 0), (0.5, 0.5), (-0.5, -0.5), (-0.4, -0.4)])
plot = mpl_renderer.get_plot(tiles)
args, style, _ = plot.get_data(tiles, {}, {})
self.assertEqual(args[0], tiles['x'])
self.assertEqual(args[1], tiles['y'])
self.assertEqual(args[2], np.ones(4))
cmap = style.pop('cmap')
self.assertEqual(style, {'reduce_C_function': np.sum,
'vmin': None, 'vmax': None,
'xscale': 'linear', 'yscale': 'linear',
'gridsize': 50, 'mincnt': None})
self.assertEqual(cmap.colors, process_cmap('viridis'))
def _updateConsensusRows(kmerDf, newClass=None):
cond = (kmerDf['id'].str.match('C[1-6]'))
numRows = len(kmerDf.loc[cond])
colors = process_cmap('glasbey_dark')[:numRows]
kmerDf = _updateClass(kmerDf, cond, newClass)
kmerDf.loc[cond, 'bSize'] = 10
kmerDf.loc[cond, 'mSize'] = 100
if (newClass is None):
kmerDf.loc[cond, 'color'] = colors
else:
kmerDf.loc[cond, 'color'] = '#d62728'
return kmerDf
def _updateAusRows(kmerDf, newClass=None):
cond = ((kmerDf['id'].str.contains('Australia'))
| (kmerDf['id'].str.contains('Sydney'))
| (kmerDf['dupId'].str.contains('Australia'))
| (kmerDf['dupId'].str.contains('Sydney')))
numRows = len(kmerDf.loc[cond])
colors = process_cmap('glasbey_dark')[:numRows]
kmerDf = _updateClass(kmerDf, cond, newClass)
kmerDf.loc[cond, 'bSize'] = 10
kmerDf.loc[cond, 'mSize'] = 100
if (newClass is None):
kmerDf.loc[cond, 'color'] = colors
else:
kmerDf.loc[cond, 'color'] = '#1f77b4'
return kmerDf
def test_hex_tiles_opts(self):
from holoviews.plotting.util import process_cmap
tiles = HexTiles([(0, 0), (0.5, 0.5), (-0.5, -0.5), (-0.4, -0.4)])
plot = mpl_renderer.get_plot(tiles)
args, style, _ = plot.get_data(tiles, {}, {})
self.assertEqual(args[0], tiles['x'])
self.assertEqual(args[1], tiles['y'])
self.assertEqual(args[2], np.ones(4))
cmap = style.pop('cmap')
self.assertEqual(
style, {
'reduce_C_function': np.sum,
'vmin': None,
'vmax': None,
'xscale': 'linear',
'yscale': 'linear',
'gridsize': 50,
'mincnt': None
})
self.assertEqual(cmap.colors, process_cmap('viridis'))
def _updateRecombinationRows(kmerDf, newClass=None):
cond = ((kmerDf['id'].str.contains('Korea/KCDC05'))
| (kmerDf['id'].str.contains('Chongqing/IVDC-CQ-001'))
| (kmerDf['id'].str.contains('Italy/INMI1-cs'))
| (kmerDf['dupId'].str.contains('Korea/KCDC05'))
| (kmerDf['dupId'].str.contains('Chongqing/IVDC-CQ-001'))
| (kmerDf['dupId'].str.contains('Italy/INMI1-cs')))
numRows = len(kmerDf.loc[cond])
colors = set(process_cmap('glasbey_warm'))[:numRows]
kmerDf = _updateClass(kmerDf, cond, newClass)
kmerDf.loc[cond, 'bSize'] = 10
kmerDf.loc[cond, 'mSize'] = 100
if (newClass is None):
kmerDf.loc[cond, 'color'] = colors
else:
kmerDf.loc[cond, 'color'] = '#ce6dbd'
return kmerDf
def _updateAnimalModelRows(kmerDf, newClass=None):
cond = ((kmerDf['id'].str.contains('Australia/VIC01'))
| (kmerDf['id'].str.contains('BetaCoV_France_IDF0372_2020_C2'))
| (kmerDf['id'].str.contains('Canada/ON-VIDO-01'))
| (kmerDf['id'].str.contains('Germany/BavPat1'))
| (kmerDf['id'].str.contains('USA/WA1'))
| (kmerDf['dupId'].str.contains('Australia/VIC01'))
| (kmerDf['dupId'].str.contains('BetaCoV_France_IDF0372_2020_C2'))
| (kmerDf['dupId'].str.contains('Canada/ON-VIDO-01'))
| (kmerDf['dupId'].str.contains('Germany/BavPat1'))
| (kmerDf['dupId'].str.contains('USA/WA1')))
numRows = len(kmerDf.loc[cond])
colors = set(process_cmap('glasbey_cool'))[:numRows]
kmerDf = _updateClass(kmerDf, cond, newClass)
kmerDf.loc[cond, 'bSize'] = 10
kmerDf.loc[cond, 'mSize'] = 100
if (newClass is None):
kmerDf.loc[cond, 'color'] = colors
else:
kmerDf.loc[cond, 'color'] = '#2ca02c'
return kmerDf
def test_bokeh_colormap_fire_r(self):
colors = process_cmap('fire_r', 3, provider='bokeh')
self.assertEqual(colors, ['#ffffff', '#ed1400', '#000000'])
def test_mpl_colormap_fire_r(self):
colors = process_cmap('fire_r', 3, provider='matplotlib')
self.assertEqual(colors, ['#ffffff', '#eb1300', '#000000'])
def test_process_cmap_bokeh(self):
colors = process_cmap('Category20', 3)
self.assertEqual(colors, ['#1f77b4', '#aec7e8', '#ff7f0e'])
hv.output(dpi=300, size=100)
doc = curdoc() # DOC for Bokeh Objects
# DATA SOURCE
source = 'tcp://10.253.0.142:6666' # LIVE
#~ source = 'tcp://127.0.0.1:8010' # emulated live
tof_in_stream = True
pnCCD_in_stream = True
gmd_in_stream = True
two_monitors = False
img_downscale = 30
#~ colormap_pnCCD = 'Plasma'
#~ colormap_pnCCD = process_cmap('rainbow',provider='colorcet')
colormap_pnCCD = process_cmap('jet', provider='matplotlib')
pnCCD_color_lower_z_lim = 0.02 #0.02
pnCCD_color_upper_z_lim = 16 #5
pnCCDavg_color_lower_z_lim = 0.005 #0.005
pnCCDavg_color_upper_z_lim = 16 #2
makeBigData_stop = False
# DATA CONFIG
N_datapts = 31000 # total number of TOF datapoints that are visualized
start_tof = 59000 # index of first TOF datapoint considered
single_photon_adu = 250
background_pnCCD = np.zeros(shape=(1024, 1024))
background_max_pnCCD = np.zeros(shape=(1024, 1024))
dark_pnCCD = np.zeros(shape=(1024, 1024))
get_background_pnCCD = False
get_background_max_pnCCD = False
def test_process_cmap_mpl(self):
colors = process_cmap('Greys', 3)
self.assertEqual(colors, ['#ffffff', '#959595', '#000000'])
def test_process_cmap_cycle(self):
colors = process_cmap(Cycle(values=['#ffffff', '#959595', '#000000']), 4)
self.assertEqual(colors, ['#ffffff', '#959595', '#000000', '#ffffff'])
def test_mpl_colormap_instance(self):
from matplotlib.cm import get_cmap
cmap = get_cmap('Greys')
colors = process_cmap(cmap, 3)
self.assertEqual(colors, ['#ffffff', '#959595', '#000000'])
def test_process_cmap_invalid_type(self):
with self.assertRaises(TypeError):
process_cmap({'A', 'B', 'C'}, 3)
def view(self):
if self.lsd is None:
return panel.pane.Markdown("No data selected.")
try:
if self.intercylinder_only:
name = "ringmap_intercyl"
else:
name = "ringmap"
container = self.data.load_file(self.revision, self.lsd, name)
except DataError as err:
return panel.pane.Markdown(
f"Error: {str(err)}. Please report this problem."
)
# Index map for ra (x-axis)
index_map_ra = container.index_map["ra"]
axis_name_ra = "RA [degrees]"
# Index map for sin(ZA)/sin(theta) (y-axis)
index_map_el = container.index_map["el"]
axis_name_el = "sin(\u03B8)"
# Apply data selections
sel_beam = np.where(container.index_map["beam"] == self.beam)[0]
sel_freq = np.where(
[f[0] for f in container.index_map["freq"]] == self.frequency
)[0]
if self.polarization == self.mean_pol_text:
sel_pol = np.where(
(container.index_map["pol"] == "XX")
| (container.index_map["pol"] == "YY")
)[0]
rmap = np.squeeze(container.map[sel_beam, sel_pol, sel_freq])
rmap = np.nanmean(rmap, axis=0)
else:
sel_pol = np.where(container.index_map["pol"] == self.polarization)[0]
rmap = np.squeeze(container.map[sel_beam, sel_pol, sel_freq])
if self.flag_mask:
rmap = np.where(self._flags_mask(container.index_map["ra"]), np.nan, rmap)
if self.weight_mask:
try:
rms = np.squeeze(container.rms[sel_pol, sel_freq])
except IndexError:
logger.error(
f"rms dataset of ringmap file for rev {self.revision} lsd "
f"{self.lsd} is missing [{sel_pol}, {sel_freq}] (polarization, "
f"frequency). rms has shape {container.rms.shape}"
)
self.weight_mask = False
else:
rmap = np.where(self._weights_mask(rms), np.nan, rmap)
# Set flagged data to nan
rmap = np.where(rmap == 0, np.nan, rmap)
if self.crosstalk_removal:
# The mean of an all-nan slice (masked?) is nan. We don't need a warning about that.
with warnings.catch_warnings():
warnings.filterwarnings("ignore", r"All-NaN slice encountered")
rmap -= np.nanmedian(rmap, axis=0)
if self.template_subtraction:
try:
rm_stack = self.data.load_file_from_path(
self._stack_path, ccontainers.RingMap
)
except DataError as err:
return panel.pane.Markdown(
f"Error: {str(err)}. Please report this problem."
)
# The stack file has all polarizations, so we can't reuse sel_pol
if self.polarization == self.mean_pol_text:
stack_sel_pol = np.where(
(rm_stack.index_map["pol"] == "XX")
| (rm_stack.index_map["pol"] == "YY")
)[0]
else:
stack_sel_pol = np.where(
rm_stack.index_map["pol"] == self.polarization
)[0]
try:
rm_stack = np.squeeze(rm_stack.map[sel_beam, stack_sel_pol, sel_freq])
except IndexError as err:
logger.error(
f"map dataset of ringmap stack file "
f"is missing [{sel_beam}, {stack_sel_pol}, {sel_freq}] (beam, polarization, "
f"frequency). map has shape {rm_stack.map.shape}:\n{err}"
)
self.template_subtraction = False
else:
if self.polarization == self.mean_pol_text:
rm_stack = np.nanmean(rm_stack, axis=0)
# FIXME: this is a hack. remove when rinmap stack file fixed.
rmap -= rm_stack.reshape(rm_stack.shape[0], -1, 2).mean(axis=-1)
if self.transpose:
rmap = rmap.T
index_x = index_map_ra
index_y = index_map_el
axis_names = [axis_name_ra, axis_name_el]
xlim, ylim = self.ylim, self.xlim
else:
index_x = index_map_el
index_y = index_map_ra
axis_names = [axis_name_el, axis_name_ra]
xlim, ylim = self.xlim, self.ylim
img = hv.Image(
(index_x, index_y, rmap),
datatype=["image", "grid"],
kdims=axis_names,
).opts(
clim=self.colormap_range,
logz=self.logarithmic_colorscale,
cmap=process_cmap("inferno", provider="matplotlib"),
colorbar=True,
xlim=xlim,
ylim=ylim,
)
if self.serverside_rendering is not None:
# set colormap
cmap_inferno = copy.copy(matplotlib_cm.get_cmap("inferno"))
cmap_inferno.set_under("black")
cmap_inferno.set_bad("lightgray")
# Set z-axis normalization (other possible values are 'eq_hist', 'cbrt').
if self.logarithmic_colorscale:
normalization = "log"
else:
normalization = "linear"
# datashade/rasterize the image
img = self.serverside_rendering(
img,
cmap=cmap_inferno,
precompute=True,
x_range=xlim,
y_range=ylim,
normalization=normalization,
)
if self.mark_moon:
# Put a ring around the location of the moon if it transits on this day
eph = skyfield_wrapper.ephemeris
# Start and end times of the CSD
st = csd_to_unix(self.lsd.lsd)
et = csd_to_unix(self.lsd.lsd + 1)
moon_time, moon_dec = chime.transit_times(
eph["moon"], st, et, return_dec=True
)
if len(moon_time):
lunar_transit = unix_to_csd(moon_time[0])
lunar_dec = moon_dec[0]
lunar_ra = (lunar_transit % 1) * 360.0
lunar_za = np.sin(np.radians(lunar_dec - 49.0))
if self.transpose:
img *= hv.Ellipse(lunar_ra, lunar_za, (5.5, 0.15))
else:
img *= hv.Ellipse(lunar_za, lunar_ra, (0.04, 21))
if self.mark_day_time:
# Calculate the sun rise/set times on this sidereal day
# Start and end times of the CSD
start_time = csd_to_unix(self.lsd.lsd)
end_time = csd_to_unix(self.lsd.lsd + 1)
times, rises = chime.rise_set_times(
skyfield_wrapper.ephemeris["sun"],
start_time,
end_time,
diameter=-10,
)
sun_rise = 0
sun_set = 0
for t, r in zip(times, rises):
if r:
sun_rise = (unix_to_csd(t) % 1) * 360
else:
sun_set = (unix_to_csd(t) % 1) * 360
# Highlight the day time data
opts = {
"color": "grey",
"alpha": 0.5,
"line_width": 1,
"line_color": "black",
"line_dash": "dashed",
}
if self.transpose:
if sun_rise < sun_set:
img *= hv.VSpan(sun_rise, sun_set).opts(**opts)
else:
img *= hv.VSpan(self.ylim[0], sun_set).opts(**opts)
img *= hv.VSpan(sun_rise, self.ylim[1]).opts(**opts)
else:
if sun_rise < sun_set:
img *= hv.HSpan(sun_rise, sun_set).opts(**opts)
else:
img *= hv.HSpan(self.ylim[0], sun_set).opts(**opts)
img *= hv.HSpan(sun_rise, self.ylim[1]).opts(**opts)
img.opts(
# Fix height, but make width responsive
height=self.height,
responsive=True,
shared_axes=True,
bgcolor="lightgray",
)
return panel.Row(img, width_policy="max")
def __call__(self, dset, **params):
self.p = ParamOverrides(self, params)
if self.p.xdim not in dset.dimensions():
raise ValueError("{} not in Dataset.".format(self.p.xdim))
if self.p.ydim not in dset.dimensions():
raise ValueError("{} not in Dataset.".format(self.p.ydim))
if ("ra" not in dset.dimensions()) or ("dec" not in dset.dimensions()):
raise ValueError("ra and/or dec not in Dataset.")
# Compute sampling
ra_range = (ra0, ra1) = dset.range("ra")
if self.p.ra_sampling:
ra_sampling = (ra1 - ra0) / self.p.x_sampling
else:
ra_sampling = None
dec_range = (dec0, dec1) = dset.range("dec")
if self.p.dec_sampling:
dec_sampling = (dec1 - dec0) / self.p.y_sampling
else:
dec_sampling = None
x_range = (x0, x1) = dset.range(self.p.xdim)
if self.p.x_sampling:
x_sampling = (x1 - x0) / self.p.x_sampling
else:
x_sampling = None
y_range = (y0, y1) = dset.range(self.p.ydim)
if self.p.y_sampling:
y_sampling = (y1 - y0) / self.p.y_sampling
else:
y_sampling = None
# Set up scatter plot
scatter_range = RangeXY()
if self.p.scatter_range_stream:
def redim_scatter(dset, x_range, y_range):
ranges = {}
if x_range and all(isfinite(v) for v in x_range):
ranges[self.p.xdim] = x_range
if y_range and all(isfinite(v) for v in x_range):
ranges[self.p.ydim] = y_range
return dset.redim.range(**ranges) if ranges else dset
dset_scatter = dset.apply(redim_scatter,
streams=[self.p.scatter_range_stream])
link_streams(self.p.scatter_range_stream, scatter_range)
else:
dset_scatter = dset
scatter_pts = dset_scatter.apply(filterpoints,
streams=[self.p.filter_stream],
xdim=self.p.xdim,
ydim=self.p.ydim)
scatter_streams = [scatter_range, PlotSize()]
scatter_rasterize = rasterize.instance(streams=scatter_streams,
x_sampling=x_sampling,
y_sampling=y_sampling)
cmap = (process_cmap(self.p.scatter_cmap)[:250]
if self.p.scatter_cmap == "fire" else self.p.scatter_cmap)
scatter_rasterized = apply_when(
scatter_pts,
operation=scatter_rasterize,
predicate=lambda pts: len(pts) > self.p.max_points
).opts(
opts.Image(clim=(1, np.nan),
clipping_colors={"min": "transparent"},
cmap=cmap),
opts.Points(clim=(1, np.nan),
clipping_colors={"min": "transparent"},
cmap=cmap),
opts.Overlay(
hooks=[partial(reset_hook, x_range=x_range, y_range=y_range)]),
)
# Set up sky plot
sky_range = RangeXY()
if self.p.sky_range_stream:
def redim_sky(dset, x_range, y_range):
ranges = {}
if x_range and all(isfinite(v) for v in x_range):
ranges["ra"] = x_range
if y_range and all(isfinite(v) for v in x_range):
ranges["dec"] = y_range
return dset.redim.range(**ranges) if ranges else dset
dset_sky = dset.apply(redim_sky, streams=[self.p.sky_range_stream])
link_streams(self.p.sky_range_stream, sky_range)
else:
dset_sky = dset
sky_pts = dset_sky.apply(filterpoints,
xdim="ra",
ydim="dec",
set_title=False,
streams=[self.p.filter_stream])
skyplot_streams = [sky_range, PlotSize()]
sky_rasterize = rasterize.instance(
aggregator=ds.mean(self.p.ydim),
streams=skyplot_streams,
x_sampling=ra_sampling,
y_sampling=dec_sampling,
)
sky_rasterized = apply_when(
sky_pts,
operation=sky_rasterize,
predicate=lambda pts: len(pts) > self.p.max_points).opts(
opts.Image(bgcolor="black",
cmap=self.p.sky_cmap,
symmetric=True),
opts.Points(bgcolor="black",
cmap=self.p.sky_cmap,
symmetric=True),
opts.Overlay(hooks=[
partial(reset_hook, x_range=ra_range, y_range=dec_range)
]),
)
# Set up BoundsXY streams to listen to box_select events and notify FilterStream
scatter_select = BoundsXY(source=scatter_pts)
scatter_notifier = partial(notify_stream,
filter_stream=self.p.filter_stream,
xdim=self.p.xdim,
ydim=self.p.ydim)
scatter_select.add_subscriber(scatter_notifier)
sky_select = BoundsXY(source=sky_pts)
sky_notifier = partial(notify_stream,
filter_stream=self.p.filter_stream,
xdim="ra",
ydim="dec")
sky_select.add_subscriber(sky_notifier)
# Reset
reset = PlotReset(source=sky_pts)
reset.add_subscriber(
partial(reset_stream, self.p.filter_stream,
[self.p.sky_range_stream, self.p.scatter_range_stream]))
raw_scatterpts = filterpoints(dset, xdim=self.p.xdim, ydim=self.p.ydim)
raw_scatter = datashade(
raw_scatterpts,
cmap=list(Greys9[::-1][:5]),
streams=scatter_streams,
x_sampling=x_sampling,
y_sampling=y_sampling,
)
scatter_p = raw_scatter * scatter_rasterized
if self.p.show_rawsky:
raw_skypts = filterpoints(dset, xdim=self.p.xdim, ydim=self.p.ydim)
raw_sky = datashade(
rawskypts,
cmap=list(Greys9[::-1][:5]),
streams=skyplot_streams,
x_sampling=ra_sampling,
y_sampling=dec_sampling,
)
sky_p = raw_sky * sky_rasterized
else:
sky_p = sky_rasterized
if self.p.show_table:
table = dset.apply(summary_table,
ydim=self.p.ydim,
streams=[self.p.filter_stream])
table = table.opts()
layout = table + scatter_p + sky_p
else:
layout = (scatter_p + sky_p).opts(sizing_mode="stretch_width")
return layout.opts(
opts.Image(colorbar=True,
responsive=True,
tools=["box_select", "hover"]),
opts.Layout(sizing_mode="stretch_width"),
opts.Points(color=self.p.ydim, tools=["hover"]),
opts.RGB(alpha=0.5),
opts.Table(width=200),
)
def hex_list(self):
if self._name is not None:
return process_cmap(self._name)
else:
return None
def test_process_cmap_list_cycle(self):
colors = process_cmap(['#ffffff', '#959595', '#000000'], 4)
self.assertEqual(colors, ['#ffffff', '#959595', '#000000', '#ffffff'])
def main(args=None):
args = parse_arguments().parse_args(args)
# if args.threads <= 4:
# log.error('')
# exit(1)
outputFolder = os.path.dirname(os.path.abspath(args.outFileName)) + '/'
raw_file_name = os.path.splitext(os.path.basename(args.outFileName))[0]
if args.numberOfNearestNeighbors is None:
cooler_obj = cooler.Cooler(args.matrix)
args.numberOfNearestNeighbors = int(cooler_obj.info['ncells'])
if args.cell_coloring_type:
cell_name_cell_type_dict = {}
cell_type_color_dict = {}
color_cell_type_dict = {}
cell_type_counter = 0
with open(args.cell_coloring_type, 'r') as file:
for i, line in enumerate(file.readlines()):
line = line.strip()
try:
cell_name, cell_type = line.split('\t')
except Exception:
cell_name, cell_type = line.split(' ')
cell_name_cell_type_dict[cell_name] = cell_type
if cell_type not in cell_type_color_dict:
cell_type_color_dict[cell_type] = cell_type_counter
color_cell_type_dict[cell_type_counter] = cell_type
cell_type_counter += 1
if args.cell_coloring_batch:
cell_name_cell_type_dict_batch = {}
cell_type_color_dict_batch = {}
color_cell_type_dict_batch = {}
cell_type_counter_batch = 0
with open(args.cell_coloring_batch, 'r') as file:
for i, line in enumerate(file.readlines()):
line = line.strip()
try:
cell_name, cell_type = line.split('\t')
except Exception:
cell_name, cell_type = line.split(' ')
cell_name_cell_type_dict_batch[cell_name] = cell_type
if cell_type not in cell_type_color_dict_batch:
cell_type_color_dict_batch[cell_type] = cell_type_counter_batch
color_cell_type_dict_batch[cell_type_counter_batch] = cell_type
cell_type_counter_batch += 1
if args.clusterMethod == 'spectral':
cluster_object = SpectralClustering(n_clusters=args.numberOfClusters, affinity='nearest_neighbors', n_jobs=args.threads, random_state=0)
elif args.clusterMethod == 'kmeans':
cluster_object = KMeans(n_clusters=args.numberOfClusters, random_state=0, n_jobs=args.threads, precompute_distances=True)
elif args.clusterMethod.startswith('agglomerative'):
for linkage in ['ward', 'complete', 'average', 'single']:
if linkage in args.clusterMethod:
cluster_object = AgglomerativeClustering(n_clusters=args.numberOfClusters, linkage=linkage)
break
elif args.clusterMethod == 'birch':
cluster_object = Birch(n_clusters=args.numberOfClusters)
else:
log.error('No valid cluster method given: {}'.format(args.clusterMethod))
umap_params_dict = {}
if not args.noUMAP:
for param in vars(args):
if 'umap_' in param:
umap_params_dict[param] = vars(args)[param]
umap_params_dict['umap_random'] = 42
# log.debug(umap_params_dict)
if args.saveMemory:
matrices_list = cell_name_list(args.matrix)
max_nnz = 0
for matrix in matrices_list:
cooler_obj = cooler.Cooler(args.matrix + '::' + matrix)
nnz = cooler_obj.info['nnz']
if max_nnz < nnz:
max_nnz = nnz
minHash_object = None
matricesPerRun = int(len(matrices_list) * args.shareOfMatrixToBeTransferred)
if matricesPerRun < 1:
matricesPerRun = 1
chromosome_indices = None
if args.intraChromosomalContactsOnly:
cooler_obj = cooler.Cooler(args.matrix + '::' + matrices_list[0])
binsDataFrame = cooler_obj.bins()[:]
chromosome_indices = {}
for chromosome in cooler_obj.chromnames:
chromosome_indices[chromosome] = np.array(binsDataFrame.index[binsDataFrame['chrom'] == chromosome].tolist())
for j, i in enumerate(range(0, len(matrices_list), matricesPerRun)):
if i < len(matrices_list) - 1:
matrices_share = matrices_list[i:i + matricesPerRun]
else:
matrices_share = matrices_list[i:]
neighborhood_matrix, matrices_list_share = open_and_store_matrix(args.matrix, matrices_share, 0, len(matrices_share),
args.chromosomes, args.intraChromosomalContactsOnly, chromosome_indices)
if minHash_object is None:
minHash_object = MinHash(n_neighbors=args.numberOfNearestNeighbors, number_of_hash_functions=args.numberOfHashFunctions, number_of_cores=args.threads,
shingle_size=0, fast=args.euclideanModeMinHash, maxFeatures=int(max_nnz), absolute_numbers=False)
if j == 0:
minHash_object.fit(neighborhood_matrix)
else:
minHash_object.partial_fit(X=neighborhood_matrix)
precomputed_graph = minHash_object.kneighbors_graph(mode='distance')
precomputed_graph = np.nan_to_num(precomputed_graph)
precomputed_graph.data[np.isinf(precomputed_graph.data)] = 0
if not args.noPCA:
pca = PCA(n_components=min(precomputed_graph.shape) - 1)
precomputed_graph = np.nan_to_num(precomputed_graph.todense())
precomputed_graph[np.isinf(precomputed_graph)] = 0
precomputed_graph = pca.fit_transform(precomputed_graph)
if args.dimensionsPCA:
args.dimensionsPCA = min(args.dimensionsPCA, precomputed_graph.shape[0])
precomputed_graph = precomputed_graph[:, :args.dimensionsPCA]
# cluster_object.fit(precomputed_graph[:, :args.dimensionsPCA])
if not args.noUMAP:
if umap_params_dict is None:
reducer = umap.UMAP()
else:
reducer = umap.UMAP(n_neighbors=umap_params_dict['umap_n_neighbors'], n_components=umap_params_dict['umap_n_components'], metric=umap_params_dict['umap_metric'],
n_epochs=umap_params_dict['umap_n_epochs'],
learning_rate=umap_params_dict['umap_learning_rate'], init=umap_params_dict['umap_init'], min_dist=umap_params_dict['umap_min_dist'], spread=umap_params_dict['umap_spread'],
set_op_mix_ratio=umap_params_dict['umap_set_op_mix_ratio'], local_connectivity=umap_params_dict['umap_local_connectivity'],
repulsion_strength=umap_params_dict['umap_repulsion_strength'], negative_sample_rate=umap_params_dict['umap_negative_sample_rate'], transform_queue_size=umap_params_dict['umap_transform_queue_size'],
a=umap_params_dict['umap_a'], b=umap_params_dict['umap_b'], angular_rp_forest=umap_params_dict['umap_angular_rp_forest'],
target_n_neighbors=umap_params_dict['umap_target_n_neighbors'], target_metric=umap_params_dict['umap_target_metric'],
target_weight=umap_params_dict['umap_target_weight'], random_state=umap_params_dict['umap_random'],
force_approximation_algorithm=umap_params_dict['umap_force_approximation_algorithm'], verbose=umap_params_dict['umap_verbose'], unique=umap_params_dict['umap_unique'])
precomputed_graph = reducer.fit_transform(precomputed_graph)
precomputed_graph = np.nan_to_num(precomputed_graph)
precomputed_graph[np.isinf(precomputed_graph)] = 0
try:
cluster_object.fit(precomputed_graph)
except Exception:
cluster_object.fit(precomputed_graph.todense())
minHashClustering = MinHashClustering(minHashObject=minHash_object, clusteringObject=cluster_object)
minHashClustering._precomputed_graph = precomputed_graph
else:
neighborhood_matrix, matrices_list = create_csr_matrix_all_cells(args.matrix, args.threads, args.chromosomes, outputFolder, raw_file_name, args.intraChromosomalContactsOnly, pDistance=args.distance)
if args.saveIntermediateRawMatrix:
save_npz(args.saveIntermediateRawMatrix, neighborhood_matrix)
if not args.saveMemory:
minHash_object = MinHash(n_neighbors=args.numberOfNearestNeighbors, number_of_hash_functions=args.numberOfHashFunctions, number_of_cores=args.threads,
shingle_size=5, fast=args.euclideanModeMinHash, maxFeatures=int(max(neighborhood_matrix.getnnz(1))), absolute_numbers=False, max_bin_size=100000,
minimal_blocks_in_common=100, excess_factor=1, prune_inverse_index=False)
minHashClustering = MinHashClustering(minHashObject=minHash_object, clusteringObject=cluster_object)
minHashClustering.fit(X=neighborhood_matrix, pSaveMemory=args.shareOfMatrixToBeTransferred, pPca=(not args.noPCA), pPcaDimensions=args.dimensionsPCA, pUmap=(not args.noUMAP), pUmapDict=umap_params_dict)
if args.noPCA and args.noUMAP:
mask = np.isnan(minHashClustering._precomputed_graph.data)
minHashClustering._precomputed_graph.data[mask] = 0
mask = np.isinf(minHashClustering._precomputed_graph.data)
minHashClustering._precomputed_graph.data[mask] = 0
labels_clustering = minHashClustering.predict(minHashClustering._precomputed_graph, pPca=args.noPCA, pPcaDimensions=args.dimensionsPCA)
if args.createScatterPlot:
if args.noPCA and args.noUMAP:
pca = PCA(n_components=min(minHashClustering._precomputed_graph.shape) - 1)
neighborhood_matrix_knn = pca.fit_transform(minHashClustering._precomputed_graph.todense())
else:
neighborhood_matrix_knn = minHashClustering._precomputed_graph
list(set(labels_clustering))
colors = process_cmap(args.colorMap)
try:
neighborhood_matrix_knn = neighborhood_matrix_knn.toarray()
except Exception:
pass
label_x = 'PC1'
label_y = 'PC2'
if not (args.noUMAP):
label_x = 'UMAP1'
label_y = 'UMAP2'
if args.cell_coloring_type:
if len(colors) < len(cell_type_color_dict):
log.error('The chosen colormap offers too less values for the number of clusters.')
exit(1)
labels_clustering_cell_type = []
for cell_name in matrices_list:
labels_clustering_cell_type.append(cell_type_color_dict[cell_name_cell_type_dict[cell_name]])
labels_clustering_cell_type = np.array(labels_clustering_cell_type)
log.debug('labels_clustering_cell_type: {}'.format(len(labels_clustering_cell_type)))
log.debug('matrices_list: {}'.format(len(matrices_list)))
plt.figure(figsize=(args.figuresize[0], args.figuresize[1]))
for i, color in enumerate(colors[:len(cell_type_color_dict)]):
mask = labels_clustering_cell_type == i
log.debug('plot cluster: {} {}'.format(color_cell_type_dict[i], np.sum(mask)))
plt.scatter(neighborhood_matrix_knn[:, 0].T[mask], neighborhood_matrix_knn[:, 1].T[mask], color=color, label=str(color_cell_type_dict[i]), s=20, alpha=0.7)
plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', fontsize=args.fontsize)
plt.xticks([])
plt.yticks([])
plt.xlabel(label_x, fontsize=args.fontsize)
plt.ylabel(label_y, fontsize=args.fontsize)
if '.' not in args.createScatterPlot:
args.createScatterPlot += '.png'
scatter_plot_name = '.'.join(args.createScatterPlot.split('.')[:-1]) + '_cell_color.' + args.createScatterPlot.split('.')[-1]
plt.tight_layout()
plt.savefig(scatter_plot_name, dpi=args.dpi)
plt.close()
# compute overlap of cell_type find found clusters
computed_clusters = set(labels_clustering)
cell_type_amounts_dict = {}
percentage_threshold = 0.8
if args.latexTable:
for threshold in [0.7, 0.8, 0.9]:
cell_type_amounts_dict[threshold] = {}
with open(args.latexTable, 'w') as matches_file:
header = '\\begin{table}[!htb]\n\\footnotesize\n\\begin{tabular}{|l'
body = '\\hline Cluster '
for i in range(len(color_cell_type_dict)):
mask_cell_type = labels_clustering_cell_type == i
header += '|c'
body += '& ' + str(color_cell_type_dict[i]) + ' (' + str(np.sum(mask_cell_type)) + ' cells)'
header += '|}\n'
body += '\\\\\n'
# body = ''
for i in computed_clusters:
body += '\\hline Cluster ' + str(i)
mask_computed_clusters = labels_clustering == i
body += ' (' + str(np.sum(mask_computed_clusters)) + ' cells)'
for j in range(len(cell_type_color_dict)):
mask_cell_type = labels_clustering_cell_type == j
mask = mask_computed_clusters & mask_cell_type
number_of_matches = np.sum(mask)
body += '& ' + str(number_of_matches)
if number_of_matches != 1:
body += ' cells / '
else:
body += ' cell / '
body += '{:.2f}'.format((number_of_matches / np.sum(mask_computed_clusters)) * 100) + ' \\% '
for threshold in [0.7, 0.8, 0.9]:
if number_of_matches / np.sum(mask_computed_clusters) >= threshold:
if color_cell_type_dict[j] in cell_type_amounts_dict[threshold]:
cell_type_amounts_dict[threshold][color_cell_type_dict[j]] += number_of_matches
else:
cell_type_amounts_dict[threshold][color_cell_type_dict[j]] = number_of_matches
else:
if color_cell_type_dict[j] in cell_type_amounts_dict[threshold]:
continue
else:
cell_type_amounts_dict[threshold][color_cell_type_dict[j]] = 0
body += '\\\\\n'
body += '\\hline ' + '&' * len(cell_type_color_dict) + '\\\\\n'
for threshold in [0.7, 0.8, 0.9]:
body += '\\hline Correct identified $>{}\\%$'.format(int(threshold * 100))
for i in range(len(cell_type_color_dict)):
mask_cell_type = labels_clustering_cell_type == i
if color_cell_type_dict[i] in cell_type_amounts_dict[threshold]:
body += '& ' + str(cell_type_amounts_dict[threshold][color_cell_type_dict[i]]) + ' / ' + str(np.sum(mask_cell_type)) + ' ('
body += '{:.2f}'.format((cell_type_amounts_dict[threshold][color_cell_type_dict[i]] / np.sum(mask_cell_type)) * 100)
else:
body += '& ' + str(0) + ' / ' + str(np.sum(mask_cell_type)) + ' ('
body += '{:.2f}'.format(0 / np.sum(mask_cell_type))
body += ' \\%)'
body += '\\\\\n'
body += '\\hline \n'
body += '\\end{tabular}\n\\caption{}\n\\end{table}'
matches_file.write(header)
matches_file.write(body)
else:
with open('matches.txt', 'w') as matches_file:
for i in computed_clusters:
mask_computed_clusters = labels_clustering == i
for j in range(len(cell_type_color_dict)):
mask_cell_type = labels_clustering_cell_type == j
mask = mask_computed_clusters & mask_cell_type
number_of_matches = np.sum(mask)
matches_file.write('Computed cluster {} (size: {}) matching with cell type {} (size: {}) {} times. Rate (matches/computed_clusters): {}%\n'.format(
i, np.sum(mask_computed_clusters), color_cell_type_dict[j], np.sum(mask_cell_type), number_of_matches, number_of_matches / np.sum(mask_computed_clusters)))
if number_of_matches / np.sum(mask_computed_clusters) >= percentage_threshold:
if color_cell_type_dict[j] in cell_type_amounts_dict:
cell_type_amounts_dict[color_cell_type_dict[j]] += number_of_matches
else:
cell_type_amounts_dict[color_cell_type_dict[j]] = number_of_matches
matches_file.write('\n')
all_detected = 0
all_possible = 0
for i in range(len(cell_type_color_dict)):
mask_cell_type = labels_clustering_cell_type == i
all_possible += np.sum(mask_cell_type)
if color_cell_type_dict[i] in cell_type_amounts_dict:
all_detected += cell_type_amounts_dict[color_cell_type_dict[i]]
cell_type_amounts_dict[color_cell_type_dict[i]] /= np.sum(mask_cell_type)
else:
cell_type_amounts_dict[color_cell_type_dict[i]] = 0.0
correct_associated = 0.0
for cell_iterator in cell_type_color_dict:
correct_associated += cell_type_amounts_dict[cell_iterator]
correct_associated /= len(cell_type_amounts_dict)
# all_detected /= all_possible
# correct_associated = ((correct_associated*4) + (all_detected)) / 5
# correct_associated = correct_associated
with open('correct_associated', 'w') as file:
file.write(str(correct_associated))
if args.cell_coloring_batch:
if len(colors) < len(cell_type_color_dict_batch):
log.error('The chosen colormap offers too less values for the number of clusters.')
exit(1)
labels_clustering_cell_type_batch = []
for cell_name in matrices_list:
labels_clustering_cell_type_batch.append(cell_type_color_dict_batch[cell_name_cell_type_dict_batch[cell_name]])
labels_clustering_cell_type_batch = np.array(labels_clustering_cell_type_batch)
log.debug('labels_clustering_cell_type: {}'.format(len(labels_clustering_cell_type_batch)))
log.debug('matrices_list: {}'.format(len(matrices_list)))
plt.figure(figsize=(args.figuresize[0], args.figuresize[1]))
for i, color in enumerate(colors[:len(cell_type_color_dict_batch)]):
mask = labels_clustering_cell_type_batch == i
log.debug('plot cluster: {} {}'.format(color_cell_type_dict_batch[i], np.sum(mask)))
plt.scatter(neighborhood_matrix_knn[:, 0].T[mask], neighborhood_matrix_knn[:, 1].T[mask], color=color, label=str(color_cell_type_dict_batch[i]), s=20, alpha=0.7)
plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', fontsize=args.fontsize)
plt.xticks([])
plt.yticks([])
plt.xlabel(label_x, fontsize=args.fontsize)
plt.ylabel(label_y, fontsize=args.fontsize)
if '.' not in args.createScatterPlot:
args.createScatterPlot += '.png'
scatter_plot_name = '.'.join(args.createScatterPlot.split('.')[:-1]) + '_cell_color_batch.' + args.createScatterPlot.split('.')[-1]
plt.tight_layout()
plt.savefig(scatter_plot_name, dpi=args.dpi)
plt.close()
plt.figure(figsize=(args.figuresize[0], args.figuresize[1]))
for i, color in enumerate(colors[:args.numberOfClusters]):
mask = labels_clustering == i
plt.scatter(neighborhood_matrix_knn[:, 0].T[mask], neighborhood_matrix_knn[:, 1].T[mask], color=color, label=str(i), s=20, alpha=0.7)
plt.legend(fontsize=args.fontsize)
plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', fontsize=args.fontsize)
plt.xticks([])
plt.yticks([])
plt.xlabel(label_x, fontsize=args.fontsize)
plt.ylabel(label_y, fontsize=args.fontsize)
if '.' not in args.createScatterPlot:
args.createScatterPlot += '.png'
scatter_plot_name = '.'.join(args.createScatterPlot.split('.')[:-1]) + '.' + args.createScatterPlot.split('.')[-1]
plt.tight_layout()
plt.savefig(scatter_plot_name, dpi=args.dpi)
plt.close()
matrices_cluster = list(zip(matrices_list, labels_clustering))
np.savetxt(args.outFileName, matrices_cluster, fmt="%s")
def test_process_cmap_invalid_str(self):
with self.assertRaises(ValueError):
process_cmap('NonexistentColorMap', 3)
def _color(self):
return process_cmap(self.color_map, 1)[0]
def test_mpl_colormap_name_palette(self):
colors = process_cmap('Greys', 3)
self.assertEqual(colors, ['#ffffff', '#959595', '#000000'])
def __init__(self,
data,
x,
y,
kind=None,
by=None,
use_index=True,
group_label='Variable',
value_label='value',
backlog=1000,
persist=False,
use_dask=False,
crs=None,
fields={},
groupby=None,
dynamic=True,
width=700,
height=300,
shared_axes=True,
grid=False,
legend=True,
rot=None,
title=None,
xlim=None,
ylim=None,
clim=None,
xticks=None,
yticks=None,
logx=False,
logy=False,
loglog=False,
hover=True,
subplots=False,
label=None,
invert=False,
stacked=False,
colorbar=None,
fontsize=None,
colormap=None,
datashade=False,
rasterize=False,
row=None,
col=None,
figsize=None,
debug=False,
xaxis=True,
yaxis=True,
framewise=True,
aggregator=None,
projection=None,
global_extent=False,
geo=False,
precompute=False,
flip_xaxis=False,
flip_yaxis=False,
dynspread=False,
hover_cols=[],
x_sampling=None,
y_sampling=None,
**kwds):
# Process data and related options
self._process_data(kind, data, x, y, by, groupby, row, col, use_dask,
persist, backlog, label, value_label, hover_cols,
kwds)
self.use_index = use_index
self.value_label = value_label
self.group_label = group_label
self.dynamic = dynamic
self.geo = geo or crs or global_extent or projection
self.crs = process_crs(crs) if self.geo else None
self.row = row
self.col = col
# Operations
self.datashade = datashade
self.rasterize = rasterize
self.dynspread = dynspread
self.aggregator = aggregator
self.precompute = precompute
self.x_sampling = x_sampling
self.y_sampling = y_sampling
# By type
self.subplots = subplots
self._by_type = NdLayout if subplots else NdOverlay
# Process options
style_opts, plot_opts, kwds = self._process_style(colormap, kwds)
self.stacked = stacked
self.invert = invert
plot_opts['logx'] = logx or loglog
plot_opts['logy'] = logy or loglog
plot_opts['show_grid'] = grid
plot_opts['shared_axes'] = shared_axes
plot_opts['show_legend'] = legend
if xticks:
plot_opts['xticks'] = xticks
if yticks:
plot_opts['yticks'] = yticks
if not xaxis:
plot_opts['xaxis'] = None
if not yaxis:
plot_opts['yaxis'] = None
if flip_xaxis:
plot_opts['invert_xaxis'] = True
if flip_yaxis:
plot_opts['invert_yaxis'] = True
if width:
plot_opts['width'] = width
if height:
plot_opts['height'] = height
if fontsize:
plot_opts['fontsize'] = fontsize
if isinstance(colorbar, bool):
plot_opts['colorbar'] = colorbar
elif self.kind in self._colorbar_types:
plot_opts['colorbar'] = True
if invert:
plot_opts['invert_axes'] = kind != 'barh'
if rot:
axis = 'yrotation' if invert else 'xrotation'
plot_opts[axis] = rot
if hover:
plot_opts['tools'] = ['hover']
if self.crs and global_extent:
plot_opts['global_extent'] = global_extent
if projection:
plot_opts['projection'] = process_crs(projection)
plot_opts['legend_position'] = 'right'
if title is not None:
plot_opts['title_format'] = title
self._plot_opts = plot_opts
options = Store.options(backend='bokeh')
el_type = self._kind_mapping[self.kind].__name__
style = options[el_type].groups['style']
cycled_opts = [
k for k, v in style.kwargs.items() if isinstance(v, Cycle)
]
for opt in cycled_opts:
color = style_opts.get('color', None)
if color is None:
color = process_cmap(colormap or 'Category10',
categorical=True)
style_opts[opt] = Cycle(
values=color) if isinstance(color, list) else color
self._style_opts = style_opts
self._norm_opts = {'framewise': framewise, 'axiswise': not shared_axes}
self.kwds = kwds
# Process dimensions and labels
self.label = label
self._relabel = {'label': label} if label else {}
self._dim_ranges = {
'x': xlim or (None, None),
'y': ylim or (None, None),
'c': clim or (None, None)
}
self._redim = fields
# High-level options
self._validate_kwds(kwds)
if debug:
kwds = dict(x=self.x,
y=self.y,
by=self.by,
kind=self.kind,
groupby=self.groupby)
self.warning('Plotting {kind} plot with parameters x: {x}, '
'y: {y}, by: {by}, groupby: {groupby}'.format(**kwds))
"""
This file defines palettes used for EDA.
"""
# pylint: disable=no-name-in-module
from bokeh.palettes import Category20 # type: ignore
from holoviews.plotting.util import process_cmap
PALETTE = Category20[20]
BIPALETTE = list(reversed(process_cmap("RdBu")))
BRG = ["#1f78b4", "#d62728", "#2ca02c"]
def __call__(self, kind, x, y):
kind = self.kind or kind
method = getattr(self, kind)
groups = self.groupby
zs = self.kwds.get('z', [])
if not isinstance(zs, list): zs = [zs]
grid = []
if self.row: grid.append(self.row)
if self.col: grid.append(self.col)
groups += grid
if groups or len(zs) > 1:
if self.streaming:
raise NotImplementedError(
"Streaming and groupby not yet implemented")
data = self.data
if not self.gridded and any(g in self.indexes for g in groups):
data = data.reset_index()
dataset = Dataset(data)
if groups:
dataset = dataset.groupby(groups, dynamic=self.dynamic)
if len(zs) > 1:
dimensions = [Dimension(self.group_label, values=zs)
] + dataset.kdims
if self.dynamic:
obj = DynamicMap(
lambda *args: getattr(self, kind)
(x, y, args[0], dataset[args[1:]].data),
kdims=dimensions)
else:
obj = HoloMap(
{(z, ) + k: getattr(self, kind)(x, y, z,
dataset[k])
for k, v in dataset.data.items() for z in zs},
kdims=dimensions)
else:
obj = dataset.map(
lambda ds: getattr(self, kind)(x, y, data=ds.data),
Dataset)
elif len(zs) > 1:
if self.dynamic:
dataset = DynamicMap(
lambda z: getattr(self, kind)
(x, y, z, data=dataset.data),
kdims=[Dimension(self.group_label, values=zs)])
else:
dataset = HoloMap(
{
z: getattr(self, kind)(x, y, z, data=dataset.data)
for z in zs
},
kdims=[self.group_label])
else:
obj = getattr(self, kind)(x, y, data=dataset.data)
if grid:
obj = obj.grid(grid).options(shared_xaxis=True,
shared_yaxis=True)
else:
if self.streaming:
cbcallable = StreamingCallable(partial(method, x, y),
periodic=self.cb)
obj = DynamicMap(cbcallable, streams=[self.stream])
else:
obj = method(x, y)
if not (self.datashade or self.rasterize):
return obj
try:
from holoviews.operation.datashader import datashade, rasterize, dynspread
from datashader import count_cat
except:
raise ImportError('Datashading is not available')
opts = dict(width=self._plot_opts['width'],
height=self._plot_opts['height'],
dynamic=self.dynamic)
if 'cmap' in self._style_opts and self.datashade:
levels = self._plot_opts.get('color_levels')
opts['cmap'] = process_cmap(self._style_opts['cmap'], levels)
opts['color_key'] = opts['cmap']
if self.by:
opts['aggregator'] = count_cat(self.by[0])
if self.aggregator:
opts['aggregator'] = self.aggregator
if self.precompute:
opts['precompute'] = self.precompute
if self.x_sampling:
opts['x_sampling'] = self.x_sampling
if self.y_sampling:
opts['y_sampling'] = self.y_sampling
style = {}
if self.datashade:
operation = datashade
eltype = 'RGB'
else:
operation = rasterize
eltype = 'Image'
if 'cmap' in self._style_opts:
style['cmap'] = self._style_opts['cmap']
if self.crs:
# Apply projection before rasterizing
import cartopy.crs as ccrs
from geoviews import project
projection = self._plot_opts.get('projection',
ccrs.GOOGLE_MERCATOR)
obj = project(obj, projection=projection)
processed = operation(obj, **opts)
if self.dynspread:
if self.datashade:
processed = dynspread(processed,
max_px=self.kwds.get('max_px', 3),
threshold=self.kwds.get(
'threshold', 0.5))
else:
self.warning(
'dynspread may only be applied on datashaded plots, '
'use datashade=True instead of rasterize=True.')
return processed.opts(
{eltype: {
'plot': self._plot_opts,
'style': style
}})
get_background_pnCCD = True # Background for plottting: This uses an averaged background - mostly for plotting
get_background_max_pnCCD = True # Background for Hitfinder: This is the background for hitfinder only it should contain on each pixel the max value from background run
# DISPLAY SETTINGS
## set display frequency relative to analysis frequency --> display routine (update displayed plots) every xxth analyzed shot
### this is neccessary because you should do the next display update only when the last update completed, otherwise update can pile up, leading to slowdown and lag of display / tool
### typically displaying takes 5 to 7 analyzed shots which is why 9 or 10 might be a good value
oa_disp_mod = 9
## setting changes size of last 5 pnccd detected hits plots
large_monitor = True
## here you can select a colormap that will be used for all image plots
### you can find a selection of available colormaps online: holoviews.org/user_guide/Colormaps.html
### examples:
### colormap_pnCCD = 'Plasma'
### colormap_pnCCD = process_cmap('rainbow',provider='colorcet')
colormap_pnCCD = process_cmap('jet',
provider='matplotlib') # by default we use jet
######### PARAMETERS CALCULATED FROM USER PARAMETERS #########
# Initialize PNCCD Backgrounds
background_pnCCD = np.zeros(shape=(1024, 1024))
background_max_pnCCD = np.zeros(shape=(1024, 1024))
# Load Files into background arrays if background substraction was actived
if get_background_pnCCD:
background_pnCCD = np.load('background_pnCCD.npy')
if get_background_max_pnCCD:
background_max_pnCCD = np.load('background_max_pnCCD.npy')
# TOF Trace Config Values
end_tof = start_tof + N_datapts # index of last TOF datapoint considered
x_tof = np.arange(start_tof, end_tof) # x-axis for tof data points
# PNCCD Dimensions
pnccd_dims = [
# styling options
opts = {
'Image':
dict(height=80,
width=280,
xaxis=None,
yaxis=None,
toolbar=None,
border=14,
show_frame=False)
}
# create a plot of 4 uniform sequential colormaps
cms = filter_cmaps('Uniform Sequential')
cms = list(cms[i] for i in [0, 6, 12, 20]) # select 4 specific colormaps
hv_cmap = [hv.Image(spacing, ydensity=1, label="{0}".format(r.name)).options(cmap=process_cmap(r.name))\
.options(opts) for r in cms]
cmap_seq_viz = (hv_cmap[0] + hv_cmap[1] + hv_cmap[2] +
hv_cmap[3]).cols(2).options(toolbar=None)
# create a plot of 4 diverging colormaps
cms = filter_cmaps('Diverging')
cms = list(cms[i] for i in [4, 8, 14, 23])
hv_cmap = [hv.Image(spacing, ydensity=1, label="{0}".format(r.name)).options(cmap=process_cmap(r.name))\
.options(opts) for r in cms]
cmap_div_viz = (hv_cmap[0] + hv_cmap[1] + hv_cmap[2] +
hv_cmap[3]).cols(2).options(toolbar=None)
