desc stringlengths 3 26.7k | decl stringlengths 11 7.89k | bodies stringlengths 8 553k |
|---|---|---|
'return the path of the arrow in the data coordinate. Use
get_path_in_displaycoord() medthod to retrieve the arrow path
in the disaply coord.'
| def get_path(self):
| _path = self.get_path_in_displaycoord()
return self.get_transform().inverted().transform_path(_path)
|
'Return the mutated path of the arrow in the display coord'
| def get_path_in_displaycoord(self):
| if (self._posA_posB is not None):
posA = self.get_transform().transform_point(self._posA_posB[0])
posB = self.get_transform().transform_point(self._posA_posB[1])
_path = self.get_connectionstyle()(posA, posB, patchA=self.patchA, patchB=self.patchB, shrinkA=self.shrinkA, shrinkB=self.shrinkB)... |
'Split the Type 1 font into its three main parts.
The three parts are: (1) the cleartext part, which ends in a
eexec operator; (2) the encrypted part; (3) the fixed part,
which contains 512 ASCII zeros possibly divided on various
lines, a cleartomark operator, and possibly something else.'
| def _split(self, data):
| idx = data.index('eexec')
idx += len('eexec')
while (data[idx] in ' DCTB \r\n'):
idx += 1
len1 = idx
idx = (data.rindex('cleartomark') - 1)
zeros = 512
while (zeros and (data[idx] in ('0', '\n', '\r'))):
if (data[idx] == '0'):
zeros -= 1
idx -= 1
i... |
'A very limited kind of parsing to find the Encoding of the
font.'
| def _parse(self):
| def tokens(text):
'\n Yield pairs (position, token), ignoring comments and\n whitespace. Numbers count as tokens.\n '
pos = 0
... |
'bbox is the Bound2D bounding box in display coords of the Axes
loc is the tick location in data coords
size is the tick size in relative, axes coords'
| def __init__(self, axes, loc, label, size=None, gridOn=None, tick1On=True, tick2On=True, label1On=True, label2On=False, major=True):
| artist.Artist.__init__(self)
if (gridOn is None):
gridOn = rcParams['axes.grid']
self.set_figure(axes.figure)
self.axes = axes
name = self.__name__.lower()
if (size is None):
if major:
size = rcParams[('%s.major.size' % name)]
pad = rcParams[('%s.major.pad... |
'Test whether the mouse event occured in the Tick marks.
This function always returns false. It is more useful to test if the
axis as a whole contains the mouse rather than the set of tick marks.'
| def contains(self, mouseevent):
| if callable(self._contains):
return self._contains(self, mouseevent)
return (False, {})
|
'Set the tick label pad in points
ACCEPTS: float'
| def set_pad(self, val):
| self._pad = val
|
'Get the value of the tick label pad in points'
| def get_pad(self):
| return self._pad
|
'Get the default Text 1 instance'
| def _get_text1(self):
| pass
|
'Get the default Text 2 instance'
| def _get_text2(self):
| pass
|
'Get the default line2D instance for tick1'
| def _get_tick1line(self):
| pass
|
'Get the default line2D instance for tick2'
| def _get_tick2line(self):
| pass
|
'Get the default grid Line2d instance for this tick'
| def _get_gridline(self):
| pass
|
'Return the tick location (data coords) as a scalar'
| def get_loc(self):
| return self._loc
|
'Set the text of ticklabel
ACCEPTS: str'
| def set_label1(self, s):
| self.label1.set_text(s)
|
'Set the text of ticklabel2
ACCEPTS: str'
| def set_label2(self, s):
| self.label2.set_text(s)
|
'return the view Interval instance for the axis this tick is ticking'
| def get_view_interval(self):
| raise NotImplementedError('Derived must override')
|
'Get the default Text instance'
| def _get_text1(self):
| (trans, vert, horiz) = self.axes.get_xaxis_text1_transform(self._pad)
size = rcParams['xtick.labelsize']
t = mtext.Text(x=0, y=0, fontproperties=font_manager.FontProperties(size=size), color=rcParams['xtick.color'], verticalalignment=vert, horizontalalignment=horiz)
t.set_transform(trans)
self._set_... |
'Get the default Text 2 instance'
| def _get_text2(self):
| (trans, vert, horiz) = self.axes.get_xaxis_text2_transform(self._pad)
t = mtext.Text(x=0, y=1, fontproperties=font_manager.FontProperties(size=rcParams['xtick.labelsize']), color=rcParams['xtick.color'], verticalalignment=vert, horizontalalignment=horiz)
t.set_transform(trans)
self._set_artist_props(t)
... |
'Get the default line2D instance'
| def _get_tick1line(self):
| l = mlines.Line2D(xdata=(0,), ydata=(0,), color='k', linestyle='None', marker=self._xtickmarkers[0], markersize=self._size)
l.set_transform(self.axes.get_xaxis_transform())
self._set_artist_props(l)
return l
|
'Get the default line2D instance'
| def _get_tick2line(self):
| l = mlines.Line2D(xdata=(0,), ydata=(1,), color='k', linestyle='None', marker=self._xtickmarkers[1], markersize=self._size)
l.set_transform(self.axes.get_xaxis_transform())
self._set_artist_props(l)
return l
|
'Get the default line2D instance'
| def _get_gridline(self):
| l = mlines.Line2D(xdata=(0.0, 0.0), ydata=(0, 1.0), color=rcParams['grid.color'], linestyle=rcParams['grid.linestyle'], linewidth=rcParams['grid.linewidth'])
l.set_transform(self.axes.get_xaxis_transform())
self._set_artist_props(l)
return l
|
'Set the location of tick in data coords with scalar *loc*'
| def update_position(self, loc):
| x = loc
nonlinear = ((hasattr(self.axes, 'yaxis') and (self.axes.yaxis.get_scale() != 'linear')) or (hasattr(self.axes, 'xaxis') and (self.axes.xaxis.get_scale() != 'linear')))
if self.tick1On:
self.tick1line.set_xdata((x,))
if self.tick2On:
self.tick2line.set_xdata((x,))
if self.gri... |
'return the Interval instance for this axis view limits'
| def get_view_interval(self):
| return self.axes.viewLim.intervalx
|
'return the Interval instance for this axis data limits'
| def get_data_interval(self):
| return self.axes.dataLim.intervalx
|
'Get the default Text instance'
| def _get_text1(self):
| (trans, vert, horiz) = self.axes.get_yaxis_text1_transform(self._pad)
t = mtext.Text(x=0, y=0, fontproperties=font_manager.FontProperties(size=rcParams['ytick.labelsize']), color=rcParams['ytick.color'], verticalalignment=vert, horizontalalignment=horiz)
t.set_transform(trans)
self._set_artist_props(t)
... |
'Get the default Text instance'
| def _get_text2(self):
| (trans, vert, horiz) = self.axes.get_yaxis_text2_transform(self._pad)
t = mtext.Text(x=1, y=0, fontproperties=font_manager.FontProperties(size=rcParams['ytick.labelsize']), color=rcParams['ytick.color'], verticalalignment=vert, horizontalalignment=horiz)
t.set_transform(trans)
self._set_artist_props(t)
... |
'Get the default line2D instance'
| def _get_tick1line(self):
| l = mlines.Line2D((0,), (0,), color='k', marker=self._ytickmarkers[0], linestyle='None', markersize=self._size)
l.set_transform(self.axes.get_yaxis_transform())
self._set_artist_props(l)
return l
|
'Get the default line2D instance'
| def _get_tick2line(self):
| l = mlines.Line2D((1,), (0,), color='k', marker=self._ytickmarkers[1], linestyle='None', markersize=self._size)
l.set_transform(self.axes.get_yaxis_transform())
self._set_artist_props(l)
return l
|
'Get the default line2D instance'
| def _get_gridline(self):
| l = mlines.Line2D(xdata=(0, 1), ydata=(0, 0), color=rcParams['grid.color'], linestyle=rcParams['grid.linestyle'], linewidth=rcParams['grid.linewidth'])
l.set_transform(self.axes.get_yaxis_transform())
self._set_artist_props(l)
return l
|
'Set the location of tick in data coords with scalar loc'
| def update_position(self, loc):
| y = loc
nonlinear = ((hasattr(self.axes, 'yaxis') and (self.axes.yaxis.get_scale() != 'linear')) or (hasattr(self.axes, 'xaxis') and (self.axes.xaxis.get_scale() != 'linear')))
if self.tick1On:
self.tick1line.set_ydata((y,))
if self.tick2On:
self.tick2line.set_ydata((y,))
if self.gri... |
'return the Interval instance for this axis view limits'
| def get_view_interval(self):
| return self.axes.viewLim.intervaly
|
'return the Interval instance for this axis data limits'
| def get_data_interval(self):
| return self.axes.dataLim.intervaly
|
'Init the axis with the parent Axes instance'
| def __init__(self, axes, pickradius=15):
| artist.Artist.__init__(self)
self.set_figure(axes.figure)
self.axes = axes
self.major = Ticker()
self.minor = Ticker()
self.callbacks = cbook.CallbackRegistry(('units', 'units finalize'))
self._autolabelpos = True
self.label = self._get_label()
self.offsetText = self._get_offset_t... |
'Set the coordinates of the label. By default, the x
coordinate of the y label is determined by the tick label
bounding boxes, but this can lead to poor alignment of
multiple ylabels if there are multiple axes. Ditto for the y
coodinate of the x label.
You can also specify the coordinate system of the label with
the ... | def set_label_coords(self, x, y, transform=None):
| self._autolabelpos = False
if (transform is None):
transform = self.axes.transAxes
self.label.set_transform(transform)
self.label.set_position((x, y))
|
'clear the current axis'
| def cla(self):
| self.set_major_locator(mticker.AutoLocator())
self.set_major_formatter(mticker.ScalarFormatter())
self.set_minor_locator(mticker.NullLocator())
self.set_minor_formatter(mticker.NullFormatter())
self.callbacks = cbook.CallbackRegistry(('units', 'units finalize'))
self._gridOnMajor = rcParams['... |
'return the Interval instance for this axis view limits'
| def get_view_interval(self):
| raise NotImplementedError('Derived must override')
|
'return the Interval instance for this axis data limits'
| def get_data_interval(self):
| raise NotImplementedError('Derived must override')
|
'Set the axis data limits'
| def set_data_interval(self):
| raise NotImplementedError('Derived must override')
|
'Iterate through all of the major and minor ticks.'
| def iter_ticks(self):
| majorLocs = self.major.locator()
majorTicks = self.get_major_ticks(len(majorLocs))
self.major.formatter.set_locs(majorLocs)
majorLabels = [self.major.formatter(val, i) for (i, val) in enumerate(majorLocs)]
minorLocs = self.minor.locator()
minorTicks = self.get_minor_ticks(len(minorLocs))
sel... |
'Get the extents of the tick labels on either side
of the axes.'
| def get_ticklabel_extents(self, renderer):
| ticklabelBoxes = []
ticklabelBoxes2 = []
interval = self.get_view_interval()
for (tick, loc, label) in self.iter_ticks():
if (tick is None):
continue
if (not mtransforms.interval_contains(interval, loc)):
continue
tick.update_position(loc)
tick.set... |
'Draw the axis lines, grid lines, tick lines and labels'
| def draw(self, renderer, *args, **kwargs):
| ticklabelBoxes = []
ticklabelBoxes2 = []
if (not self.get_visible()):
return
renderer.open_group(__name__)
interval = self.get_view_interval()
for (tick, loc, label) in self.iter_ticks():
if (tick is None):
continue
if (not mtransforms.interval_contains(interv... |
'Return the grid lines as a list of Line2D instance'
| def get_gridlines(self):
| ticks = self.get_major_ticks()
return cbook.silent_list('Line2D gridline', [tick.gridline for tick in ticks])
|
'Return the axis label as a Text instance'
| def get_label(self):
| return self.label
|
'Return the axis offsetText as a Text instance'
| def get_offset_text(self):
| return self.offsetText
|
'Return the depth of the axis used by the picker'
| def get_pickradius(self):
| return self.pickradius
|
'Return a list of Text instances for the major ticklabels'
| def get_majorticklabels(self):
| ticks = self.get_major_ticks()
labels1 = [tick.label1 for tick in ticks if tick.label1On]
labels2 = [tick.label2 for tick in ticks if tick.label2On]
return cbook.silent_list('Text major ticklabel', (labels1 + labels2))
|
'Return a list of Text instances for the minor ticklabels'
| def get_minorticklabels(self):
| ticks = self.get_minor_ticks()
labels1 = [tick.label1 for tick in ticks if tick.label1On]
labels2 = [tick.label2 for tick in ticks if tick.label2On]
return cbook.silent_list('Text minor ticklabel', (labels1 + labels2))
|
'Return a list of Text instances for ticklabels'
| def get_ticklabels(self, minor=False):
| if minor:
return self.get_minorticklabels()
return self.get_majorticklabels()
|
'Return the major tick lines as a list of Line2D instances'
| def get_majorticklines(self):
| lines = []
ticks = self.get_major_ticks()
for tick in ticks:
lines.append(tick.tick1line)
lines.append(tick.tick2line)
return cbook.silent_list('Line2D ticklines', lines)
|
'Return the minor tick lines as a list of Line2D instances'
| def get_minorticklines(self):
| lines = []
ticks = self.get_minor_ticks()
for tick in ticks:
lines.append(tick.tick1line)
lines.append(tick.tick2line)
return cbook.silent_list('Line2D ticklines', lines)
|
'Return the tick lines as a list of Line2D instances'
| def get_ticklines(self, minor=False):
| if minor:
return self.get_minorticklines()
return self.get_majorticklines()
|
'Get the major tick locations in data coordinates as a numpy array'
| def get_majorticklocs(self):
| return self.major.locator()
|
'Get the minor tick locations in data coordinates as a numpy array'
| def get_minorticklocs(self):
| return self.minor.locator()
|
'Get the tick locations in data coordinates as a numpy array'
| def get_ticklocs(self, minor=False):
| if minor:
return self.minor.locator()
return self.major.locator()
|
'return the default tick intsance'
| def _get_tick(self, major):
| raise NotImplementedError('derived must override')
|
'Copy the props from src tick to dest tick'
| def _copy_tick_props(self, src, dest):
| if ((src is None) or (dest is None)):
return
dest.label1.update_from(src.label1)
dest.label2.update_from(src.label2)
dest.tick1line.update_from(src.tick1line)
dest.tick2line.update_from(src.tick2line)
dest.gridline.update_from(src.gridline)
dest.tick1On = src.tick1On
dest.tick2On... |
'Get the locator of the major ticker'
| def get_major_locator(self):
| return self.major.locator
|
'Get the locator of the minor ticker'
| def get_minor_locator(self):
| return self.minor.locator
|
'Get the formatter of the major ticker'
| def get_major_formatter(self):
| return self.major.formatter
|
'Get the formatter of the minor ticker'
| def get_minor_formatter(self):
| return self.minor.formatter
|
'get the tick instances; grow as necessary'
| def get_major_ticks(self, numticks=None):
| if (numticks is None):
numticks = len(self.get_major_locator()())
if (len(self.majorTicks) < numticks):
for i in range((numticks - len(self.majorTicks))):
tick = self._get_tick(major=True)
self.majorTicks.append(tick)
if (self._lastNumMajorTicks < numticks):
p... |
'get the minor tick instances; grow as necessary'
| def get_minor_ticks(self, numticks=None):
| if (numticks is None):
numticks = len(self.get_minor_locator()())
if (len(self.minorTicks) < numticks):
for i in range((numticks - len(self.minorTicks))):
tick = self._get_tick(major=False)
self.minorTicks.append(tick)
if (self._lastNumMinorTicks < numticks):
... |
'Set the axis grid on or off; b is a boolean use *which* =
\'major\' | \'minor\' to set the grid for major or minor ticks
if *b* is *None* and len(kwargs)==0, toggle the grid state. If
*kwargs* are supplied, it is assumed you want the grid on and *b*
will be set to True
*kwargs* are used to set the line properties of ... | def grid(self, b=None, which='major', **kwargs):
| if len(kwargs):
b = True
if (which.lower().find('minor') >= 0):
if (b is None):
self._gridOnMinor = (not self._gridOnMinor)
else:
self._gridOnMinor = b
for tick in self.minorTicks:
if (tick is None):
continue
tick.gr... |
'introspect *data* for units converter and update the
axis.converter instance if necessary. Return *True* is *data* is
registered for unit conversion'
| def update_units(self, data):
| converter = munits.registry.get_converter(data)
if (converter is None):
return False
self.converter = converter
default = self.converter.default_units(data)
if ((default is not None) and (self.units is None)):
self.set_units(default)
self._update_axisinfo()
return True
|
'check the axis converter for the stored units to see if the
axis info needs to be updated'
| def _update_axisinfo(self):
| if (self.converter is None):
return
info = self.converter.axisinfo(self.units)
if (info is None):
return
if ((info.majloc is not None) and (self.major.locator != info.majloc)):
self.set_major_locator(info.majloc)
if ((info.minloc is not None) and (self.minor.locator != info.m... |
'set the units for axis
ACCEPTS: a units tag'
| def set_units(self, u):
| pchanged = False
if (u is None):
self.units = None
pchanged = True
elif (u != self.units):
self.units = u
pchanged = True
if pchanged:
self._update_axisinfo()
self.callbacks.process('units')
self.callbacks.process('units finalize')
|
'return the units for axis'
| def get_units(self):
| return self.units
|
'Set the formatter of the major ticker
ACCEPTS: A :class:`~matplotlib.ticker.Formatter` instance'
| def set_major_formatter(self, formatter):
| self.major.formatter = formatter
formatter.set_axis(self)
|
'Set the formatter of the minor ticker
ACCEPTS: A :class:`~matplotlib.ticker.Formatter` instance'
| def set_minor_formatter(self, formatter):
| self.minor.formatter = formatter
formatter.set_axis(self)
|
'Set the locator of the major ticker
ACCEPTS: a :class:`~matplotlib.ticker.Locator` instance'
| def set_major_locator(self, locator):
| self.major.locator = locator
locator.set_axis(self)
|
'Set the locator of the minor ticker
ACCEPTS: a :class:`~matplotlib.ticker.Locator` instance'
| def set_minor_locator(self, locator):
| self.minor.locator = locator
locator.set_axis(self)
|
'Set the depth of the axis used by the picker
ACCEPTS: a distance in points'
| def set_pickradius(self, pickradius):
| self.pickradius = pickradius
|
'Set the text values of the tick labels. Return a list of Text
instances. Use *kwarg* *minor=True* to select minor ticks.
ACCEPTS: sequence of strings'
| def set_ticklabels(self, ticklabels, *args, **kwargs):
| minor = kwargs.pop('minor', False)
if minor:
self.set_minor_formatter(mticker.FixedFormatter(ticklabels))
ticks = self.get_minor_ticks()
else:
self.set_major_formatter(mticker.FixedFormatter(ticklabels))
ticks = self.get_major_ticks()
self.set_major_formatter(mticker.Fixe... |
'Set the locations of the tick marks from sequence ticks
ACCEPTS: sequence of floats'
| def set_ticks(self, ticks, minor=False):
| ticks = self.convert_units(ticks)
if (len(ticks) > 1):
(xleft, xright) = self.get_view_interval()
if (xright > xleft):
self.set_view_interval(min(ticks), max(ticks))
else:
self.set_view_interval(max(ticks), min(ticks))
if minor:
self.set_minor_locator(... |
'Update the label position based on the sequence of bounding
boxes of all the ticklabels'
| def _update_label_position(self, bboxes, bboxes2):
| raise NotImplementedError('Derived must override')
|
'Update the label position based on the sequence of bounding
boxes of all the ticklabels'
| def _update_offset_text_postion(self, bboxes, bboxes2):
| raise NotImplementedError('Derived must override')
|
'Pan *numsteps* (can be positive or negative)'
| def pan(self, numsteps):
| self.major.locator.pan(numsteps)
|
'Zoom in/out on axis; if *direction* is >0 zoom in, else zoom out'
| def zoom(self, direction):
| self.major.locator.zoom(direction)
|
'Test whether the mouse event occured in the x axis.'
| def contains(self, mouseevent):
| if callable(self._contains):
return self._contains(self, mouseevent)
(x, y) = (mouseevent.x, mouseevent.y)
try:
trans = self.axes.transAxes.inverted()
(xaxes, yaxes) = trans.transform_point((x, y))
except ValueError:
return (False, {})
(l, b) = self.axes.transAxes.tra... |
'Return the label position (top or bottom)'
| def get_label_position(self):
| return self.label_position
|
'Set the label position (top or bottom)
ACCEPTS: [ \'top\' | \'bottom\' ]'
| def set_label_position(self, position):
| assert ((position == 'top') or (position == 'bottom'))
if (position == 'top'):
self.label.set_verticalalignment('bottom')
else:
self.label.set_verticalalignment('top')
self.label_position = position
|
'Update the label position based on the sequence of bounding
boxes of all the ticklabels'
| def _update_label_position(self, bboxes, bboxes2):
| if (not self._autolabelpos):
return
(x, y) = self.label.get_position()
if (self.label_position == 'bottom'):
if (not len(bboxes)):
bottom = self.axes.bbox.ymin
else:
bbox = mtransforms.Bbox.union(bboxes)
bottom = bbox.y0
self.label.set_posi... |
'Update the offset_text position based on the sequence of bounding
boxes of all the ticklabels'
| def _update_offset_text_position(self, bboxes, bboxes2):
| (x, y) = self.offsetText.get_position()
if (not len(bboxes)):
bottom = self.axes.bbox.ymin
else:
bbox = mtransforms.Bbox.union(bboxes)
bottom = bbox.y0
self.offsetText.set_position((x, (bottom - ((self.OFFSETTEXTPAD * self.figure.dpi) / 72.0))))
|
'Returns the amount of space one should reserve for text
above and below the axes. Returns a tuple (above, below)'
| def get_text_heights(self, renderer):
| (bbox, bbox2) = self.get_ticklabel_extents(renderer)
padPixels = self.majorTicks[0].get_pad_pixels()
above = 0.0
if bbox2.height:
above += (bbox2.height + padPixels)
below = 0.0
if bbox.height:
below += (bbox.height + padPixels)
if (self.get_label_position() == 'top'):
... |
'Set the ticks position (top, bottom, both, default or none)
both sets the ticks to appear on both positions, but does not
change the tick labels. default resets the tick positions to
the default: ticks on both positions, labels at bottom. none
can be used if you don\'t want any ticks.
ACCEPTS: [ \'top\' | \'bottom\'... | def set_ticks_position(self, position):
| assert (position in ('top', 'bottom', 'both', 'default', 'none'))
ticks = list(self.get_major_ticks())
ticks.extend(self.get_minor_ticks())
if (position == 'top'):
for t in ticks:
t.tick1On = False
t.tick2On = True
t.label1On = False
t.label2On = T... |
'use ticks only on top'
| def tick_top(self):
| self.set_ticks_position('top')
|
'use ticks only on bottom'
| def tick_bottom(self):
| self.set_ticks_position('bottom')
|
'Return the ticks position (top, bottom, default or unknown)'
| def get_ticks_position(self):
| majt = self.majorTicks[0]
mT = self.minorTicks[0]
majorTop = ((not majt.tick1On) and majt.tick2On and (not majt.label1On) and majt.label2On)
minorTop = ((not mT.tick1On) and mT.tick2On and (not mT.label1On) and mT.label2On)
if (majorTop and minorTop):
return 'top'
MajorBottom = (majt.tic... |
'return the Interval instance for this axis view limits'
| def get_view_interval(self):
| return self.axes.viewLim.intervalx
|
'return the Interval instance for this axis data limits'
| def get_data_interval(self):
| return self.axes.dataLim.intervalx
|
'return the Interval instance for this axis data limits'
| def set_data_interval(self, vmin, vmax, ignore=False):
| if ignore:
self.axes.dataLim.intervalx = (vmin, vmax)
else:
(Vmin, Vmax) = self.get_data_interval()
self.axes.dataLim.intervalx = (min(vmin, Vmin), max(vmax, Vmax))
|
'Test whether the mouse event occurred in the y axis.
Returns *True* | *False*'
| def contains(self, mouseevent):
| if callable(self._contains):
return self._contains(self, mouseevent)
(x, y) = (mouseevent.x, mouseevent.y)
try:
trans = self.axes.transAxes.inverted()
(xaxes, yaxes) = trans.transform_point((x, y))
except ValueError:
return (False, {})
(l, b) = self.axes.transAxes.tra... |
'Return the label position (left or right)'
| def get_label_position(self):
| return self.label_position
|
'Set the label position (left or right)
ACCEPTS: [ \'left\' | \'right\' ]'
| def set_label_position(self, position):
| assert ((position == 'left') or (position == 'right'))
if (position == 'right'):
self.label.set_horizontalalignment('left')
else:
self.label.set_horizontalalignment('right')
self.label_position = position
|
'Update the label position based on the sequence of bounding
boxes of all the ticklabels'
| def _update_label_position(self, bboxes, bboxes2):
| if (not self._autolabelpos):
return
(x, y) = self.label.get_position()
if (self.label_position == 'left'):
if (not len(bboxes)):
left = self.axes.bbox.xmin
else:
bbox = mtransforms.Bbox.union(bboxes)
left = bbox.x0
self.label.set_position((... |
'Update the offset_text position based on the sequence of bounding
boxes of all the ticklabels'
| def _update_offset_text_position(self, bboxes, bboxes2):
| (x, y) = self.offsetText.get_position()
top = self.axes.bbox.ymax
self.offsetText.set_position((x, (top + ((self.OFFSETTEXTPAD * self.figure.dpi) / 72.0))))
|
'Set the ticks position (left, right, both or default)
both sets the ticks to appear on both positions, but
does not change the tick labels.
default resets the tick positions to the default:
ticks on both positions, labels on the left.
ACCEPTS: [ \'left\' | \'right\' | \'both\' | \'default\' | \'none\' ]'
| def set_ticks_position(self, position):
| assert (position in ('left', 'right', 'both', 'default', 'none'))
ticks = list(self.get_major_ticks())
ticks.extend(self.get_minor_ticks())
if (position == 'right'):
self.set_offset_position('right')
for t in ticks:
t.tick1On = False
t.tick2On = True
t... |
'use ticks only on right'
| def tick_right(self):
| self.set_ticks_position('right')
|
'use ticks only on left'
| def tick_left(self):
| self.set_ticks_position('left')
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.