def __init__(self,
edgecolors=None,
facecolors=None,
linewidths=None,
antialiaseds = None,
offsets = None,
transOffset = identity_transform(),
norm = None, # optional for ScalarMappable
cmap = None, # ditto
):
Collection.__init__(self)
ScalarMappable.__init__(self, norm, cmap)
if edgecolors is None: edgecolors =\
self._get_color(rcParams['patch.edgecolor'])
if facecolors is None: facecolors = \
self._get_color(rcParams['patch.facecolor'])
if linewidths is None: linewidths = ( rcParams['patch.linewidth'],)
if antialiaseds is None: antialiaseds = ( rcParams['patch.antialiased'],)
self._edgecolors = edgecolors
self._facecolors = facecolors
self._linewidths = linewidths
self._antialiaseds = antialiaseds
self._offsets = offsets
self._transOffset = transOffset
def __init__(self,
edgecolors=None,
facecolors=None,
linewidths=None,
antialiaseds = None,
offsets = None,
transOffset = identity_transform(),
norm = None, # optional for ScalarMappable
cmap = None, # ditto
):
Collection.__init__(self)
ScalarMappable.__init__(self, norm, cmap)
if edgecolors is None: edgecolors =\
self._get_color(rcParams['patch.edgecolor'])
if facecolors is None: facecolors = \
self._get_color(rcParams['patch.facecolor'])
if linewidths is None: linewidths = ( rcParams['patch.linewidth'],)
if antialiaseds is None: antialiaseds = ( rcParams['patch.antialiased'],)
self._edgecolors = edgecolors
self._facecolors = facecolors
self._linewidths = linewidths
self._antialiaseds = antialiaseds
self._offsets = offsets
self._transOffset = transOffset
def __init__(self, segments,
linewidths = None,
colors = None,
antialiaseds = None,
linestyle = 'solid',
offsets = None,
transOffset = None,#identity_transform(),
):
"""
segments is a sequence of ( line0, line1, line2), where
linen = (x0, y0), (x1, y1), ... (xm, ym).
Each line can be a different length.
colors must be a tuple of RGBA tuples (eg arbitrary color
strings, etc, not allowed).
antialiaseds must be a sequence of ones or zeros
linestyles is a string or dash tuple. Legal string values are
solid|dashed|dashdot|dotted. The dash tuple is (offset, onoffseq)
where onoffseq is an even length tuple of on and off ink in points.
If linewidths, colors, or antialiaseds is None, they default to
their rc params setting, in sequence form.
If offsets and transOffset are not None, then
offsets are transformed by transOffset and applied after
the segments have been transformed to display coordinates.
If offsets is not None but transOffset is None, then the
offsets are added to the segments before any transformation.
In this case, a single offset can be specified as offsets=(xo,yo),
and this value will be
added cumulatively to each successive segment, so as
to produce a set of successively offset curves.
"""
Collection.__init__(self)
if linewidths is None :
linewidths = (rcParams['lines.linewidth'], )
if colors is None :
colors = self._get_color(rcParams['lines.color'])
if antialiaseds is None :
antialiaseds = (rcParams['lines.antialiased'], )
self._segments = list(segments)
self._colors = colors
self._aa = antialiaseds
self._lw = linewidths
self.set_linestyle(linestyle)
if transOffset is None:
if offsets is not None:
self._add_offsets(offsets)
offsets = None
transOffset = identity_transform()
self._offsets = offsets
self._transOffset = transOffset
def __init__(self):
self.figure = None
self._transform = identity_transform()
self._transformSet = False
self._visible = True
self._alpha = 1.0
self.clipbox = None
self._clipon = False
self._lod = False
def __init__(self):
self.figure = None
self._transform = identity_transform()
self._transformSet = False
self._visible = True
self._alpha = 1.0
self.clipbox = None
self._clipon = False
self._lod = False
def _get_offset_text(self):
# x in display coords, y in axes coords (to be updated at draw time)
offsetText = Text(x=0, y=0.5,
fontproperties = FontProperties(size=rcParams['ytick.labelsize']),
color = rcParams['ytick.color'],
verticalalignment = 'bottom',
horizontalalignment = 'left',
)
offsetText.set_transform(blend_xy_sep_transform(self.axes.transAxes,
identity_transform()) )
self._set_artist_props(offsetText)
self.offset_text_position='left'
return offsetText
def _get_offset_text(self):
# x in axes coords, y in display coords (to be updated at draw time)
offsetText = Text(x=1, y=0,
fontproperties = FontProperties(size=rcParams['tick.labelsize']),
color = rcParams['tick.color'],
verticalalignment='top',
horizontalalignment='right',
)
offsetText.set_transform( blend_xy_sep_transform( self.axes.transAxes,
identity_transform() ))
self._set_artist_props(offsetText)
self.offset_text_position='bottom'
return offsetText
def _get_label(self):
# x in axes coords, y in display coords (to be updated at draw
# time by _update_label_positions
label = Text(x=0.5, y=0,
fontproperties = FontProperties(size=rcParams['axes.labelsize']),
color = rcParams['axes.labelcolor'],
verticalalignment='top',
horizontalalignment='center',
)
label.set_transform( blend_xy_sep_transform( self.axes.transAxes,
identity_transform() ))
self._set_artist_props(label)
return label
def _get_label(self):
# x in axes coords, y in display coords (to be updated at draw
# time by _update_label_positions
label = Text(x=0.5, y=0,
fontproperties = FontProperties(size=rcParams['axes.labelsize']),
color = rcParams['axes.labelcolor'],
verticalalignment='top',
horizontalalignment='center',
)
label.set_transform( blend_xy_sep_transform( self.axes.transAxes,
identity_transform() ))
self._set_artist_props(label)
return label
def __init__(self):
self.figure = None
self._transform = identity_transform()
self._transformSet = False
self._visible = True
self._alpha = 1.0
self.clipbox = None
self._clipon = False
self._lod = False
self._label = ''
self.eventson = False # fire events only if eventson
self._oid = 0 # an observer id
self._propobservers = {} # a dict from oids to funcs
def __init__(self):
self.figure = None
self._transform = identity_transform()
self._transformSet = False
self._visible = True
self._alpha = 1.0
self.clipbox = None
self._clipon = False
self._lod = False
self._label = ''
self.eventson = False # fire events only if eventson
self._oid = 0 # an observer id
self._propobservers = {} # a dict from oids to funcs
def _get_label(self):
# x in display coords (updated by _update_label_position)
# y in axes coords
label = Text(x=0, y=0.5,
# todo: get the label position
fontproperties=FontProperties(size=rcParams['axes.labelsize']),
color = rcParams['axes.labelcolor'],
verticalalignment='center',
horizontalalignment='right',
rotation='vertical',
)
label.set_transform( blend_xy_sep_transform( identity_transform(),
self.axes.transAxes) )
self._set_artist_props(label)
return label
def _get_label(self):
# x in display coords (updated by _update_label_position)
# y in axes coords
label = Text(x=0, y=0.5,
# todo: get the label position
fontproperties=FontProperties(size=rcParams['axes.labelsize']),
color = rcParams['axes.labelcolor'],
verticalalignment='center',
horizontalalignment='right',
rotation='vertical',
)
label.set_transform( blend_xy_sep_transform( identity_transform(),
self.axes.transAxes) )
self._set_artist_props(label)
return label
def __init__(
self,
edgecolors=None,
facecolors=None,
linewidths=None,
antialiaseds=None,
offsets=None,
transOffset=identity_transform(),
norm=None, # optional for ScalarMappable
cmap=None, # ditto
):
Collection.__init__(self)
ScalarMappable.__init__(self, norm, cmap)
if facecolors is None: facecolors = rcParams['patch.facecolor']
if edgecolors is None: edgecolors = rcParams['patch.edgecolor']
if linewidths is None: linewidths = (rcParams['patch.linewidth'], )
if antialiaseds is None:
antialiaseds = (rcParams['patch.antialiased'], )
self._facecolors = colorConverter.to_rgba_list(facecolors)
if edgecolors == 'None':
self._edgecolors = self._facecolors
linewidths = (0, )
else:
self._edgecolors = colorConverter.to_rgba_list(edgecolors)
self._linewidths = linewidths
self._antialiaseds = antialiaseds
#self._offsets = offsets
self._original_offsets = offsets
self._cached_offsets = offsets
self._transOffset = transOffset
self._xunits = self._yunits = None
self._update_cache = {
'_original_offsets': None,
'_xunits': None,
'_yunits': None
}
def __init__(self,
artist,
s,
loc=None,
padx='auto',
pady='auto',
autopad=3,
**props):
"""
Annotate the matplotlib.Artist artist with string s. kwargs
props are passed on to the Text base class and are text
properties.
loc is an x, y tuple. If the location codes are a string and
the artist supports the
"get_window_extent method" (eg matplotlib.patches.Patch and
children, Text, Axes, Figure, Line2D) the location code can be
a pair of strings
A: 'inside left', 'inside upper'
B: 'outside right', 'outside lower'
C: 'center', 'center'
D: 'inside left', 'outside bottom'
E: 'center', 'outside top'
inside and outside cannot be used with 'center'. With
upper, lower, left and right, inside will be assumed if
inside|outside is not provided
E
--------------------------------------------
| A |
| |
| |
| C |
| |
| |
| |
|__________________________________________|
D B
These codes also work with Axes and Figure instances
Otherwise it must be an x,y pair which will use the artist's
own transformation
eg
Annotation(rectangle, 'some text', loc=('center', 'outside top'), color='red', size=14)
Annotation(axes, 'A', loc=('inside left', 'inside top'))
padx and pady are number of points to pad the text in the x
and y direction. When used with string codes, 'auto' will pad
autopad points in the appropriate direction given the
inside/outside left/right/center bottom/top/center location
codes
"""
# we'll draw ourself after the artist we annotate by default
zorder = props.get('zorder', artist.get_zorder() + 1)
Text.__init__(self, text=s, **props)
self.set_zorder(zorder)
self.set_transform(identity_transform())
self._loc = tuple(loc)
self._padx, self._pady, self._autopad = padx, pady, autopad
self._annotateArtist = artist
# funcx and funcy are used to place the x, y coords for
# artists who define get_window_extent
if is_string_like(
self._loc[0]) and is_string_like(self._loc[1]) and hasattr(
self._annotateArtist, 'get_window_extent'):
xloc, yloc = self._loc
self._process_xloc(xloc)
self._process_yloc(yloc)
else:
self._funcx = None
self._funcy = None
self._renderer = None
def __init__(
self,
segments,
linewidths=None,
colors=None,
antialiaseds=None,
linestyle='solid',
offsets=None,
transOffset=None, #identity_transform(),
):
"""
segments is a sequence of ( line0, line1, line2), where
linen = (x0, y0), (x1, y1), ... (xm, ym).
Each line can be a different length.
colors must be a tuple of RGBA tuples (eg arbitrary color
strings, etc, not allowed).
antialiaseds must be a sequence of ones or zeros
linestyles is a string or dash tuple. Legal string values are
solid|dashed|dashdot|dotted. The dash tuple is (offset, onoffseq)
where onoffseq is an even length tuple of on and off ink in points.
If linewidths, colors, or antialiaseds is None, they default to
their rc params setting, in sequence form.
If offsets and transOffset are not None, then
offsets are transformed by transOffset and applied after
the segments have been transformed to display coordinates.
If offsets is not None but transOffset is None, then the
offsets are added to the segments before any transformation.
In this case, a single offset can be specified as offsets=(xo,yo),
and this value will be
added cumulatively to each successive segment, so as
to produce a set of successively offset curves.
"""
Collection.__init__(self)
if linewidths is None:
linewidths = (rcParams['lines.linewidth'], )
if colors is None:
colors = self._get_color(rcParams['lines.color'])
if antialiaseds is None:
antialiaseds = (rcParams['lines.antialiased'], )
self._segments = list(segments)
self._colors = colors
self._aa = antialiaseds
self._lw = linewidths
self.set_linestyle(linestyle)
if transOffset is None:
if offsets is not None:
self._add_offsets(offsets)
offsets = None
transOffset = identity_transform()
self._offsets = offsets
self._transOffset = transOffset
def __init__(self, artist, s, loc=None,
padx='auto', pady='auto', autopad=3, **props):
"""
Annotate the matplotlib.Artist artist with string s. kwargs
props are passed on to the Text base class and are text
properties.
loc is an x, y tuple. If the location codes are a string and
the artist supports the
"get_window_extent method" (eg matplotlib.patches.Patch and
children, Text, Axes, Figure, Line2D) the location code can be
a pair of strings
A: 'inside left', 'inside upper'
B: 'outside right', 'outside lower'
C: 'center', 'center'
D: 'inside left', 'outside bottom'
E: 'center', 'outside top'
inside and outside cannot be used with 'center'. With
upper, lower, left and right, inside will be assumed if
inside|outside is not provided
E
--------------------------------------------
| A |
| |
| |
| C |
| |
| |
| |
|__________________________________________|
D B
These codes also work with Axes and Figure instances
Otherwise it must be an x,y pair which will use the artist's
own transformation
eg
Annotation(rectangle, 'some text', loc=('center', 'outside top'), color='red', size=14)
Annotation(axes, 'A', loc=('inside left', 'inside top'))
padx and pady are number of points to pad the text in the x
and y direction. When used with string codes, 'auto' will pad
autopad points in the appropriate direction given the
inside/outside left/right/center bottom/top/center location
codes
"""
# we'll draw ourself after the artist we annotate by default
zorder = props.get('zorder', artist.get_zorder() + 1)
Text.__init__(self, text=s, **props)
self.set_zorder(zorder)
self.set_transform(identity_transform())
self._loc = tuple(loc)
self._padx, self._pady, self._autopad = padx, pady, autopad
self._annotateArtist = artist
# funcx and funcy are used to place the x, y coords for
# artists who define get_window_extent
if is_string_like(self._loc[0]) and is_string_like(self._loc[1]) and hasattr(self._annotateArtist, 'get_window_extent'):
xloc, yloc = self._loc
self._process_xloc(xloc)
self._process_yloc(yloc)
else:
self._funcx = None
self._funcy = None
self._renderer = None
def __init__(
self,
segments, # Can be None.
linewidths=None,
colors=None,
antialiaseds=None,
linestyle='solid',
offsets=None,
transOffset=None, #identity_transform(),
norm=None,
cmap=None,
):
"""
segments is a sequence of ( line0, line1, line2), where
linen = (x0, y0), (x1, y1), ... (xm, ym), or the
equivalent numerix array with two columns.
Each line can be a different length.
colors must be a tuple of RGBA tuples (eg arbitrary color
strings, etc, not allowed).
antialiaseds must be a sequence of ones or zeros
linestyles is a string or dash tuple. Legal string values are
solid|dashed|dashdot|dotted. The dash tuple is (offset, onoffseq)
where onoffseq is an even length tuple of on and off ink in points.
If linewidths, colors, or antialiaseds is None, they default to
their rc params setting, in sequence form.
If offsets and transOffset are not None, then
offsets are transformed by transOffset and applied after
the segments have been transformed to display coordinates.
If offsets is not None but transOffset is None, then the
offsets are added to the segments before any transformation.
In this case, a single offset can be specified as offsets=(xo,yo),
and this value will be
added cumulatively to each successive segment, so as
to produce a set of successively offset curves.
norm = None, # optional for ScalarMappable
cmap = None, # ditto
The use of ScalarMappable is optional. If the ScalarMappable
matrix _A is not None (ie a call to set_array has been made), at
draw time a call to scalar mappable will be made to set the colors.
"""
Collection.__init__(self)
ScalarMappable.__init__(self, norm, cmap)
if linewidths is None:
linewidths = (rcParams['lines.linewidth'], )
if colors is None:
colors = (rcParams['lines.color'], )
if antialiaseds is None:
antialiaseds = (rcParams['lines.antialiased'], )
self._colors = colorConverter.to_rgba_list(colors)
self._aa = antialiaseds
self._lw = linewidths
self.set_linestyle(linestyle)
self._uniform_offsets = None
if offsets is not None:
offsets = asarray(offsets)
if len(offsets.shape) == 1:
offsets = offsets[newaxis, :] # Make it Nx2.
if transOffset is None:
if offsets is not None:
self._uniform_offsets = offsets
offsets = None
transOffset = identity_transform()
self._offsets = offsets
self._transOffset = transOffset
self.set_segments(segments)
def get_transform(self):
'return the Transformation instance used by this artist'
if self._transform is None:
self._transform = identity_transform()
return self._transform
