def test_holomap_redim_nested(self): hmap = HoloMap({i: Dataset({'x':self.xs, 'y': self.ys * i}, kdims=['x'], vdims=['y']) for i in range(10)}, kdims=['z']) redimmed = hmap.redim(x='Time', z='Magnitude') self.assertEqual(redimmed.dimensions('all', True), ['Magnitude', 'Time', 'y'])
def update_sheet_activity(sheet_name, force=False): """ Update the '_activity_buffer' ViewMap for a given sheet by name. If force is False and the existing Activity Image isn't stale, the existing view is returned. """ name = 'ActivityBuffer' sheet = topo.sim.objects(Sheet)[sheet_name] view = sheet.views.Maps.get(name, False) time = topo.sim.time() metadata = AttrDict(precedence=sheet.precedence, row_precedence=sheet.row_precedence, src_name=sheet.name, shape=sheet.activity.shape, timestamp=time) if not view: im = Image(np.array(sheet.activity), sheet.bounds) im.metadata = metadata view = HoloMap((time, im), key_dimensions=[Time]) view.metadata = metadata sheet.views.Maps[name] = view else: if force or view.range('Time')[1] < time: im = Image(np.array(sheet.activity), sheet.bounds) im.metadata = metadata view[time] = im return view
def update_sheet_activity(sheet_name, force=False): """ Update the '_activity_buffer' ViewMap for a given sheet by name. If force is False and the existing Activity Image isn't stale, the existing view is returned. """ name = 'ActivityBuffer' sheet = topo.sim.objects(Sheet)[sheet_name] view = sheet.views.Maps.get(name, False) time = topo.sim.time() metadata = AttrDict(precedence=sheet.precedence, row_precedence=sheet.row_precedence, src_name=sheet.name, shape=sheet.activity.shape, timestamp=time) if not view: im = Image(np.array(sheet.activity), sheet.bounds) im.metadata=metadata view = HoloMap((time, im), key_dimensions=[Time]) view.metadata = metadata sheet.views.Maps[name] = view else: if force or view.range('Time')[1] < time: im = Image(np.array(sheet.activity), sheet.bounds) im.metadata=metadata view[time] = im return view
def test_holomap_hist_two_dims(self): hmap = HoloMap({i: Dataset({'x':self.xs, 'y': self.ys * i}, kdims=['x'], vdims=['y']) for i in range(10)}, kdims=['z']) hists = hmap.hist(dimension=['x', 'y']) self.assertEqual(hists['right'].last.kdims, ['y']) self.assertEqual(hists['top'].last.kdims, ['x'])
def test_unique_keys_no_overlap_exception(self): hmap1 = HoloMap({i: Curve(range(10)) for i in range(5)}, kdims=['A']) hmap2 = HoloMap({i: Curve(range(10)) for i in range(3, 10)}) exception = ('When combining HoloMaps into a composite plot ' 'their dimensions must be subsets of each other.') with self.assertRaisesRegexp(Exception, exception): dims, keys = unique_dimkeys(hmap1 + hmap2)
def test_layout_overlay_holomap_reverse(self): t = HoloMap({0: self.el3}) * (self.el1 + self.el2) self.assertEqual( t, Layout([ HoloMap({0: self.el3 * self.el1}), HoloMap({0: self.el3 * self.el2}) ]))
def test_layout_overlay_holomap(self): t = (self.el1 + self.el2) * HoloMap({0: self.el3}) self.assertEqual( t, Layout([ HoloMap({0: self.el1 * self.el3}), HoloMap({0: self.el2 * self.el3}) ]))
def test_dataset_groupby(self): group1 = {'Age':[10,16], 'Weight':[15,18], 'Height':[0.8,0.6]} group2 = {'Age':[12], 'Weight':[10], 'Height':[0.8]} grouped = HoloMap([('M', Dataset(group1, kdims=['Age'], vdims=self.vdims)), ('F', Dataset(group2, kdims=['Age'], vdims=self.vdims))], kdims=['Gender'], sort=False) print(grouped.keys()) self.assertEqual(self.table.groupby(['Gender']), grouped)
def test_layout_title(self): hmap1 = HoloMap({a: Image(np.random.rand(10, 10)) for a in range(3)}) hmap2 = HoloMap({a: Image(np.random.rand(10, 10)) for a in range(3)}) plot = bokeh_renderer.get_plot(hmap1 + hmap2) title = plot.handles['title'] self.assertIsInstance(title, Div) text = "<span style='font-size: 16pt'><b>Default: 0</b></font>" self.assertEqual(title.text, text)
def test_layout_title_fontsize(self): hmap1 = HoloMap({a: Image(np.random.rand(10, 10)) for a in range(3)}) hmap2 = HoloMap({a: Image(np.random.rand(10, 10)) for a in range(3)}) layout = Layout([hmap1, hmap2])(plot=dict(fontsize={'title': '12pt'})) plot = bokeh_renderer.get_plot(layout) title = plot.handles['title'] self.assertIsInstance(title, Div) text = "<span style='font-size: 12pt'><b>Default: 0</b></font>" self.assertEqual(title.text, text)
def test_unique_keys_partial_overlap(self): hmap1 = HoloMap( {(i, j): Curve(range(10)) for i in range(5) for j in range(3)}, kdims=['A', 'B']) hmap2 = HoloMap({i: Curve(range(10)) for i in range(5)}, kdims=['A']) dims, keys = unique_dimkeys(hmap1 + hmap2) self.assertEqual(hmap1.kdims, dims) self.assertEqual(keys, [(i, j) for i in range(5) for j in list(range(3))])
def _collate_results(self, p): results = Layout() timestamp = self.metadata.timestamp axis_name = p.x_axis.capitalize() axis_feature = [f for f in self.features if f.name.lower() == p.x_axis][0] if axis_feature.cyclic: axis_feature.values.append(axis_feature.range[1]) curve_label = ''.join([p.measurement_prefix, axis_name, 'Tuning']) dimensions = [features.Time, features.Duration] + [f for f in self.outer] + [axis_feature] pattern_dimensions = self.outer + self.inner pattern_dim_label = '_'.join(f.name.capitalize() for f in pattern_dimensions) for label in self.measurement_product: # Deconstruct label into source name and feature_values name = label[0] f_vals = label[1:] # Get data and metadata from the DistributionMatrix objects dist_matrix = self._featureresponses[name][f_vals][p.x_axis] curve_responses = dist_matrix.distribution_matrix output_metadata = self.metadata.outputs[name] rows, cols = output_metadata['shape'] # Create top level NdMapping indexing over time, duration, the outer # feature dimensions and the x_axis dimension if (curve_label, name) not in results: vmap = HoloMap(kdims=dimensions, group=curve_label, label=name) vmap.metadata = AttrDict(**output_metadata) results.set_path((curve_label, name), vmap) metadata = AttrDict(timestamp=timestamp, **output_metadata) # Populate the ViewMap with measurements for each x value for x in curve_responses[0, 0]._data.iterkeys(): y_axis_values = np.zeros(output_metadata['shape'], activity_dtype) for i in range(rows): for j in range(cols): y_axis_values[i, j] = curve_responses[i, j].get_value(x) key = (timestamp,)+f_vals+(x,) im = Image(y_axis_values, bounds=output_metadata['bounds'], label=name, group=' '.join([curve_label, 'Response']), vdims=['Response']) im.metadata = metadata.copy() results[(curve_label, name)][key] = im if axis_feature.cyclic and x == axis_feature.range[0]: symmetric_key = (timestamp,)+f_vals+(axis_feature.range[1],) results[(curve_label, name)][symmetric_key] = im if p.store_responses: info = (p.pattern_generator.__class__.__name__, pattern_dim_label, 'Response') results.set_path(('%s_%s_%s' % info, name), self._responses[name]) return results
def _collate_results(self, p): """ Collate responses into the results dictionary containing a ProjectionGrid for each measurement source. """ results = Layout() timestamp = self.metadata.timestamp dimensions = [features.Time, features.Duration] pattern_dimensions = self.outer + self.inner pattern_dim_label = '_'.join(f.name.capitalize() for f in pattern_dimensions) grids, responses = {}, {} for labels in self.measurement_product: in_label, out_label, duration = labels input_metadata = self.metadata.inputs[in_label] output_metadata = self.metadata.outputs[out_label] rows, cols, scs = self._compute_roi(p, output_metadata) time_key = (timestamp, duration) grid_key = (in_label, out_label) if grid_key not in grids: if p.store_responses: responses[in_label] = self._responses[in_label] responses[out_label] = self._responses[out_label] grids[grid_key] = GridSpace(group='RFs', label=out_label) view = grids[grid_key] rc_response = self._featureresponses[in_label][out_label][duration] for i, ii in enumerate(rows): for j, jj in enumerate(cols): coord = scs.matrixidx2sheet(ii, jj) im = Image(rc_response[i, j], bounds=input_metadata['bounds'], label=out_label, group='Receptive Field', vdims=['Weight']) im.metadata = AttrDict(timestamp=timestamp) if coord in view: view[coord][time_key] = im else: view[coord] = HoloMap((time_key, im), kdims=dimensions, label=out_label, group='Receptive Field') view[coord].metadata = AttrDict(**input_metadata) for (in_label, out_label), view in grids.items(): results.set_path(('%s_Reverse_Correlation' % in_label, out_label), view) if p.store_responses: info = (p.pattern_generator.__class__.__name__, pattern_dim_label, 'Response') results.set_path(('%s_%s_%s' % info, in_label), responses[in_label]) results.set_path(('%s_%s_%s' % info, out_label), responses[out_label]) return results
def test_holomap_map_with_none(self): hmap = HoloMap( { i: Dataset( { 'x': self.xs, 'y': self.ys * i }, kdims=['x'], vdims=['y']) for i in range(10) }, kdims=['z']) mapped = hmap.map(lambda x: x if x.range(1)[1] > 0 else None, Dataset) self.assertEqual(hmap[1:10], mapped)
def _update_proj_cog(self, p, proj): """Measure the CoG of the specified projection and register corresponding SheetViews.""" sheet = proj.dest rows, cols = sheet.activity.shape xcog = np.zeros((rows, cols), np.float64) ycog = np.zeros((rows, cols), np.float64) for r in xrange(rows): for c in xrange(cols): cf = proj.cfs[r, c] r1, r2, c1, c2 = cf.input_sheet_slice row_centroid, col_centroid = centroid(cf.weights) xcentroid, ycentroid = proj.src.matrix2sheet( r1 + row_centroid + 0.5, c1 + col_centroid + 0.5) xcog[r][c] = xcentroid ycog[r][c] = ycentroid metadata = AttrDict(precedence=sheet.precedence, row_precedence=sheet.row_precedence, src_name=sheet.name) timestamp = topo.sim.time() lbrt = sheet.bounds.lbrt() xsv = Image(xcog, sheet.bounds, label=proj.name, group='X CoG', vdims=[Dimension('X CoG', range=(lbrt[0], lbrt[2]))]) ysv = Image(ycog, sheet.bounds, label=proj.name, group='Y CoG', vdims=[Dimension('Y CoG', range=(lbrt[1], lbrt[3]))]) lines = [] hlines, vlines = xsv.data.shape for hind in range(hlines)[::p.stride]: lines.append(np.vstack([xsv.data[hind, :].T, ysv.data[hind, :]]).T) for vind in range(vlines)[::p.stride]: lines.append(np.vstack([xsv.data[:, vind].T, ysv.data[:, vind]]).T) cogmesh = Contours(lines, extents=sheet.bounds.lbrt(), label=proj.name, group='Center of Gravity') xcog_map = HoloMap((timestamp, xsv), kdims=[features.Time]) xcog_map.metadata = metadata ycog_map = HoloMap((timestamp, ysv), kdims=[features.Time]) ycog_map.metadata = metadata contour_map = HoloMap((timestamp, cogmesh), kdims=[features.Time]) contour_map.metadata = metadata return {'XCoG': xcog_map, 'YCoG': ycog_map, 'CoG': contour_map}
def test_render_holomap_individual_widget_position(self): hmap = HoloMap({i: Curve([1, 2, i]) for i in range(5)}) obj, _ = self.renderer.instance(widget_location='top')._validate(hmap, None) self.assertIsInstance(obj, pn.pane.HoloViews) self.assertEqual(obj.center, True) self.assertEqual(obj.widget_location, 'top') self.assertEqual(obj.widget_type, 'individual')
def setUp(self): super(TestWidgets, self).setUp() im1 = Image(np.array([[1, 2], [3, 4]])) im2 = Image(np.array([[1, 2], [3, 5]])) holomap = HoloMap(initial_items=[(0, im1), (1, im2)], kdims=['test']) self.plot1 = RasterPlot(im1) self.plot2 = RasterPlot(holomap)
def setUp(self): if 'bokeh' not in Store.renderers: raise SkipTest("Bokeh required to test widgets") self.image1 = Image(np.array([[0, 1], [2, 3]]), label='Image1') self.image2 = Image(np.array([[1, 0], [4, -2]]), label='Image2') self.map1 = HoloMap({1: self.image1, 2: self.image2}, label='TestMap') self.renderer = BokehRenderer.instance()
def setUp(self): self.basename = 'no-file' self.image1 = Image(np.array([[0, 1], [2, 3]]), label='Image1') self.image2 = Image(np.array([[1, 0], [4, -2]]), label='Image2') self.map1 = HoloMap({1: self.image1, 2: self.image2}, label='TestMap') self.renderer = Store.renderer.instance()
def test_dataset_groupby(self): group1 = {'Age':[10,16], 'Weight':[15,18], 'Height':[0.8,0.6]} group2 = {'Age':[12], 'Weight':[10], 'Height':[0.8]} grouped = HoloMap([('M', Dataset(group1, kdims=['Age'], vdims=self.vdims)), ('F', Dataset(group2, kdims=['Age'], vdims=self.vdims))], kdims=['Gender']) self.assertEqual(self.table.groupby(['Gender']), grouped)
def test_dynamic_holomap_overlay(self): fn = lambda i: Image(sine_array(0, i)) dmap = DynamicMap(fn, sampled=True) hmap = HoloMap({i: Image(sine_array(0, i * 2)) for i in range(10)}) dynamic_overlay = dmap * hmap overlaid = Image(sine_array(0, 5)) * Image(sine_array(0, 10)) self.assertEqual(dynamic_overlay[5], overlaid)
def test_render_holomap_scrubber_fps(self): hmap = HoloMap({i: Curve([1, 2, i]) for i in range(5)}) obj, _ = self.renderer.instance(fps=2)._validate(hmap, 'scrubber') self.assertIsInstance(obj, pn.pane.HoloViews) widgets = obj.layout.select(Player) self.assertEqual(len(widgets), 1) player = widgets[0] self.assertEqual(player.interval, 500)
def test_dataset_groupby_alias(self): group1 = {'age':[10,16], 'weight':[15,18], 'height':[0.8,0.6]} group2 = {'age':[12], 'weight':[10], 'height':[0.8]} grouped = HoloMap([('M', Dataset(group1, kdims=[('age', 'Age')], vdims=self.alias_vdims)), ('F', Dataset(group2, kdims=[('age', 'Age')], vdims=self.alias_vdims))], kdims=[('gender', 'Gender')]) self.assertEqual(self.alias_table.groupby('Gender'), grouped)
def setUp(self): self.data1 = 'An example of arbitrary data' self.data2 = 'Another example...' self.data3 = 'A third example.' self.view1 = Element(self.data1, label='View1') self.view2 = Element(self.data2, label='View2') self.view3 = Element(self.data3, label='View3') self.hmap = HoloMap({0: self.view1, 1: self.view2, 2: self.view3})
def test_columns_groupby(self): group1 = {'Age': [10, 16], 'Weight': [15, 18], 'Height': [0.8, 0.6]} group2 = {'Age': [12], 'Weight': [10], 'Height': [0.8]} with sorted_context(False): grouped = HoloMap( [('M', Columns(group1, kdims=['Age'], vdims=self.vdims)), ('F', Columns(group2, kdims=['Age'], vdims=self.vdims))], kdims=['Gender']) self.assertEqual(self.table.groupby(['Gender']), grouped)
def _collate_results(self, responses, label): time = self.metadata.timestamp dims = [f.Time, f.Duration] response_label = label + ' Response' results = Layout() for label, response in responses.items(): name, duration = label path = (response_label.replace(' ', ''), name) label = ' '.join([name, response_label]) metadata = self.metadata['outputs'][name] if path not in results: vmap = HoloMap(key_dimensions=dims) vmap.metadata = AttrDict(**metadata) results.set_path(path, vmap) im = Image(response, metadata['bounds'], label=label, group='Activity') im.metadata=AttrDict(timestamp=time) results[path][(time, duration)] = im return results
def test_render_holomap_individual(self): hmap = HoloMap({i: Curve([1, 2, i]) for i in range(5)}) obj, _ = self.renderer._validate(hmap, None) self.assertIsInstance(obj, pn.pane.HoloViews) self.assertEqual(obj.center, True) self.assertEqual(obj.widget_location, 'right') self.assertEqual(obj.widget_type, 'individual') widgets = obj.layout.select(DiscreteSlider) self.assertEqual(len(widgets), 1) slider = widgets[0] self.assertEqual(slider.options, OrderedDict([(str(i), i) for i in range(5)]))
def anim(self, duration, offset=0, timestep=1, label=None, unit=None, time_fn=param.Dynamic.time_fn): """ duration: The temporal duration to animate in the units defined on the global time function. offset: The temporal offset from which the animation is generated given the supplied pattern timestep: The time interval between successive frames. The duration must be an exact multiple of the timestep. label: A label string to override the label of the global time function (if not None). unit: The unit string to override the unit value of the global time function (if not None). time_fn: The global time function object that is shared across the time-varying objects that are being sampled. Note that the offset, timestep and time_fn only affect patterns parameterized by time-dependent number generators. Otherwise, the frames are generated by successive call to the pattern which may or may not be varying (e.g to view the patterns contained within a Selector). """ frames = (duration // timestep) + 1 if duration % timestep != 0: raise ValueError( "The duration value must be an exact multiple of the timestep." ) if label is None: label = time_fn.label if hasattr(time_fn, 'label') else 'Time' unit = time_fn.unit if (not unit and hasattr(time_fn, 'unit')) else unit vmap = HoloMap( key_dimensions=[Dimension(label, unit=unit if unit else '')]) self.state_push() with time_fn as t: t(offset) for i in range(frames): vmap[t()] = self[:] t += timestep self.state_pop() return vmap
def view(self, sheet_x, sheet_y, timestamp=None, situated=False, **kwargs): """ Return a single connection field Image, for the unit located nearest to sheet coordinate (sheet_x,sheet_y). """ if timestamp is None: timestamp = self.src.simulation.time() time_dim = Dimension("Time", type=param.Dynamic.time_fn.time_type) (r, c) = self.dest.sheet2matrixidx(sheet_x, sheet_y) cf = self.cfs[r, c] r1, r2, c1, c2 = cf.input_sheet_slice situated_shape = self.src.activity.shape situated_bounds = self.src.bounds roi_bounds = cf.get_bounds(self.src) if situated: matrix_data = np.zeros(situated_shape, dtype=np.float64) matrix_data[r1:r2, c1:c2] = cf.weights.copy() bounds = situated_bounds else: matrix_data = cf.weights.copy() bounds = roi_bounds sv = CFView(matrix_data, bounds, situated_bounds=situated_bounds, input_sheet_slice=(r1, r2, c1, c2), roi_bounds=roi_bounds, label=self.name, group='CF Weight') sv.metadata = AttrDict(timestamp=timestamp) viewmap = HoloMap((timestamp, sv), kdims=[time_dim]) viewmap.metadata = AttrDict(coords=(sheet_x, sheet_y), dest_name=self.dest.name, precedence=self.src.precedence, proj_name=self.name, src_name=self.src.name, row_precedence=self.src.row_precedence, timestamp=timestamp, **kwargs) return viewmap
def test_overlay_update_sources(self): hmap = HoloMap({ i: (Curve(np.arange(i), label='A') * Curve(np.arange(i) * 2, label='B')) for i in range(10, 13) }) plot = bokeh_renderer.get_plot(hmap) plot.update((12, )) subplot1, subplot2 = plot.subplots.values() self.assertEqual(subplot1.handles['source'].data['y'], np.arange(12)) self.assertEqual(subplot2.handles['source'].data['y'], np.arange(12) * 2)
def test_render_holomap_scrubber(self): hmap = HoloMap({i: Curve([1, 2, i]) for i in range(5)}) obj, _ = self.renderer._validate(hmap, 'scrubber') self.assertIsInstance(obj, pn.pane.HoloViews) self.assertEqual(obj.center, True) self.assertEqual(obj.widget_location, 'bottom') self.assertEqual(obj.widget_type, 'scrubber') widgets = obj.layout.select(Player) self.assertEqual(len(widgets), 1) player = widgets[0] self.assertEqual(player.start, 0) self.assertEqual(player.end, 4)
def setUp(self): if 'bokeh' not in Store.renderers and pn is not None: raise SkipTest("Bokeh and Panel required to test 'bokeh' renderer") self.image1 = Image(np.array([[0, 1], [2, 3]]), label='Image1') self.image2 = Image(np.array([[1, 0], [4, -2]]), label='Image2') self.map1 = HoloMap({1: self.image1, 2: self.image2}, label='TestMap') self.renderer = BokehRenderer.instance() self.nbcontext = Renderer.notebook_context self.comm_manager = Renderer.comm_manager with param.logging_level('ERROR'): Renderer.notebook_context = False Renderer.comm_manager = CommManager
def setUp(self): if 'matplotlib' not in Store.renderers: raise SkipTest("Matplotlib required to test widgets") self.basename = 'no-file' self.image1 = Image(np.array([[0,1],[2,3]]), label='Image1') self.image2 = Image(np.array([[1,0],[4,-2]]), label='Image2') self.map1 = HoloMap({1:self.image1, 2:self.image2}, label='TestMap') self.unicode_table = ItemTable([('β','Δ1'), ('°C', '3×4')], label='Poincaré', group='α Festkörperphysik') self.renderer = MPLRenderer.instance()
def test_grid_title(self): grid = GridSpace({ (i, j): HoloMap({a: Image(np.random.rand(10, 10)) for a in range(3)}, kdims=['X']) for i in range(2) for j in range(3) }) plot = bokeh_renderer.get_plot(grid) title = plot.handles['title'] self.assertIsInstance(title, Div) text = "<span style='font-size: 16pt'><b>X: 0</b></font>" self.assertEqual(title.text, text)
def view(self, sheet_x, sheet_y, timestamp=None, situated=False, **kwargs): """ Return a single connection field Image, for the unit located nearest to sheet coordinate (sheet_x,sheet_y). """ if timestamp is None: timestamp = self.src.simulation.time() time_dim = Dimension("Time", type=param.Dynamic.time_fn.time_type) (r, c) = self.dest.sheet2matrixidx(sheet_x, sheet_y) cf = self.cfs[r, c] r1, r2, c1, c2 = cf.input_sheet_slice situated_shape = self.src.activity.shape situated_bounds = self.src.bounds roi_bounds = cf.get_bounds(self.src) if situated: matrix_data = np.zeros(situated_shape, dtype=np.float64) matrix_data[r1:r2, c1:c2] = cf.weights.copy() bounds = situated_bounds else: matrix_data = cf.weights.copy() bounds = roi_bounds sv = CFView(matrix_data, bounds, situated_bounds=situated_bounds, input_sheet_slice=(r1, r2, c1, c2), roi_bounds=roi_bounds, label=self.name, group='CF Weight') sv.metadata=AttrDict(timestamp=timestamp) viewmap = HoloMap((timestamp, sv), kdims=[time_dim]) viewmap.metadata = AttrDict(coords=(sheet_x, sheet_y), dest_name=self.dest.name, precedence=self.src.precedence, proj_name=self.name, src_name=self.src.name, row_precedence=self.src.row_precedence, timestamp=timestamp, **kwargs) return viewmap
def test_columns_collapse_heterogeneous(self): collapsed = HoloMap( { i: Dataset( { 'x': self.xs, 'y': self.ys * i }, kdims=['x'], vdims=['y']) for i in range(10) }, kdims=['z']).collapse('z', np.mean) expected = Dataset({ 'x': self.xs, 'y': self.ys * 4.5 }, kdims=['x'], vdims=['y']) self.compare_dataset(collapsed, expected)
def _update_proj_cog(self, p, proj): """Measure the CoG of the specified projection and register corresponding SheetViews.""" sheet = proj.dest rows, cols = sheet.activity.shape xcog = np.zeros((rows, cols), np.float64) ycog = np.zeros((rows, cols), np.float64) for r in xrange(rows): for c in xrange(cols): cf = proj.cfs[r, c] r1, r2, c1, c2 = cf.input_sheet_slice row_centroid, col_centroid = centroid(cf.weights) xcentroid, ycentroid = proj.src.matrix2sheet( r1 + row_centroid + 0.5, c1 + col_centroid + 0.5) xcog[r][c] = xcentroid ycog[r][c] = ycentroid metadata = AttrDict(precedence=sheet.precedence, row_precedence=sheet.row_precedence, src_name=sheet.name) timestamp = topo.sim.time() lbrt = sheet.bounds.lbrt() xsv = Image(xcog, sheet.bounds, label=proj.name, group='X CoG', value_dimensions=[Dimension('X CoG', range=(lbrt[0], lbrt[2]))]) ysv = Image(ycog, sheet.bounds, label=proj.name, group='Y CoG', value_dimensions=[Dimension('Y CoG', range=(lbrt[1], lbrt[3]))]) lines = [] hlines, vlines = xsv.data.shape for hind in range(hlines)[::p.stride]: lines.append(np.vstack([xsv.data[hind,:].T, ysv.data[hind,:]]).T) for vind in range(vlines)[::p.stride]: lines.append(np.vstack([xsv.data[:,vind].T, ysv.data[:,vind]]).T) cogmesh = Contours(lines, extents=sheet.bounds.lbrt(), label=proj.name, group='Center of Gravity') xcog_map = HoloMap((timestamp, xsv), key_dimensions=[features.Time]) xcog_map.metadata = metadata ycog_map = HoloMap((timestamp, ysv), key_dimensions=[features.Time]) ycog_map.metadata = metadata contour_map = HoloMap((timestamp, cogmesh), key_dimensions=[features.Time]) contour_map.metadata = metadata return {'XCoG': xcog_map, 'YCoG': ycog_map, 'CoG': contour_map}
def test_holomap_map_with_none(self): hmap = HoloMap({i: Dataset({'x':self.xs, 'y': self.ys * i}, kdims=['x'], vdims=['y']) for i in range(10)}, kdims=['z']) mapped = hmap.map(lambda x: x if x.range(1)[1] > 0 else None, Dataset) self.assertEqual(hmap[1:10], mapped)
def _collate_results(self, p): results = Layout() timestamp = self.metadata.timestamp # Generate dimension info dictionary from features dimensions = [features.Time, features.Duration] + self.outer pattern_dimensions = self.outer + self.inner pattern_dim_label = '_'.join(f.name.capitalize() for f in pattern_dimensions) for label in self.measurement_product: name = label[0] # Measurement source f_vals = label[1:] # Duration and outer feature values #Metadata inner_features = dict([(f.name, f) for f in self.inner]) output_metadata = dict(self.metadata.outputs[name], inner_features=inner_features) # Iterate over inner features fr = self._featureresponses[name][f_vals] for fname, fdist in fr.items(): feature = fname.capitalize() base_name = self.measurement_prefix + feature # Get information from the feature fp = [f for f in self.features if f.name.lower() == fname][0] pref_fn = fp.preference_fn if has_preference_fn(fp)\ else self.preference_fn if p.selectivity_multiplier is not None: pref_fn.selectivity_scale = (pref_fn.selectivity_scale[0], p.selectivity_multiplier) # Get maps and iterate over them response = fdist.apply_DSF(pref_fn) for k, maps in response.items(): for map_name, map_view in maps.items(): # Set labels and metadata map_index = base_name + k + map_name.capitalize() map_label = ' '.join([base_name, map_name.capitalize()]) cyclic = (map_name != 'selectivity' and fp.cyclic) fprange = fp.range if cyclic else (None, None) value_dimension = Dimension(map_label, cyclic=cyclic, range=fprange) self._set_style(fp, map_name) # Create views and stacks im = Image(map_view, bounds=output_metadata['bounds'], label=name, group=map_label, vdims=[value_dimension]) im.metadata=AttrDict(timestamp=timestamp) key = (timestamp,)+f_vals if (map_label.replace(' ', ''), name) not in results: vmap = HoloMap((key, im), kdims=dimensions, label=name, group=map_label) vmap.metadata = AttrDict(**output_metadata) results.set_path((map_index, name), vmap) else: results.path_items[(map_index, name)][key] = im if p.store_responses: info = (p.pattern_generator.__class__.__name__, pattern_dim_label, 'Response') results.set_path(('%s_%s_%s' % info, name), self._responses[name]) return results