示例#1
0
    def plot(self, **kwargs):
        style = kwargs.pop('style', 'errorbar')
        kwargs['label'] = get_lookup_val('label', kwargs.get('label'))
        # Plot object on this axis
        axis_name = kwargs.pop('axis', 'ax')
        try:
            ax = getattr(self, axis_name)
        except AttributeError as e:
            log.critical('The axis name {0} does not exist.'.format(axis_name))
            log.critical(e)
            raise

        if kwargs['color'] == 'auto':
            kwargs['color'] = next(self.auto_colors)
        if kwargs['edgecolor'] == 'auto':
            kwargs['edgecolor'] = kwargs['color']

        kwargs['color'] = get_lookup_val('color', kwargs.get('color'))
        # Facecolor is always set using the color argument.
        kwargs['facecolor'] = kwargs['color']

        kwargs['edgecolor'] = get_lookup_val('color', kwargs.get('edgecolor'))
        if style == 'errorbar':
            artist = plot_errorbar(ax=ax, **kwargs)
        elif style == 'band':
            artist = plot_band(ax=ax, **kwargs)
        elif style == 'histo':
            artist = plot_histo(ax=ax, **kwargs)
        elif style == 'line':
            artist = plot_line(ax=ax, **kwargs)
        elif style == 'errorlines':
            artist = plot_errorlines(ax=ax, **kwargs)
        elif style == 'heatmap':
            # special case for z scale and lims in heatmaps since they have to be set by the object instead of the axis.
            kwargs['z_log'] = self.z_log
            kwargs['z_lims'] = self.z_lims
            artist = plot_heatmap(ax=self.ax, **kwargs)
            self.colorbar_mappable = artist
        else:
            raise ValueError('Style {0} not supported.'.format(style))

        self._ids.append(kwargs['id'])
        self._legend_handles.append(artist)
        self._legend_labels.append(kwargs['label'])

        return artist
示例#2
0
文件: rebinning.py 项目: claria/plot
 def __call__(self, config):
     print config.get('data_lims', [])
     if any(id == 'all' for id, kwargs in config.get('data_lims', [])):
         all_kwargs = [kwargs for id, kwargs in config['data_lims'] if id == 'all'][0] 
         config['data_lims'] = [(id, all_kwargs) for id in config['objects'].keys() if (id != '_default')]
     for id, kwargs in config['data_lims']:
         if id not in config['objects']:
             raise ValueError('Requested id {} not found.'.format(id))
         if not 'obj' in config['objects'][id]:
             continue
         log.info('Rebinning id {0}'.format(id))
         obj = config['objects'][id]['obj']
         min_val = float(get_lookup_val('data_lims', kwargs.get('min', None)))
         max_val = float(get_lookup_val('data_lims', kwargs.get('max', None)))
         if isinstance(obj, ROOT.TH1):
             config['objects'][id]['obj'] = rebin_histo(obj, min_val, max_val)
         elif isinstance(obj, ROOT.TGraph):
             config['objects'][id]['obj'] = rebin_tgraph(obj, min_val, max_val)
示例#3
0
    def __init__(self, histos=None, **kwargs):

        super(Plot, self).__init__(**kwargs)
        if not kwargs['add_subplot']:
            self.ax = self.fig.add_subplot(111)
            self.ax1 = None
        else:
            self.ax = plt.subplot2grid((4, 1), (0, 0), rowspan=3)
            self.ax1 = plt.subplot2grid((4, 1), (3, 0), rowspan=1)
        self.histos = histos

        self.x_lims = [get_lookup_val('x_lims', val) for val in kwargs.pop('x_lims', [None, None])]
        self.x_lims = [any2float(v) for v in self.x_lims]
        self.y_lims = [get_lookup_val('y_lims', val) for val in kwargs.pop('y_lims', [None, None])]
        self.y_lims = [any2float(v) for v in self.y_lims]
        self.y_subplot_lims = kwargs.pop('y_subplot_lims', (None, None))
        self.y_subplot_lims = [any2float(v) for v in self.y_subplot_lims]
        self.z_lims = kwargs.pop('z_lims', (None, None))
        self.z_lims = [any2float(v) for v in self.z_lims]

        self.margin = kwargs.pop('margin', 0.1)


        self.x_log = kwargs.pop('x_log', False)
        self.y_log = kwargs.pop('y_log', False)
        self.z_log = kwargs.pop('z_log', False)

        self.x_axis_formatter = kwargs.pop('x_axis_formatter', 'scalar')
        self.y_axis_formatter = kwargs.pop('y_axis_formatter', 'scalar')
        self.z_axis_formatter = kwargs.pop('z_axis_formatter', 'scalar')

        self.x_label = get_lookup_val('x_label', kwargs.pop('x_label', ''))
        self.y_label = get_lookup_val('y_label', kwargs.pop('y_label', ''))
        self.y_subplot_label = get_lookup_val('y_label', kwargs.pop('y_subplot_label', ''))
        self.z_label = get_lookup_val('z_label', kwargs.pop('z_label', ''))

        self.show_legend = kwargs.pop('show_legend', True)
        self.combine_legend_entries = kwargs.pop('combine_legend_entries', [])
        self.legend_loc = kwargs.pop('legend_loc', 'best')
        self.legend_ncol = kwargs.pop('legend_ncol', 1)
        self.legend_bbox_anchor = kwargs.pop('legend_bbox_anchor', None)

        self.texts = kwargs.pop('ax_texts', [])
        self.vlines = kwargs.pop('ax_vlines', [])
        self.hlines = kwargs.pop('ax_hlines', [])

        self.auto_colors = itertools.cycle(matplotlib.rcParams['axes.color_cycle'])

        self.colorbar_mappable = None

        # helpers for legend labels/artists
        self._ids = []
        self._legend_handles = []
        self._legend_labels = []
示例#4
0
    def finish(self):

        # Add colorbar if there is a mappable
        if self.colorbar_mappable:
            cb = self.fig.colorbar(self.colorbar_mappable, ax=self.ax)
            cb.ax.minorticks_on()
            cb.solids.set_rasterized(True)
            if self.z_label:
                cb.set_label(self.z_label)

        # Add axis texts
        for text in self.texts:
            text = get_lookup_val('ax_texts', text)
            default_text_kwargs = {'x': 0.05, 'y': 0.95, 'va': 'top', 'ha': 'left'}
            text_kwargs = parse_query(text)
            default_text_kwargs.update(text_kwargs)
            ax_name = default_text_kwargs.pop('axis', 'ax')

            s = default_text_kwargs.pop('s')
            r = re.compile(r'\$([^$]*)\$')
            s = r.sub(lambda m: m.group().replace('.', '.\!'), s)
            try:
                cax = getattr(self, ax_name)
            except AttributeError as e:
                log.critical('The axis name {0} does not exist.'.format(ax_name))
                log.critical(e)
                raise
            cax.text(s=s, transform=cax.transAxes, **default_text_kwargs)

        # Add horizontal lines to ax
        for hline_kwargs in self.hlines:
            ax_name = hline_kwargs.pop('axis', 'ax')
            try:
                cax = getattr(self, ax_name)
            except AttributeError as e:
                log.critical('The axis name {0} does not exist.'.format(ax_name))
                log.critical(e)
                raise
            cax.axhline(**hline_kwargs)

        # Add vertical lines to ax
        for vline_kwargs in self.vlines:
            ax_name = vline_kwargs.pop('axis', 'ax')
            try:
                cax = getattr(self, ax_name)
            except AttributeError as e:
                log.critical('The axis name {0} does not exist.'.format(ax_name))
                log.critical(e)
                raise
            cax.axvline(**vline_kwargs)

        # a specified position of the label can be set via label?json_dict
        x_label_kwargs = {'position': (1.0, 0.0), 'ha': 'right', 'va': 'top'}
        x_label, user_x_label_kwargs = parse_optionstring(self.x_label)
        x_label_kwargs.update(user_x_label_kwargs)
        if self.ax1:
            self.ax1.set_xlabel(x_label, **x_label_kwargs)
        else:
            self.ax.set_xlabel(x_label, **x_label_kwargs)

        y_label_kwargs = {'position': (0.0, 1.0), 'ha': 'right', 'va': 'bottom'}
        y_label, user_y_label_kwargs = parse_optionstring(self.y_label)
        y_label_kwargs.update(user_y_label_kwargs)
        self.ax.set_ylabel(y_label, **y_label_kwargs)

        if self.ax1:
            y_subplot_label, y_subplot_label_kwargs = parse_optionstring(self.y_subplot_label)
            self.ax1.set_ylabel(y_subplot_label, **y_subplot_label_kwargs)

        if self.x_log:
            self.ax.set_xscale('log')

            if self.x_axis_formatter == 'scalar':
                xfmt = ScalarFormatter()
                self.ax.xaxis.set_major_formatter(xfmt)
            elif self.x_axis_formatter == 'scalar2':
                xfmt = ScalarFormatter()
                self.ax.xaxis.set_minor_formatter(plt.FuncFormatter(log_locator_filter))
                self.ax.xaxis.set_major_formatter(xfmt)
            if self.ax1:
                self.ax1.set_xscale('log')
                if self.x_axis_formatter == 'scalar':
                    xfmt = ScalarFormatter()
                    self.ax1.xaxis.set_major_formatter(xfmt)
                elif self.x_axis_formatter == 'scalar2':
                    xfmt = ScalarFormatter()
                    self.ax1.xaxis.set_minor_formatter(plt.FuncFormatter(log_locator_filter))
                    self.ax1.xaxis.set_major_formatter(xfmt)

        else:
            self.ax.set_xscale('linear')


        if self.y_log:
            self.ax.set_yscale('log', nonposy='clip')
            if self.y_axis_formatter == 'scalar':
                xfmt = ScalarFormatter()
                self.ax.yaxis.set_major_formatter(xfmt)
            elif self.y_axis_formatter == 'scalar2':
                xfmt = ScalarFormatter()
                self.ax.yaxis.set_major_formatter(xfmt)
                self.ax.yaxis.set_minor_formatter(plt.FuncFormatter(log_locator_filter))
        else:
            self.ax.set_yscale('linear')
       
        # By default set a 10% margin
        plot_tools.set_margin(margin=self.margin)

        self.ax.set_ylim(ymin=self.y_lims[0], ymax=self.y_lims[1])
        self.ax.set_xlim(xmin=self.x_lims[0], xmax=self.x_lims[1])

        if self.show_legend:
            # handles, labels = self.ax.get_legend_handles_labels()
            no_legend_ids = ['nolegend', '_nolegend_', '__nolegend__','none', '']

            # handles = self._legend_handles
            # labels = self._legend_labels
            # TODO combine legend entries
            for id, id2 in self.combine_legend_entries:
                log.debug('Combining legend entries {0} and {1}'.format(id, id2))
                if id in self._ids and id2 in self._ids:
                    self._legend_handles[self._ids.index(id)] = (self._legend_handles[self._ids.index(id2)],self._legend_handles[self._ids.index(id)]) 
            leg_entry_dict = OrderedDict(zip(self._legend_labels, self._legend_handles))
            for key in leg_entry_dict.keys():
                if key.lower() in no_legend_ids:
                    del leg_entry_dict[key]

            if leg_entry_dict:
                labels, handles = zip(*leg_entry_dict.items())
                if 'outside' in self.legend_loc:
                    if self.legend_bbox_anchor:
                        bbox_to_anchor = self.legend_bbox_anchor
                    else:
                        bbox_to_anchor = (1, 1)

                    self.legend_loc = self.legend_loc.replace('outside', '').strip()
                else:
                    bbox_to_anchor = None
                legend = self.ax.legend(handles, labels, loc=self.legend_loc, ncol=self.legend_ncol, bbox_to_anchor=bbox_to_anchor)
                legend.get_frame().set_alpha(0.0)

                # [obj.set_rasterized(True) for obj in legend.get_patches()]
                # for obj in legend.get_patches():
                    # obj.set_rasterized(True)

                # legend.draw()
                # self.ax.legend_ = None
                # self.ax.add_artist(legend)
            else:
                log.debug('Omit legend since all labels are empty.')

        if self.ax1:
            self.ax1.set_ylim(ymin=self.y_subplot_lims[0], ymax=self.y_subplot_lims[1])
            plt.setp(self.ax.get_xticklabels(), visible=False)
            plt.setp(self.ax.get_xticklabels(minor=True), visible=False)
            # self.ax1.set_xscale(self.ax.get_xscale())
            self.ax1.set_xlim(self.ax.get_xlim())
            plt.subplots_adjust(hspace=0.15)

        callbacks.trigger('after_plot', plt=self)

        self.save_fig()
        plt.close(self.fig)