def setUp(self):
self.dmap_element = DynamicMap(lambda: Image([]))
self.dmap_overlay = DynamicMap(lambda: Overlay([Curve([]), Points([])]))
self.dmap_ndoverlay = DynamicMap(lambda: NdOverlay({0: Curve([]), 1: Curve([])}))
self.element = Scatter([])
self.el1, self.el2 = Path([]), HLine(0)
self.overlay = Overlay([self.el1, self.el2])
self.ndoverlay = NdOverlay({0: VectorField([]), 1: VectorField([])})
def test_ndlayout_overlay_ndlayout_partial_reverse(self):
items = [(0, self.view1), (1, self.view2), (3, self.view2)]
grid = NdLayout(items, 'X')
items2 = [(0, self.view2), (2, self.view2), (3, self.view3)]
grid2 = NdLayout(items2, 'X')
expected_items = [(0, Overlay([self.view2, self.view1])),
(1, Overlay([self.view2])),
(2, Overlay([self.view2])),
(3, Overlay([self.view3, self.view2]))]
expected = NdLayout(expected_items, 'X')
self.assertEqual(grid2 * grid, expected)
def test_gridspace_overlay_gridspace_partial_reverse(self):
items = [(0, self.view1), (1, self.view2), (3, self.view2)]
grid = GridSpace(items, 'X')
items2 = [(0, self.view2), (2, self.view2), (3, self.view3)]
grid2 = GridSpace(items2, 'X')
expected_items = [(0, Overlay([self.view2, self.view1])),
(1, Overlay([self.view2])),
(2, Overlay([self.view2])),
(3, Overlay([self.view3, self.view2]))]
expected = GridSpace(expected_items, 'X')
self.assertEqual(grid2 * grid, expected)
def test_overlay_options_complete(self):
"""
Complete specification style.
"""
data = [zip(range(10), range(10)), zip(range(5), range(5))]
o = Overlay([Curve(c) for c in data])({
'Curve.Curve': {
'plot': {
'show_grid': True
},
'style': {
'color': 'b'
}
}
})
self.assertEqual(
Store.lookup_options('matplotlib', o.Curve.I,
'plot').kwargs['show_grid'], True)
self.assertEqual(
Store.lookup_options('matplotlib', o.Curve.II,
'plot').kwargs['show_grid'], True)
self.assertEqual(
Store.lookup_options('matplotlib', o.Curve.I,
'style').kwargs['color'], 'b')
self.assertEqual(
Store.lookup_options('matplotlib', o.Curve.II,
'style').kwargs['color'], 'b')
def test_overlay_options_partitioned(self):
"""
The new style introduced in #73
"""
data = [zip(range(10), range(10)), zip(range(5), range(5))]
o = Overlay([Curve(c) for c in data
])(dict(plot={'Curve.Curve': {
'show_grid': False
}},
style={'Curve.Curve': {
'color': 'k'
}}))
self.assertEqual(
Store.lookup_options('matplotlib', o.Curve.I,
'plot').kwargs['show_grid'], False)
self.assertEqual(
Store.lookup_options('matplotlib', o.Curve.II,
'plot').kwargs['show_grid'], False)
self.assertEqual(
Store.lookup_options('matplotlib', o.Curve.I,
'style').kwargs['color'], 'k')
self.assertEqual(
Store.lookup_options('matplotlib', o.Curve.II,
'style').kwargs['color'], 'k')
def test_interleaved_overlay(self):
"""
Test to avoid regression after fix of https://github.com/ioam/holoviews/issues/41
"""
o = Overlay([
Curve(np.array([[0, 1]])),
Scatter([[1, 1]]),
Curve(np.array([[0, 1]]))
])
OverlayPlot(o)
def __init__(self, **params):
self._session = params.get("session")
self.title = params.get("viz_instance").title
self.overlays = Overlay()
self.traces = []
self.tracesParam = []
self.id = params.get("viz_instance").id
self.dictParameters = self.get_param_values()
self.configTracePanel = pn.Column()
self.configVizPanel = pn.Column()
self.debugPanel = pn.Column()
self.silently = False
super(BaseVizApp, self).__init__(**params)
def compose_overlay_plot(self, x_range: Optional[Sequence[float]] = (-1.6, -1.2),
y_range: Optional[Sequence[float]] = (50.8, 51.05)) \
-> Union[Overlay, Element]:
"""
Compose all generated HoloViews layers in self.data_layers into a single overlay plot.
Overlaid in a first-on-the-bottom manner.
If plot bounds has moved outside of data bounds, generate more as required.
:param tuple x_range: (min, max) longitude range in EPSG:4326 coordinates
:param tuple y_range: (min, max) latitude range in EPSG:4326 coordinates
:returns: overlay plot of stored layers
"""
from itertools import chain
try:
if not self._preload_complete:
# If layers aren't preloaded yet just return the map tiles
self._progress_callback('Still preloading layer data...')
plot = self._base_tiles
else:
# Construct box around requested bounds
bounds_poly = make_bounds_polygon(x_range, y_range)
raster_shape = self._get_raster_dimensions(
bounds_poly, self.raster_resolution_m)
# Ensure bounds are small enough to render without OOM or heat death of universe
if bounds_poly.area < 0.2:
from time import time
t0 = time()
self._progress_bar_callback(10)
self.generate_layers(bounds_poly, raster_shape)
self._progress_bar_callback(50)
plot = Overlay([
res[0] for res in self._generated_data_layers.values()
])
print("Generated all layers in ", time() - t0)
if self.annotation_layers:
import matplotlib.pyplot as mpl
plot = Overlay([
res[0]
for res in self._generated_data_layers.values()
])
raw_datas = [
res[2]
for res in self._generated_data_layers.values()
]
raster_indices = dict(
Longitude=np.linspace(x_range[0],
x_range[1],
num=raster_shape[0]),
Latitude=np.linspace(y_range[0],
y_range[1],
num=raster_shape[1]))
raster_grid = np.zeros(
(raster_shape[1], raster_shape[0]),
dtype=np.float64)
for res in self._generated_data_layers.values():
layer_raster_grid = res[1]
if layer_raster_grid is not None:
nans = np.isnan(layer_raster_grid)
layer_raster_grid[nans] = 0
raster_grid += layer_raster_grid
raster_grid = np.flipud(raster_grid)
raster_indices['Latitude'] = np.flip(
raster_indices['Latitude'])
self._progress_callback('Annotating Layers...')
res = jl.Parallel(
n_jobs=1, verbose=1, backend='threading')(
jl.delayed(layer.annotate)(raw_datas, (
raster_indices, raster_grid))
for layer in self.annotation_layers)
annotation_overlay = Overlay(
[annot for annot in res if annot is not None])
plot = Overlay(
[self._base_tiles, plot,
annotation_overlay]).collate()
else:
plot = Overlay([self._base_tiles, plot]).collate()
self._progress_bar_callback(90)
else:
self._progress_callback('Area too large to render!')
if not self._generated_data_layers:
plot = self._base_tiles
else:
plot = Overlay([
self._base_tiles,
*list(self._generated_data_layers.values())
])
layers = []
for layer in chain(self.data_layers, self.annotation_layers):
d = {'key': layer.key}
if hasattr(layer, '_colour'):
d.update(colour=layer._colour)
if hasattr(layer, '_osm_tag'):
d.update(dataTag=layer._osm_tag)
layers.append(d)
self._progress_callback("Rendering new map...")
self._update_callback(
list(chain(self.data_layers, self.annotation_layers)))
except Exception as e:
# Catch-all to prevent plot blanking out and/or crashing app
# Just display map tiles in case this was transient
import traceback
traceback.print_exc()
print(e)
plot = self._base_tiles
return plot.opts(width=self.plot_size[0],
height=self.plot_size[1],
tools=self.tools,
active_tools=self.active_tools)
def test_overlay_group(self):
t1 = (self.el1 * self.el2)
t2 = Overlay(list(t1.relabel(group='NewValue')))
self.assertEqual(t2.keys(), [('NewValue', 'I'), ('NewValue', 'II')])
def test_overlay_constructor2(self):
t = Overlay([self.el8])
self.assertEqual(t.keys(), [('ValA', 'LabelB')])
def test_overlay_values_2(self):
t = Overlay([self.el1, self.el2])
self.assertEqual(t.values(), [self.el1, self.el2])
def overlaypairs(self, pairs):
"returns an overlay to display the pairings"
return Overlay([
Curve([self._toxy(f1), self._toxy(f2)])
for i, (f1, f2) in enumerate(pairs)
])
def test_overlay_keys_2(self):
t = Overlay([self.el1, self.el2])
self.assertEqual(t.keys(), [('Element', 'I'), ('Element', 'II')])
def test_overlay_with_holomap(self):
overlay = Overlay([('Custom', self.el6)])
composite = overlay * HoloMap({0: Element(None, group='HoloMap')})
self.assertEqual(composite.last.keys(), [('Custom', 'LabelA'), ('HoloMap', 'I')])
def test_overlay_constructor1(self):
t = Overlay([self.el1])
self.assertEqual(t.keys(), [('Element', 'I')])
def test_overlay_constructor_retains_custom_path(self):
overlay = Overlay([('Custom', self.el1)])
paths = Overlay([overlay, self.el2]).keys()
self.assertEqual(paths, [('Custom', 'I'), ('Element', 'I')])
def test_overlay_id_inheritance(self):
overlay = Overlay([], id=1)
self.assertEqual(overlay.clone().id, 1)
self.assertEqual(overlay.clone()._plot_id, overlay._plot_id)
self.assertNotEqual(overlay.clone([])._plot_id, overlay._plot_id)
def test_overlay_from_values_retains_custom_path_with_label(self):
overlay = Overlay([('Custom', self.el6)])
paths = Overlay.from_values([overlay, self.el2]).keys()
self.assertEqual(paths, [('Custom', 'LabelA'), ('Element', 'I')])
def compose_overlay_plot(self, x_range: Optional[Sequence[float]] = (-1.6, -1.2),
y_range: Optional[Sequence[float]] = (50.8, 51.05)) \
-> Union[Overlay, Element]:
"""
Compose all generated HoloViews layers in self.data_layers into a single overlay plot.
Overlaid in a first-on-the-bottom manner.
If plot bounds has moved outside of data bounds, generate more as required.
:param tuple x_range: (min, max) longitude range in EPSG:4326 coordinates
:param tuple y_range: (min, max) latitude range in EPSG:4326 coordinates
:returns: overlay plot of stored layers
"""
try:
if not self._preload_complete:
# If layers aren't preloaded yet just return the map tiles
self._progress_callback('Still preloading layer data...')
plot = self._base_tiles
else:
# Construct box around requested bounds
bounds_poly = make_bounds_polygon(x_range, y_range)
raster_shape = self._get_raster_dimensions(
bounds_poly, self.raster_resolution_m)
# Ensure bounds are small enough to render without OOM or heat death of universe
if (raster_shape[0] * raster_shape[1]) < 7e5:
from time import time
t0 = time()
self._progress_bar_callback(10)
# TODO: This will give multiple data layers, these need to be able to fed into their relevent pathfinding layers
for annlayer in self.annotation_layers:
new_layer = FatalityRiskLayer(
'Fatality Risk', ac=annlayer.aircraft['name'])
self.add_layer(new_layer)
self.remove_duplicate_layers()
self._progress_bar_callback(20)
self.generate_layers(bounds_poly, raster_shape)
self._progress_bar_callback(50)
plt_lyr = list(self._generated_data_layers)[0]
plot = Overlay([self._generated_data_layers[plt_lyr][0]])
print("Generated all layers in ", time() - t0)
if self.annotation_layers:
plot = Overlay(
[self._generated_data_layers[plt_lyr][0]])
res = []
prog_bar = 50
for dlayer in self.data_layers:
raster_indices = dict(
Longitude=np.linspace(x_range[0],
x_range[1],
num=raster_shape[0]),
Latitude=np.linspace(y_range[0],
y_range[1],
num=raster_shape[1]))
raw_data = [
self._generated_data_layers[dlayer.key][2]
]
raster_grid = np.sum([
remove_raster_nans(
self._generated_data_layers[dlayer.key][1])
],
axis=0)
raster_grid = np.flipud(raster_grid)
raster_indices['Latitude'] = np.flip(
raster_indices['Latitude'])
for alayer in self.annotation_layers:
if alayer.aircraft == dlayer.ac_dict:
self._progress_bar_callback(prog_bar)
prog_bar += 40 / len(
self.annotation_layers)
self._progress_callback(
f'Finding a path for {alayer.aircraft["name"]}'
)
res.append(
alayer.annotate(
raw_data,
(raster_indices, raster_grid)))
self._progress_callback('Plotting paths')
self._progress_bar_callback(90)
# res = jl.Parallel(n_jobs=1, verbose=1, backend='threading')(
# jl.delayed(layer.annotate)(raw_datas, (raster_indices, raster_grid)) for layer in
# self.annotation_layers )
plot = Overlay([
self._base_tiles, plot,
*[annot for annot in res if annot is not None]
]).collate()
else:
plot = Overlay([self._base_tiles, plot]).collate()
self._progress_bar_callback(90)
else:
self._progress_callback('Area too large to render!')
if not self._generated_data_layers:
plot = self._base_tiles
else:
plot = Overlay([
self._base_tiles,
*list(self._generated_data_layers.values())
])
self._update_layer_list()
self._progress_callback("Rendering new map...")
except Exception as e:
# Catch-all to prevent plot blanking out and/or crashing app
# Just display map tiles in case this was transient
import traceback
traceback.print_exc()
self._progress_callback(
f'Plotting failed with the following error: {e}. Please attempt to re-generate the plot'
)
print(e)
plot = self._base_tiles
return plot.opts(width=self.plot_size[0],
height=self.plot_size[1],
tools=self.tools,
active_tools=self.active_tools)
