def __call__(self, **params):
p = ParamOverrides(self, params)
measured_sheets = [s for s in topo.sim.objects(CFSheet).values()
if hasattr(s,'measure_maps') and s.measure_maps]
results = Layout()
# Could easily be extended to measure CoG of all projections
# and e.g. register them using different names (e.g. "Afferent
# XCoG"), but then it's not clear how the PlotGroup would be
# able to find them automatically (as it currently supports
# only a fixed-named plot).
requested_proj=p.proj_name
for sheet in measured_sheets:
for proj in sheet.in_connections:
if (proj.name == requested_proj) or \
(requested_proj == '' and (proj.src != sheet)):
cog_data = self._update_proj_cog(p, proj)
for key, data in cog_data.items():
name = proj.name[0].upper() + proj.name[1:]
results.set_path((key, name), data)
if p.measurement_storage_hook:
p.measurement_storage_hook(results)
return results
def __call__(self, **params):
p = ParamOverrides(self, params)
measured_sheets = [
s for s in topo.sim.objects(CFSheet).values()
if hasattr(s, 'measure_maps') and s.measure_maps
]
results = AttrTree()
# Could easily be extended to measure CoG of all projections
# and e.g. register them using different names (e.g. "Afferent
# XCoG"), but then it's not clear how the PlotGroup would be
# able to find them automatically (as it currently supports
# only a fixed-named plot).
requested_proj = p.proj_name
for sheet in measured_sheets:
for proj in sheet.in_connections:
if (proj.name == requested_proj) or \
(requested_proj == '' and (proj.src != sheet)):
cog_data = self._update_proj_cog(p, proj)
for key, data in cog_data.items():
name = proj.name[0].upper() + proj.name[1:]
results.set_path((key, name), data)
if p.measurement_storage_hook:
p.measurement_storage_hook(results)
return results
def __call__(self, **params):
p = ParamOverrides(self, params, allow_extra_keywords=True)
self._set_presenter_overrides(p)
results = {}
for coord in p.coords:
p.x = p.preference_lookup_fn('x', p.outputs[0], coord,
default=coord[0])
p.y = p.preference_lookup_fn('y', p.outputs[0], coord,
default=coord[1])
results[coord] = self._compute_curves(p)
self._restore_presenter_defaults()
return results
def __call__(self, dset, **params):
self.p = ParamOverrides(self, params)
if self.p.vdim is None:
vdim = dset.vdims[0].name
else:
vdim = self.p.vdim
pts = hv.util.Dynamic(dset, operation=skypoints,
streams=[self.p.filter_stream])
if self.p.aggregator == 'mean':
aggregator = ds.mean(vdim)
elif self.p.aggregator == 'std':
aggregator = ds.std(vdim)
elif self.p.aggregator == 'count':
aggregator = ds.count()
decimate_opts = dict(plot={'tools': ['hover',
'box_select']},
style={'alpha': 0,
'size': self.p.decimate_size,
'nonselection_alpha': 0})
decimated = decimate(pts).opts(**decimate_opts)
raster_ = rasterize(pts, aggregator=aggregator)
color_gadget = raster_.opts(cmap=Viridis[256], colorbar=True, alpha=0)
sky_shaded = shade(raster_, cmap=viridis)
plot = dynspread(sky_shaded) * decimated * color_gadget
return plot.options(bgcolor="black", responsive=True, min_height=100)
def __call__(self, **params):
p = ParamOverrides(self, params)
measured_sheets = [
s for s in topo.sim.objects(CFSheet).values()
if hasattr(s, 'measure_maps') and s.measure_maps
]
results = {}
# Could easily be extended to measure CoG of all projections
# and e.g. register them using different names (e.g. "Afferent
# XCoG"), but then it's not clear how the PlotGroup would be
# able to find them automatically (as it currently supports
# only a fixed-named plot).
requested_proj = p.proj_name
for sheet in measured_sheets:
if sheet not in results:
results[sheet.name] = {}
for proj in sheet.in_connections:
if (proj.name == requested_proj) or \
(requested_proj == '' and (proj.src != sheet)):
results[sheet.name][proj.name] = self._update_proj_cog(
p, proj)
return results
def __call__(self,**params):
p=ParamOverrides(self,params)
for output in p.outputs:
s = getattr(topo.sim,output,None)
if s is not None:
for x,y in p.coords:
s.update_unit_view(x,y,'' if p.projection is None else p.projection.name)
def __call__(self,**params):
p = ParamOverrides(self,params)
command_labels,available_targets = _stuff(p.targets)
for cmd in command_labels:
c = available_targets[cmd]
print c
system(c)
def __call__(self, **params):
p = ParamOverrides(self, params, allow_extra_keywords=True)
self._set_presenter_overrides(p)
if not p.num_orientation % 2:
raise Exception("Use odd number of surround orientation to ensure"
"the orthogonal to the preferred orientation is"
"covered.")
results = {}
for coord in p.coords:
self.or_surrounds = []
orientation = p.preference_lookup_fn('orientation', p.outputs[0],
coord,
default=p.orientation_center)
p.orientationcenter = orientation
orientation_step = np.pi / (p.num_orientation - 1)
for i in xrange(0, p.num_orientation - 1):
self.or_surrounds.append(
orientation - np.pi / 2 + i * orientation_step)
p.x = p.preference_lookup_fn('x', p.outputs[0], coord,
default=coord[0])
p.y = p.preference_lookup_fn('y', p.outputs[0], coord,
default=coord[1])
results[coord] = self._compute_curves(p)
results = self._populate_grid(results)
self._restore_presenter_defaults()
return results
def __call__(self, pattern, pattern_label, pattern_number, master_seed,
**params):
p = ParamOverrides(self, params, allow_extra_keywords=True)
new_pattern = copy.copy(pattern)
new_pattern.orientation = pattern.get_value_generator('orientation')+\
numbergen.VonMisesRandom(
mu = self.mu,
kappa = self.kappa,
seed=master_seed+21+pattern_number,
name=("OrientationCoordinator" + str(pattern_number)))
return new_pattern
def __call__(self, **params):
p = ParamOverrides(self, params)
for sheet_name in p.outputs:
s = getattr(topo.sim, sheet_name, None)
if s is not None:
for conn in s.in_connections:
if not isinstance(conn, Projection):
topo.sim.debug("Skipping non-Projection " + conn.name)
else:
v = conn.projection_view(topo.sim.time())
key = v.metadata.proj_name + 'ProjectionActivity'
topo.sim[v.metadata.src_name].views.Maps[key] = v
def __call__(self, **params):
p = ParamOverrides(self, params, allow_extra_keywords=True)
self._apply_cmd_overrides(p)
for fn in p.metadata_fns:
self.metadata = AttrDict(p.metadata, **fn(p.inputs, p.outputs))
output_names = self.metadata['outputs'].keys()
input_names = self.metadata.inputs.keys()
inputs = dict.fromkeys(input_names)
for k in inputs.keys():
inputs[k] = copy.deepcopy(p.pattern_generator)
responses = p.pattern_response_fn(inputs, output_names,
durations=p.durations)
results = self._collate_results(responses)
if p.measurement_storage_hook:
p.measurement_storage_hook(results)
return results
def __call__(self, **params):
p = ParamOverrides(self, params, allow_extra_keywords=True)
self._apply_cmd_overrides(p)
self.metadata = AttrDict(p.metadata)
for fn in p.metadata_fns:
self.metadata.update(fn(p.inputs, p.outputs))
output_names = self.metadata.outputs.keys()
input_names = self.metadata.inputs.keys()
inputs = dict.fromkeys(input_names)
if p.input_patterns:
for k, ip in p.input_patterns.items():
inputs[k] = ip
for name in [k for k, ip in inputs.items() if ip is None]:
self.warning("No pattern specified for input %s, defaulting"
"to blank Constant pattern." % name)
inputs[name] = imagen.Constant(scale=0)
else:
for k in inputs.keys():
inputs[k] = copy.deepcopy(p.pattern_generator)
for f in p.pre_presentation_hooks: f()
responses = p.pattern_response_fn(inputs, output_names,
durations=p.durations)
for f in p.post_presentation_hooks: f()
label = inputs.values()[0].__class__.__name__
results = self._collate_results(responses, label)
if p.measurement_storage_hook:
p.measurement_storage_hook(results)
return results
def __call__(self, **params):
p = ParamOverrides(self, params, allow_extra_keywords=True)
self._set_presenter_overrides(p)
results = {}
for coord in p.coords:
orientation = p.preference_lookup_fn('orientation', p.outputs[0],
coord, default=p.orientation_center)
p.orientationcenter = orientation
p.phase = p.preference_lookup_fn('phase', p.outputs[0],
coord, default=p.orientation_center)
p.x = p.preference_lookup_fn('x', p.outputs[0], coord,
default=coord[0])
p.y = p.preference_lookup_fn('y', p.outputs[0], coord,
default=coord[1])
self.or_surrounds = list(np.linspace(-np.pi/2, np.pi/2, p.num_orientation))
results[coord] = self._compute_curves(p)
results = self._populate_grid(results)
self._restore_presenter_defaults()
return results
def __call__(self, **params):
p = ParamOverrides(self, params, allow_extra_keywords=True)
self._set_presenter_overrides(p)
results = {}
for coord in p.coords:
# Orientations are stored as a normalized value beween 0
# and 1, so we scale them by pi to get the true orientations.
p.orientation = p.preference_lookup_fn('orientation', p.outputs[0],
coord)
p.x = p.preference_lookup_fn('x', p.outputs[0], coord,
default=coord[0])
p.y = p.preference_lookup_fn('y', p.outputs[0], coord,
default=coord[1])
results[coord] = self._compute_curves(p)
self._restore_presenter_defaults()
return results
def __call__(self, dset, **params):
self.p = ParamOverrides(self, params)
if self.p.vdim is None:
vdim = dset.vdims[0].name
else:
vdim = self.p.vdim
pts = hv.util.Dynamic(dset,
operation=skypoints,
streams=[self.p.filter_stream])
if self.p.aggregator == 'mean':
aggregator = ds.mean(vdim)
elif self.p.aggregator == 'std':
aggregator = ds.std(vdim)
elif self.p.aggregator == 'count':
aggregator = ds.count()
kwargs = dict(cmap=cc.palette[self.p.cmap], aggregator=aggregator)
if self.p.width is not None:
kwargs.update(width=self.p.width, height=self.p.height)
# streams=[hv.streams.RangeXY])
decimate_opts = dict(plot={'tools': ['hover', 'box_select']},
style={
'alpha': 0,
'size': self.p.decimate_size,
'nonselection_alpha': 0
})
decimated = decimate(pts).opts(**decimate_opts)
sky_shaded = datashade(pts, **kwargs)
return dynspread(sky_shaded) * decimated
def __call__(self, **params):
p = ParamOverrides(self, params, allow_extra_keywords=True)
self._set_presenter_overrides(p)
results = {}
for coord in p.coords:
orientation = p.preference_lookup_fn('orientation', p.outputs[0],
coord)
self.curve_parameters = [{"orientation": orientation + ro}
for ro in p.relative_orientations]
p.x = p.preference_lookup_fn('x', p.outputs[0], coord,
default=coord[0])
p.y = p.preference_lookup_fn('y', p.outputs[0], coord,
default=coord[1])
results[coord] = self._compute_curves(p, val_format="%.4f")
self._restore_presenter_defaults()
return results
def __call__(self, **params):
p = ParamOverrides(self, params, allow_extra_keywords=True)
self._set_presenter_overrides(p)
results = {}
for coord in p.coords:
self.or_surrounds = []
orientation = p.preference_lookup_fn('orientation', p.outputs[0],
coord,
default=p.orientation_center)
p.orientationcenter = orientation
orientation_step = np.pi / (p.num_orientation - 1)
for i in xrange(0, p.num_orientation - 1):
self.or_surrounds.append(
orientation - np.pi / 2 + i * orientation_step)
p.x = p.preference_lookup_fn('x', p.outputs[0], coord,
default=coord[0])
p.y = p.preference_lookup_fn('y', p.outputs[0], coord,
default=coord[1])
results[coord] = self._compute_curves(p)
self._restore_presenter_defaults()
return results
def __call__(self, **params):
p = ParamOverrides(self, params)
return p.projection.grid(p.rows, p.cols)
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.')
# Set up scatter plot
scatter_filterpoints = filterpoints.instance(xdim=self.p.xdim, ydim=self.p.ydim)
scatter_pts = hv.util.Dynamic(dset, operation=scatter_filterpoints,
streams=[self.p.filter_stream])
scatter_opts = dict(plot={'height': self.p.height, 'responsive':True},
norm=dict(axiswise=True))
scatter_shaded = datashade(scatter_pts,
# cmap=cc.palette[self.p.scatter_cmap])
cmap=viridis)
scatter = dynspread(scatter_shaded).opts(**scatter_opts)
# Set up sky plot
sky_filterpoints = filterpoints.instance(xdim='ra', ydim='dec', set_title=False)
sky_pts = hv.util.Dynamic(dset, operation=sky_filterpoints,
streams=[self.p.filter_stream])
sky_opts = dict(plot={'height': self.p.height, 'responsive': True}, # cmap width?
norm=dict(axiswise=True))
sky_shaded = rasterize(sky_pts,
aggregator=ds.mean(self.p.ydim)).options(colorbar=True,
responsive=True,
# cmap=cc.palette[self.p.sky_cmap])
cmap=Viridis[256])
sky = sky_shaded.opts(**sky_opts)
# sky = dynspread(sky_shaded).opts(**sky_opts)
# Set up summary table
table = hv.util.Dynamic(dset, operation=summary_table.instance(ydim=self.p.ydim),
streams=[self.p.filter_stream])
table = table.opts(plot={'width': 200})
# Set up BoundsXY streams to listen to box_select events and notify FilterStream
scatter_select = BoundsXY(source=scatter)
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)
sky_notifier = partial(notify_stream, filter_stream=self.p.filter_stream,
xdim='ra', ydim='dec')
sky_select.add_subscriber(sky_notifier)
# Reset
reset = Reset(source=scatter)
reset.add_subscriber(partial(reset_stream, self.p.filter_stream))
raw_scatter = datashade(scatter_filterpoints(dset), cmap=Greys9[::-1][:5])
scatter_p = (raw_scatter*scatter).options(bgcolor="black")
if self.p.show_rawsky:
raw_sky = datashade(sky_filterpoints(dset), cmap=Greys9[::-1][:5])
sky_p = raw_sky*sky
else:
sky_p = sky
sky_p = sky_p.options(bgcolor="black")
if self.p.show_table:
return (table + scatter_p + sky_p)
else:
return (scatter_p + sky_p).options(sizing_mode='stretch_width')
def __call__(self, dset, **params):
self.p = ParamOverrides(self, params)
if self.p.vdim is None:
vdim = dset.vdims[0].name
else:
vdim = self.p.vdim
ra_range = (ra0, ra1) = dset.range("ra")
if self.p.ra_sampling:
xsampling = (ra1 - ra0) / self.p.ra_sampling
else:
xsampling = None
dec_range = (dec0, dec1) = dset.range("dec")
if self.p.dec_sampling:
ysampling = (dec1 - dec0) / self.p.dec_sampling
else:
ysampling = None
if self.p.aggregator == "mean":
aggregator = ds.mean(vdim)
elif self.p.aggregator == "std":
aggregator = ds.std(vdim)
elif self.p.aggregator == "count":
aggregator = ds.count()
sky_range = RangeXY()
if self.p.range_stream:
def redim(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 = dset.apply(redim, streams=[self.p.range_stream])
link_streams(self.p.range_stream, sky_range)
streams = [sky_range, PlotSize()]
pts = dset.apply(skypoints, streams=[self.p.filter_stream])
reset = PlotReset(source=pts)
reset.add_subscriber(partial(reset_stream, None,
[self.p.range_stream]))
rasterize_inst = rasterize.instance(aggregator=aggregator,
streams=streams,
x_sampling=xsampling,
y_sampling=ysampling)
raster_pts = apply_when(
pts,
operation=rasterize_inst,
predicate=lambda pts: len(pts) > self.p.max_points)
return raster_pts.opts(
opts.Image(
bgcolor="black",
colorbar=True,
cmap=self.p.cmap,
min_height=100,
responsive=True,
tools=["hover"],
symmetric=True,
),
opts.Points(
color=vdim,
cmap=self.p.cmap,
framewise=True,
size=self.p.decimate_size,
tools=["hover"],
symmetric=True,
),
opts.Overlay(hooks=[
partial(reset_hook, x_range=ra_range, y_range=dec_range)
]),
)
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),
)
