|
""" Place a table below the x-axis at location loc.
The table consists of a grid of cells.
The grid need not be rectangular and can have holes.
Cells are added by specifying their row and column.
For the purposes of positioning the cell at (0, 0) is assumed to be at the top left and the cell at (max_row, max_col) is assumed to be at bottom right.
You can add additional cells outside this range to have convenient ways of positioning more interesting grids.
Author : John Gill <jng@europe.renre.com> Copyright : 2004 John Gill and John Hunter License : matplotlib license
"""
""" A cell is a `.Rectangle` with some associated text. """
edgecolor='k', facecolor='w', fill=True, text='', loc=None, fontproperties=None ):
# Call base Rectangle.__init__(self, xy, width=width, height=height, edgecolor=edgecolor, facecolor=facecolor) self.set_clip_on(False)
# Create text object if loc is None: loc = 'right' self._loc = loc self._text = Text(x=xy[0], y=xy[1], text=text, fontproperties=fontproperties) self._text.set_clip_on(False)
Rectangle.set_transform(self, trans) # the text does not get the transform! self.stale = True
Rectangle.set_figure(self, fig) self._text.set_figure(fig)
"""Return the cell `.Text` instance.""" return self._text
self._text.set_fontsize(size) self.stale = True
"""Return the cell fontsize.""" return self._text.get_fontsize()
""" Shrink font size until text fits. """ fontsize = self.get_fontsize() required = self.get_required_width(renderer) while fontsize > 1 and required > self.get_width(): fontsize -= 1 self.set_fontsize(fontsize) required = self.get_required_width(renderer)
return fontsize
def draw(self, renderer): if not self.get_visible(): return # draw the rectangle Rectangle.draw(self, renderer)
# position the text self._set_text_position(renderer) self._text.draw(renderer) self.stale = False
""" Set text up so it draws in the right place.
Currently support 'left', 'center' and 'right' """ bbox = self.get_window_extent(renderer) l, b, w, h = bbox.bounds
# draw in center vertically self._text.set_verticalalignment('center') y = b + (h / 2.0)
# now position horizontally if self._loc == 'center': self._text.set_horizontalalignment('center') x = l + (w / 2.0) elif self._loc == 'left': self._text.set_horizontalalignment('left') x = l + (w * self.PAD) else: self._text.set_horizontalalignment('right') x = l + (w * (1.0 - self.PAD))
self._text.set_position((x, y))
""" Get text bounds in axes co-ordinates. """ bbox = self._text.get_window_extent(renderer) bboxa = bbox.inverse_transformed(self.get_data_transform()) return bboxa.bounds
""" Get width required for this cell. """ l, b, w, h = self.get_text_bounds(renderer) return w * (1.0 + (2.0 * self.PAD))
'update the text properties with kwargs' self._text.update(kwargs) self.stale = True
""" A subclass of Cell where the sides may be visibly toggled. """
'closed': _edges, # default 'horizontal': 'BT', 'vertical': 'RL' }
super().__init__(*args, **kwargs) self.visible_edges = visible_edges
def visible_edges(self): return self._visible_edges
def visible_edges(self, value): if value is None: self._visible_edges = self._edges elif value in self._edge_aliases: self._visible_edges = self._edge_aliases[value] else: for edge in value: if edge not in self._edges: raise ValueError('Invalid edge param {}, must only be one ' 'of {} or string of {}'.format( value, ", ".join(self._edge_aliases), ", ".join(self._edges))) self._visible_edges = value self.stale = True
""" Return a path where the edges specified by _visible_edges are drawn. """ codes = [Path.MOVETO]
for edge in self._edges: if edge in self._visible_edges: codes.append(Path.LINETO) else: codes.append(Path.MOVETO)
if Path.MOVETO not in codes[1:]: # All sides are visible codes[-1] = Path.CLOSEPOLY
return Path( [[0.0, 0.0], [1.0, 0.0], [1.0, 1.0], [0.0, 1.0], [0.0, 0.0]], codes, readonly=True )
""" Create a table of cells.
Table can have (optional) row and column headers.
Each entry in the table can be either text or patches.
Column widths and row heights for the table can be specified.
Return value is a sequence of text, line and patch instances that make up the table """ 'upper right': 1, # default 'upper left': 2, 'lower left': 3, 'lower right': 4, 'center left': 5, 'center right': 6, 'lower center': 7, 'upper center': 8, 'center': 9, 'top right': 10, 'top left': 11, 'bottom left': 12, 'bottom right': 13, 'right': 14, 'left': 15, 'top': 16, 'bottom': 17, }
Artist.__init__(self)
if isinstance(loc, str): if loc not in self.codes: warnings.warn('Unrecognized location %s. Falling back on ' 'bottom; valid locations are\n%s\t' % (loc, '\n\t'.join(self.codes))) loc = 'bottom' loc = self.codes[loc] self.set_figure(ax.figure) self._axes = ax self._loc = loc self._bbox = bbox
# use axes coords self.set_transform(ax.transAxes)
self._texts = [] self._cells = {} self._edges = None self._autoRows = [] self._autoColumns = [] self._autoFontsize = True self.update(kwargs)
self.set_clip_on(False)
""" Add a cell to the table.
Parameters ---------- row : int Row index. col : int Column index.
Returns ------- `CustomCell`: Automatically created cell
""" xy = (0, 0) cell = CustomCell(xy, visible_edges=self.edges, *args, **kwargs) self[row, col] = cell return cell
""" Set a custom cell in a given position. """ if not isinstance(cell, CustomCell): raise TypeError('Table only accepts CustomCell') try: row, col = position[0], position[1] except Exception: raise KeyError('Only tuples length 2 are accepted as coordinates') cell.set_figure(self.figure) cell.set_transform(self.get_transform()) cell.set_clip_on(False) self._cells[row, col] = cell self.stale = True
""" Retrieve a custom cell from a given position. """ try: row, col = position[0], position[1] except Exception: raise KeyError('Only tuples length 2 are accepted as coordinates') return self._cells[row, col]
def edges(self): return self._edges
def edges(self, value): self._edges = value self.stale = True
return (self.FONTSIZE / 72.0 * self.figure.dpi / self._axes.bbox.height * 1.2)
def draw(self, renderer): # Need a renderer to do hit tests on mouseevent; assume the last one # will do if renderer is None: renderer = self.figure._cachedRenderer if renderer is None: raise RuntimeError('No renderer defined')
if not self.get_visible(): return renderer.open_group('table') self._update_positions(renderer)
for key in sorted(self._cells): self._cells[key].draw(renderer)
renderer.close_group('table') self.stale = False
"""Get a bbox, in axes co-ordinates for the cells.
Only include those in the range (0,0) to (maxRow, maxCol)""" boxes = [cell.get_window_extent(renderer) for (row, col), cell in self._cells.items() if row >= 0 and col >= 0] bbox = Bbox.union(boxes) return bbox.inverse_transformed(self.get_transform())
"""Test whether the mouse event occurred in the table.
Returns T/F, {} """ if callable(self._contains): return self._contains(self, mouseevent)
# TODO: Return index of the cell containing the cursor so that the user # doesn't have to bind to each one individually. renderer = self.figure._cachedRenderer if renderer is not None: boxes = [cell.get_window_extent(renderer) for (row, col), cell in self._cells.items() if row >= 0 and col >= 0] bbox = Bbox.union(boxes) return bbox.contains(mouseevent.x, mouseevent.y), {} else: return False, {}
"""Return the Artists contained by the table.""" return list(self._cells.values())
"""Return the bounding box of the table in window coords.""" boxes = [cell.get_window_extent(renderer) for cell in self._cells.values()] return Bbox.union(boxes)
""" Calculate row heights and column widths.
Position cells accordingly. """ # Calculate row/column widths widths = {} heights = {} for (row, col), cell in self._cells.items(): height = heights.setdefault(row, 0.0) heights[row] = max(height, cell.get_height()) width = widths.setdefault(col, 0.0) widths[col] = max(width, cell.get_width())
# work out left position for each column xpos = 0 lefts = {} for col in sorted(widths): lefts[col] = xpos xpos += widths[col]
ypos = 0 bottoms = {} for row in sorted(heights, reverse=True): bottoms[row] = ypos ypos += heights[row]
# set cell positions for (row, col), cell in self._cells.items(): cell.set_x(lefts[col]) cell.set_y(bottoms[row])
""" Given column indexs in either List, Tuple or int. Will be able to automatically set the columns into optimal sizes.
Here is the example of the input, which triger automatic adjustment on columns to optimal size by given index numbers. -1: the row labling 0: the 1st column 1: the 2nd column
Args: col(List): list of indexs >>>table.auto_set_column_width([-1,0,1])
col(Tuple): tuple of indexs >>>table.auto_set_column_width((-1,0,1))
col(int): index integer >>>table.auto_set_column_width(-1) >>>table.auto_set_column_width(0) >>>table.auto_set_column_width(1) """ # check for col possibility on iteration try: iter(col) except (TypeError, AttributeError): self._autoColumns.append(col) else: for cell in col: self._autoColumns.append(cell)
self.stale = True
"""Automatically set width for column.""" cells = [key for key in self._cells if key[1] == col]
# find max width width = 0 for cell in cells: c = self._cells[cell] width = max(c.get_required_width(renderer), width)
# Now set the widths for cell in cells: self._cells[cell].set_width(width)
""" Automatically set font size. """ self._autoFontsize = value self.stale = True
if len(self._cells) == 0: return fontsize = next(iter(self._cells.values())).get_fontsize() cells = [] for key, cell in self._cells.items(): # ignore auto-sized columns if key[1] in self._autoColumns: continue size = cell.auto_set_font_size(renderer) fontsize = min(fontsize, size) cells.append(cell)
# now set all fontsizes equal for cell in self._cells.values(): cell.set_fontsize(fontsize)
""" Scale column widths by xscale and row heights by yscale. """ for c in self._cells.values(): c.set_width(c.get_width() * xscale) c.set_height(c.get_height() * yscale)
""" Set the font size, in points, of the cell text.
Parameters ---------- size : float """
for cell in self._cells.values(): cell.set_fontsize(size) self.stale = True
"""Move all the artists by ox, oy (axes coords).""" for c in self._cells.values(): x, y = c.get_x(), c.get_y() c.set_x(x + ox) c.set_y(y + oy)
# called from renderer to allow more precise estimates of # widths and heights with get_window_extent
# Do any auto width setting for col in self._autoColumns: self._auto_set_column_width(col, renderer)
if self._autoFontsize: self._auto_set_font_size(renderer)
# Align all the cells self._do_cell_alignment()
bbox = self._get_grid_bbox(renderer) l, b, w, h = bbox.bounds
if self._bbox is not None: # Position according to bbox rl, rb, rw, rh = self._bbox self.scale(rw / w, rh / h) ox = rl - l oy = rb - b self._do_cell_alignment() else: # Position using loc (BEST, UR, UL, LL, LR, CL, CR, LC, UC, C, TR, TL, BL, BR, R, L, T, B) = range(len(self.codes)) # defaults for center ox = (0.5 - w / 2) - l oy = (0.5 - h / 2) - b if self._loc in (UL, LL, CL): # left ox = self.AXESPAD - l if self._loc in (BEST, UR, LR, R, CR): # right ox = 1 - (l + w + self.AXESPAD) if self._loc in (BEST, UR, UL, UC): # upper oy = 1 - (b + h + self.AXESPAD) if self._loc in (LL, LR, LC): # lower oy = self.AXESPAD - b if self._loc in (LC, UC, C): # center x ox = (0.5 - w / 2) - l if self._loc in (CL, CR, C): # center y oy = (0.5 - h / 2) - b
if self._loc in (TL, BL, L): # out left ox = - (l + w) if self._loc in (TR, BR, R): # out right ox = 1.0 - l if self._loc in (TR, TL, T): # out top oy = 1.0 - b if self._loc in (BL, BR, B): # out bottom oy = - (b + h)
self._offset(ox, oy)
"""Return a dict of cells in the table.""" return self._cells
cellText=None, cellColours=None, cellLoc='right', colWidths=None, rowLabels=None, rowColours=None, rowLoc='left', colLabels=None, colColours=None, colLoc='center', loc='bottom', bbox=None, edges='closed', **kwargs): """ TABLE(cellText=None, cellColours=None, cellLoc='right', colWidths=None, rowLabels=None, rowColours=None, rowLoc='left', colLabels=None, colColours=None, colLoc='center', loc='bottom', bbox=None, edges='closed')
Factory function to generate a Table instance.
Thanks to John Gill for providing the class and table. """
if cellColours is None and cellText is None: raise ValueError('At least one argument from "cellColours" or ' '"cellText" must be provided to create a table.')
# Check we have some cellText if cellText is None: # assume just colours are needed rows = len(cellColours) cols = len(cellColours[0]) cellText = [[''] * cols] * rows
rows = len(cellText) cols = len(cellText[0]) for row in cellText: if len(row) != cols: raise ValueError("Each row in 'cellText' must have {} columns" .format(cols))
if cellColours is not None: if len(cellColours) != rows: raise ValueError("'cellColours' must have {} rows".format(rows)) for row in cellColours: if len(row) != cols: raise ValueError("Each row in 'cellColours' must have {} " "columns".format(cols)) else: cellColours = ['w' * cols] * rows
# Set colwidths if not given if colWidths is None: colWidths = [1.0 / cols] * cols
# Fill in missing information for column # and row labels rowLabelWidth = 0 if rowLabels is None: if rowColours is not None: rowLabels = [''] * rows rowLabelWidth = colWidths[0] elif rowColours is None: rowColours = 'w' * rows
if rowLabels is not None: if len(rowLabels) != rows: raise ValueError("'rowLabels' must be of length {0}".format(rows))
# If we have column labels, need to shift # the text and colour arrays down 1 row offset = 1 if colLabels is None: if colColours is not None: colLabels = [''] * cols else: offset = 0 elif colColours is None: colColours = 'w' * cols
# Set up cell colours if not given if cellColours is None: cellColours = ['w' * cols] * rows
# Now create the table table = Table(ax, loc, bbox, **kwargs) table.edges = edges height = table._approx_text_height()
# Add the cells for row in range(rows): for col in range(cols): table.add_cell(row + offset, col, width=colWidths[col], height=height, text=cellText[row][col], facecolor=cellColours[row][col], loc=cellLoc) # Do column labels if colLabels is not None: for col in range(cols): table.add_cell(0, col, width=colWidths[col], height=height, text=colLabels[col], facecolor=colColours[col], loc=colLoc)
# Do row labels if rowLabels is not None: for row in range(rows): table.add_cell(row + offset, -1, width=rowLabelWidth or 1e-15, height=height, text=rowLabels[row], facecolor=rowColours[row], loc=rowLoc) if rowLabelWidth == 0: table.auto_set_column_width(-1)
ax.add_table(table) return table
|