offsetbox

matplotlib.offsetbox

The OffsetBox is a simple container artist. The child artist are meant to be drawn at a relative position to its parent. The [VH]Packer, DrawingArea and TextArea are derived from the OffsetBox.

The [VH]Packer automatically adjust the relative postisions of their children, which should be instances of the OffsetBox. This is used to align similar artists together, e.g., in legend.

The DrawingArea can contain any Artist as a child. The DrawingArea has a fixed width and height. The position of children relative to the parent is fixed. The TextArea is contains a single Text instance. The width and height of the TextArea instance is the width and height of the its child text.

class matplotlib.offsetbox.AnchoredOffsetbox(loc, pad=0.4, borderpad=0.5, child=None, prop=None, frameon=True, bbox_to_anchor=None, bbox_transform=None, **kwargs)

Bases: matplotlib.offsetbox.OffsetBox

An offset box placed according to the legend location loc. AnchoredOffsetbox has a single child. When multiple children is needed, use other OffsetBox class to enclose them. By default, the offset box is anchored against its parent axes. You may explicitly specify the bbox_to_anchor.

loc is a string or an integer specifying the legend location. The valid location codes are:

'upper right'  : 1,
'upper left'   : 2,
'lower left'   : 3,
'lower right'  : 4,
'right'        : 5,
'center left'  : 6,
'center right' : 7,
'lower center' : 8,
'upper center' : 9,
'center'       : 10,

pad : pad around the child for drawing a frame. given in

fraction of fontsize.

borderpad : pad between offsetbox frame and the bbox_to_anchor,

child : OffsetBox instance that will be anchored.

prop : font property. This is only used as a reference for paddings.

frameon : draw a frame box if True.

bbox_to_anchor : bbox to anchor. Use self.axes.bbox if None.

bbox_transform : with which the bbox_to_anchor will be transformed.

draw(renderer)

draw the artist

get_bbox_to_anchor()

return the bbox that the legend will be anchored

get_child()

return the child

get_children()

return the list of children

get_extent(renderer)

return the extent of the artist. The extent of the child added with the pad is returned

get_window_extent(renderer)

get the bounding box in display space.

set_bbox_to_anchor(bbox, transform=None)

set the bbox that the child will be anchored.

bbox can be a Bbox instance, a list of [left, bottom, width, height], or a list of [left, bottom] where the width and height will be assumed to be zero. The bbox will be transformed to display coordinate by the given transform.

set_child(child)

set the child to be anchored

update_frame(bbox, fontsize=None)

zorder = 5

class matplotlib.offsetbox.AnchoredText(s, loc, pad=0.4, borderpad=0.5, prop=None, **kwargs)

Bases: matplotlib.offsetbox.AnchoredOffsetbox

AnchoredOffsetbox with Text.

Parameters:

s : string

Text.

loc : str

Location code.

pad : float, optional

Pad between the text and the frame as fraction of the font size.

borderpad : float, optional

Pad between the frame and the axes (or bbox_to_anchor).

prop : matplotlib.font_manager.FontProperties

Font properties.

Notes

Other keyword parameters of AnchoredOffsetbox are also allowed.

class matplotlib.offsetbox.AnnotationBbox(offsetbox, xy, xybox=None, xycoords='data', boxcoords=None, frameon=True, pad=0.4, annotation_clip=None, box_alignment=(0.5, 0.5), bboxprops=None, arrowprops=None, fontsize=None, **kwargs)

Bases: matplotlib.artist.Artist, matplotlib.text._AnnotationBase

Annotation-like class, but with offsetbox instead of Text.

offsetbox : OffsetBox instance

xycoords : same as Annotation but can be a tuple of two

strings which are interpreted as x and y coordinates.

boxcoords : similar to textcoords as Annotation but can be a

tuple of two strings which are interpreted as x and y coordinates.

box_alignment : a tuple of two floats for a vertical and

horizontal alignment of the offset box w.r.t. the boxcoords. The lower-left corner is (0.0) and upper-right corner is (1.1).

other parameters are identical to that of Annotation.

anncoords

contains(event)

draw(renderer)

Draw the Annotation object to the given renderer.

get_children()

get_fontsize(s=None)

return fontsize in points

set_figure(fig)

set_fontsize(s=None)

set fontsize in points

update_positions(renderer)

Update the pixel positions of the annotated point and the text.

xyann

zorder = 3

class matplotlib.offsetbox.AuxTransformBox(aux_transform)

Bases: matplotlib.offsetbox.OffsetBox

Offset Box with the aux_transform . Its children will be transformed with the aux_transform first then will be offseted. The absolute coordinate of the aux_transform is meaning as it will be automatically adjust so that the left-lower corner of the bounding box of children will be set to (0,0) before the offset transform.

It is similar to drawing area, except that the extent of the box is not predetermined but calculated from the window extent of its children. Furthermore, the extent of the children will be calculated in the transformed coordinate.

add_artist(a)

Add any Artist to the container box

draw(renderer)

Draw the children

get_extent(renderer)

get_offset()

return offset of the container.

get_transform()

Return the Transform applied to the children

get_window_extent(renderer)

get the bounding box in display space.

set_offset(xy)

set offset of the container.

Accept : tuple of x,y coordinate in disokay units.

set_transform(t)

set_transform is ignored.

class matplotlib.offsetbox.DraggableAnnotation(annotation, use_blit=False)

Bases: matplotlib.offsetbox.DraggableBase

save_offset()

update_offset(dx, dy)

class matplotlib.offsetbox.DraggableBase(ref_artist, use_blit=False)

Bases: object

helper code for a draggable artist (legend, offsetbox) The derived class must override following two method.

def saveoffset(self):

pass

def update_offset(self, dx, dy):

pass

saveoffset is called when the object is picked for dragging and it is meant to save reference position of the artist.

update_offset is called during the dragging. dx and dy is the pixel

offset from the point where the mouse drag started.

Optionally you may override following two methods.

def artist_picker(self, artist, evt):

return self.ref_artist.contains(evt)

def finalize_offset(self):

pass

artist_picker is a picker method that will be

used. finalize_offset is called when the mouse is released. In current implementaion of DraggableLegend and DraggableAnnotation, update_offset places the artists simply in display coordinates. And finalize_offset recalculate their position in the normalized axes coordinate and set a relavant attribute.

artist_picker(artist, evt)

disconnect()

disconnect the callbacks

finalize_offset()

on_motion(evt)

on_motion_blit(evt)

on_pick(evt)

on_release(event)

save_offset()

update_offset(dx, dy)

class matplotlib.offsetbox.DraggableOffsetBox(ref_artist, offsetbox, use_blit=False)

Bases: matplotlib.offsetbox.DraggableBase

get_loc_in_canvas()

save_offset()

update_offset(dx, dy)

class matplotlib.offsetbox.DrawingArea(width, height, xdescent=0.0, ydescent=0.0, clip=False)

Bases: matplotlib.offsetbox.OffsetBox

The DrawingArea can contain any Artist as a child. The DrawingArea has a fixed width and height. The position of children relative to the parent is fixed. The children can be clipped at the boundaries of the parent.

width, height : width and height of the container box. xdescent, ydescent : descent of the box in x- and y-direction. clip : Whether to clip the children

add_artist(a)

Add any Artist to the container box

clip_children

If the children of this DrawingArea should be clipped by DrawingArea bounding box.

draw(renderer)

Draw the children

get_extent(renderer)

Return with, height, xdescent, ydescent of box

get_offset()

return offset of the container.

get_transform()

Return the Transform applied to the children

get_window_extent(renderer)

get the bounding box in display space.

set_offset(xy)

set offset of the container.

Accept : tuple of x,y cooridnate in disokay units.

set_transform(t)

set_transform is ignored.

class matplotlib.offsetbox.HPacker(pad=None, sep=None, width=None, height=None, align='baseline', mode='fixed', children=None)

Bases: matplotlib.offsetbox.PackerBase

The HPacker has its children packed horizontally. It automatically adjusts the relative positions of children at draw time.

Parameters:

pad : float, optional

Boundary pad.

sep : float, optional

Spacing between items.

width : float, optional

height : float, optional

Width and height of the container box, calculated if None.

align : str

Alignment of boxes.

mode : str

Packing mode.

Notes

pad and sep need to given in points and will be scale with the renderer dpi, while width and height need to be in pixels.

get_extent_offsets(renderer)

update offset of children and return the extents of the box

class matplotlib.offsetbox.OffsetBox(*args, **kwargs)

Bases: matplotlib.artist.Artist

The OffsetBox is a simple container artist. The child artist are meant to be drawn at a relative position to its parent.

axes

The Axes instance the artist resides in, or None.

contains(mouseevent)

draw(renderer)

Update the location of children if necessary and draw them to the given renderer.

get_children()

Return a list of artists it contains.

get_extent(renderer)

Return with, height, xdescent, ydescent of box

get_extent_offsets(renderer)

get_offset(width, height, xdescent, ydescent, renderer)

Get the offset

accepts extent of the box

get_visible_children()

Return a list of visible artists it contains.

get_window_extent(renderer)

get the bounding box in display space.

set_figure(fig)

Set the figure

accepts a class:Figure instance

set_height(height)

Set the height

accepts float

set_offset(xy)

Set the offset

accepts x, y, tuple, or a callable object.

set_width(width)

Set the width

accepts float

class matplotlib.offsetbox.OffsetImage(arr, zoom=1, cmap=None, norm=None, interpolation=None, origin=None, filternorm=1, filterrad=4.0, resample=False, dpi_cor=True, **kwargs)

Bases: matplotlib.offsetbox.OffsetBox

draw(renderer)

Draw the children

get_children()

get_data()

get_extent(renderer)

get_offset()

return offset of the container.

get_window_extent(renderer)

get the bounding box in display space.

get_zoom()

set_data(arr)

set_zoom(zoom)

class matplotlib.offsetbox.PackerBase(pad=None, sep=None, width=None, height=None, align=None, mode=None, children=None)

Bases: matplotlib.offsetbox.OffsetBox

Parameters:

pad : float, optional

Boundary pad.

sep : float, optional

Spacing between items.

width : float, optional

height : float, optional

Width and height of the container box, calculated if None.

align : str, optional

Alignment of boxes. Can be one of top, bottom, left, right, center and baseline

mode : str, optional

Packing mode.

Notes

pad and sep need to given in points and will be scale with the renderer dpi, while width and height need to be in pixels.

class matplotlib.offsetbox.PaddedBox(child, pad=None, draw_frame=False, patch_attrs=None)

Bases: matplotlib.offsetbox.OffsetBox

pad : boundary pad

Note

pad need to given in points and will be scale with the renderer dpi, while width and height need to be in pixels.

draw(renderer)

Update the location of children if necessary and draw them to the given renderer.

draw_frame(renderer)

get_extent_offsets(renderer)

update offset of childrens and return the extents of the box

update_frame(bbox, fontsize=None)

class matplotlib.offsetbox.TextArea(s, textprops=None, multilinebaseline=None, minimumdescent=True)

Bases: matplotlib.offsetbox.OffsetBox

The TextArea is contains a single Text instance. The text is placed at (0,0) with baseline+left alignment. The width and height of the TextArea instance is the width and height of the its child text.

Parameters:

s : str

a string to be displayed.

textprops : FontProperties, optional

multilinebaseline : bool, optional

If True, baseline for multiline text is adjusted so that it is (approximatedly) center-aligned with singleline text.

minimumdescent : bool, optional

If True, the box has a minimum descent of “p”.

draw(renderer)

Draw the children

get_extent(renderer)

get_minimumdescent()

get minimumdescent.

get_multilinebaseline()

get multilinebaseline .

get_offset()

return offset of the container.

get_text()

Returns the string representation of this area’s text

get_window_extent(renderer)

get the bounding box in display space.

set_minimumdescent(t)

Set minimumdescent .

If True, extent of the single line text is adjusted so that it has minimum descent of “p”

set_multilinebaseline(t)

Set multilinebaseline .

If True, baseline for multiline text is adjusted so that it is (approximatedly) center-aligned with singleline text.

set_offset(xy)

set offset of the container.

Accept : tuple of x,y coordinates in display units.

set_text(s)

Set the text of this area as a string.

set_transform(t)

set_transform is ignored.

class matplotlib.offsetbox.VPacker(pad=None, sep=None, width=None, height=None, align='baseline', mode='fixed', children=None)

Bases: matplotlib.offsetbox.PackerBase

The VPacker has its children packed vertically. It automatically adjust the relative positions of children in the drawing time.

Parameters:

pad : float, optional

Boundary pad.

sep : float, optional

Spacing between items.

width : float, optional

height : float, optional

width and height of the container box, calculated if None.

align : str, optional

Alignment of boxes.

mode : str, optional

Packing mode.

Notes

pad and sep need to given in points and will be scale with the renderer dpi, while width and height need to be in pixels.

get_extent_offsets(renderer)

update offset of childrens and return the extents of the box

matplotlib.offsetbox.bbox_artist(*args, **kwargs)