def trimesh(self):
trimesh = super(QuadMesh, self).trimesh()
node_params = util.get_param_values(trimesh.nodes)
node_params['crs'] = self.crs
nodes = TriMesh.node_type(trimesh.nodes.data, **node_params)
return TriMesh((trimesh.data, nodes), crs=self.crs,
**util.get_param_values(trimesh))
def trimesh(self):
trimesh = super(QuadMesh, self).trimesh()
node_params = get_param_values(trimesh.nodes)
nodes = TriMesh.node_type(trimesh.nodes.data, **node_params)
return TriMesh((trimesh.data, nodes),
crs=self.crs,
**get_param_values(trimesh))
def _process_element(self, element):
proj = self.p.projection
irregular = any(element.interface.irregular(element, kd)
for kd in element.kdims)
zs = element.dimension_values(2, flat=False)
if irregular:
X, Y = [np.asarray(element.interface.coords(
element, kd, expanded=True, edges=False))
for kd in element.kdims]
else:
X = element.interface.coords(element, 0, True, True, False)
if np.all(X[0, 1:] < X[0, :-1]):
X = X[:, ::-1]
Y = element.interface.coords(element, 1, True, True, False)
if np.all(Y[1:, 0] < Y[:-1, 0]):
Y = Y[::-1, :]
if X.shape != zs.shape:
X = X[:-1] + np.diff(X, axis=0)/2.
X = X[:, :-1] + (np.diff(X, axis=1)/2.)
if Y.shape != zs.shape:
Y = Y[:-1] + np.diff(Y, axis=0)/2.
Y = Y[:, :-1] + (np.diff(Y, axis=1)/2.)
coords = proj.transform_points(element.crs, X, Y)
PX, PY = coords[..., 0], coords[..., 1]
# Mask quads which are wrapping around the x-axis
wrap_proj_types = (ccrs._RectangularProjection,
ccrs._WarpedRectangularProjection,
ccrs.InterruptedGoodeHomolosine,
ccrs.Mercator)
if isinstance(proj, wrap_proj_types):
with np.errstate(invalid='ignore'):
edge_lengths = np.hypot(
np.diff(PX, axis=1),
np.diff(PY, axis=1)
)
to_mask = (
(edge_lengths >= abs(proj.x_limits[1] -
proj.x_limits[0]) / 2) |
np.isnan(edge_lengths)
)
if np.any(to_mask):
mask = np.zeros(zs.shape, dtype=np.bool_)
mask[:, 1:][to_mask] = True
mask[:, 2:][to_mask[:, :-1]] = True
mask[:, :-1][to_mask] = True
mask[:, :-2][to_mask[:, 1:]] = True
mask[1:, 1:][to_mask[:-1]] = True
mask[1:, :-1][to_mask[:-1]] = True
mask[:-1, 1:][to_mask[1:]] = True
mask[:-1, :-1][to_mask[1:]] = True
zs[mask] = np.NaN
params = get_param_values(element)
return element.clone((PX, PY, zs), crs=self.p.projection, **params)
def _process_element(self, element):
proj = self.p.projection
irregular = any(element.interface.irregular(element, kd)
for kd in element.kdims)
zs = element.dimension_values(2, flat=False)
if irregular:
X, Y = [np.asarray(element.interface.coords(
element, kd, expanded=True, edges=False))
for kd in element.kdims]
else:
X = element.interface.coords(element, 0, True, True, False)
if np.all(X[0, 1:] < X[0, :-1]):
X = X[:, ::-1]
Y = element.interface.coords(element, 1, True, True, False)
if np.all(Y[1:, 0] < Y[:-1, 0]):
Y = Y[::-1, :]
if X.shape != zs.shape:
X = X[:-1] + np.diff(X, axis=0)/2.
X = X[:, :-1] + (np.diff(X, axis=1)/2.)
if Y.shape != zs.shape:
Y = Y[:-1] + np.diff(Y, axis=0)/2.
Y = Y[:, :-1] + (np.diff(Y, axis=1)/2.)
coords = proj.transform_points(element.crs, X, Y)
PX, PY = coords[..., 0], coords[..., 1]
# Mask quads which are wrapping around the x-axis
wrap_proj_types = (ccrs._RectangularProjection,
ccrs._WarpedRectangularProjection,
ccrs.InterruptedGoodeHomolosine,
ccrs.Mercator)
if isinstance(proj, wrap_proj_types):
with np.errstate(invalid='ignore'):
edge_lengths = np.hypot(
np.diff(PX, axis=1),
np.diff(PY, axis=1)
)
to_mask = (
(edge_lengths >= abs(proj.x_limits[1] -
proj.x_limits[0]) / 2) |
np.isnan(edge_lengths)
)
if np.any(to_mask):
mask = np.zeros(zs.shape, dtype=np.bool)
mask[:, 1:][to_mask] = True
mask[:, 2:][to_mask[:, :-1]] = True
mask[:, :-1][to_mask] = True
mask[:, :-2][to_mask[:, 1:]] = True
mask[1:, 1:][to_mask[:-1]] = True
mask[1:, :-1][to_mask[:-1]] = True
mask[:-1, 1:][to_mask[1:]] = True
mask[:-1, :-1][to_mask[1:]] = True
zs[mask] = np.NaN
params = get_param_values(element)
return QuadMesh((PX, PY, zs), crs=self.p.projection, **params)
def get_data(self, element, ranges, style):
if not isinstance(element.data['geometry'], poly_types):
style['fill_alpha'] = 0
if isinstance(element.data['geometry'], line_types):
el_type = Contours
style['plot_method'] = 'multi_line'
style.pop('fill_color', None)
style.pop('fill_alpha', None)
else:
el_type = Polygons
polys = el_type([element.data], crs=element.crs, **util.get_param_values(element))
return super(GeoShapePlot, self).get_data(polys, ranges, style)
def get_data(self, element, ranges, style):
if not isinstance(element.data['geometry'], poly_types):
style['fill_alpha'] = 0
if isinstance(element.data['geometry'], line_types):
el_type = Contours
style['plot_method'] = 'multi_line'
style.pop('fill_color', None)
style.pop('fill_alpha', None)
else:
el_type = Polygons
polys = el_type([element.data], crs=element.crs, **util.get_param_values(element))
return super(GeoShapePlot, self).get_data(polys, ranges, style)
def _process(self, element, key=None):
regridder, arrays = self._get_regridder(element)
x, y = element.kdims
ds = xr.Dataset({vd: regridder(arr) for vd, arr in arrays.items()})
ds = ds.rename({'lon': x.name, 'lat': y.name})
params = get_param_values(element)
if is_geographic(element):
try:
return Image(ds, crs=element.crs, **params)
except:
return QuadMesh(ds, crs=element.crs, **params)
try:
return HvImage(ds, **params)
except:
return HvQuadMesh(ds, **params)
def _process(self, element, key=None):
regridder, arrays = self._get_regridder(element)
x, y = element.kdims
ds = xr.Dataset({vd: regridder(arr) for vd, arr in arrays.items()})
ds = ds.rename({'lon': x.name, 'lat': y.name})
params = get_param_values(element)
if is_geographic(element):
try:
return Image(ds, crs=element.crs, **params)
except:
return QuadMesh(ds, crs=element.crs, **params)
try:
return HvImage(ds, **params)
except:
return HvQuadMesh(ds, **params)
def _process_element(self, element):
proj = self.p.projection
irregular = any(
element.interface.irregular(element, kd) for kd in element.kdims)
zs = element.dimension_values(2, flat=False)
if irregular:
X, Y = [
np.asarray(element.interface.coords(element, kd,
expanded=True))
for kd in element.kdims
]
else:
X = element.dimension_values(0, expanded=True)
Y = element.dimension_values(1, expanded=True)
zs = zs.T
coords = proj.transform_points(element.crs, X, Y)
PX, PY = coords[..., 0], coords[..., 1]
# Mask quads which are wrapping around the x-axis
wrap_proj_types = (ccrs._RectangularProjection,
ccrs._WarpedRectangularProjection,
ccrs.InterruptedGoodeHomolosine, ccrs.Mercator)
if isinstance(proj, wrap_proj_types):
with np.errstate(invalid='ignore'):
edge_lengths = np.hypot(np.diff(PX, axis=1), np.diff(PY,
axis=1))
to_mask = ((edge_lengths >=
abs(proj.x_limits[1] - proj.x_limits[0]) / 2)
| np.isnan(edge_lengths))
if np.any(to_mask):
mask = np.zeros(zs.shape, dtype=np.bool)
mask[:, 1:][to_mask] = True
mask[:, 2:][to_mask[:, :-1]] = True
mask[:, :-1][to_mask] = True
mask[:, :-2][to_mask[:, 1:]] = True
mask[1:, 1:][to_mask[:-1]] = True
mask[1:, :-1][to_mask[:-1]] = True
mask[:-1, 1:][to_mask[1:]] = True
mask[:-1, :-1][to_mask[1:]] = True
zs[mask] = np.NaN
params = get_param_values(element)
if PX.ndim < 2:
PX = PX.reshape(zs.shape)
if PY.ndim < 2:
PY = PY.reshape(zs.shape)
return QuadMesh((PX, PY, zs), crs=self.projection, **params)
def groupby(cls,
dataset,
dims,
container_type=HoloMap,
group_type=None,
**kwargs):
"""
Groups the data by one or more dimensions returning a container
indexed by the grouped dimensions containing slices of the
cube wrapped in the group_type. This makes it very easy to
break up a high-dimensional dataset into smaller viewable chunks.
"""
import iris
if not isinstance(dims, list): dims = [dims]
dims = [dataset.get_dimension(d, strict=True) for d in dims]
constraints = [d.name for d in dims]
slice_dims = [d for d in dataset.kdims if d not in dims]
# Update the kwargs appropriately for Element group types
group_kwargs = {}
group_type = dict if group_type == 'raw' else group_type
if issubclass(group_type, Element):
group_kwargs.update(util.get_param_values(dataset))
group_kwargs['kdims'] = slice_dims
group_kwargs.update(kwargs)
drop_dim = any(d not in group_kwargs['kdims'] for d in slice_dims)
unique_coords = product(
*[cls.values(dataset, d, expanded=False) for d in dims])
data = []
for key in unique_coords:
constraint = iris.Constraint(**dict(zip(constraints, key)))
extracted = dataset.data.extract(constraint)
if drop_dim:
extracted = group_type(extracted,
kdims=slice_dims,
vdims=dataset.vdims).columns()
cube = group_type(extracted, **group_kwargs)
data.append((key, cube))
if issubclass(container_type, NdMapping):
with item_check(False), sorted_context(False):
return container_type(data, kdims=dims)
else:
return container_type(data)
def get_data(self, element, ranges, style):
mapping = dict(self._mapping)
if self.static_source: return {}, mapping, style
if hasattr(element.data, 'with_scale'):
feature = element.data.with_scale(self.scale)
else:
feature = copy.copy(element.data)
feature.scale = self.scale
geoms = list(feature.geometries())
if isinstance(geoms[0], line_types):
el_type = Contours
style['plot_method'] = 'multi_line'
style.pop('fill_color', None)
style.pop('fill_alpha', None)
else:
el_type = Polygons
polys = el_type(geoms, crs=element.crs, **util.get_param_values(element))
return super(FeaturePlot, self).get_data(polys, ranges, style)
def get_data(self, element, ranges, style):
mapping = dict(self._mapping)
if self.static_source: return {}, mapping, style
if hasattr(element.data, 'with_scale'):
feature = element.data.with_scale(self.scale)
else:
feature = copy.copy(element.data)
feature.scale = self.scale
geoms = list(feature.geometries())
if isinstance(geoms[0], line_types):
el_type = Contours
style['plot_method'] = 'multi_line'
style.pop('fill_color', None)
style.pop('fill_alpha', None)
else:
el_type = Polygons
polys = el_type(geoms, crs=element.crs, **util.get_param_values(element))
return super(FeaturePlot, self).get_data(polys, ranges, style)
def groupby(cls, dataset, dims, container_type=HoloMap, group_type=None, **kwargs):
"""
Groups the data by one or more dimensions returning a container
indexed by the grouped dimensions containing slices of the
cube wrapped in the group_type. This makes it very easy to
break up a high-dimensional dataset into smaller viewable chunks.
"""
import iris
if not isinstance(dims, list): dims = [dims]
dims = [dataset.get_dimension(d, strict=True) for d in dims]
constraints = [d.name for d in dims]
slice_dims = [d for d in dataset.kdims if d not in dims]
# Update the kwargs appropriately for Element group types
group_kwargs = {}
group_type = dict if group_type == 'raw' else group_type
if issubclass(group_type, Element):
group_kwargs.update(util.get_param_values(dataset))
group_kwargs['kdims'] = slice_dims
group_kwargs.update(kwargs)
drop_dim = any(d not in group_kwargs['kdims'] for d in slice_dims)
unique_coords = product(*[cls.values(dataset, d, expanded=False)
for d in dims])
data = []
for key in unique_coords:
constraint = iris.Constraint(**dict(zip(constraints, key)))
extracted = dataset.data.extract(constraint)
if drop_dim:
extracted = group_type(extracted, kdims=slice_dims,
vdims=dataset.vdims).columns()
cube = group_type(extracted, **group_kwargs)
data.append((key, cube))
if issubclass(container_type, NdMapping):
with item_check(False), sorted_context(False):
return container_type(data, kdims=dims)
else:
return container_type(data)
