def __call__(self, ax, **kwargs): """Panel realizer Realize a panel to a generator of matplotlib subaxeses by combining the saved and new arguments. It accepts the same keyworded arguments as Visual.__init__(). Therefore, its argument list matches Visual.__init__() with `panelable` replaced by `ax`. Args: ax (matplotlib.axis.Axes): A matplotlib Axes for Panel's subaxeses to realize on. **kwargs (dict): Arbitrary Panel-specific keyworded arguments that are used to construct the subaxeses. """ kwprops = merge_dict(self.kwprops, kwargs) box = divide(ax.get_position(), list(map(type, self.panels)).count(Panel), inrow=kwprops['inrow']) for p in self.panels: if isinstance(p, Panel): subax = newaxes(ax.figure, next(box)) yield subax else: ax.axis('on') yield ax
def draw(self, ax, *args, **kwargs): """Panel drawer/renderer Draw or render a Panel by combining the saved and new arguments. Its argument list is designed to match Visual.draw() so that a Panel and Visual draw in the same way. This duck typing allows Panel to draw all its subpanels and subvisuals recusively. Saved and new panel properties are combined to create subaxeses. The passed `args` and non-Panel-specific keyworded arguments are passed recusively to the subpanels and eventially to some ehtplot Visuals. Args: ax (matplotlib.axis.Axes): A matplotlib Axes for Panel to draw/render on. *args (tuple): Variable length argument list that is eventually passed to some ehtplot Visuals. **kwargs (dict): Arbitrary keyworded arguments that are split into Panel-specific and non-Panel-specific keyworded arguments. The Panel-specific ones are used to construct the subaxeses, while others are eventually passed to some ehtplot Visuals. """ kwargs, kwprops = split_dict(kwargs, self._prop_keys) kwprops = merge_dict(self.kwprops, kwprops) return [ p.draw(a, *args, **kwargs) for p, a in zip(self.panels, self(ax, **kwprops)) ]
def __call__(self, **kwargs): """Figure realizer The Figure class only keeps track of a root panel. It does not contain an actual matplotlib Figure instance. Whenever a figure needs to be created, Figure creates a new matplotlib Figure in order to drew/rendered/realized the figure. Args: **kwargs (dict): Arbitrary Figure-specific keyworded arguments that are used to construct the matplotlib Figure. """ kwprops = merge_dict(self.kwprops, kwargs) style = kwprops.pop('style') with mpl.rc_context(): mpl.rcdefaults() plt.style.use(style) imode = mpl.is_interactive() if imode: plt.ioff() fig = plt.figure(**kwprops) ax = newaxes(fig) yield fig, ax if imode: plt.ion()
def __call__(self, ax, *args, **kwargs): """Visual realizer Realize a visual by combining the saved and new arguments. The realization uses the new `args` list if it is provided, and uses the saved attribute otherwise. Saved and new `kwargs` are always combined. Args: ax (matplotlib.axis.Axes): A matplotlib Axes for Visual to draw/render/realize on. *args (tuple): Variable length argument list that overrides the saved on when realizing an instance of Visual. **kwargs (dict): Arbitrary keyworded arguments that are passed to the visualizing function the when realizing an instance of Visual. """ props = args if args else self.props kwprops = merge_dict(self.kwprops, kwargs) return self.visual(ax, *props, **kwprops)
def draw(self, *args, **kwargs): """Figure drawer/renderer The Figure class only keeps track of a root panel. It does not contain an actual matplotlib Figure instance. Whenever a figure needs to be created, Figure creates a new matplotlib Figure in order to drew/rendered/realized the figure. Args: *args (tuple): Variable length argument list that is passed to the root panel. **kwargs (dict): Arbitrary keyworded arguments that are split into properties of the figure and the panel. """ kwargs, kwprops = split_dict(kwargs, self._prop_keys) kwprops = merge_dict(self.kwprops, kwprops) with self(**kwprops) as (fig, ax): self.panel.draw(ax, *args, **kwargs) return fig
def __init__(self, panelable, **kwargs): """Panel initializer The Panel class is the "node class" that allows ehtplot to hierarchically organize subpanels and subvisuals, and to manage their properties. Args: panelable (list): A list that contains subpanels and/or subvisuals. **kwargs (dict): Arbitrary keyworded arguments that are passed to the subaxes constructor when realizing an instance of Panel. Attributes: panels (list): A list of subpanels, subvisuals, or list of them generated from the `args` argument. kwprops (dict): The default keywords used in creating subaxeses when realizing an instance of Panel. """ self.panels = panelable self.kwprops = merge_dict(self._default_kwprops, kwargs)
def __init__(self, panel, **kwargs): """Figure initializer The Figure class takes a single argument with type Panel: fig = Figure(pnl, kw0=..., kw1=..., ...) this makes `pnl` the built-in root panel of `fig`. Args: panel (ehtplot.Panel): The root panel of the Figure. **kwargs (dict): If Figure is initialized in the second way, then this is an arbitrary keyworded arguments passed to create the root panel. Attributes: panel (ehtplot.Panel): The root panel of the Figure. kwprops (dict): The default keywords for creating a figure. """ self.panel = panel self.kwprops = merge_dict(self._default_kwprops, kwargs)