def __init__(self, config=None):
if config is None:
config = SectionPlotConfig()
self.config = config
self._disconnect_data = []
self._width = self._height = self._pixels = None
self._plt = plot.mpl_init(self.config.font_size)
self._fig = fig = self._plt.figure(figsize=self.config.size_inch)
rect = [0., 0., 1., 1.]
self._axes_xy = Axes(fig, rect)
self._axes_xz = Axes(fig, rect)
self._axes_zy = Axes(fig, rect)
self._view_limits = num.zeros((3, 2))
self._view_limits[:, :] = num.nan
self._update_geometry()
for axes in self.axes_list:
fig.add_axes(axes)
self._connect(axes, 'xlim_changed', self.lim_changed_handler)
self._connect(axes, 'ylim_changed', self.lim_changed_handler)
self._cid_resize = fig.canvas.mpl_connect('resize_event',
self.resize_handler)
self._connect(fig, 'dpi_changed', self.dpi_changed_handler)
self._lim_changed_depth = 0
def __init__(self, ax, cview_args={}, display_args={}, colormap=[]):
cview_ax = Axes(ax.get_figure(), ax.get_position(original=True))
cmap_ax = Axes(ax.get_figure(), ax.get_position(original=True))
self.ax = ax
self.cview = ColorViewer(cview_ax, **cview_args)
self.colormap = MapDisplay(cmap_ax, self.cview, **display_args)
for name, color in colormap:
self.colormap.add_item(name, color)
divider = make_axes_locatable(ax)
pad = Size.Fixed(0.1)
colormap_width = Size.Fraction(0.29, Size.AxesX(ax))
cview_width = Size.Fraction(0.7, Size.AxesX(ax))
divider.set_horizontal([colormap_width, pad, cview_width])
cmap_ax.set_axes_locator(divider.new_locator(nx=0, ny=0))
ax.figure.add_axes(cmap_ax)
cview_ax.set_axes_locator(divider.new_locator(nx=2, ny=0))
ax.figure.add_axes(cview_ax)
ax.tick_params(left=False,
bottom=False,
labelleft=False,
labelbottom=False)
ax.set_axis_off()
def __init__(self, draw, data, ax_kwargs={},
dpi=50, frameon=False, figsize=[8, 6],
transparent=False, axes_off=True):
super().__init__(dpi=dpi, frameon=frameon, figsize=figsize)
ax = Axes(self, [0., 0., 1., 1.])
if axes_off:
ax.set_axis_off()
result = draw(**data, **ax_kwargs, ax=ax)
# if draw function only returns the axes
if isinstance(result, Axes):
ax = result
else:
(ax, self.x_lim, self.y_lim) = result[0:3]
if len(result) > 3:
self.other_returns = result[3:]
self.add_axes(ax)
self.buffer = io.BytesIO()
self.savefig(self.buffer,
transparent=transparent, dpi=dpi,
pad_inches=0, format='png')
def set_colorbar(self, vmin: float, vmax: float, cmap="viridis", norm=None, label: str = None):
"""
Create a colorbar and display the figure in the colorbar widget
Args:
vmin: Minimun value of the colorbar
vmax: Maximum value of the colorbar
cmap: Colormap of the colorbar
norm: (optionl) Normalization, in case that not, this is internally managed
label: Text to display as label in the colorbar
Returns:
"""
if self.colorbar is not None:
if isinstance(cmap, str):
cmap = plt.get_cmap(cmap)
label = label if label is not None else self._label
cb = Figure()
ax = Axes(cb, self._dim_label_ax)
cb.add_axes(ax)
norm = matplotlib.colors.Normalize(vmin=vmin, vmax=vmax) if norm is None else norm
cb1 = matplotlib.colorbar.ColorbarBase(ax, cmap=cmap, norm=norm, orientation=self.pos_colorbar)
cb1.set_label(label, size=self._size_label_cbar) if label is not None else None
cb1.ax.tick_params(labelsize=self._size_label_cbar)
self.colorbar.object = cb
self.colorbar.param.trigger("object")
def __init__(self, selection, font_sz = 8, pad = 4, legend = None):
self._selection = selection
self._ax = Axes(selection._graph.ax.get_figure(), selection._graph.ax.get_position(original = True))
self._legend = legend
button_sz = 1.0 / (self._ax.figure.get_dpi() / (font_sz + pad))
n_rows, pad_sz = 5, 0.02
rows = [ i * (button_sz + pad_sz) for i in range(n_rows) ]
self._actions = {
"hide": Option(self._ax, (0.0, rows[4]), 0.49, button_sz, font_sz, "hide selection", self._hide_selection),
"restore": Option(self._ax, (0.51, rows[4]), 0.49, button_sz, font_sz, "restore selection", self._restore_selection),
"in": Toggle(self._ax, (0.0, rows[3]), 0.49, button_sz, font_sz, self._toggle_in_neighbors, "hide in neighbors", "restore in neighbors"),
"out": Toggle(self._ax, (0.51, rows[3]), 0.49, button_sz, font_sz, self._toggle_out_neighbors, "hide out neighbors", "restore out neighbors"),
"complement": Toggle(self._ax, (0.0, rows[2]), 1.0, button_sz, font_sz, self._toggle_complement, "hide others", "restore others"),
"remove": Option(self._ax, (0.0, rows[1]), 1.0, button_sz, font_sz, "remove selection", self._remove_selection),
"deselect": Option(self._ax, (0.0, rows[0]), 1.0, button_sz, font_sz, "deselect all", self._deselect_all),
}
self._ax.tick_params(left = False, labelleft = False, bottom = False, labelbottom = False)
self._ax.set_frame_on(False)
self._ax.set_anchor("NW")
self._ax.set_ylim(0, n_rows * button_sz + (n_rows - 1) * pad_sz)
def __init__(self, graph, selection):
self._graph = graph
self._selection = selection
self._groups = []
self._ax = Axes(self._graph.ax.get_figure(),
self._graph.ax.get_position(original=True))
def __init__(self, graph, font_sz=8, pad=4):
self._graph = graph
self._ax = Axes(graph.ax.get_figure(),
graph.ax.get_position(original=True))
button_sz = 1.0 / (self._ax.figure.get_dpi() / (font_sz + pad))
n_rows, pad_sz = len(graph.press_actions), 0.02
rows = [i * (button_sz + pad_sz) for i in range(n_rows)]
self._actions = {}
for name, row in zip(graph.press_actions, rows):
action = self._set_action(name)
self._actions[name] = Toggle(self._ax, (0.0, row), 1.0, button_sz,
font_sz, action, name)
current = graph._press_action
self._actions[current]._set_pressed()
self._ax.tick_params(left=False,
labelleft=False,
bottom=False,
labelbottom=False)
self._ax.set_frame_on(False)
self._ax.set_anchor("NW")
self._ax.set_ylim(0, n_rows * button_sz + (n_rows - 1) * pad_sz)
def configure_axes(figure, rect=None, _=None):
axes = Axes(figure, rect or [0, 0, 1, 1])
figure.add_axes(axes)
return axes
def _process(self, element, key=None):
try:
from matplotlib.contour import QuadContourSet
from matplotlib.axes import Axes
from matplotlib.figure import Figure
except ImportError:
raise ImportError("contours operation requires matplotlib.")
extent = element.range(0) + element.range(1)[::-1]
if type(element) is Raster:
data = [np.flipud(element.data)]
elif isinstance(element, Image):
data = [np.flipud(element.dimension_values(2, flat=False))]
elif isinstance(element, QuadMesh):
data = (element.dimension_values(0, False),
element.dimension_values(1, False), element.data[2])
if isinstance(self.p.levels, int):
levels = self.p.levels + 1 if self.p.filled else self.p.levels
zmin, zmax = element.range(2)
levels = np.linspace(zmin, zmax, levels)
else:
levels = self.p.levels
xdim, ydim = element.dimensions('key', label=True)
fig = Figure()
ax = Axes(fig, [0, 0, 1, 1])
contour_set = QuadContourSet(ax,
*data,
filled=self.p.filled,
extent=extent,
levels=levels)
if self.p.filled:
contour_type = Polygons
levels = np.convolve(levels, np.ones((2, )) / 2, mode='valid')
else:
contour_type = Contours
vdims = element.vdims[:1]
paths = []
for level, cset in zip(levels, contour_set.collections):
for path in cset.get_paths():
if path.codes is None:
subpaths = [path.vertices]
else:
subpaths = np.split(path.vertices,
np.where(path.codes == 1)[0][1:])
for p in subpaths:
paths.append({
(xdim, ydim): p,
element.vdims[0].name: level
})
contours = contour_type(paths,
label=element.label,
kdims=element.kdims,
vdims=vdims)
if self.p.overlaid:
contours = element * contours
return contours
def get_contours(self):
from matplotlib.contour import QuadContourSet
from matplotlib.axes import Axes
from matplotlib.figure import Figure
# Use method matplotlib
fig = Figure()
ax = Axes(fig, [0, 0, 1, 1])
# Get extent
if self.dic:
extent=(self.x0_ppm, self.x1_ppm, self.y0_ppm, self.y1_ppm)
else:
extent=None
# calculate contour levels
cl = self.get_contour_levels()
# Get contours
contour_set = QuadContourSet(ax, self.data, filled=False, extent=extent, levels=cl)
# To plot in bokeh
xs = []
ys = []
intensity = []
xt = []
yt = []
col = []
text = []
isolevelid = 0
color_palettes = bp.viridis(len(cl))
for level, isolevel in zip(cl, contour_set.collections):
level_round = round(level, 2)
#theiso = str(contour_set.get_array()[isolevelid])
theiso = str(level_round)
# Get colour
#isocol = isolevel.get_color()[0]
#thecol = 3 * [None]
#for i in range(3):
# thecol[i] = int(255 * isocol[i])
#thecol = '#%02x%02x%02x' % (thecol[0], thecol[1], thecol[2])
thecol = color_palettes[isolevelid]
for path in isolevel.get_paths():
v = path.vertices
x = v[:, 0]
y = v[:, 1]
xs.append(x.tolist())
ys.append(y.tolist())
intensity.append(level)
xt.append(x[int(len(x) / 2)])
yt.append(y[int(len(y) / 2)])
text.append(theiso)
col.append(thecol)
# Add to counter
isolevelid += 1
cdata={'xs': xs, 'ys': ys, 'line_color': col, 'intensity': intensity}
ctext={'xt':xt,'yt':yt,'text':text}
return cdata, ctext
def figure(self, key):
style = self[key]
figure = Figure(figsize=(0.1, 0.1)) # TODO: hardcoded
axes = Axes(figure, [0, 0, 1, 1], yticks=[], xticks=[], frame_on=False)
figure.add_axes(axes)
axes.patch.set_visible(False)
marker_style = style.point_style()
marker_style["s"] = 40 # Reset size
axes.scatter(0, 0, **marker_style)
return figure
def figure(self, name):
from matplotlib.axes import Axes
style = self[name]
plt.figure(figsize=(0.1, 0.1)) # TODO: hardcoded
ax = Axes(plt.gcf(), [0, 0, 1, 1], yticks=[], xticks=[], frame_on=False)
plt.gcf().delaxes(plt.gca())
plt.gcf().add_axes(ax)
#plt.axis('off')
plt.scatter(0, 0, marker=style["marker"], c=[style["color"]])
plt.autoscale(tight=True)
def create_and_prepare_axes(figure, extent, **kwargs):
# import matplotlib.figure.Figure.text
ax = Axes(figure, extent) # , label=kwargs.get('toc_uid', ''))
ax.spines['right'].set_visible(False)
ax.spines['top'].set_visible(False)
ax.spines['left'].set_visible(False)
ax.spines['bottom'].set_visible(False)
ax.xaxis.set_major_locator(NullLocator())
ax.yaxis.set_major_locator(NullLocator())
figure.add_axes(ax)
return ax
def __init__(self, ax):
self.ax = Axes(ax.get_figure(), ax.get_position(original=True))
self.ax.set_aspect("equal")
self.ax.set_anchor("NE")
self._visible_vertices, self._visible_edges = {}, {}
self._hidden_vertices, self._hidden_edges = {}, {}
self._press_action = "move"
self._press_actions = {
"move": None,
}
def __init__(self, extent: list = None, **kwargs):
"""Importing packages and setting correctly the path to the devito package, this beacuse we need the examples"""
self.Load_Area = LoadSaveTopoModule(extent=extent, **kwargs)
self.vp = None # Normalized or smoothed or None topography to be the velocity model
self.model: Model = None # the model
self.time_range = None # the time of the simulation
self.src = None # the ricker source
self.u = None # wavefield time function
self.pde = None # PDE to solve. Wave equation with corresponding discretizations
self.stencil = None # a time marching updating equation known as a stencil using customized SymPy functions
self.src_coordinates = []
self.src_term = [] # all sources together
self.rec = None
self.rec_term = [] # all receivers
# After constructing all the necessary expressions for updating the wavefield,
# injecting the source term and interpolating onto the receiver points, we can now create the Devito operator
self.op = None
self.n_frames_speed = 10
self.frequency = 0.025 # Source peak frequency is 25Hz (0.025 kHz)
# self.aruco_sources_coord = []
# For the cropping, because when normalizing the velocities dont work
self.crop = True
self.xy_aruco = []
# for the plotting
self.timeslice = 0
self.threshold = 0.03
self.field = None
self.p_velocity = True
self.ready_velocity = False
self.p_wave = True
self.ready_wave = False
self.framerate = 10
self._vp = None
self._w = None
self.real_time = False
self.model_extent = None
self.frame = None
self.extent = None
self.max_wave_frame = 1
# Widgets
self.lock = None
self.figure = Figure()
self.axes = Axes(self.figure, [0., 0., 1., 1.])
self.figure.add_axes(self.axes)
self.panel_figure = pn.pane.Matplotlib(self.figure, tight=True)
plt.close(self.figure) # close figure to prevent inline display
logger.info("SeismicModule loaded successfully")
def inset_axes(self,
bounds,
*,
polar=True,
transform=None,
zorder=5,
**kwargs):
""" Serves as a stand-in for Axes.inset_axes, but also allows polar projection
Args:
self (Axes): Axes object
bounds (list): (x, y, xsize, ysize)
polar (bool): polar projection
transform (Transfomr): Defaults to `ax.transAxes`, i.e. the units of *rect* are in
axes-relative coordinates.
zorder (int): Defaults to 5 (same as `.Axes.legend`). Adjust higher or lower
to change whether it is above or below data plotted on the
parent axes.
**kwargs: Other *kwargs* are passed on to the `axes.Axes` child axes.
Returns:
Axes - The created `.axes.Axes` instance.
"""
if transform is None:
transform = self.transAxes
label = kwargs.pop('label', 'inset_axes')
# This puts the rectangle into figure-relative coordinates.
inset_locator = _make_inset_locator(bounds, transform, self)
bb = inset_locator(None, None)
if polar:
inset_ax = PolarAxes(self.figure,
bb.bounds,
zorder=zorder,
label=label,
**kwargs)
else:
inset_ax = Axes(self.figure,
bb.bounds,
zorder=zorder,
label=label,
**kwargs)
# this locator lets the axes move if in data coordinates.
# it gets called in `ax.apply_aspect() (of all places)
inset_ax.set_axes_locator(inset_locator)
self.add_child_axes(inset_ax)
return inset_ax
def preview(path, ext=0, width=None, minwidth=256, maxwidth=1024):
"""
Preview FITS image as PNG
"""
base = stdconf.get('basepath', '.')
fullpath = os.path.join(base, path)
# Optional parameters
fmt = request.args.get('format', 'jpeg')
quality = int(request.args.get('quality', 80))
width = request.args.get('width', width)
if width is not None:
width = int(width)
data = fits.getdata(fullpath, ext)
figsize = [data.shape[1], data.shape[0]]
if width is None:
if figsize[0] < minwidth:
width = minwidth
elif figsize[0] > maxwidth:
width = maxwidth
if width is not None and figsize[0] != width:
figsize[1] = width*figsize[1]/figsize[0]
figsize[0] = width
fig = Figure(facecolor='white', dpi=72, figsize=(figsize[0]/72, figsize[1]/72))
ax = Axes(fig, [0., 0., 1., 1.])
# ax.set_axis_off()
fig.add_axes(ax)
plots.imshow(data, ax=ax, show_axis=False, show_colorbar=False,
cmap=request.args.get('cmap', 'Blues_r'),
stretch=request.args.get('stretch', 'linear'),
qq=[float(request.args.get('qmin', 0.5)), float(request.args.get('qmax', 99.5))])
if request.args.get('ra', None) is not None and request.args.get('dec', None) is not None:
# Show the position of the object
header = fits.getheader(fullpath, ext)
wcs = WCS(header)
x,y = wcs.all_world2pix(float(request.args.get('ra')), float(request.args.get('dec')), 0)
ax.add_artist(Circle((x, y), 5.0, edgecolor='red', facecolor='none', ls='-', lw=2))
buf = io.BytesIO()
fig.savefig(buf, format=fmt, quality=quality)
return Response(buf.getvalue(), mimetype='image/%s' % fmt)
def inset_axes(parent_axes, width, height, loc=1,
bbox_to_anchor=None, bbox_transform=None,
axes_class=None,
axes_kwargs=None,
**kwargs):
if axes_class is None:
axes_class = Axes
if axes_kwargs is None:
inset_axes = Axes(parent_axes.figure, parent_axes.get_position())
else:
inset_axes = Axes(parent_axes.figure, parent_axes.get_position(),
**axes_kwargs)
axes_locator = AnchoredSizeLocator(parent_axes.bbox,
width, height,
loc=loc)
inset_axes.set_axes_locator(axes_locator)
_add_inset_axes(parent_axes, inset_axes)
return inset_axes
def __init__(self,
numbers,
left_labels = None,
right_labels = None, # 'proportion' 'rank'
colors = None,
line_dic = None,
sort = False,
slice = None, # one-based indexing
global_view = False,
auto_scale = False,
color_dic = None,
title = None,
xlabel = None,
ylabel = None,
legend_title = None,
legend_visible = True,
file_name = None,
**kwargs):
"""
The data space can adapt to long labels but only to
some extent because the long label sizes are fixed.
This class moves the edges of the axes to make room
for labels (SEE Matplotlib HOW-TOs).
"""
if 'log_level' in kwargs:
logging.basicConfig(format='{levelname}:\n{message}',
level= getattr(logging, kwargs['log_level']),
style = '{')
# Configuration: matplotlibrc is decorated by conf.py.
self.conf = Conf.change_conf(kwargs)
# Data formatted by the model.
self.data = None
# Core Matplotlib objects.
self.fig = None
self.ax = None
self.canvas = None
self.vertical_line = None
self.bars = None # BarContainer.
self._virtual_bars = None # For global_view.
# Helper attributes.
self._left_label_data = None
self._right_label_texts = None
# Titles.
self.title = title
self.xlabel = xlabel
self.ylabel = ylabel
self.legend_title = legend_title
self._global_view = global_view
self.legend = None
self._legend_width = 0
self.legend_visible = legend_visible
# The vertical line.
self.line_x = None
self.line_label = None
self.line_color = None
# Original position of the axes edges in the figure.
self._x0 = 0
self._y0 = 0
self._width = 1
self._height = 1
# To deal with not square figures,
# only x sizes are adapted.
self._x_coeff = 1
#########################################################
# Model.
factory = ModelFactory(
numbers,
global_view = global_view,
left_labels = left_labels,
right_labels = right_labels,
colors = colors,
sort = sort,
slice = slice,
default_label = self.conf['default_label'],
color_dic = color_dic,
tints = self.conf['tints'],
default_color = self.conf['default_color'])
self.data = factory.model
self.fig = Figure(figsize = self.conf['figsize'],
dpi = self.conf['dpi'])
self.canvas = FigureCanvasAgg(self.fig)
self.ax = Axes(self.fig,
[self._x0,
self._y0,
self._width,
self._height])
self.fig.add_axes(self.ax)
self.canvas.draw()
w, h = self.fig.get_size_inches()
self._x_coeff = h / w
# margin.
margin = self.conf['margin']
self._x0 = self._x_coeff * margin
self._y0 = margin
self._width = self._width - 2 * self._x_coeff * margin
self._height = self._height - 2 * margin
self._set_position()
self.ax.tick_params(axis = 'y',
length = 0)
self.ax.grid(b = True,
axis = 'x',
which = 'both',
color = 'black',
alpha = 0.3)
for name in ['top', 'right']:
self.ax.spines[name].set_visible(False)
# xscale.
if auto_scale is True:
# To improve clarity.
if self.data.spread > 1 or self.data.maximum > 1e6:
self.ax.set(xscale = 'log')
else:
default_formatter = self.ax.get_xaxis().get_major_formatter()
custom_formatter = self.build_formatter(default_formatter)
formatter = matplotlib.ticker.FuncFormatter(custom_formatter)
self.ax.get_xaxis().set_major_formatter(formatter)
# Title.
if self.title is not None:
self._manage_title()
_kwargs = dict()
# Left labels.
if self.data.left_labels is not None:
_kwargs['tick_label'] = self.data.left_labels
else:
_kwargs['tick_label'] = ''
# colors.
if self.data.actual_colors is not None:
_kwargs['color'] = self.data.actual_colors
else:
_kwargs['color'] = self.data.default_color
# bars.
self.bars = self.ax.barh(list(range(self.data.length)),
self.data.numbers,
height = 1,
edgecolor = 'white',
linewidth = 1, # 0.4
alpha = self.conf['color_alpha'],
**_kwargs)
# To fix x bounds, virtual bars are used.
if self._global_view is True:
self._virtual_bars = self.ax.barh(
[0, 0],
[self.data.minimum,
self.data.maximum],
height = 0.5,
edgecolor = 'white',
linewidth = 1, # 0.4
alpha = self.conf['color_alpha'],
visible = False)
# The vertical line.
if line_dic is not None:
self._set_line(line_dic)
if (self.line_x is not None and
self.data.minimum <= self.line_x <= self.data.maximum):
#
self.vertical_line = self.ax.axvline(
self.line_x,
ymin = 0,
ymax = 1,
color = self.line_color,
linewidth = 2,
alpha = self.conf['color_alpha'])
# Left label constraint solving.
self._make_room_for_left_labels()
# ylabel.
if self.ylabel is not None:
self._manage_ylabel()
# Legend.
if (self.legend_visible is True and
self.data.colors is not None):
#
self._draw_legend()
self._make_room_for_legend()
# Right labels.
if self.data.right_labels is not None:
self._draw_right_labels()
self._make_room_for_right_labels()
min_tick_y = self._clean_x_ticklabels()
# xlabel.
if self.xlabel is not None:
self._manage_xlabel(min_tick_y)
else:
delta_y0 = abs(self._y0 - min_tick_y)
self._y0 = self._y0 + delta_y0
self._height = self._height - delta_y0
self._set_position()
self.canvas.draw()
# Printing.
if file_name is not None:
self.canvas.print_png(file_name)
def plot_hex_and_violin(abscissa,
ordinate,
bin_edges,
extent=None,
xlabel="",
ylabel="",
zlabel="",
do_hex=True,
do_violin=True,
cm=plt.cm.inferno,
axis=None,
v_padding=.015,
**kwargs):
"""
takes two arrays of coordinates and creates a 2D hexbin plot and a violin plot (or
just one of them)
Parameters
----------
abscissa, ordinate : arrays
the coordinates of the data to plot
bin_edges : array
bin edges along the abscissa
extent : 4-tuple of floats (default: None)
extension of the abscissa, ordinate; given as is to plt.hexbin
xlabel, ylabel : strings (defaults: "")
labels for the two axes of either plot
zlabel : string (default: "")
label for the colorbar of the hexbin plot
do_hex, do_violin : bools (defaults: True)
whether or not to do the respective plots
cm : colour map (default: plt.cm.inferno)
colour map to be used for the hexbin plot
kwargs : args dictionary
more arguments to be passed to plt.hexbin
"""
if axis:
if do_hex and do_violin:
from matplotlib.axes import Axes
from matplotlib.transforms import Bbox
axis_bbox = axis.get_position()
axis.axis("off")
else:
plt.sca(axis)
# make a normal 2D hexplot from the given data
if do_hex:
# if we do both plot types,
if do_violin:
if axis:
ax_hex_pos = axis_bbox.get_points().copy(
) # [[x0, y0], [x1, y1]]
ax_hex_pos[0, 1] += np.diff(ax_hex_pos,
axis=0)[0, 1] * (.5 + v_padding)
ax_hex = Axes(plt.gcf(), Bbox.from_extents(ax_hex_pos))
plt.gcf().add_axes(ax_hex)
plt.sca(ax_hex)
ax_hex.set_xticklabels([])
else:
plt.subplot(211)
plt.hexbin(abscissa,
ordinate,
gridsize=40,
extent=extent,
cmap=cm,
**kwargs)
cb = plt.colorbar()
cb.set_label(zlabel)
plt.xlabel(xlabel)
plt.ylabel(ylabel)
if extent:
plt.xlim(extent[:2])
plt.ylim(extent[2:])
# prepare and draw the data for the violin plot
if do_violin:
# if we do both plot types, open a subplot
if do_hex:
if axis:
ax_vio_pos = axis_bbox.get_points().copy(
) # [[x0, y0], [x1, y1]]
ax_vio_pos[1, 1] -= np.diff(ax_vio_pos,
axis=0)[0, 1] * (.5 + v_padding)
ax_vio = Axes(plt.gcf(), Bbox.from_extents(ax_vio_pos))
plt.gcf().add_axes(ax_vio)
plt.sca(ax_vio)
else:
plt.subplot(212)
# to plot the violins, sort the ordinate values into a dictionary
# the keys are the central values of the bins given by `bin_edges`
val_vs_dep = {}
bin_centres = (bin_edges[1:] + bin_edges[:-1]) / 2.
for dep, val in zip(abscissa, ordinate):
# get the bin number this event belongs into
# outliers are put into the first and last bin accordingly
ibin = np.clip(
np.digitize(dep, bin_edges) - 1, 0,
len(bin_centres) - 1)
# the central value of the bin is the key for the dictionary
if bin_centres[ibin] not in val_vs_dep:
val_vs_dep[bin_centres[ibin]] = [val]
else:
val_vs_dep[bin_centres[ibin]] += [val]
keys = [k[0] for k in sorted(val_vs_dep.items())]
vals = [k[1] for k in sorted(val_vs_dep.items())]
# calculate the widths of the violins as 90 % of the corresponding bin width
widths = []
for cen, wid in zip(bin_centres, (bin_edges[1:] - bin_edges[:-1])):
if cen in keys:
widths.append(wid * .9)
plt.violinplot(vals,
keys,
points=60,
widths=widths,
showextrema=False,
showmedians=True)
plt.xlabel(xlabel)
plt.ylabel(ylabel)
if extent:
# adding a colour bar to the hexbin plot reduces its width by 1/5
# adjusting the extent of the violin plot to sync up with the hexbin plot
plt.xlim([
extent[0],
(5. * extent[1] - extent[0]) / 4. if do_hex else extent[1]
])
# for good measure also sync the vertical extent
plt.ylim(extent[2:])
plt.grid()
def draw(self):
prefs = self.prefs
dpi = self.ax_contain.figure.get_dpi()
# Update palette
palette = prefs.get('colors', {})
if palette:
self.palette.addPalette(palette)
xlabel = prefs.get('xlabel', '')
ylabel = prefs.get('ylabel', '')
xticks_flag = prefs.get('xticks', True)
yticks_flag = prefs.get('yticks', True)
text_size = prefs['text_size']
text_padding = prefs['text_padding']
label_text_size = prefs.get('label_text_size', text_size)
label_text_size_point = pixelToPoint(label_text_size, dpi)
tick_text_size = prefs.get('tick_text_size', text_size)
tick_text_size_point = pixelToPoint(tick_text_size, dpi)
ytick_length = prefs.get('ytick_length', 7 * tick_text_size)
plot_title = prefs.get('plot_title', '')
if not plot_title or plot_title == 'NoTitle':
plot_title_size = 0
plot_title_padding = 0
else:
plot_title_size = prefs.get('plot_title_size', text_size)
plot_title_padding = prefs.get('plot_text_padding', text_padding)
plot_title_size_point = pixelToPoint(plot_title_size, dpi)
stats_flag = prefs.get('statistics_line', False)
stats_line = ''
stats_line_space = 0.
if stats_flag:
stats_line = self.gdata.getStatString()
stats_line_size = label_text_size
stats_line_padding = label_text_size * 2.
stats_line_space = stats_line_size + stats_line_padding
plot_padding = prefs['plot_padding']
plot_left_padding = prefs.get('plot_left_padding', plot_padding)
plot_right_padding = prefs.get('plot_right_padding', 0)
plot_bottom_padding = prefs.get('plot_bottom_padding', plot_padding)
plot_top_padding = prefs.get('plot_top_padding', 0)
frame_flag = prefs['frame']
# Create plot axes, and set properties
left, bottom, width, height = self.ax_contain.get_window_extent(
).bounds
l, b, f_width, f_height = self.figure.get_window_extent().bounds
# Space needed for labels and ticks
x_label_space = 0
if xticks_flag:
x_label_space += tick_text_size * 1.5
if xlabel:
x_label_space += label_text_size * 1.5
y_label_space = 0
if yticks_flag:
y_label_space += ytick_length
if ylabel:
y_label_space += label_text_size * 1.5
ax_plot_rect = ( float( plot_left_padding + left + y_label_space ) / f_width,
float( plot_bottom_padding + bottom + x_label_space + stats_line_space ) / f_height,
float( width - plot_left_padding - plot_right_padding - y_label_space ) / f_width,
float( height - plot_bottom_padding - plot_top_padding - x_label_space - \
plot_title_size - 2 * plot_title_padding - stats_line_space ) / f_height )
ax = Axes(self.figure, ax_plot_rect)
if prefs['square_axis']:
l, b, a_width, a_height = ax.get_window_extent().bounds
delta = abs(a_height - a_width)
if a_height > a_width:
a_height = a_width
ax_plot_rect = (
float(plot_left_padding + left) / f_width,
float(plot_bottom_padding + bottom + delta / 2.) /
f_height,
float(width - plot_left_padding - plot_right_padding) /
f_width,
float(height - plot_bottom_padding - plot_title_size -
2 * plot_title_padding - delta) / f_height)
else:
a_width = a_height
ax_plot_rect = (
float(plot_left_padding + left + delta / 2.) / f_width,
float(plot_bottom_padding + bottom) / f_height,
float(width - plot_left_padding - delta) / f_width,
float(height - plot_bottom_padding - plot_title_size -
2 * plot_title_padding) / f_height)
ax.set_position(ax_plot_rect)
self.figure.add_axes(ax)
self.ax = ax
frame = ax.patch
frame.set_fill(False)
if frame_flag.lower() == 'off':
self.ax.set_axis_off()
self.log_xaxis = False
self.log_yaxis = False
else:
# If requested, make x/y axis logarithmic
if prefs.get('log_xaxis', 'False').find('r') >= 0:
ax.semilogx()
self.log_xaxis = True
else:
self.log_xaxis = False
if prefs.get('log_yaxis', 'False').find('r') >= 0:
ax.semilogy()
self.log_yaxis = True
else:
self.log_yaxis = False
if xticks_flag:
setp(ax.get_xticklabels(), family=prefs['font_family'])
setp(ax.get_xticklabels(), fontname=prefs['font'])
setp(ax.get_xticklabels(), size=tick_text_size_point)
else:
setp(ax.get_xticklabels(), size=0)
if yticks_flag:
setp(ax.get_yticklabels(), family=prefs['font_family'])
setp(ax.get_yticklabels(), fontname=prefs['font'])
setp(ax.get_yticklabels(), size=tick_text_size_point)
else:
setp(ax.get_yticklabels(), size=0)
setp(ax.get_xticklines(), markeredgewidth=pixelToPoint(0.5, dpi))
setp(ax.get_xticklines(),
markersize=pixelToPoint(text_size / 2., dpi))
setp(ax.get_yticklines(), markeredgewidth=pixelToPoint(0.5, dpi))
setp(ax.get_yticklines(),
markersize=pixelToPoint(text_size / 2., dpi))
setp(ax.get_xticklines(), zorder=4.0)
line_width = prefs.get('line_width', 1.0)
frame_line_width = prefs.get('frame_line_width', line_width)
grid_line_width = prefs.get('grid_line_width', 0.1)
plot_line_width = prefs.get('plot_line_width', 0.1)
setp(ax.patch, linewidth=pixelToPoint(plot_line_width, dpi))
#setp( ax.spines, linewidth=pixelToPoint(frame_line_width,dpi) )
#setp( ax.axvline(), linewidth=pixelToPoint(1.0,dpi) )
axis_grid_flag = prefs.get('plot_axis_grid', True)
if axis_grid_flag:
ax.grid(True,
color='#555555',
linewidth=pixelToPoint(grid_line_width, dpi))
plot_axis_flag = prefs.get('plot_axis', True)
if plot_axis_flag:
# Set labels
if xlabel:
t = ax.set_xlabel(xlabel)
t.set_family(prefs['font_family'])
t.set_fontname(prefs['font'])
t.set_size(label_text_size)
if ylabel:
t = ax.set_ylabel(ylabel)
t.set_family(prefs['font_family'])
t.set_fontname(prefs['font'])
t.set_size(label_text_size)
else:
self.ax.set_axis_off()
# Create a plot title, if necessary
if plot_title:
self.ax.title = self.ax.text(
0.5,
1. + float(plot_title_padding) / height,
plot_title,
verticalalignment='bottom',
horizontalalignment='center',
size=pixelToPoint(plot_title_size, dpi),
family=prefs['font_family'],
fontname=prefs['font'])
self.ax.title.set_transform(self.ax.transAxes)
self.ax.title.set_family(prefs['font_family'])
self.ax.title.set_fontname(prefs['font'])
if stats_line:
self.ax.stats = self.ax.text(0.5, (-stats_line_space) / height,
stats_line,
verticalalignment='top',
horizontalalignment='center',
size=pixelToPoint(
stats_line_size, dpi))
self.ax.stats.set_transform(self.ax.transAxes)
def timeseriesPlot(category_list, **kwargs):
"""
Supported arguments (via \**kwargs):
:param curve_XXX: colon-separated curve info: (module_instance,[subtable],expr,title)
:param filter: include only rows where specified column in result set matches value, can be specified more than once: col,value
:param filter_XXX: include only rows where specified column in result set matches value for curve XXX, can be specified more than once: col,value
:param exclude: include only rows where specified column in result set matches value, can be specified more than once: col,value
:param exclude_XXX: include only rows where specified column in result set matches value for curve XXX, can be specified more than once: col,value
:param legend: Show legend in image
:param title: (string) Display a title above plot
:param ylabel: self-explanatory
:param start_date: Start date (Y-m-d)
:param end_date: End date (Y-m-d)
:param start_time: Start time (H:M)
:param end_date: End time (H:M)
:param renormalize: (true, false / 1, 0) Scales all curves to a [0,1] interval
"""
from matplotlib.axes import Axes
from matplotlib.figure import Figure
from matplotlib.dates import AutoDateFormatter, AutoDateLocator, date2num
import matplotlib.pyplot as plt
logger = logging.getLogger(__name__ + ".timeseriesPlot")
# generate plot
fig = plt.figure()
ax = Axes(fig, [.12, .15, .84, 0.78])
fig.add_axes(ax)
# extract constraints from kwargs dictionary
constraint = {'filter': {}, 'exclude': {}}
for t in constraint.iterkeys():
for key, value in kwargs.iteritems():
if key.startswith(t):
if len(key) <= len(t) + 1:
curve = None
else:
curve = key[len(t) + 1:]
if type(value) is not list:
value = [
value,
]
for constr in value:
if curve not in constraint[t]:
constraint[t][curve] = []
constraint[t][curve].append(constr.split(','))
errors = []
try:
# STAGE 1
logger.debug("TEST")
dat = getTimeseriesPlotConfig(**kwargs)
logger.debug(
"config: %s", "\n".join(
map(lambda x: str(x[0]) + ": " + str(x[1]), dat.iteritems())))
curve_dict = dat["curve_dict"]
data_sources = dat["data_sources"]
title = dat["title"]
legend = dat["legend"]
ylabel = dat["ylabel"]
timerange = dat["timerange"]
renormalize = dat["renormalize"]
auth_required = dat["auth_required"]
timerange = dat["timerange"]
errors.extend(dat["errors"])
# STAGE 3
# Calculate the data structures for each curve
vardict_name = "__internal_column_value_dict__"
regexp_dollarvar = re.compile(r"\$([_a-zA-Z0-9]+)")
for curve_name, (title, table, module_instance, expr,
table_name) in curve_dict.iteritems():
query = __timeseriesTableQuery(curve_name, table, module_instance,
constraint, timerange)
try:
result = query.execute()
try:
column_index = dict(
(col, i) for i, col in enumerate(result.keys()))
except TypeError: # backward compatibility
column_index = dict(
(col, i) for i, col in enumerate(result.keys))
source_data = result.fetchall()
except Exception, e:
logger.warning("Retrieving plot data:\n" +
traceback.format_exc())
errors.append("Data '%s': %s" % (key, str(e)))
continue
try:
num_rows = len(source_data)
if num_rows == 0:
logger.debug("no data downloaded for curve")
curve_dict[curve_name] = (title, [], [])
continue
logger.debug("Entries in sources: %i" % num_rows)
dates = np.zeros(num_rows)
data_points = np.zeros(num_rows)
min_val = max_val = None
use_matheval = False
math_expr = expr
# does the expression not match a column name?
# Replace $varnames by a dict call to create valid math expression.
if expr not in column_index:
use_matheval = True
math_expr = regexp_dollarvar.sub(vardict_name + "['\\1']",
expr)
logger.debug("Math expression " + repr(math_expr))
for i, row in enumerate(source_data):
variables = dict(
(col, row[i]) for col, i in column_index.iteritems())
dates[i] = date2num(row[0])
if use_matheval:
val = hf.utility.matheval(math_expr,
{vardict_name: variables})
else:
val = variables[expr]
data_points[i] = val
if min_val is None:
min_val = val
elif min_val > val:
min_val = val
if max_val is None:
max_val = val
elif max_val < val:
max_val = val
if renormalize and max_val - min_val != 0:
data_points = (data_points - min_val) / (max_val - min_val)
elif renormalize:
data_points = np.zeros(len(data_points)) + 0.5
curve_dict[curve_name] = (title, dates, data_points)
except Exception, e:
curve_dict[curve_name] = (title, [], [])
logger.warning("Retrieving plot data:\n" +
traceback.format_exc())
errors.append("Data '%s': %s" % (key, str(e)))
bingFile.split('/')[-1])
f.write("** Produced by %s\n" % sys.argv[0].split('/')[-1])
f.write("** Perpendicular distances [m]: %s\n" %
', '.join(str(k) for k in list(distances.keys())))
f.write("** Parellel distances [m]: %s\n" %
', '.join(str(k) for k in list(distances.values())))
f.write("** Resolution regular background grid: %dm\n" % bg_resolution)
for coord in zip(grid_x, grid_y):
f.write("RE disccart %0.1f %0.1f\n" % (coord[0], coord[1]))
f.close()
print("AERMOD receptor definition written to %s" % outputFile)
print("Plot roads and grid points")
fig = Figure(figsize=[14, 14])
ax = Axes(fig, [.1, .1, .8, .8])
# Add coordinates as lines to the plot
for i in range(len(knew)):
#for i in range(10):
(line1_xs, line1_ys) = zip(*knew[i])
#(line1_xs, line1_ys) = knew[i]
fig.add_axes(ax)
ax.add_line(Line2D(line1_xs, line1_ys, linewidth=2, color='k'))
ax.set_xlim(temp_xmin, temp_xmax)
ax.set_ylim(temp_ymin, temp_ymax)
# Plot road following points in red
ax.scatter(road_x, road_y, color='red', s=3)
def draw(self):
prefs = self.prefs
dpi = self.ax_contain.figure.get_dpi()
# Update palette
palette = prefs.get("colors", {})
if palette:
self.palette.addPalette(palette)
xlabel = prefs.get("xlabel", "")
ylabel = prefs.get("ylabel", "")
xticks_flag = prefs.get("xticks", True)
yticks_flag = prefs.get("yticks", True)
text_size = prefs["text_size"]
text_padding = prefs["text_padding"]
label_text_size = prefs.get("label_text_size", text_size)
label_text_size_point = pixelToPoint(label_text_size, dpi)
tick_text_size = prefs.get("tick_text_size", text_size)
tick_text_size_point = pixelToPoint(tick_text_size, dpi)
ytick_length = prefs.get("ytick_length", 7 * tick_text_size)
plot_title = prefs.get("plot_title", "")
if not plot_title or plot_title == "NoTitle":
plot_title_size = 0
plot_title_padding = 0
else:
plot_title_size = prefs.get("plot_title_size", text_size)
plot_title_padding = prefs.get("plot_text_padding", text_padding)
plot_title_size_point = pixelToPoint(plot_title_size, dpi)
stats_flag = prefs.get("statistics_line", False)
stats_line = ""
stats_line_space = 0.0
if stats_flag:
stats_line = self.gdata.getStatString()
stats_line_size = label_text_size
stats_line_padding = label_text_size * 2.0
stats_line_space = stats_line_size + stats_line_padding
plot_padding = prefs["plot_padding"]
plot_left_padding = prefs.get("plot_left_padding", plot_padding)
plot_right_padding = prefs.get("plot_right_padding", 0)
plot_bottom_padding = prefs.get("plot_bottom_padding", plot_padding)
plot_top_padding = prefs.get("plot_top_padding", 0)
frame_flag = prefs["frame"]
# Create plot axes, and set properties
left, bottom, width, height = self.ax_contain.get_window_extent(
).bounds
l, b, f_width, f_height = self.figure.get_window_extent().bounds
# Space needed for labels and ticks
x_label_space = 0
if xticks_flag:
x_label_space += tick_text_size * 1.5
if xlabel:
x_label_space += label_text_size * 1.5
y_label_space = 0
if yticks_flag:
y_label_space += ytick_length
if ylabel:
y_label_space += label_text_size * 1.5
ax_plot_rect = (
float(plot_left_padding + left + y_label_space) / f_width,
float(plot_bottom_padding + bottom + x_label_space +
stats_line_space) / f_height,
float(width - plot_left_padding - plot_right_padding -
y_label_space) / f_width,
float(height - plot_bottom_padding - plot_top_padding -
x_label_space - plot_title_size - 2 * plot_title_padding -
stats_line_space) / f_height,
)
ax = Axes(self.figure, ax_plot_rect)
if prefs["square_axis"]:
l, b, a_width, a_height = ax.get_window_extent().bounds
delta = abs(a_height - a_width)
if a_height > a_width:
a_height = a_width
ax_plot_rect = (
float(plot_left_padding + left) / f_width,
float(plot_bottom_padding + bottom + delta / 2.0) /
f_height,
float(width - plot_left_padding - plot_right_padding) /
f_width,
float(height - plot_bottom_padding - plot_title_size -
2 * plot_title_padding - delta) / f_height,
)
else:
a_width = a_height
ax_plot_rect = (
float(plot_left_padding + left + delta / 2.0) / f_width,
float(plot_bottom_padding + bottom) / f_height,
float(width - plot_left_padding - delta) / f_width,
float(height - plot_bottom_padding - plot_title_size -
2 * plot_title_padding) / f_height,
)
ax.set_position(ax_plot_rect)
self.figure.add_axes(ax)
self.ax = ax
frame = ax.patch
frame.set_fill(False)
if frame_flag.lower() == "off":
self.ax.set_axis_off()
self.log_xaxis = False
self.log_yaxis = False
else:
# If requested, make x/y axis logarithmic
if prefs.get("log_xaxis", "False").find("r") >= 0:
ax.semilogx()
self.log_xaxis = True
else:
self.log_xaxis = False
if prefs.get("log_yaxis", "False").find("r") >= 0:
ax.semilogy()
self.log_yaxis = True
else:
self.log_yaxis = False
if xticks_flag:
setp(ax.get_xticklabels(), family=prefs["font_family"])
setp(ax.get_xticklabels(), fontname=prefs["font"])
setp(ax.get_xticklabels(), size=tick_text_size_point)
else:
setp(ax.get_xticklabels(), size=0)
if yticks_flag:
setp(ax.get_yticklabels(), family=prefs["font_family"])
setp(ax.get_yticklabels(), fontname=prefs["font"])
setp(ax.get_yticklabels(), size=tick_text_size_point)
else:
setp(ax.get_yticklabels(), size=0)
setp(ax.get_xticklines(), markeredgewidth=pixelToPoint(0.5, dpi))
setp(ax.get_xticklines(),
markersize=pixelToPoint(text_size / 2.0, dpi))
setp(ax.get_yticklines(), markeredgewidth=pixelToPoint(0.5, dpi))
setp(ax.get_yticklines(),
markersize=pixelToPoint(text_size / 2.0, dpi))
setp(ax.get_xticklines(), zorder=4.0)
line_width = prefs.get("line_width", 1.0)
frame_line_width = prefs.get("frame_line_width", line_width)
grid_line_width = prefs.get("grid_line_width", 0.1)
plot_line_width = prefs.get("plot_line_width", 0.1)
setp(ax.patch, linewidth=pixelToPoint(plot_line_width, dpi))
# setp( ax.spines, linewidth=pixelToPoint(frame_line_width,dpi) )
# setp( ax.axvline(), linewidth=pixelToPoint(1.0,dpi) )
axis_grid_flag = prefs.get("plot_axis_grid", True)
if axis_grid_flag:
ax.grid(True,
color="#555555",
linewidth=pixelToPoint(grid_line_width, dpi))
plot_axis_flag = prefs.get("plot_axis", True)
if plot_axis_flag:
# Set labels
if xlabel:
t = ax.set_xlabel(xlabel)
t.set_fontname(prefs["font"])
t.set_fontsize(label_text_size)
if ylabel:
t = ax.set_ylabel(ylabel)
t.set_fontname(prefs["font"])
t.set_fontsize(label_text_size)
else:
self.ax.set_axis_off()
# Create a plot title, if necessary
if plot_title:
self.ax.title = self.ax.text(
0.5,
1.0 + float(plot_title_padding) / height,
plot_title,
verticalalignment="bottom",
horizontalalignment="center",
size=pixelToPoint(plot_title_size, dpi),
family=prefs["font_family"],
fontname=prefs["font"],
)
self.ax.title.set_transform(self.ax.transAxes)
self.ax.title.set_fontname(prefs["font"])
if stats_line:
self.ax.stats = self.ax.text(
0.5,
(-stats_line_space) / height,
stats_line,
verticalalignment="top",
horizontalalignment="center",
size=pixelToPoint(stats_line_size, dpi),
)
self.ax.stats.set_transform(self.ax.transAxes)
def create_panel(self):
""" Initializes the matplotlib figure and empty axes according to projector calibration.
The figure can be accessed by its attribute. It will be 'deactivated' to prevent random apperance in notebooks.
"""
pn.extension(raw_css=[self.css])
# Create a panel object and serve it within an external bokeh browser that will be opened in a separate window
# In this special case, a "tight" layout would actually add again white space to the plt canvas,
# which was already cropped by specifying limits to the axis
self.figure = Figure(figsize=(self.p_frame_width / self.dpi, self.p_frame_height / self.dpi),
dpi=self.dpi)
self.ax = Axes(self.figure, [0., 0., 1., 1.])
self.figure.add_axes(self.ax)
self.ax.set_axis_off()
self.ax.get_xaxis().set_visible(False)
self.ax.get_yaxis().set_visible(False)
self.frame = pn.pane.Matplotlib(self.figure,
width=self.p_frame_width,
height=self.p_frame_height,
margin=[self.p_frame_top, 0, 0, self.p_frame_left],
tight=False,
dpi=self.dpi,
css_classes=['frame']
)
plt.close(self.figure) # close figure to prevent inline display
if self.enable_colorbar:
self.create_colorbar()
if self.enable_legend:
self.create_legend()
if self.enable_hot:
self.create_hot()
if self.enable_profile:
self.create_profile()
# Combine panel and deploy bokeh server
if self.pos_colorbar == "vertical":
self.sidebar = pn.Column(self.colorbar, self.legend, self.hot, self.profile,
margin=[self.p_frame_top, 0, 0, 0],
)
self.panel = pn.Row(pn.Column(self.frame, None),
self.sidebar,
width=self.p_width,
height=self.p_height,
sizing_mode='fixed',
css_classes=['panel']
)
elif self.pos_colorbar == "horizontal":
self.sidebar = pn.Column(self.legend, self.hot, self.profile,
margin=[self.p_frame_top, 0, 0, 0],
)
self.panel = pn.Row(pn.Column(self.frame, self.colorbar),
self.sidebar,
width=self.p_width,
height=self.p_height,
sizing_mode='fixed',
css_classes=['panel']
)
else:
raise AttributeError
return True
def _process(self, element, key=None):
try:
from matplotlib.contour import QuadContourSet
from matplotlib.axes import Axes
from matplotlib.figure import Figure
except ImportError:
raise ImportError("contours operation requires matplotlib.")
extent = element.range(0) + element.range(1)[::-1]
if type(element) is Raster:
data = [np.flipud(element.data)]
elif isinstance(element, Image):
data = [np.flipud(element.dimension_values(2, flat=False))]
elif isinstance(element, QuadMesh):
data = (element.dimension_values(0, False, flat=False),
element.dimension_values(1, False, flat=False),
element.dimension_values(2, flat=False))
xdim, ydim = element.dimensions('key', label=True)
if self.p.filled:
contour_type = Polygons
else:
contour_type = Contours
vdims = element.vdims[:1]
if isinstance(self.p.levels, int):
levels = self.p.levels + 2 if self.p.filled else self.p.levels + 3
zmin, zmax = element.range(2)
levels = np.linspace(zmin, zmax, levels)
if zmin == zmax:
contours = contour_type([], [xdim, ydim], vdims)
return (element * contours) if self.p.overlaid else contours
else:
levels = self.p.levels
fig = Figure()
ax = Axes(fig, [0, 0, 1, 1])
contour_set = QuadContourSet(ax,
*data,
filled=self.p.filled,
extent=extent,
levels=levels)
paths = []
empty = np.full((1, 2), np.NaN)
for level, cset in zip(contour_set.get_array(),
contour_set.collections):
subpaths = []
for path in cset.get_paths():
if path.codes is None:
subpaths.append(path.vertices)
else:
subpaths += np.split(path.vertices,
np.where(path.codes == 1)[0][1:])
if len(subpaths):
subpath = np.concatenate(
[p for sp in subpaths for p in (sp, empty)][:-1])
else:
subpath = np.array([])
paths.append({(xdim, ydim): subpath, element.vdims[0].name: level})
contours = contour_type(paths,
label=element.label,
kdims=element.kdims,
vdims=vdims)
if self.p.overlaid:
contours = element * contours
return contours
def _process(self, element, key=None):
try:
from matplotlib.contour import QuadContourSet
from matplotlib.axes import Axes
from matplotlib.figure import Figure
from matplotlib.dates import num2date, date2num
except ImportError:
raise ImportError("contours operation requires matplotlib.")
extent = element.range(0) + element.range(1)[::-1]
xs = element.dimension_values(0, True, flat=False)
ys = element.dimension_values(1, True, flat=False)
zs = element.dimension_values(2, flat=False)
# Ensure that coordinate arrays specify bin centers
if xs.shape[0] != zs.shape[0]:
xs = xs[:-1] + np.diff(xs, axis=0)/2.
if xs.shape[1] != zs.shape[1]:
xs = xs[:, :-1] + (np.diff(xs, axis=1)/2.)
if ys.shape[0] != zs.shape[0]:
ys = ys[:-1] + np.diff(ys, axis=0)/2.
if ys.shape[1] != zs.shape[1]:
ys = ys[:, :-1] + (np.diff(ys, axis=1)/2.)
data = (xs, ys, zs)
# if any data is a datetime, transform to matplotlib's numerical format
data_is_datetime = tuple(isdatetime(arr) for k, arr in enumerate(data))
if any(data_is_datetime):
data = tuple(
date2num(d) if is_datetime else d
for d, is_datetime in zip(data, data_is_datetime)
)
xdim, ydim = element.dimensions('key', label=True)
if self.p.filled:
contour_type = Polygons
else:
contour_type = Contours
vdims = element.vdims[:1]
kwargs = {}
levels = self.p.levels
zmin, zmax = element.range(2)
if isinstance(self.p.levels, int):
if zmin == zmax:
contours = contour_type([], [xdim, ydim], vdims)
return (element * contours) if self.p.overlaid else contours
data += (levels,)
else:
kwargs = {'levels': levels}
fig = Figure()
ax = Axes(fig, [0, 0, 1, 1])
contour_set = QuadContourSet(ax, *data, filled=self.p.filled,
extent=extent, **kwargs)
levels = np.array(contour_set.get_array())
crange = levels.min(), levels.max()
if self.p.filled:
levels = levels[:-1] + np.diff(levels)/2.
vdims = [vdims[0].clone(range=crange)]
paths = []
empty = np.array([[np.nan, np.nan]])
for level, cset in zip(levels, contour_set.collections):
exteriors = []
interiors = []
for geom in cset.get_paths():
interior = []
polys = geom.to_polygons(closed_only=False)
for ncp, cp in enumerate(polys):
if any(data_is_datetime[0:2]):
# transform x/y coordinates back to datetimes
xs, ys = np.split(cp, 2, axis=1)
if data_is_datetime[0]:
xs = np.array(num2date(xs))
if data_is_datetime[1]:
ys = np.array(num2date(ys))
cp = np.concatenate((xs, ys), axis=1)
if ncp == 0:
exteriors.append(cp)
exteriors.append(empty)
else:
interior.append(cp)
if len(polys):
interiors.append(interior)
if not exteriors:
continue
geom = {
element.vdims[0].name:
num2date(level) if data_is_datetime[2] else level,
(xdim, ydim): np.concatenate(exteriors[:-1])
}
if self.p.filled and interiors:
geom['holes'] = interiors
paths.append(geom)
contours = contour_type(paths, label=element.label, kdims=element.kdims, vdims=vdims)
if self.p.overlaid:
contours = element * contours
return contours
elif("".join( radar.sweep_mode['data'][0][0:3])).lower()\
in vpt_modes:
sweep_type = 'vpt'
else:
#strings
if radar.sweep_mode['data'][0].lower() in ppi_modes:
sweep_type = 'ppi'
elif radar.sweep_mode['data'][0].lower() in rhi_modes:
sweep_type = 'rhi'
elif radar.sweep_mode['data'][0].lower() in vpt_modes:
sweep_type = 'vpt'
except:
sweep_type = 'ppi'
fig = plt.figure(figsize=[1, 0.73])
ax = Axes(plt.gcf(), [0, 0, 1, 1], yticks=[], xticks=[], frame_on=False)
#Create radar display
radar_display = pyart.graph.RadarDisplay(radar)
#Plot
if sweep_type == 'ppi':
plt.gcf().delaxes(plt.gca())
plt.gcf().add_axes(ax)
radar_display.plot_ppi(primary_measurement,
0,
vmin=pvmin,
vmax=pvmax,
mask_outside=False,
title_flag=False,
axislabels_flag=False,
colorbar_flag=False,
