Source code for pyrocko.plot.smartplot

# http://pyrocko.org - GPLv3
#
# The Pyrocko Developers, 21st Century
# ---|P------/S----------~Lg----------

'''
Matplotlib plotting with some fancy extras.
'''

from collections import defaultdict
import math
import logging

import numpy as num
import matplotlib
from matplotlib.axes import Axes
# from matplotlib.ticker import MultipleLocator
from matplotlib import cm, colors, colorbar, figure

from pyrocko.guts import Tuple, Float, Object
from pyrocko import plot

import scipy.optimize

logger = logging.getLogger('pyrocko.plot.smartplot')

guts_prefix = 'pf'

inch = 2.54


def get_callbacks(obj):
    try:
        return obj.callbacks
    except AttributeError:
        return obj._callbacks


class SmartplotAxes(Axes):

    if matplotlib.__version__.split('.') < '3.6'.split('.'):
        # Subclassing cla is deprecated on newer mpl but need this fallback for
        # older versions. Code is duplicated because mpl behaviour depends
        # on the existence of cla in the subclass...
        def cla(self):
            if hasattr(self, 'callbacks'):
                callbacks = self.callbacks
                Axes.cla(self)
                self.callbacks = callbacks
            else:
                Axes.cla(self)

    else:
        def clear(self):
            if hasattr(self, 'callbacks'):
                callbacks = self.callbacks
                Axes.clear(self)
                self.callbacks = callbacks
            elif hasattr(self, '_callbacks'):
                callbacks = self._callbacks
                Axes.clear(self)
                self._callbacks = callbacks
            else:
                Axes.clear(self)


class SmartplotFigure(figure.Figure):

    def set_smartplot(self, plot):
        self._smartplot = plot

    def draw(self, *args, **kwargs):
        if hasattr(self, '_smartplot'):
            try:
                self._smartplot._update_layout()
            except NotEnoughSpace:
                logger.error('Figure is too small to show the plot.')
                return

        return figure.Figure.draw(self, *args, **kwargs)


def limits(points):
    lims = num.zeros((3, 2))
    if points.size != 0:
        lims[:, 0] = num.min(points, axis=0)
        lims[:, 1] = num.max(points, axis=0)

    return lims


def wcenter(rect):
    return rect[0] + rect[2]*0.5


def hcenter(rect):
    return rect[1] + rect[3]*0.5


def window_min(n, w, ml, mu, s, x):
    return ml + x/float(n) * (w - (ml + mu + (n-1)*s)) + math.floor(x) * s


def window_max(n, w, ml, mu, s, x):
    return ml + x/float(n) * (w - (ml + mu + (n-1)*s)) + (math.floor(x)-1) * s


def make_smap(cmap, norm=None):
    if isinstance(norm, tuple):
        norm = colors.Normalize(*norm, clip=False)
    smap = cm.ScalarMappable(cmap=cmap, norm=norm)
    smap._A = []  # not needed in newer versions of mpl?
    return smap


def solve_layout_fixed_panels(size, shape, limits, aspects, fracs=None):

    weight_aspect = 1000.

    sx, sy = size
    nx, ny = shape
    nvar = nx+ny
    vxs, vys = limits
    uxs = vxs[:, 1] - vxs[:, 0]
    uys = vys[:, 1] - vys[:, 0]
    aspects_xx, aspects_yy, aspects_xy = aspects

    if fracs is None:
        wxs = num.full(nx, sx / nx)
        wys = num.full(ny, sy / ny)
    else:
        frac_x, frac_y = fracs
        wxs = sx * frac_x / num.sum(frac_x)
        wys = sy * frac_y / num.sum(frac_y)

    data = []
    weights = []
    rows = []
    bounds = []
    for ix in range(nx):
        u = uxs[ix]
        assert u > 0.0
        row = num.zeros(nvar)
        row[ix] = u
        rows.append(row)
        data.append(wxs[ix])
        weights.append(1.0 / u)
        bounds.append((0, wxs[ix] / u))

    for iy in range(ny):
        u = uys[iy]
        assert u > 0.0
        row = num.zeros(nvar)
        row[nx+iy] = u
        rows.append(row)
        data.append(wys[iy])
        weights.append(1.0)
        bounds.append((0, wys[iy] / u))

    for ix1, ix2, aspect in aspects_xx:
        row = num.zeros(nvar)
        row[ix1] = aspect
        row[ix2] = -1.0
        weights.append(weight_aspect/aspect)
        rows.append(row)
        data.append(0.0)

    for iy1, iy2, aspect in aspects_yy:
        row = num.zeros(nvar)
        row[nx+iy1] = aspect
        row[nx+iy2] = -1.0
        weights.append(weight_aspect/aspect)
        rows.append(row)
        data.append(0.0)

    for ix, iy, aspect in aspects_xy:
        row = num.zeros(nvar)
        row[ix] = aspect
        row[nx+iy] = -1.0
        weights.append(weight_aspect/aspect)
        rows.append(row)
        data.append(0.0)

    weights = num.array(weights)
    data = num.array(data)
    mat = num.vstack(rows) * weights[:, num.newaxis]
    data *= weights

    bounds = num.array(bounds).T

    model = scipy.optimize.lsq_linear(mat, data, bounds).x

    cxs = model[:nx]
    cys = model[nx:nx+ny]

    vlimits_x = num.zeros((nx, 2))
    for ix in range(nx):
        u = wxs[ix] / cxs[ix]
        vmin, vmax = vxs[ix]
        udata = vmax - vmin
        eps = 1e-7 * u
        assert udata <= u + eps
        vlimits_x[ix, 0] = (vmin + vmax) / 2.0 - u / 2.0
        vlimits_x[ix, 1] = (vmin + vmax) / 2.0 + u / 2.0

    vlimits_y = num.zeros((ny, 2))
    for iy in range(ny):
        u = wys[iy] / cys[iy]
        vmin, vmax = vys[iy]
        udata = vmax - vmin
        eps = 1e-7 * u
        assert udata <= u + eps
        vlimits_y[iy, 0] = (vmin + vmax) / 2.0 - u / 2.0
        vlimits_y[iy, 1] = (vmin + vmax) / 2.0 + u / 2.0

    def check_aspect(a, awant, eps=1e-2):
        if abs(1.0 - (a/awant)) > eps:
            logger.error(
                'Unable to comply with requested aspect ratio '
                '(wanted: %g, achieved: %g)' % (awant, a))

    for ix1, ix2, aspect in aspects_xx:
        check_aspect(cxs[ix2] / cxs[ix1], aspect)

    for iy1, iy2, aspect in aspects_yy:
        check_aspect(cys[iy2] / cys[iy1], aspect)

    for ix, iy, aspect in aspects_xy:
        check_aspect(cys[iy] / cxs[ix], aspect)

    return (vlimits_x, vlimits_y), (wxs, wys)


def solve_layout_iterative(size, shape, limits, aspects, niterations=3):

    sx, sy = size
    nx, ny = shape
    vxs, vys = limits
    uxs = vxs[:, 1] - vxs[:, 0]
    uys = vys[:, 1] - vys[:, 0]
    aspects_xx, aspects_yy, aspects_xy = aspects

    fracs_x, fracs_y = num.ones(nx), num.ones(ny)
    for i in range(niterations):
        (vlimits_x, vlimits_y), (wxs, wys) = solve_layout_fixed_panels(
            size, shape, limits, aspects, (fracs_x, fracs_y))

        uxs_view = vlimits_x[:, 1] - vlimits_x[:, 0]
        uys_view = vlimits_y[:, 1] - vlimits_y[:, 0]
        wxs_used = wxs * uxs / uxs_view
        wys_used = wys * uys / uys_view
        # wxs_wasted = wxs * (1.0 - uxs / uxs_view)
        # wys_wasted = wys * (1.0 - uys / uys_view)

        fracs_x = wxs_used
        fracs_y = wys_used

    return (vlimits_x, vlimits_y), (wxs, wys)


class PlotError(Exception):
    pass


class NotEnoughSpace(PlotError):
    pass


[docs]class PlotConfig(Object): ''' Configuration for :py:class:`Plot`. ''' font_size = Float.T(default=9.0) size_cm = Tuple.T( 2, Float.T(), default=(20., 20.)) margins_em = Tuple.T( 4, Float.T(), default=(8., 6., 8., 6.)) separator_em = Float.T(default=1.5) colorbar_width_em = Float.T(default=2.0) label_offset_em = Tuple.T( 2, Float.T(), default=(2., 2.)) tick_label_offset_em = Tuple.T( 2, Float.T(), default=(0.5, 0.5)) @property def size_inch(self): return self.size_cm[0]/inch, self.size_cm[1]/inch
[docs]class Plot(object): ''' Matplotlib plotting with some fancy extras. - Absolute sized figure margins, also for interactive plots. - Improved label placement for grids of axes. - Improved shared axis'es across multiple axes, e.g. for cross section plots. - Fixed aspect plotting across multiple axis'es on separate axes. - Automatic subplot sizing based on aspect and data limit constraints. - Serializable plot configuration. ''' def __init__( self, x_dims=['x'], y_dims=['y'], z_dims=[], config=None, fig=None, call_mpl_init=True): if config is None: config = PlotConfig() self._shape = len(x_dims), len(y_dims) dims = [] for dim in x_dims + y_dims + z_dims: dim = dim.lstrip('-') if dim not in dims: dims.append(dim) self.config = config self._disconnect_data = [] self._width = self._height = self._pixels = None if call_mpl_init: self._plt = plot.mpl_init(self.config.font_size) if fig is None: fig = self._plt.figure( figsize=self.config.size_inch, FigureClass=SmartplotFigure) else: assert isinstance(fig, SmartplotFigure) fig.set_smartplot(self) self._fig = fig self._colorbar_width = 0.0 self._colorbar_height = 0.0 self._colorbar_axes = [] self._dims = dims self._dim_index = self._dims.index self._ndims = len(dims) self._labels = {} self._aspects = {} self.setup_axes() self._view_limits = num.zeros((self._ndims, 2)) self._view_limits[:, :] = num.nan self._last_mpl_view_limits = None self._x_dims = [dim.lstrip('-') for dim in x_dims] self._x_dims_invert = [dim.startswith('-') for dim in x_dims] self._y_dims = [dim.lstrip('-') for dim in y_dims] self._y_dims_invert = [dim.startswith('-') for dim in y_dims] self._z_dims = [dim.lstrip('-') for dim in z_dims] self._z_dims_invert = [dim.startswith('-') for dim in z_dims] self._mappables = {} self._updating_layout = False self._need_update_layout = True 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) try: self._connect(fig, 'dpi_changed', self.dpi_changed_handler) except ValueError: # 'dpi_changed' event has been removed in MPL 3.8. # canvas 'resize_event' may be sufficient but needs to be checked. # https://matplotlib.org/stable/api/prev_api_changes/api_changes_3.8.0.html#text-get-rotation pass self._lim_changed_depth = 0 def reset_size(self): self._fig.set_size_inches(self.config.size_inch) def axes(self, ix, iy): if not (isinstance(ix, int) and isinstance(iy, int)): ix = self._x_dims.index(ix) iy = self._y_dims.index(iy) return self._axes[iy][ix] def set_color_dim(self, mappable, dim): assert dim in self._dims self._mappables[mappable] = dim def set_aspect(self, ydim, xdim, aspect=1.0): self._aspects[ydim, xdim] = aspect @property def dims(self): return self._dims @property def fig(self): return self._fig @property def axes_list(self): axes = [] for row in self._axes: axes.extend(row) return axes @property def axes_bottom_list(self): return self._axes[0] @property def axes_left_list(self): return [row[0] for row in self._axes] def setup_axes(self): rect = [0., 0., 1., 1.] nx, ny = self._shape axes = [] for iy in range(ny): axes.append([]) for ix in range(nx): axes[-1].append(SmartplotAxes(self.fig, rect)) self._axes = axes for _, _, axes_ in self.iaxes(): axes_.set_autoscale_on(False) def _connect(self, obj, sig, handler): cid = get_callbacks(obj).connect(sig, handler) self._disconnect_data.append((obj, cid)) def _disconnect_all(self): for obj, cid in self._disconnect_data: get_callbacks(obj).disconnect(cid) self._fig.canvas.mpl_disconnect(self._cid_resize) def dpi_changed_handler(self, fig): if self._updating_layout: return self._update_geometry() def resize_handler(self, event): if self._updating_layout: return self._update_geometry() def lim_changed_handler(self, axes): if self._updating_layout: return current = self._get_mpl_view_limits() last = self._last_mpl_view_limits if last is None: return for iy, ix, axes in self.iaxes(): acurrent = current[iy][ix] alast = last[iy][ix] if acurrent[0] != alast[0]: xdim = self._x_dims[ix] logger.debug( 'X limits have been changed interactively in subplot ' '(%i, %i)' % (ix, iy)) self.set_lim(xdim, *sorted(acurrent[0])) if acurrent[1] != alast[1]: ydim = self._y_dims[iy] logger.debug( 'Y limits have been changed interactively in subplot ' '(%i, %i)' % (ix, iy)) self.set_lim(ydim, *sorted(acurrent[1])) def _update_geometry(self): w, h = self._fig.canvas.get_width_height() dp = self.get_device_pixel_ratio() p = self.get_pixels_factor() * dp if (self._width, self._height, self._pixels) != (w, h, p, dp): logger.debug( 'New figure size: %g x %g, ' 'logical-pixel/point: %g, physical-pixel/logical-pixel: %g' % ( w, h, p, dp)) self._width = w # logical pixel self._height = h # logical pixel self._pixels = p # logical pixel / point self._device_pixel_ratio = dp # physical / logical self.need_update_layout() @property def margins(self): return tuple( x * self.config.font_size / self._pixels for x in self.config.margins_em) @property def separator(self): return self.config.separator_em * self.config.font_size / self._pixels def rect_to_figure_coords(self, rect): left, bottom, width, height = rect return ( left / self._width, bottom / self._height, width / self._width, height / self._height) def point_to_axes_coords(self, axes, point): x, y = point aleft, abottom, awidth, aheight = axes.get_position().bounds x_fig = x / self._width y_fig = y / self._height x_axes = (x_fig - aleft) / awidth y_axes = (y_fig - abottom) / aheight return (x_axes, y_axes) def get_pixels_factor(self): try: r = self._fig.canvas.get_renderer() return 1.0 / r.points_to_pixels(1.0) except AttributeError: return 1.0 def get_device_pixel_ratio(self): try: return self._fig.canvas.device_pixel_ratio except AttributeError: return 1.0 def make_limits(self, lims): a = plot.AutoScaler(space=0.05) return a.make_scale(lims)[:2] def iaxes(self): for iy, row in enumerate(self._axes): for ix, axes in enumerate(row): yield iy, ix, axes def get_data_limits(self): dim_to_values = defaultdict(list) for iy, ix, axes in self.iaxes(): dim_to_values[self._y_dims[iy]].extend( axes.get_yaxis().get_data_interval()) dim_to_values[self._x_dims[ix]].extend( axes.get_xaxis().get_data_interval()) for mappable, dim in self._mappables.items(): dim_to_values[dim].extend(mappable.get_clim()) lims = num.zeros((self._ndims, 2)) for idim in range(self._ndims): dim = self._dims[idim] if dim in dim_to_values: vs = num.array( dim_to_values[self._dims[idim]], dtype=float) vs = vs[num.isfinite(vs)] if vs.size > 0: lims[idim, :] = num.min(vs), num.max(vs) else: lims[idim, :] = num.nan, num.nan else: lims[idim, :] = num.nan, num.nan lims[num.logical_not(num.isfinite(lims))] = 0.0 return lims def set_lim(self, dim, vmin, vmax): assert vmin <= vmax self._view_limits[self._dim_index(dim), :] = vmin, vmax self.need_update_layout() def set_x_invert(self, ix, invert): self._x_dims_invert[ix] = invert self.need_update_layout() def set_y_invert(self, iy, invert): self._y_dims_invert[iy] = invert self.need_update_layout() def _get_mpl_view_limits(self): vl = [] for row in self._axes: vl_row = [] for axes in row: vl_row.append(( axes.get_xaxis().get_view_interval().tolist(), axes.get_yaxis().get_view_interval().tolist())) vl.append(vl_row) return vl def _remember_mpl_view_limits(self): self._last_mpl_view_limits = self._get_mpl_view_limits() def window_xmin(self, x): return window_min( self._shape[0], self._width, self.margins[0], self.margins[2] + self._colorbar_width, self.separator, x) def window_xmax(self, x): return window_max( self._shape[0], self._width, self.margins[0], self.margins[2] + self._colorbar_width, self.separator, x) def window_ymin(self, y): return window_min( self._shape[1], self._height, self.margins[3] + self._colorbar_height, self.margins[1], self.separator, y) def window_ymax(self, y): return window_max( self._shape[1], self._height, self.margins[3] + self._colorbar_height, self.margins[1], self.separator, y) def need_update_layout(self): self._need_update_layout = True def _update_layout(self): assert not self._updating_layout if not self._need_update_layout: return self._updating_layout = True try: data_limits = self.get_data_limits() limits = num.zeros((self._ndims, 2)) for idim in range(self._ndims): limits[idim, :] = self.make_limits(data_limits[idim, :]) mask = num.isfinite(self._view_limits) limits[mask] = self._view_limits[mask] # deltas = limits[:, 1] - limits[:, 0] # data_w = deltas[0] # data_h = deltas[1] ml, mt, mr, mb = self.margins mr += self._colorbar_width mb += self._colorbar_height sw = sh = self.separator nx, ny = self._shape # data_r = data_h / data_w em = self.config.font_size em_pixels = em / self._pixels w = self._width h = self._height fig_w_avail = w - mr - ml - (nx-1) * sw fig_h_avail = h - mt - mb - (ny-1) * sh if fig_w_avail <= 0.0 or fig_h_avail <= 0.0: raise NotEnoughSpace() x_limits = num.zeros((nx, 2)) for ix, xdim in enumerate(self._x_dims): x_limits[ix, :] = limits[self._dim_index(xdim)] y_limits = num.zeros((ny, 2)) for iy, ydim in enumerate(self._y_dims): y_limits[iy, :] = limits[self._dim_index(ydim)] def get_aspect(dim1, dim2): if (dim2, dim1) in self._aspects: return 1.0/self._aspects[dim2, dim1] return self._aspects.get((dim1, dim2), None) aspects_xx = [] for ix1, xdim1 in enumerate(self._x_dims): for ix2, xdim2 in enumerate(self._x_dims): aspect = get_aspect(xdim2, xdim1) if aspect: aspects_xx.append((ix1, ix2, aspect)) aspects_yy = [] for iy1, ydim1 in enumerate(self._y_dims): for iy2, ydim2 in enumerate(self._y_dims): aspect = get_aspect(ydim2, ydim1) if aspect: aspects_yy.append((iy1, iy2, aspect)) aspects_xy = [] for iy, ix, axes in self.iaxes(): xdim = self._x_dims[ix] ydim = self._y_dims[iy] aspect = get_aspect(ydim, xdim) if aspect: aspects_xy.append((ix, iy, aspect)) (x_limits, y_limits), (aws, ahs) = solve_layout_iterative( size=(fig_w_avail, fig_h_avail), shape=(nx, ny), limits=(x_limits, y_limits), aspects=( aspects_xx, aspects_yy, aspects_xy)) for iy, ix, axes in self.iaxes(): rect = [ ml + num.sum(aws[:ix])+(ix*sw), mb + num.sum(ahs[:iy])+(iy*sh), aws[ix], ahs[iy]] axes.set_position( self.rect_to_figure_coords(rect), which='both') self.set_label_coords( axes, 'x', [ wcenter(rect), self.config.label_offset_em[0]*em_pixels + self._colorbar_height]) self.set_label_coords( axes, 'y', [ self.config.label_offset_em[1]*em_pixels, hcenter(rect)]) axes.get_xaxis().set_tick_params( bottom=(iy == 0), top=(iy == ny-1), labelbottom=(iy == 0), labeltop=False) axes.get_yaxis().set_tick_params( left=(ix == 0), right=(ix == nx-1), labelleft=(ix == 0), labelright=False) istride = -1 if self._x_dims_invert[ix] else 1 axes.set_xlim(*x_limits[ix, ::istride]) istride = -1 if self._y_dims_invert[iy] else 1 axes.set_ylim(*y_limits[iy, ::istride]) axes.tick_params( axis='x', pad=self.config.tick_label_offset_em[0]*em) axes.tick_params( axis='y', pad=self.config.tick_label_offset_em[0]*em) self._remember_mpl_view_limits() for mappable, dim in self._mappables.items(): mappable.set_clim(*limits[self._dim_index(dim)]) # scaler = plot.AutoScaler() # aspect tick incs same # # inc = scaler.make_scale( # [0, min(data_expanded_w, data_expanded_h)], # override_mode='off')[2] # # for axes in self.axes_list: # axes.set_xlim(*limits[0, :]) # axes.set_ylim(*limits[1, :]) # # tl = MultipleLocator(inc) # axes.get_xaxis().set_major_locator(tl) # tl = MultipleLocator(inc) # axes.get_yaxis().set_major_locator(tl) for axes, orientation, position in self._colorbar_axes: if orientation == 'horizontal': xmin = self.window_xmin(position[0]) xmax = self.window_xmax(position[1]) ymin = mb - self._colorbar_height ymax = mb - self._colorbar_height \ + self.config.colorbar_width_em * em_pixels else: ymin = self.window_ymin(position[0]) ymax = self.window_ymax(position[1]) xmin = w - mr + 2 * sw xmax = w - mr + 2 * sw \ + self.config.colorbar_width_em * em_pixels rect = [xmin, ymin, xmax-xmin, ymax-ymin] axes.set_position( self.rect_to_figure_coords(rect), which='both') for ix, axes in enumerate(self.axes_bottom_list): dim = self._x_dims[ix] s = self._labels.get(dim, dim) axes.set_xlabel(s) for iy, axes in enumerate(self.axes_left_list): dim = self._y_dims[iy] s = self._labels.get(dim, dim) axes.set_ylabel(s) self._need_update_layout = False self.update_layout_hook() finally: self._updating_layout = False def update_layout_hook(self): pass def set_label_coords(self, axes, which, point): axis = axes.get_xaxis() if which == 'x' else axes.get_yaxis() axis.set_label_coords(*self.point_to_axes_coords(axes, point)) def plot(self, points, *args, **kwargs): for iy, row in enumerate(self._axes): y = points[:, self._dim_index(self._y_dims[iy])] for ix, axes in enumerate(row): x = points[:, self._dim_index(self._x_dims[ix])] axes.plot(x, y, *args, **kwargs) def close(self): self._disconnect_all() self._plt.close(self._fig) def show(self): self._plt.show() self.reset_size() def set_label(self, dim, s): # just set attribute, handle in update_layout self._labels[dim] = s def colorbar( self, dim, orientation='vertical', position=None): if dim not in self._dims: raise PlotError( 'dimension "%s" is not defined') if orientation not in ('vertical', 'horizontal'): raise PlotError( 'orientation must be "vertical" or "horizontal"') mappable = None for mappable_, dim_ in self._mappables.items(): if dim_ == dim: if mappable is None: mappable = mappable_ else: mappable_.set_cmap(mappable.get_cmap()) if mappable is None: raise PlotError( 'no mappable registered for dimension "%s"' % dim) if position is None: if orientation == 'vertical': position = (0, self._shape[1]) else: position = (0, self._shape[0]) em_pixels = self.config.font_size / self._pixels if orientation == 'vertical': self._colorbar_width = self.config.colorbar_width_em*em_pixels + \ self.separator * 2.0 else: self._colorbar_height = self.config.colorbar_width_em*em_pixels + \ self.separator + self.margins[3] axes = SmartplotAxes(self.fig, [0., 0., 1., 1.]) self.fig.add_axes(axes) self._colorbar_axes.append( (axes, orientation, position)) self.need_update_layout() # axes.plot([1], [1]) label = self._labels.get(dim, dim) return colorbar.Colorbar( axes, mappable, orientation=orientation, label=label) def __call__(self, *args): return self.axes(*args)
if __name__ == '__main__': import sys from pyrocko import util logging.getLogger('matplotlib').setLevel(logging.WARNING) util.setup_logging('smartplot', 'debug') iplots = [int(x) for x in sys.argv[1:]] if 0 in iplots: p = Plot(['x'], ['y']) n = 100 x = num.arange(n) * 2.0 y = num.random.normal(size=n) p(0, 0).plot(x, y, 'o') p.show() if 1 in iplots: p = Plot(['x', 'x'], ['y']) n = 100 x = num.arange(n) * 2.0 y = num.random.normal(size=n) p(0, 0).plot(x, y, 'o') x = num.arange(n) * 2.0 y = num.random.normal(size=n) p(1, 0).plot(x, y, 'o') p.show() if 11 in iplots: p = Plot(['x'], ['y']) p.set_aspect('y', 'x', 2.0) n = 100 xy = num.random.normal(size=(n, 2)) p(0, 0).plot(xy[:, 0], xy[:, 1], 'o') p.show() if 12 in iplots: p = Plot(['x', 'x2'], ['y']) p.set_aspect('x2', 'x', 2.0) p.set_aspect('y', 'x', 2.0) n = 100 xy = num.random.normal(size=(n, 2)) p(0, 0).plot(xy[:, 0], xy[:, 1], 'o') p(1, 0).plot(xy[:, 0], xy[:, 1], 'o') p.show() if 13 in iplots: p = Plot(['x'], ['y', 'y2']) p.set_aspect('y2', 'y', 2.0) p.set_aspect('y', 'x', 2.0) n = 100 xy = num.random.normal(size=(n, 2)) p(0, 0).plot(xy[:, 0], xy[:, 1], 'o') p(0, 1).plot(xy[:, 0], xy[:, 1], 'o') p.show() if 2 in iplots: p = Plot(['easting', 'depth'], ['northing', 'depth']) n = 100 ned = num.random.normal(size=(n, 3)) p(0, 0).plot(ned[:, 1], ned[:, 0], 'o') p(1, 0).plot(ned[:, 2], ned[:, 0], 'o') p(0, 1).plot(ned[:, 1], ned[:, 2], 'o') p.show() if 3 in iplots: p = Plot(['easting', 'depth'], ['-depth', 'northing']) p.set_aspect('easting', 'northing', 1.0) p.set_aspect('easting', 'depth', 0.5) p.set_aspect('northing', 'depth', 0.5) n = 100 ned = num.random.normal(size=(n, 3)) ned[:, 2] *= 0.25 p(0, 1).plot(ned[:, 1], ned[:, 0], 'o', color='black') p(0, 0).plot(ned[:, 1], ned[:, 2], 'o') p(1, 1).plot(ned[:, 2], ned[:, 0], 'o') p(1, 0).set_visible(False) p.set_lim('depth', 0., 0.2) p.show() if 5 in iplots: p = Plot(['time'], ['northing', 'easting', '-depth'], ['depth']) n = 100 t = num.arange(n) xyz = num.random.normal(size=(n, 4)) xyz[:, 0] *= 0.5 smap = make_smap('summer') p(0, 0).scatter( t, xyz[:, 0], c=xyz[:, 2], cmap=smap.cmap, norm=smap.norm) p(0, 1).scatter( t, xyz[:, 1], c=xyz[:, 2], cmap=smap.cmap, norm=smap.norm) p(0, 2).scatter( t, xyz[:, 2], c=xyz[:, 2], cmap=smap.cmap, norm=smap.norm) p.set_lim('depth', -1., 1.) p.set_color_dim(smap, 'depth') p.set_aspect('northing', 'easting', 1.0) p.set_aspect('northing', 'depth', 1.0) p.set_label('time', 'Time [s]') p.set_label('depth', 'Depth [km]') p.set_label('easting', 'Easting [km]') p.set_label('northing', 'Northing [km]') p.colorbar('depth') p.show() if 6 in iplots: km = 1000. p = Plot( ['easting'], ['northing']*3, ['displacement']) nn, ne = 50, 40 n = num.linspace(-5*km, 5*km, nn) e = num.linspace(-10*km, 10*km, ne) displacement = num.zeros((nn, ne, 3)) g = num.exp( -(n[:, num.newaxis]**2 + e[num.newaxis, :]**2) / (5*km)**2) displacement[:, :, 0] = g displacement[:, :, 1] = g * 0.5 displacement[:, :, 2] = -g * 0.2 for icomp in (0, 1, 2): c = p(0, icomp).pcolormesh( e/km, n/km, displacement[:, :, icomp], shading='gouraud') p.set_color_dim(c, 'displacement') p.colorbar('displacement') p.set_lim('displacement', -1.0, 1.0) p.set_label('easting', 'Easting [km]') p.set_label('northing', 'Northing [km]') p.set_aspect('northing', 'easting') p.set_lim('northing', -5.0, 5.0) p.set_lim('easting', -3.0, 3.0) p.show()