def __init__(self, data=None, axes=None, *aw, **kw):
self.labels = {}
if type(data) == types.DictType:
for label, ddict in data.items():
#self.labels[label] = pretty_float(max([ float(x) for x in ddict.values() if x ]) )
self.labels[label] = "%.1f" % max(
[float(x) for x in ddict.values() if x])
elif type(data) == types.InstanceType and data.__class__ == GraphData:
self.labels = data.getLabels()
else:
self.labels = data
#self.labels.reverse()
self.ax = axes
self.canvas = None
if self.ax:
self.canvas = self.ax.figure.canvas
self.ax.set_axis_off()
self.prefs = evalPrefs(*aw, **kw)
self.palette = Palette()
if self.labels and self.labels[0][0] != 'NoLabels':
percent_flag = self.prefs.get('legend_unit', '')
if percent_flag == "%":
sum_value = sum(data.label_values)
if sum_value > 0.:
self.labels = [(l, v / sum_value * 100.)
for l, v in self.labels]
self.__get_column_width()
def __init__(self, data=None, axes=None, *aw, **kw):
self.text_size = 0
self.column_width = 0
self.labels = {}
if isinstance(data, dict):
for label, ddict in data.items():
# self.labels[label] = pretty_float(max([ float(x) for x in ddict.values() if x ]) )
self.labels[label] = "%.1f" % max(
[float(x) for x in ddict.values() if x])
elif isinstance(data, GraphData):
self.labels = data.getLabels()
else:
self.labels = data
# self.labels.reverse()
self.ax = axes
self.canvas = None
if self.ax:
self.canvas = self.ax.figure.canvas
self.ax.set_axis_off()
self.prefs = evalPrefs(*aw, **kw)
self.palette = Palette()
if self.labels and self.labels[0][0] != "NoLabels":
percent_flag = self.prefs.get("legend_unit", "")
if percent_flag == "%":
sum_value = sum(data.label_values)
if sum_value > 0.0:
self.labels = [(l, v / sum_value * 100.0)
for l, v in self.labels]
self.__get_column_width()
def __init__(self,data=None,axes=None,*aw,**kw):
self.labels = {}
if type(data) == types.DictType:
for label,ddict in data.items():
#self.labels[label] = pretty_float(max([ float(x) for x in ddict.values() if x ]) )
self.labels[label] = "%.1f" % max([ float(x) for x in ddict.values() if x ])
elif type(data) == types.InstanceType and data.__class__ == GraphData:
self.labels = data.getLabels()
else:
self.labels = data
#self.labels.reverse()
self.ax = axes
self.canvas = None
if self.ax:
self.canvas = self.ax.figure.canvas
self.ax.set_axis_off()
self.prefs = evalPrefs(*aw,**kw)
self.palette = Palette()
if self.labels and self.labels[0][0] != 'NoLabels':
percent_flag = self.prefs.get('legend_unit','')
if percent_flag == "%":
sum_value = sum(data.label_values)
if sum_value > 0.:
self.labels = [(l,v/sum_value*100.) for l,v in self.labels ]
self.__get_column_width()
def __init__(self, data=None, axes=None, *aw, **kw):
self.ax_contain = axes
self.canvas = None
self.figure = None
if self.ax_contain:
self.figure = self.ax_contain.get_figure()
self.canvas = self.figure.canvas
self.dpi = self.ax_contain.figure.get_dpi()
self.ax_contain.set_axis_off()
self.prefs = evalPrefs(*aw, **kw)
self.coords = {}
self.palette = Palette()
if isinstance(data, dict):
self.gdata = GraphData(data)
elif isinstance(data, object) and data.__class__ == GraphData:
self.gdata = data
def __init__( self, data = None, axes = None, *aw, **kw ):
self.ax_contain = axes
self.canvas = None
self.figure = None
if self.ax_contain:
self.figure = self.ax_contain.get_figure()
self.canvas = self.figure.canvas
self.dpi = self.ax_contain.figure.get_dpi()
self.ax_contain.set_axis_off()
self.prefs = evalPrefs( *aw, **kw )
self.coords = {}
self.palette = Palette()
if isinstance( data, dict):
self.gdata = GraphData( data )
elif isinstance( data, object) and data.__class__ == GraphData:
self.gdata = data
class Legend:
def __init__(self,data=None,axes=None,*aw,**kw):
self.labels = {}
if type(data) == types.DictType:
for label,ddict in data.items():
#self.labels[label] = pretty_float(max([ float(x) for x in ddict.values() if x ]) )
self.labels[label] = "%.1f" % max([ float(x) for x in ddict.values() if x ])
elif type(data) == types.InstanceType and data.__class__ == GraphData:
self.labels = data.getLabels()
else:
self.labels = data
#self.labels.reverse()
self.ax = axes
self.canvas = None
if self.ax:
self.canvas = self.ax.figure.canvas
self.ax.set_axis_off()
self.prefs = evalPrefs(*aw,**kw)
self.palette = Palette()
if self.labels and self.labels[0][0] != 'NoLabels':
percent_flag = self.prefs.get('legend_unit','')
if percent_flag == "%":
sum_value = sum(data.label_values)
if sum_value > 0.:
self.labels = [(l,v/sum_value*100.) for l,v in self.labels ]
self.__get_column_width()
def dumpPrefs(self):
for key in self.prefs:
print key.rjust(20),':',str(self.prefs[key]).ljust(40)
def setLabels(self,labels):
self.labels = labels
def setAxes(self,axes):
self.ax = axes
self.canvas = self.ax.figure.canvas
self.ax.set_axis_off()
def getLegendSize(self):
self.__get_column_width()
legend_position = self.prefs['legend_position']
legend_width = float(self.prefs['legend_width'])
legend_height = float(self.prefs['legend_height'])
legend_padding = float(self.prefs['legend_padding'])
legend_text_size = self.prefs.get('legend_text_size',self.prefs['text_size'])
legend_text_padding = self.prefs.get('legend_text_padding',self.prefs['text_padding'])
if legend_position in ['right','left']:
# One column in case of vertical legend
legend_width = self.column_width+legend_padding
nLabels = len(self.labels)
legend_max_height = nLabels*(legend_text_size+legend_text_padding)
elif legend_position == 'bottom':
nColumns = min(self.prefs['legend_max_columns'],int(legend_width/self.column_width))
nLabels = len(self.labels)
maxRows = self.prefs['legend_max_rows']
nRows_ax = int(legend_height/1.6/self.prefs['text_size'])
nRows_label = nLabels/nColumns + (nLabels%nColumns != 0)
nRows = max(1,min(min(nRows_label,maxRows),nRows_ax ))
text_padding = self.prefs['text_padding']
text_padding = pixelToPoint(text_padding,self.prefs['dpi'])
legend_height = min(legend_height,(nRows*(self.text_size+text_padding)+text_padding))
legend_max_height = nLabels*(self.text_size+text_padding)
return legend_width,legend_height,legend_max_height
def __get_legend_text_size(self):
dpi = self.prefs['dpi']
text_size = self.prefs['text_size']
text_padding = self.prefs['text_padding']
legend_text_size = self.prefs.get('legend_text_size',text_size)
legend_text_padding = self.prefs.get('legend_text_padding',text_padding)
return legend_text_size,legend_text_padding
def __get_column_width(self):
max_length = 0
max_column_text = ''
flag = self.prefs.get('legend_numbers',True)
unit = self.prefs.get('legend_unit',False)
for label,num in self.labels:
if not flag: num = None
if num is not None:
column_length = len(str(label)+str(num)) + 1
else:
column_length = len(str(label)) + 1
if column_length > max_length:
max_length = column_length
if flag:
if type(num) == types.IntType or type(num) == types.LongType:
numString = str(num)
else:
numString = "%.1f" % float(num)
max_column_text = '%s %s' % (str(label),numString)
if unit:
max_column_text += "%"
else:
max_column_text = '%s ' % str(label)
figure = Figure()
canvas = FigureCanvasAgg(figure)
dpi = self.prefs['dpi']
figure.set_dpi( dpi )
l_size,l_padding = self.__get_legend_text_size()
self.text_size = pixelToPoint(l_size,dpi)
text = Text(0.,0.,text=max_column_text,size=self.text_size)
text.set_figure(figure)
bbox = text.get_window_extent(canvas.get_renderer())
self.column_width = bbox.width+6*l_size
def draw(self):
dpi = self.prefs['dpi']
ax_xsize = self.ax.get_window_extent().width
ax_ysize = self.ax.get_window_extent().height
nLabels = len(self.labels)
nColumns = min(self.prefs['legend_max_columns'],int(ax_xsize/self.column_width))
maxRows = self.prefs['legend_max_rows']
nRows_ax = int(ax_ysize/1.6/self.prefs['text_size'])
nRows_label = nLabels/nColumns + (nLabels%nColumns != 0)
nRows = max(1,min(min(nRows_label,maxRows),nRows_ax ))
maxLabels = nColumns*nRows - 1
self.ax.set_xlim(0.,float(ax_xsize))
self.ax.set_ylim(-float(ax_ysize),0.)
legend_text_size,legend_text_padding = self.__get_legend_text_size()
legend_text_size_point = pixelToPoint(legend_text_size,dpi)
box_width = legend_text_size
legend_offset = (ax_xsize - nColumns*self.column_width)/2
nc = 0
#self.labels.reverse()
for label,num in self.labels:
num_flag = self.prefs.get('legend_numbers',True)
percent_flag = self.prefs.get('legend_unit','')
if num_flag:
if percent_flag == "%":
num = "%.1f" % num +'%'
else:
num = "%.1f" % num
else:
num = None
color = self.palette.getColor(label)
row = nc%nRows
column = nc/nRows
if row == nRows-1 and column == nColumns-1 and nc != nLabels-1:
last_text = '... plus %d more' % (nLabels-nc)
self.ax.text(float(column*self.column_width)+legend_offset,-float(row*1.6*box_width),
last_text,horizontalalignment='left',
verticalalignment='top',size=legend_text_size_point)
break
else:
self.ax.text(float(column*self.column_width)+2.*box_width+legend_offset,-row*1.6*box_width,
str(label),horizontalalignment='left',
verticalalignment='top',size=legend_text_size_point)
if num is not None:
self.ax.text(float((column+1)*self.column_width)-2*box_width+legend_offset,-float(row*1.6*box_width),
str(num),horizontalalignment='right',
verticalalignment='top',size=legend_text_size_point)
box = Rectangle((float(column*self.column_width)+legend_offset,-float(row*1.6*box_width)-box_width),
box_width,box_width)
box.set_ec('black')
box.set_linewidth(pixelToPoint(0.5,dpi))
box.set_fc(color)
self.ax.add_patch(box)
nc += 1
class PlotBase(object):
def __init__(self, data=None, axes=None, *aw, **kw):
self.ax_contain = axes
self.canvas = None
self.figure = None
if self.ax_contain:
self.figure = self.ax_contain.get_figure()
self.canvas = self.figure.canvas
self.dpi = self.ax_contain.figure.get_dpi()
self.ax_contain.set_axis_off()
self.prefs = evalPrefs(*aw, **kw)
self.coords = {}
self.palette = Palette()
if isinstance(data, dict):
self.gdata = GraphData(data)
elif isinstance(data, object) and data.__class__ == GraphData:
self.gdata = data
def dumpPrefs(self):
for key in self.prefs:
print(key.rjust(20), ':', str(self.prefs[key]).ljust(40))
def setAxes(self, axes):
self.ax_contain = axes
self.ax_contain.set_axis_off()
self.figure = self.ax_contain.get_figure()
self.canvas = self.figure.canvas
self.dpi = self.ax_contain.figure.get_dpi()
def draw(self):
prefs = self.prefs
dpi = self.ax_contain.figure.get_dpi()
# Update palette
palette = prefs.get('colors', {})
if palette:
self.palette.addPalette(palette)
xlabel = prefs.get('xlabel', '')
ylabel = prefs.get('ylabel', '')
xticks_flag = prefs.get('xticks', True)
yticks_flag = prefs.get('yticks', True)
text_size = prefs['text_size']
text_padding = prefs['text_padding']
label_text_size = prefs.get('label_text_size', text_size)
label_text_size_point = pixelToPoint(label_text_size, dpi)
tick_text_size = prefs.get('tick_text_size', text_size)
tick_text_size_point = pixelToPoint(tick_text_size, dpi)
ytick_length = prefs.get('ytick_length', 7 * tick_text_size)
plot_title = prefs.get('plot_title', '')
if not plot_title or plot_title == 'NoTitle':
plot_title_size = 0
plot_title_padding = 0
else:
plot_title_size = prefs.get('plot_title_size', text_size)
plot_title_padding = prefs.get('plot_text_padding', text_padding)
plot_title_size_point = pixelToPoint(plot_title_size, dpi)
stats_flag = prefs.get('statistics_line', False)
stats_line = ''
stats_line_space = 0.
if stats_flag:
stats_line = self.gdata.getStatString()
stats_line_size = label_text_size
stats_line_padding = label_text_size * 2.
stats_line_space = stats_line_size + stats_line_padding
plot_padding = prefs['plot_padding']
plot_left_padding = prefs.get('plot_left_padding', plot_padding)
plot_right_padding = prefs.get('plot_right_padding', 0)
plot_bottom_padding = prefs.get('plot_bottom_padding', plot_padding)
plot_top_padding = prefs.get('plot_top_padding', 0)
frame_flag = prefs['frame']
# Create plot axes, and set properties
left, bottom, width, height = self.ax_contain.get_window_extent(
).bounds
l, b, f_width, f_height = self.figure.get_window_extent().bounds
# Space needed for labels and ticks
x_label_space = 0
if xticks_flag:
x_label_space += tick_text_size * 1.5
if xlabel:
x_label_space += label_text_size * 1.5
y_label_space = 0
if yticks_flag:
y_label_space += ytick_length
if ylabel:
y_label_space += label_text_size * 1.5
ax_plot_rect = ( float( plot_left_padding + left + y_label_space ) / f_width,
float( plot_bottom_padding + bottom + x_label_space + stats_line_space ) / f_height,
float( width - plot_left_padding - plot_right_padding - y_label_space ) / f_width,
float( height - plot_bottom_padding - plot_top_padding - x_label_space - \
plot_title_size - 2 * plot_title_padding - stats_line_space ) / f_height )
ax = Axes(self.figure, ax_plot_rect)
if prefs['square_axis']:
l, b, a_width, a_height = ax.get_window_extent().bounds
delta = abs(a_height - a_width)
if a_height > a_width:
a_height = a_width
ax_plot_rect = (
float(plot_left_padding + left) / f_width,
float(plot_bottom_padding + bottom + delta / 2.) /
f_height,
float(width - plot_left_padding - plot_right_padding) /
f_width,
float(height - plot_bottom_padding - plot_title_size -
2 * plot_title_padding - delta) / f_height)
else:
a_width = a_height
ax_plot_rect = (
float(plot_left_padding + left + delta / 2.) / f_width,
float(plot_bottom_padding + bottom) / f_height,
float(width - plot_left_padding - delta) / f_width,
float(height - plot_bottom_padding - plot_title_size -
2 * plot_title_padding) / f_height)
ax.set_position(ax_plot_rect)
self.figure.add_axes(ax)
self.ax = ax
frame = ax.patch
frame.set_fill(False)
if frame_flag.lower() == 'off':
self.ax.set_axis_off()
self.log_xaxis = False
self.log_yaxis = False
else:
# If requested, make x/y axis logarithmic
if prefs.get('log_xaxis', 'False').find('r') >= 0:
ax.semilogx()
self.log_xaxis = True
else:
self.log_xaxis = False
if prefs.get('log_yaxis', 'False').find('r') >= 0:
ax.semilogy()
self.log_yaxis = True
else:
self.log_yaxis = False
if xticks_flag:
setp(ax.get_xticklabels(), family=prefs['font_family'])
setp(ax.get_xticklabels(), fontname=prefs['font'])
setp(ax.get_xticklabels(), size=tick_text_size_point)
else:
setp(ax.get_xticklabels(), size=0)
if yticks_flag:
setp(ax.get_yticklabels(), family=prefs['font_family'])
setp(ax.get_yticklabels(), fontname=prefs['font'])
setp(ax.get_yticklabels(), size=tick_text_size_point)
else:
setp(ax.get_yticklabels(), size=0)
setp(ax.get_xticklines(), markeredgewidth=pixelToPoint(0.5, dpi))
setp(ax.get_xticklines(),
markersize=pixelToPoint(text_size / 2., dpi))
setp(ax.get_yticklines(), markeredgewidth=pixelToPoint(0.5, dpi))
setp(ax.get_yticklines(),
markersize=pixelToPoint(text_size / 2., dpi))
setp(ax.get_xticklines(), zorder=4.0)
line_width = prefs.get('line_width', 1.0)
frame_line_width = prefs.get('frame_line_width', line_width)
grid_line_width = prefs.get('grid_line_width', 0.1)
plot_line_width = prefs.get('plot_line_width', 0.1)
setp(ax.patch, linewidth=pixelToPoint(plot_line_width, dpi))
#setp( ax.spines, linewidth=pixelToPoint(frame_line_width,dpi) )
#setp( ax.axvline(), linewidth=pixelToPoint(1.0,dpi) )
axis_grid_flag = prefs.get('plot_axis_grid', True)
if axis_grid_flag:
ax.grid(True,
color='#555555',
linewidth=pixelToPoint(grid_line_width, dpi))
plot_axis_flag = prefs.get('plot_axis', True)
if plot_axis_flag:
# Set labels
if xlabel:
t = ax.set_xlabel(xlabel)
t.set_family(prefs['font_family'])
t.set_fontname(prefs['font'])
t.set_size(label_text_size)
if ylabel:
t = ax.set_ylabel(ylabel)
t.set_family(prefs['font_family'])
t.set_fontname(prefs['font'])
t.set_size(label_text_size)
else:
self.ax.set_axis_off()
# Create a plot title, if necessary
if plot_title:
self.ax.title = self.ax.text(
0.5,
1. + float(plot_title_padding) / height,
plot_title,
verticalalignment='bottom',
horizontalalignment='center',
size=pixelToPoint(plot_title_size, dpi),
family=prefs['font_family'],
fontname=prefs['font'])
self.ax.title.set_transform(self.ax.transAxes)
self.ax.title.set_family(prefs['font_family'])
self.ax.title.set_fontname(prefs['font'])
if stats_line:
self.ax.stats = self.ax.text(0.5, (-stats_line_space) / height,
stats_line,
verticalalignment='top',
horizontalalignment='center',
size=pixelToPoint(
stats_line_size, dpi))
self.ax.stats.set_transform(self.ax.transAxes)
class PlotBase( object ):
def __init__( self, data = None, axes = None, *aw, **kw ):
self.ax_contain = axes
self.canvas = None
self.figure = None
if self.ax_contain:
self.figure = self.ax_contain.get_figure()
self.canvas = self.figure.canvas
self.dpi = self.ax_contain.figure.get_dpi()
self.ax_contain.set_axis_off()
self.prefs = evalPrefs( *aw, **kw )
self.coords = {}
self.palette = Palette()
if isinstance( data, dict):
self.gdata = GraphData( data )
elif isinstance( data, object) and data.__class__ == GraphData:
self.gdata = data
def dumpPrefs( self ):
for key in self.prefs:
print key.rjust( 20 ), ':', str( self.prefs[key] ).ljust( 40 )
def setAxes( self, axes ):
self.ax_contain = axes
self.ax_contain.set_axis_off()
self.figure = self.ax_contain.get_figure()
self.canvas = self.figure.canvas
self.dpi = self.ax_contain.figure.get_dpi()
def draw( self ):
prefs = self.prefs
dpi = self.ax_contain.figure.get_dpi()
# Update palette
palette = prefs.get( 'colors', {} )
if palette:
self.palette.addPalette( palette )
xlabel = prefs.get( 'xlabel', '' )
ylabel = prefs.get( 'ylabel', '' )
xticks_flag = prefs.get( 'xticks', True )
yticks_flag = prefs.get( 'yticks', True )
text_size = prefs['text_size']
text_padding = prefs['text_padding']
label_text_size = prefs.get( 'label_text_size', text_size )
label_text_size_point = pixelToPoint( label_text_size, dpi )
tick_text_size = prefs.get( 'tick_text_size', text_size )
tick_text_size_point = pixelToPoint( tick_text_size, dpi )
ytick_length = prefs.get( 'ytick_length', 7 * tick_text_size )
plot_title = prefs.get( 'plot_title', '' )
if not plot_title or plot_title == 'NoTitle':
plot_title_size = 0
plot_title_padding = 0
else:
plot_title_size = prefs.get( 'plot_title_size', text_size )
plot_title_padding = prefs.get( 'plot_text_padding', text_padding )
plot_title_size_point = pixelToPoint( plot_title_size, dpi )
stats_flag = prefs.get( 'statistics_line', False )
stats_line = ''
stats_line_space = 0.
if stats_flag:
stats_line = self.gdata.getStatString()
stats_line_size = label_text_size
stats_line_padding = label_text_size * 2.
stats_line_space = stats_line_size + stats_line_padding
plot_padding = prefs['plot_padding']
plot_left_padding = prefs.get( 'plot_left_padding', plot_padding )
plot_right_padding = prefs.get( 'plot_right_padding', 0 )
plot_bottom_padding = prefs.get( 'plot_bottom_padding', plot_padding )
plot_top_padding = prefs.get( 'plot_top_padding', 0 )
frame_flag = prefs['frame']
# Create plot axes, and set properties
left, bottom, width, height = self.ax_contain.get_window_extent().bounds
l, b, f_width, f_height = self.figure.get_window_extent().bounds
# Space needed for labels and ticks
x_label_space = 0
if xticks_flag:
x_label_space += tick_text_size * 1.5
if xlabel:
x_label_space += label_text_size * 1.5
y_label_space = 0
if yticks_flag:
y_label_space += ytick_length
if ylabel:
y_label_space += label_text_size * 1.5
ax_plot_rect = ( float( plot_left_padding + left + y_label_space ) / f_width,
float( plot_bottom_padding + bottom + x_label_space + stats_line_space ) / f_height,
float( width - plot_left_padding - plot_right_padding - y_label_space ) / f_width,
float( height - plot_bottom_padding - plot_top_padding - x_label_space - \
plot_title_size - 2 * plot_title_padding - stats_line_space ) / f_height )
ax = Axes( self.figure, ax_plot_rect )
if prefs['square_axis']:
l, b, a_width, a_height = ax.get_window_extent().bounds
delta = abs( a_height - a_width )
if a_height > a_width:
a_height = a_width
ax_plot_rect = ( float( plot_left_padding + left ) / f_width,
float( plot_bottom_padding + bottom + delta / 2. ) / f_height,
float( width - plot_left_padding - plot_right_padding ) / f_width,
float( height - plot_bottom_padding - plot_title_size - 2 * plot_title_padding - delta ) / f_height )
else:
a_width = a_height
ax_plot_rect = ( float( plot_left_padding + left + delta / 2. ) / f_width,
float( plot_bottom_padding + bottom ) / f_height,
float( width - plot_left_padding - delta ) / f_width,
float( height - plot_bottom_padding - plot_title_size - 2 * plot_title_padding ) / f_height )
ax.set_position( ax_plot_rect )
self.figure.add_axes( ax )
self.ax = ax
frame = ax.patch
frame.set_fill( False )
if frame_flag.lower() == 'off':
self.ax.set_axis_off()
self.log_xaxis = False
self.log_yaxis = False
else:
# If requested, make x/y axis logarithmic
if prefs.get( 'log_xaxis', 'False' ).find( 'r' ) >= 0:
ax.semilogx()
self.log_xaxis = True
else:
self.log_xaxis = False
if prefs.get( 'log_yaxis', 'False' ).find( 'r' ) >= 0:
ax.semilogy()
self.log_yaxis = True
else:
self.log_yaxis = False
if xticks_flag:
setp( ax.get_xticklabels(), family = prefs['font_family'] )
setp( ax.get_xticklabels(), fontname = prefs['font'] )
setp( ax.get_xticklabels(), size = tick_text_size_point )
else:
setp( ax.get_xticklabels(), size = 0 )
if yticks_flag:
setp( ax.get_yticklabels(), family = prefs['font_family'] )
setp( ax.get_yticklabels(), fontname = prefs['font'] )
setp( ax.get_yticklabels(), size = tick_text_size_point )
else:
setp( ax.get_yticklabels(), size = 0 )
setp( ax.get_xticklines(), markeredgewidth = pixelToPoint( 0.5, dpi ) )
setp( ax.get_xticklines(), markersize = pixelToPoint( text_size / 2., dpi ) )
setp( ax.get_yticklines(), markeredgewidth = pixelToPoint( 0.5, dpi ) )
setp( ax.get_yticklines(), markersize = pixelToPoint( text_size / 2., dpi ) )
setp( ax.get_xticklines(), zorder = 4.0 )
line_width = prefs.get( 'line_width', 1.0 )
frame_line_width = prefs.get( 'frame_line_width', line_width )
grid_line_width = prefs.get( 'grid_line_width', 0.1 )
plot_line_width = prefs.get( 'plot_line_width', 0.1 )
setp( ax.patch, linewidth = pixelToPoint( plot_line_width, dpi ) )
#setp( ax.spines, linewidth=pixelToPoint(frame_line_width,dpi) )
#setp( ax.axvline(), linewidth=pixelToPoint(1.0,dpi) )
axis_grid_flag = prefs.get( 'plot_axis_grid', True )
if axis_grid_flag:
ax.grid( True, color = '#555555', linewidth = pixelToPoint( grid_line_width, dpi ) )
plot_axis_flag = prefs.get( 'plot_axis', True )
if plot_axis_flag:
# Set labels
if xlabel:
t = ax.set_xlabel( xlabel )
t.set_family( prefs['font_family'] )
t.set_fontname( prefs['font'] )
t.set_size( label_text_size )
if ylabel:
t = ax.set_ylabel( ylabel )
t.set_family( prefs['font_family'] )
t.set_fontname( prefs['font'] )
t.set_size( label_text_size )
else:
self.ax.set_axis_off()
# Create a plot title, if necessary
if plot_title:
self.ax.title = self.ax.text( 0.5,
1. + float( plot_title_padding ) / height,
plot_title,
verticalalignment = 'bottom',
horizontalalignment = 'center',
size = pixelToPoint( plot_title_size, dpi ),
family = prefs['font_family'],
fontname = prefs['font'])
self.ax.title.set_transform( self.ax.transAxes )
self.ax.title.set_family( prefs['font_family'] )
self.ax.title.set_fontname( prefs['font'] )
if stats_line:
self.ax.stats = self.ax.text( 0.5, ( -stats_line_space ) / height,
stats_line,
verticalalignment = 'top',
horizontalalignment = 'center',
size = pixelToPoint( stats_line_size, dpi ) )
self.ax.stats.set_transform( self.ax.transAxes )
class Legend:
def __init__(self, data=None, axes=None, *aw, **kw):
self.labels = {}
if type(data) == types.DictType:
for label, ddict in data.items():
#self.labels[label] = pretty_float(max([ float(x) for x in ddict.values() if x ]) )
self.labels[label] = "%.1f" % max(
[float(x) for x in ddict.values() if x])
elif type(data) == types.InstanceType and data.__class__ == GraphData:
self.labels = data.getLabels()
else:
self.labels = data
#self.labels.reverse()
self.ax = axes
self.canvas = None
if self.ax:
self.canvas = self.ax.figure.canvas
self.ax.set_axis_off()
self.prefs = evalPrefs(*aw, **kw)
self.palette = Palette()
if self.labels and self.labels[0][0] != 'NoLabels':
percent_flag = self.prefs.get('legend_unit', '')
if percent_flag == "%":
sum_value = sum(data.label_values)
if sum_value > 0.:
self.labels = [(l, v / sum_value * 100.)
for l, v in self.labels]
self.__get_column_width()
def dumpPrefs(self):
for key in self.prefs:
print key.rjust(20), ':', str(self.prefs[key]).ljust(40)
def setLabels(self, labels):
self.labels = labels
def setAxes(self, axes):
self.ax = axes
self.canvas = self.ax.figure.canvas
self.ax.set_axis_off()
def getLegendSize(self):
self.__get_column_width()
legend_position = self.prefs['legend_position']
legend_width = float(self.prefs['legend_width'])
legend_height = float(self.prefs['legend_height'])
legend_padding = float(self.prefs['legend_padding'])
legend_text_size = self.prefs.get('legend_text_size',
self.prefs['text_size'])
legend_text_padding = self.prefs.get('legend_text_padding',
self.prefs['text_padding'])
if legend_position in ['right', 'left']:
# One column in case of vertical legend
legend_width = self.column_width + legend_padding
nLabels = len(self.labels)
legend_max_height = nLabels * (legend_text_size +
legend_text_padding)
elif legend_position == 'bottom':
nColumns = min(self.prefs['legend_max_columns'],
int(legend_width / self.column_width))
nLabels = len(self.labels)
maxRows = self.prefs['legend_max_rows']
nRows_ax = int(legend_height / 1.6 / self.prefs['text_size'])
nRows_label = nLabels / nColumns + (nLabels % nColumns != 0)
nRows = max(1, min(min(nRows_label, maxRows), nRows_ax))
text_padding = self.prefs['text_padding']
text_padding = pixelToPoint(text_padding, self.prefs['dpi'])
legend_height = min(
legend_height,
(nRows * (self.text_size + text_padding) + text_padding))
legend_max_height = nLabels * (self.text_size + text_padding)
return legend_width, legend_height, legend_max_height
def __get_legend_text_size(self):
dpi = self.prefs['dpi']
text_size = self.prefs['text_size']
text_padding = self.prefs['text_padding']
legend_text_size = self.prefs.get('legend_text_size', text_size)
legend_text_padding = self.prefs.get('legend_text_padding',
text_padding)
return legend_text_size, legend_text_padding
def __get_column_width(self):
max_length = 0
max_column_text = ''
flag = self.prefs.get('legend_numbers', True)
unit = self.prefs.get('legend_unit', False)
for label, num in self.labels:
if not flag: num = None
if num is not None:
column_length = len(str(label) + str(num)) + 1
else:
column_length = len(str(label)) + 1
if column_length > max_length:
max_length = column_length
if flag:
if type(num) == types.IntType or type(
num) == types.LongType:
numString = str(num)
else:
numString = "%.1f" % float(num)
max_column_text = '%s %s' % (str(label), numString)
if unit:
max_column_text += "%"
else:
max_column_text = '%s ' % str(label)
figure = Figure()
canvas = FigureCanvasAgg(figure)
dpi = self.prefs['dpi']
figure.set_dpi(dpi)
l_size, l_padding = self.__get_legend_text_size()
self.text_size = pixelToPoint(l_size, dpi)
text = Text(0., 0., text=max_column_text, size=self.text_size)
text.set_figure(figure)
bbox = text.get_window_extent(canvas.get_renderer())
self.column_width = bbox.width + 6 * l_size
def draw(self):
dpi = self.prefs['dpi']
ax_xsize = self.ax.get_window_extent().width
ax_ysize = self.ax.get_window_extent().height
nLabels = len(self.labels)
nColumns = min(self.prefs['legend_max_columns'],
int(ax_xsize / self.column_width))
maxRows = self.prefs['legend_max_rows']
nRows_ax = int(ax_ysize / 1.6 / self.prefs['text_size'])
nRows_label = nLabels / nColumns + (nLabels % nColumns != 0)
nRows = max(1, min(min(nRows_label, maxRows), nRows_ax))
maxLabels = nColumns * nRows - 1
self.ax.set_xlim(0., float(ax_xsize))
self.ax.set_ylim(-float(ax_ysize), 0.)
legend_text_size, legend_text_padding = self.__get_legend_text_size()
legend_text_size_point = pixelToPoint(legend_text_size, dpi)
box_width = legend_text_size
legend_offset = (ax_xsize - nColumns * self.column_width) / 2
nc = 0
#self.labels.reverse()
for label, num in self.labels:
num_flag = self.prefs.get('legend_numbers', True)
percent_flag = self.prefs.get('legend_unit', '')
if num_flag:
if percent_flag == "%":
num = "%.1f" % num + '%'
else:
num = "%.1f" % num
else:
num = None
color = self.palette.getColor(label)
row = nc % nRows
column = nc / nRows
if row == nRows - 1 and column == nColumns - 1 and nc != nLabels - 1:
last_text = '... plus %d more' % (nLabels - nc)
self.ax.text(float(column * self.column_width) + legend_offset,
-float(row * 1.6 * box_width),
last_text,
horizontalalignment='left',
verticalalignment='top',
size=legend_text_size_point)
break
else:
self.ax.text(float(column * self.column_width) +
2. * box_width + legend_offset,
-row * 1.6 * box_width,
str(label),
horizontalalignment='left',
verticalalignment='top',
size=legend_text_size_point)
if num is not None:
self.ax.text(float((column + 1) * self.column_width) -
2 * box_width + legend_offset,
-float(row * 1.6 * box_width),
str(num),
horizontalalignment='right',
verticalalignment='top',
size=legend_text_size_point)
box = Rectangle(
(float(column * self.column_width) + legend_offset,
-float(row * 1.6 * box_width) - box_width), box_width,
box_width)
box.set_ec('black')
box.set_linewidth(pixelToPoint(0.5, dpi))
box.set_fc(color)
self.ax.add_patch(box)
nc += 1
class Legend(object):
def __init__(self, data=None, axes=None, *aw, **kw):
self.text_size = 0
self.column_width = 0
self.labels = {}
if isinstance(data, dict):
for label, ddict in data.items():
# self.labels[label] = pretty_float(max([ float(x) for x in ddict.values() if x ]) )
self.labels[label] = "%.1f" % max(
[float(x) for x in ddict.values() if x])
elif isinstance(data, GraphData):
self.labels = data.getLabels()
else:
self.labels = data
# self.labels.reverse()
self.ax = axes
self.canvas = None
if self.ax:
self.canvas = self.ax.figure.canvas
self.ax.set_axis_off()
self.prefs = evalPrefs(*aw, **kw)
self.palette = Palette()
if self.labels and self.labels[0][0] != "NoLabels":
percent_flag = self.prefs.get("legend_unit", "")
if percent_flag == "%":
sum_value = sum(data.label_values)
if sum_value > 0.0:
self.labels = [(l, v / sum_value * 100.0)
for l, v in self.labels]
self.__get_column_width()
def dumpPrefs(self):
for key in self.prefs:
print(key.rjust(20), ":", str(self.prefs[key]).ljust(40))
def setLabels(self, labels):
self.labels = labels
def setAxes(self, axes):
self.ax = axes
self.canvas = self.ax.figure.canvas
self.ax.set_axis_off()
def getLegendSize(self):
self.__get_column_width()
legend_position = self.prefs["legend_position"]
legend_width = float(self.prefs["legend_width"])
legend_height = float(self.prefs["legend_height"])
legend_padding = float(self.prefs["legend_padding"])
legend_text_size = self.prefs.get("legend_text_size",
self.prefs["text_size"])
legend_text_padding = self.prefs.get("legend_text_padding",
self.prefs["text_padding"])
if legend_position in ["right", "left"]:
# One column in case of vertical legend
legend_width = self.column_width + legend_padding
nLabels = len(self.labels)
legend_max_height = nLabels * (legend_text_size +
legend_text_padding)
elif legend_position == "bottom":
nColumns = min(self.prefs["legend_max_columns"],
int(legend_width / self.column_width))
nLabels = len(self.labels)
maxRows = self.prefs["legend_max_rows"]
nRows_ax = int(legend_height / 1.6 / self.prefs["text_size"])
nRows_label = nLabels / nColumns + (nLabels % nColumns != 0)
nRows = int(max(1, min(min(nRows_label, maxRows), nRows_ax)))
text_padding = self.prefs["text_padding"]
text_padding = pixelToPoint(text_padding, self.prefs["dpi"])
legend_height = int(
min(legend_height,
(nRows * (self.text_size + text_padding) + text_padding)))
legend_max_height = int(nLabels * (self.text_size + text_padding))
return legend_width, legend_height, legend_max_height
def __get_legend_text_size(self):
text_size = self.prefs["text_size"]
text_padding = self.prefs["text_padding"]
legend_text_size = self.prefs.get("legend_text_size", text_size)
legend_text_padding = self.prefs.get("legend_text_padding",
text_padding)
return legend_text_size, legend_text_padding
def __get_column_width(self):
max_length = 0
max_column_text = ""
flag = self.prefs.get("legend_numbers", True)
unit = self.prefs.get("legend_unit", False)
for label, num in self.labels:
if not flag:
num = None
if num is not None:
column_length = len(str(label) + str(num)) + 1
else:
column_length = len(str(label)) + 1
if column_length > max_length:
max_length = column_length
if flag:
if isinstance(num, six.integer_types):
numString = str(num)
else:
numString = "%.1f" % float(num)
max_column_text = "%s %s" % (str(label), numString)
if unit:
max_column_text += "%"
else:
max_column_text = "%s " % str(label)
figure = Figure()
canvas = FigureCanvasAgg(figure)
dpi = self.prefs["dpi"]
figure.set_dpi(dpi)
l_size, _ = self.__get_legend_text_size()
self.text_size = pixelToPoint(l_size, dpi)
text = Text(0.0, 0.0, text=max_column_text, size=self.text_size)
text.set_figure(figure)
bbox = text.get_window_extent(canvas.get_renderer())
columnwidth = bbox.width + 6 * l_size
# make sure the legend fit in the box
self.column_width = (columnwidth
if columnwidth <= self.prefs["legend_width"] else
self.prefs["legend_width"] - 6 * l_size)
def draw(self):
dpi = self.prefs["dpi"]
ax_xsize = self.ax.get_window_extent().width
ax_ysize = self.ax.get_window_extent().height
nLabels = len(self.labels)
nColumns = min(self.prefs["legend_max_columns"],
int(ax_xsize / self.column_width))
maxRows = self.prefs["legend_max_rows"]
nRows_ax = int(ax_ysize / 1.6 / self.prefs["text_size"])
nRows_label = nLabels / nColumns + (nLabels % nColumns != 0)
nRows = max(1, min(min(nRows_label, maxRows), nRows_ax))
self.ax.set_xlim(0.0, float(ax_xsize))
self.ax.set_ylim(-float(ax_ysize), 0.0)
legend_text_size, legend_text_padding = self.__get_legend_text_size()
legend_text_size_point = pixelToPoint(legend_text_size, dpi)
box_width = legend_text_size
legend_offset = (ax_xsize - nColumns * self.column_width) / 2
nc = 0
# self.labels.reverse()
for label, num in self.labels:
num_flag = self.prefs.get("legend_numbers", True)
percent_flag = self.prefs.get("legend_unit", "")
if num_flag:
if percent_flag == "%":
num = "%.1f" % num + "%"
else:
num = "%.1f" % num
else:
num = None
color = self.palette.getColor(label)
row = nc % nRows
column = int(nc / nRows)
if row == nRows - 1 and column == nColumns - 1 and nc != nLabels - 1:
last_text = "... plus %d more" % (nLabels - nc)
self.ax.text(
float(column * self.column_width) + legend_offset,
-float(row * 1.6 * box_width),
last_text,
horizontalalignment="left",
verticalalignment="top",
size=legend_text_size_point,
)
break
else:
self.ax.text(
float(column * self.column_width) + 2.0 * box_width +
legend_offset,
-row * 1.6 * box_width,
str(label),
horizontalalignment="left",
verticalalignment="top",
size=legend_text_size_point,
)
if num is not None:
self.ax.text(
float((column + 1) * self.column_width) -
2 * box_width + legend_offset,
-float(row * 1.6 * box_width),
str(num),
horizontalalignment="right",
verticalalignment="top",
size=legend_text_size_point,
)
box = Rectangle(
(float(column * self.column_width) + legend_offset,
-float(row * 1.6 * box_width) - box_width),
box_width,
box_width,
)
box.set_edgecolor("black")
box.set_linewidth(pixelToPoint(0.5, dpi))
box.set_facecolor(color)
self.ax.add_patch(box)
nc += 1
