Source code for rootpy.plotting.canvas

This module implements python classes which inherit from
and extend the functionality of the ROOT canvas classes.
from __future__ import absolute_import

from .. import ROOT, QROOT, asrootpy
from .base import convert_color
from ..base import NamedObject
from ..context import invisible_canvas
from ..decorators import snake_case_methods
from ..memory.keepalive import keepalive

from array import array

__all__ = [

class _PadBase(NamedObject):

    # can remove this after 6.10/04
    EmitVA = None

    def cd(self, *args):
        pad = asrootpy(super(_PadBase, self).cd(*args))
        if pad and pad is not self:
            keepalive(self, pad)
        return pad

    def axes(self, ndim=1,
             xlimits=None, ylimits=None, zlimits=None,
             xbins=1, ybins=1, zbins=1):
        Create and return axes on this pad
        if xlimits is None:
            xlimits = (0, 1)
        if ylimits is None:
            ylimits = (0, 1)
        if zlimits is None:
            zlimits = (0, 1)
        if ndim == 1:
            from .hist import Hist
            hist = Hist(1, xlimits[0], xlimits[1])
        elif ndim == 2:
            from .hist import Hist2D
            hist = Hist2D(1, xlimits[0], xlimits[1],
                          1, ylimits[0], ylimits[1])
        elif ndim == 3:
            from .hist import Hist3D
            hist = Hist3D(1, xlimits[0], xlimits[1],
                          1, ylimits[0], ylimits[1],
                          1, zlimits[0], zlimits[1])
            raise ValueError("ndim must be 1, 2, or 3")
        with self:
        xaxis = hist.xaxis
        yaxis = hist.yaxis
        if isinstance(xbins, (list, tuple)):
            xbins = array('d', xbins)
        if hasattr(xbins, '__iter__'):
            xaxis.Set(len(xbins) - 1, xbins)
            xaxis.Set(xbins, *xlimits)
        if ndim > 1:
            if isinstance(ybins, (list, tuple)):
                ybins = array('d', ybins)
            if hasattr(ybins, '__iter__'):
                yaxis.Set(len(ybins) - 1, ybins)
                yaxis.Set(ybins, *ylimits)
            yaxis.limits = ylimits
            yaxis.range_user = ylimits
        if ndim > 1:
            zaxis = hist.zaxis
            if ndim == 3:
                if isinstance(zbins, (list, tuple)):
                    zbins = array('d', zbins)
                if hasattr(zbins, '__iter__'):
                    zaxis.Set(len(zbins) - 1, zbins)
                    zaxis.Set(zbins, *zlimits)
                zaxis.limits = zlimits
                zaxis.range_user = zlimits
            return xaxis, yaxis, zaxis
        return xaxis, yaxis

    def primitives(self):
        return asrootpy(self.GetListOfPrimitives())

    def find_all_primitives(self):
        Recursively find all primities on a pad, even those hiding behind a
        GetListOfFunctions() of a primitive
        # delayed import to avoid circular import
        from .utils import find_all_primitives
        return find_all_primitives(self)

    def canvas(self):
        return asrootpy(self.GetCanvas())

    def mother(self):
        return asrootpy(self.GetMother())

    def margin(self):
        return (self.GetLeftMargin(), self.GetRightMargin(),
                self.GetBottomMargin(), self.GetTopMargin())

    def margin(self, bounds):
        left, right, bottom, top = bounds
        super(_PadBase, self).SetMargin(left, right, bottom, top)

    def margin_pixels(self):
        left, right, bottom, top = self.margin
        width = self.width_pixels
        height = self.height_pixels
        return (int(left * width), int(right * width),
                int(bottom * height), int(top * height))

    def margin_pixels(self, bounds):
        left, right, bottom, top = bounds
        width = float(self.width_pixels)
        height = float(self.height_pixels)
        super(_PadBase, self).SetMargin(left / width, right / width,
                                        bottom / height, top / height)

    def range(self):
        x1, y1 = ROOT.Double(), ROOT.Double()
        x2, y2 = ROOT.Double(), ROOT.Double()
        super(_PadBase, self).GetRange(x1, y1, x2, y2)
        return x1, y1, x2, y2

    def range(self, bounds):
        x1, y1, x2, y2 = bounds
        super(_PadBase, self).Range(x1, y1, x2, y2)

    def range_axis(self):
        x1, y1 = ROOT.Double(), ROOT.Double()
        x2, y2 = ROOT.Double(), ROOT.Double()
        super(_PadBase, self).GetRangeAxis(x1, y1, x2, y2)
        return x1, y1, x2, y2

    def range_axis(self, bounds):
        x1, y1, x2, y2 = bounds
        super(_PadBase, self).RangeAxis(x1, y1, x2, y2)

    def __enter__(self):
        self._prev_pad = ROOT.gPad
        return self

    def __exit__(self, type, value, traceback):
        # similar to preserve_current_canvas in rootpy/
        if self._prev_pad:
        elif ROOT.gPad:
            # Put things back how they were before.
            with invisible_canvas():
                # This is a round-about way of resetting gPad to None.
                # No other technique I tried could do it.
        self._prev_pad = None
        return False

[docs]@snake_case_methods class Pad(_PadBase, QROOT.TPad): _ROOT = QROOT.TPad def __init__(self, xlow, ylow, xup, yup, color=-1, bordersize=-1, bordermode=-2, name=None, title=None): color = convert_color(color, 'root') super(Pad, self).__init__(xlow, ylow, xup, yup, color, bordersize, bordermode, name=name, title=title) def Draw(self, *args): ret = super(Pad, self).Draw(*args) canvas = self.GetCanvas() keepalive(canvas, self) return ret @property def width(self): return self.GetWNDC() @property def height(self): return self.GetHNDC() @property def width_pixels(self): mother = self.mother canvas = self.canvas w = self.GetWNDC() while mother is not canvas: w *= mother.GetWNDC() mother = mother.mother return int(w * mother.width) @property def height_pixels(self): mother = self.mother canvas = self.canvas h = self.GetHNDC() while mother is not canvas: h *= mother.GetHNDC() mother = mother.mother return int(h * mother.height)
[docs]@snake_case_methods class Canvas(_PadBase, QROOT.TCanvas): _ROOT = QROOT.TCanvas def __init__(self, width=None, height=None, x=None, y=None, name=None, title=None, size_includes_decorations=False): # The following line will trigger finalSetup and start the graphics # thread if not started already style = ROOT.gStyle if width is None: width = style.GetCanvasDefW() if height is None: height = style.GetCanvasDefH() if x is None: x = style.GetCanvasDefX() if y is None: y = style.GetCanvasDefY() super(Canvas, self).__init__(x, y, width, height, name=name, title=title) if not size_includes_decorations: # Canvas dimensions include the window manager's decorations by # default in vanilla ROOT. I think this is a bad default. # Since in the most common case I don't care about the window # decorations, the default will be to set the dimensions of the # paintable area of the canvas. if self.IsBatch(): self.SetCanvasSize(width, height) else: self.SetWindowSize(width + (width - self.GetWw()), height + (height - self.GetWh())) self.size_includes_decorations = size_includes_decorations @property def width(self): return self.GetWw() @width.setter def width(self, value): value = int(value) if self.IsBatch(): self.SetCanvasSize(value, self.GetWh()) else: curr_height = self.GetWh() self.SetWindowSize(value, curr_height) if not getattr(self, 'size_includes_decorations', False): self.SetWindowSize(value + (value - self.GetWw()), curr_height + (curr_height - self.GetWh())) @property def width_pixels(self): return self.GetWw() @width_pixels.setter def width_pixels(self, value): self.width = value @property def height(self): return self.GetWh() @height.setter def height(self, value): value = int(value) if self.IsBatch(): self.SetCanvasSize(self.GetWw(), value) else: curr_width = self.GetWw() self.SetWindowSize(curr_width, value) if not getattr(self, 'size_includes_decorations', False): self.SetWindowSize(curr_width + (curr_width - self.GetWw()), value + (value - self.GetWh())) @property def height_pixels(self): return self.GetWh() @height_pixels.setter def height_pixels(self, value): self.height = value