BEAT - plot/bar/1

Parameters 20

Parameters allow users to change the configuration of an plotter when scheduling an experiment

Name	Description	Type	Default
xlabel	The label of the X-axis (horizontal)	string
ylabel	The label of the Y-axis (vertical)	string
title	The title for this plot	string	Bar plot
title-fontsize	Controls the title font size	uint16	10
xaxis_multiplier	The multiplication factor for the X-axis (horizontal)	float64	1.0
yaxis_multiplier	The multiplication factor for the Y-axis (vertical)	float64	1.0
legend	Short description of the data, to be added to the plot	string
legend-fontsize	Controls the font size of the legend	uint16	12
legend-loc	The location of the legend	string	best
legend-bbox-to-anchor	Specify any arbitrary location for the legend	string	1.0&1.0
grid	If we should draw grid lines or not for the plot	bool	False
yaxis_log	If Y-axis (vertical) should be in log-scale	bool	False
dpi	Dots-per-inch in raster image formats	uint16	60
bar-alpha	Value for the alpha effect in the bar plot	float64	0.75
bar-norm	If set to true will normalize the distribution between 0-1	bool	True
width	Width of the resulting image in pixels	uint16	400
height	Height of the resulting image in pixels	uint16	300
axis-fontsize	Controls the axis font size (labels and values)	uint16	10
content_type	The type of image returned	string	image/png
bar_attributes	Bar attributes passed directly to Matplotlib	string

# Makes sure we won't require an X11 connection
import matplotlib
matplotlib.use('Agg')

import numpy
import itertools

class Plotter(baselib.Plotter):

def setup(self, parameters):

super(Plotter, self).setup(parameters)
        
        self.loc = parameters.get('legend-loc', '')
        self.legend_bbox_to_anchor = parameters.get('legend-bbox-to-anchor', '').split('&')
        self.legend_bbox_to_anchor = [float(self.legend_bbox_to_anchor[k]) for k in range(2) ] #Taking only the two first arguments and cast to float64
        
        self.bar_attributes = parameters.get('bar_attributes', '').split('&')
        self.bar_attributes = [k for k in self.bar_attributes if k]
        self.bar_default_ratio_width = 1
        self.bar_alpha       = parameters.get('bar-alpha', '')
        self.axis_fontsize    = parameters.get('axis-fontsize', '')
        
        self.bar_norm = parameters.get('bar-norm', '')
        
        self.title_fontsize  = parameters.get('title-fontsize', '')
        
        self.legend_fontsize = parameters.get('legend-fontsize', '')

# These are the "Tableau 20" colors as RGB.
        self.tableau20 = [(31, 119, 180), (174, 199, 232), (255, 127, 14), (255, 187, 120),
                          (44, 160, 44), (152, 223, 138), (214, 39, 40), (255, 152, 150),
                          (148, 103, 189), (197, 176, 213), (140, 86, 75), (196, 156, 148),
                          (227, 119, 194), (247, 182, 210), (127, 127, 127), (199, 199, 199),
                          (188, 189, 34), (219, 219, 141), (23, 190, 207), (158, 218, 229)]
        # Scale the RGB values to the [0, 1] range, which is the format matplotlib accepts.
        for i in range(len(self.tableau20)):
            r, g, b = self.tableau20[i]
            self.tableau20[i] = (r / 255., g / 255., b / 255.)

return True

def process(self, inputs):

fig, ax = super(Plotter, self).prepare_canvas()
        super(Plotter, self).apply_parameters(ax)

ax.set_title(self.title, fontdict={'fontsize':self.title_fontsize})
        
        if(self.bar_norm):
            ax.set_ylabel("Normalized frequency", fontdict={'fontsize':self.axis_fontsize}) 
            ax.set_ylim(0,1.1)
        else:
            ax.set_ylabel("Frequency", fontdict={'fontsize':self.axis_fontsize})            
        
        
        args = []
        label = []

single_experiment = len(inputs) == 1

n_plots = 0
        bar_lst = []

for xp_label, experiment in inputs:
            for cur_bar in experiment.data:
                n_plots += 1

# Massages the input data
                x = cur_bar.x * self.xaxis_multiplier
                y = cur_bar.y * self.yaxis_multiplier
                
                #Normalizing if necessary
                if(self.bar_norm):
                    y = (y - numpy.min(y))/(numpy.max(y) - numpy.min(y))
                
                args = (x,y)

# Additional attributes
                if self.bar_attributes: args = args + (self.bar_attributes,)
                width = self.bar_default_ratio_width * (x[1] - x[0])
                kwargs = {'color': self.tableau20[n_plots % len(self.tableau20)], 'width': width, 'alpha':self.bar_alpha, 'linewidth':0.25}

# Append labels
                if self.label: #gets the label from user overwritten input
                    if single_experiment:
                        # ignore user label and use only bar labels
                        label.append(cur_bar.label)
                    else:
                        # user-provided labels refer to experiment names
                        text = [k for k in (self.label[len(label)%len(self.label)], cur_bar.label) if k]
                        label.append('-'.join(text))                        
                else: #make-up label
                    if single_experiment:
                        label.append(cur_bar.label)
                    else:
                        text = [k for k in (xp_label, cur_bar.label) if k]
                        label.append('-'.join(text))

# Plots
                bar_lst.append(ax.bar(*args, **kwargs))

if n_plots > 1:
            ax.legend(bar_lst, label, loc=self.loc, fontsize=self.legend_fontsize, fancybox=True, framealpha=0.5)

return super(Plotter, self).encode_figure(fig)

This is the default plotter for bar plots. It provides sensible defaults in case the user has not selected any.

Reports

	Updated	Name	Actions
	Jan. 5, 2017	sbhatta/replay_antispoofing (PAD experiments using ReplayAttack database)	2
	July 15, 2016	pkorshunov/MFCC-GMM-based-PAD-system (Performance of MFCC-GMM-based PAD system on presentation attacks)	1

plotters plot bar 1

Parameters 20

Reports

plotters

plot

bar

1