holoviews.mpl Package#

`mpl` Package#

holoviews.plotting.mpl.set_style(key)[source]#: Select a style by name, e.g. set_style(‘default’). To revert to the previous style use the key ‘unset’ or False.

`annotation` Module#

Inheritance diagram of holoviews.plotting.mpl.annotation

class holoviews.plotting.mpl.annotation.ABLine2D(slope, intercept, *args, **kwargs)[source]#

Bases: matplotlib.lines.Line2D

Draw a line based on its slope and y-intercept. Additional arguments are passed to the <matplotlib.lines.Line2D> constructor.

add_callback(func)#

Add a callback function that will be called whenever one of the .Artist’s properties changes.

funccallable

The callback function. It must have the signature:

def func(artist: Artist) -> Any

where artist is the calling .Artist. Return values may exist but are ignored.

int: The observer id associated with the callback. This id can be used for removing the callback with .remove_callback later.

remove_callback

property axes#: The ~.axes.Axes instance the artist resides in, or None.

contains(mouseevent)#

Test whether mouseevent occurred on the line.

An event is deemed to have occurred “on” the line if it is less than self.pickradius (default: 5 points) away from it. Use ~.Line2D.get_pickradius or ~.Line2D.set_pickradius to get or set the pick radius.

mouseevent : matplotlib.backend_bases.MouseEvent

containsbool

Whether any values are within the radius.

detailsdict

A dictionary {'ind': pointlist}, where pointlist is a list of points of the line that are within the pickradius around the event position.

TODO: sort returned indices by distance

convert_xunits(x)#

Convert x using the unit type of the xaxis.

If the artist is not in contained in an Axes or if the xaxis does not have units, x itself is returned.

convert_yunits(y)#

Convert y using the unit type of the yaxis.

If the artist is not in contained in an Axes or if the yaxis does not have units, y itself is returned.

draw(renderer)#

Draw the Artist (and its children) using the given renderer.

This has no effect if the artist is not visible (.Artist.get_visible returns False).

renderer : .RendererBase subclass.

This method is overridden in the Artist subclasses.

findobj(match=None, include_self=True)#

Find artist objects.

Recursively find all .Artist instances contained in the artist.

match

A filter criterion for the matches. This can be

None: Return all objects contained in artist.
A function with signature def match(artist: Artist) -> bool. The result will only contain artists for which the function returns True.
A class instance: e.g., .Line2D. The result will only contain artists of this class or its subclasses (isinstance check).

include_selfbool

Include self in the list to be checked for a match.

list of .Artist

format_cursor_data(data)#

Return a string representation of data.

Note

This method is intended to be overridden by artist subclasses. As an end-user of Matplotlib you will most likely not call this method yourself.

The default implementation converts ints and floats and arrays of ints and floats into a comma-separated string enclosed in square brackets.

get_cursor_data

get_aa()#: Alias for get_antialiased.

get_agg_filter()#: Return filter function to be used for agg filter.

get_alpha()#: Return the alpha value used for blending - not supported on all backends.

get_animated()#: Return whether the artist is animated.

get_antialiased()#: Return whether antialiased rendering is used.

get_c()#: Alias for get_color.

get_children()#: Return a list of the child .Artists of this .Artist.

get_clip_box()#: Return the clipbox.

get_clip_on()#: Return whether the artist uses clipping.

get_clip_path()#: Return the clip path.

get_color()#

Return the line color.

See also ~.Line2D.set_linestyle.

is_transform_set()#

Return whether the Artist has an explicitly set transform.

This is True after .set_transform has been called.

property mouseover#

If this property is set to True, the artist will be queried for custom context information when the mouse cursor moves over it.

See also get_cursor_data(), ToolCursorPosition and NavigationToolbar2.

pchanged()#

Call all of the registered callbacks.

This function is triggered internally when a property is changed.

add_callback remove_callback

pick(mouseevent)#

Process a pick event.

Each child artist will fire a pick event if mouseevent is over the artist and the artist has picker set.

set_picker, get_picker, pickable

pickable()#

Return whether the artist is pickable.

set_picker, get_picker, pick

property pickradius#

Return the pick radius used for containment tests.

See .contains for more details.

properties()#: Return a dictionary of all the properties of the artist.

remove()#

Remove the artist from the figure if possible.

The effect will not be visible until the figure is redrawn, e.g., with .FigureCanvasBase.draw_idle. Call ~.axes.Axes.relim to update the axes limits if desired.

Note: ~.axes.Axes.relim will not see collections even if the collection was added to the axes with autolim = True.

Note: there is no support for removing the artist’s legend entry.

remove_callback(oid)#

Remove a callback based on its observer id.

add_callback

set(**kwargs)#: A property batch setter. Pass kwargs to set properties.

set_aa(b)#: Alias for set_antialiased.

set_agg_filter(filter_func)#

Set the agg filter.

filter_funccallable: A filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array.

set_alpha(alpha)#

Set the alpha value used for blending - not supported on all backends.

alphascalar or None: alpha must be within the 0-1 range, inclusive.

set_animated(b)#

Set whether the artist is intended to be used in an animation.

If True, the artist is excluded from regular drawing of the figure. You have to call .Figure.draw_artist / .Axes.draw_artist explicitly on the artist. This appoach is used to speed up animations using blitting.

See also matplotlib.animation and /tutorials/advanced/blitting.

b : bool

set_antialiased(b)#

Set whether to use antialiased rendering.

b : bool

set_c(color)#: Alias for set_color.

set_clip_box(clipbox)#

Set the artist’s clip .Bbox.

clipbox : .Bbox

set_clip_on(b)#

Set whether the artist uses clipping.

When False artists will be visible outside of the axes which can lead to unexpected results.

b : bool

set_clip_path(path, transform=None)#

Set the artist’s clip path.

path.Patch or .Path or .TransformedPath or None: The clip path. If given a .Path, transform must be provided as well. If None, a previously set clip path is removed.
transform~matplotlib.transforms.Transform, optional: Only used if path is a .Path, in which case the given .Path is converted to a .TransformedPath using transform.

For efficiency, if path is a .Rectangle this method will set the clipping box to the corresponding rectangle and set the clipping path to None.

For technical reasons (support of ~.Artist.set), a tuple (path, transform) is also accepted as a single positional parameter.

set_color(color)#

Set the color of the line.

color : color

set_contains(picker)#

[Deprecated] Define a custom contains test for the artist.

The provided callable replaces the default .contains method of the artist.

pickercallable

A custom picker function to evaluate if an event is within the artist. The function must have the signature:

def contains(artist: Artist, event: MouseEvent) -> bool, dict

that returns:

a bool indicating if the event is within the artist
a dict of additional information. The dict should at least return the same information as the default contains() implementation of the respective artist, but may provide additional information.

Deprecated since version 3.3.

set_dash_capstyle(s)#

How to draw the end caps if the line is ~Line2D.is_dashed.

s : .CapStyle or {‘butt’, ‘projecting’, ‘round’}

set_dash_joinstyle(s)#

How to join segments of the line if it ~Line2D.is_dashed.

s : .JoinStyle or {‘miter’, ‘round’, ‘bevel’}

set_dashes(seq)#

Set the dash sequence.

The dash sequence is a sequence of floats of even length describing the length of dashes and spaces in points.

For example, (5, 2, 1, 2) describes a sequence of 5 point and 1 point dashes separated by 2 point spaces.

seqsequence of floats (on/off ink in points) or (None, None): If seq is empty or (None, None), the linestyle will be set to solid.

set_data(*args)#

Set the x and y data.

*args : (2, N) array or two 1D arrays

set_drawstyle(drawstyle)#

Set the drawstyle of the plot.

The drawstyle determines how the points are connected.

drawstyle{‘default’, ‘steps’, ‘steps-pre’, ‘steps-mid’, ‘steps-post’}, default: ‘default’

For ‘default’, the points are connected with straight lines.

The steps variants connect the points with step-like lines, i.e. horizontal lines with vertical steps. They differ in the location of the step:

‘steps-pre’: The step is at the beginning of the line segment, i.e. the line will be at the y-value of point to the right.
‘steps-mid’: The step is halfway between the points.
‘steps-post: The step is at the end of the line segment, i.e. the line will be at the y-value of the point to the left.
‘steps’ is equal to ‘steps-pre’ and is maintained for backward-compatibility.

For examples see /gallery/lines_bars_and_markers/step_demo.

set_ds(drawstyle)#: Alias for set_drawstyle.

set_figure(fig)#

Set the .Figure instance the artist belongs to.

fig : .Figure

set_fillstyle(fs)#

Set the marker fill style.

fs{‘full’, ‘left’, ‘right’, ‘bottom’, ‘top’, ‘none’}

Possible values:

‘full’: Fill the whole marker with the markerfacecolor.
‘left’, ‘right’, ‘bottom’, ‘top’: Fill the marker half at the given side with the markerfacecolor. The other half of the marker is filled with markerfacecoloralt.
‘none’: No filling.

For examples see marker_fill_styles.

set_gid(gid)#

Set the (group) id for the artist.

gid : str

set_in_layout(in_layout)#

Set if artist is to be included in layout calculations, E.g. /tutorials/intermediate/constrainedlayout_guide, .Figure.tight_layout(), and fig.savefig(fname, bbox_inches='tight').

in_layout : bool

set_label(s)#

Set a label that will be displayed in the legend.

sobject: s will be converted to a string by calling str.

set_linestyle(ls)#

Set the linestyle of the line.

ls{‘-’, ‘–’, ‘-.’, ‘:’, ‘’, (offset, on-off-seq), …}

Possible values:

A string:

Linestyle

Description

'-' or 'solid'

solid line

'--' or 'dashed'

dashed line

'-.' or 'dashdot'

dash-dotted line

':' or 'dotted'

dotted line

'None' or ' ' or ''

draw nothing
Alternatively a dash tuple of the following form can be provided:
```
(offset, onoffseq)
```
where onoffseq is an even length tuple of on and off ink in points. See also set_dashes().

Linestyle	Description
`'-'` or `'solid'`	solid line
`'--'` or `'dashed'`	dashed line
`'-.'` or `'dashdot'`	dash-dotted line
`':'` or `'dotted'`	dotted line
`'None'` or `' '` or `''`	draw nothing

For examples see /gallery/lines_bars_and_markers/linestyles.

set_linewidth(w)#

Set the line width in points.

wfloat: Line width, in points.

set_ls(ls)#: Alias for set_linestyle.

set_lw(w)#: Alias for set_linewidth.

set_marker(marker)#

Set the line marker.

markermarker style string, ~.path.Path or ~.markers.MarkerStyle: See ~matplotlib.markers for full description of possible arguments.

set_markeredgecolor(ec)#

Set the marker edge color.

ec : color

set_markeredgewidth(ew)#

Set the marker edge width in points.

ewfloat: Marker edge width, in points.

set_markerfacecolor(fc)#

Set the marker face color.

fc : color

set_markerfacecoloralt(fc)#

Set the alternate marker face color.

fc : color

set_markersize(sz)#

Set the marker size in points.

szfloat: Marker size, in points.

set_markevery(every)#

Set the markevery property to subsample the plot when using markers.

e.g., if every=5, every 5-th marker will be plotted.

everyNone or int or (int, int) or slice or list[int] or float or (float, float) or list[bool]

Which markers to plot.

every=None, every point will be plotted.
every=N, every N-th marker will be plotted starting with marker 0.
every=(start, N), every N-th marker, starting at point start, will be plotted.
every=slice(start, end, N), every N-th marker, starting at point start, up to but not including point end, will be plotted.
every=[i, j, m, n], only markers at points i, j, m, and n will be plotted.
every=[True, False, True], positions that are True will be plotted.
every=0.1, (i.e. a float) then markers will be spaced at approximately equal distances along the line; the distance along the line between markers is determined by multiplying the display-coordinate distance of the axes bounding-box diagonal by the value of every.
every=(0.5, 0.1) (i.e. a length-2 tuple of float), the same functionality as every=0.1 is exhibited but the first marker will be 0.5 multiplied by the display-coordinate-diagonal-distance along the line.

For examples see /gallery/lines_bars_and_markers/markevery_demo.

Setting the markevery property will only show markers at actual data points. When using float arguments to set the markevery property on irregularly spaced data, the markers will likely not appear evenly spaced because the actual data points do not coincide with the theoretical spacing between markers.

When using a start offset to specify the first marker, the offset will be from the first data point which may be different from the first the visible data point if the plot is zoomed in.

If zooming in on a plot when using float arguments then the actual data points that have markers will change because the distance between markers is always determined from the display-coordinates axes-bounding-box-diagonal regardless of the actual axes data limits.

set_mec(ec)#: Alias for set_markeredgecolor.

set_mew(ew)#: Alias for set_markeredgewidth.

set_mfc(fc)#: Alias for set_markerfacecolor.

set_mfcalt(fc)#: Alias for set_markerfacecoloralt.

set_ms(sz)#: Alias for set_markersize.

set_path_effects(path_effects)#

Set the path effects.

path_effects : .AbstractPathEffect

set_picker(p)#

Sets the event picker details for the line.

pfloat or callable[[Artist, Event], tuple[bool, dict]]: If a float, it is used as the pick radius in points.

set_pickradius(d)#

Set the pick radius used for containment tests.

See .contains for more details.

dfloat: Pick radius, in points.

set_rasterized(rasterized)#

Force rasterized (bitmap) drawing for vector graphics output.

Rasterized drawing is not supported by all artists. If you try to enable this on an artist that does not support it, the command has no effect and a warning will be issued.

This setting is ignored for pixel-based output.

See also /gallery/misc/rasterization_demo.

rasterized : bool

set_sketch_params(scale=None, length=None, randomness=None)#

Set the sketch parameters.

scalefloat, optional: The amplitude of the wiggle perpendicular to the source line, in pixels. If scale is None, or not provided, no sketch filter will be provided.
lengthfloat, optional: The length of the wiggle along the line, in pixels (default 128.0)
randomnessfloat, optional: The scale factor by which the length is shrunken or expanded (default 16.0)

set_snap(snap)#

Set the snapping behavior.

Snapping aligns positions with the pixel grid, which results in clearer images. For example, if a black line of 1px width was defined at a position in between two pixels, the resulting image would contain the interpolated value of that line in the pixel grid, which would be a grey value on both adjacent pixel positions. In contrast, snapping will move the line to the nearest integer pixel value, so that the resulting image will really contain a 1px wide black line.

Snapping is currently only supported by the Agg and MacOSX backends.

snapbool or None

Possible values:

True: Snap vertices to the nearest pixel center.
False: Do not modify vertex positions.
None: (auto) If the path contains only rectilinear line segments, round to the nearest pixel center.

set_solid_capstyle(s)#

How to draw the end caps if the line is solid (not ~Line2D.is_dashed)

s : .CapStyle or {‘butt’, ‘projecting’, ‘round’}

set_solid_joinstyle(s)#

How to join segments if the line is solid (not ~Line2D.is_dashed).

s : .JoinStyle or {‘miter’, ‘round’, ‘bevel’}

set_transform(t)#

Set the Transformation instance used by this artist.

t : matplotlib.transforms.Transform

set_url(url)#

Set the url for the artist.

url : str

set_visible(b)#

Set the artist’s visibility.

b : bool

set_xdata(x)#

Set the data array for x.

x : 1D array

set_ydata(y)#

Set the data array for y.

y : 1D array

set_zorder(level)#

Set the zorder for the artist. Artists with lower zorder values are drawn first.

level : float

property stale#: Whether the artist is ‘stale’ and needs to be re-drawn for the output to match the internal state of the artist.

property sticky_edges#

x and y sticky edge lists for autoscaling.

When performing autoscaling, if a data limit coincides with a value in the corresponding sticky_edges list, then no margin will be added–the view limit “sticks” to the edge. A typical use case is histograms, where one usually expects no margin on the bottom edge (0) of the histogram.

This attribute cannot be assigned to; however, the x and y lists can be modified in place as needed.

>>> artist.sticky_edges.x[:] = (xmin, xmax)
>>> artist.sticky_edges.y[:] = (ymin, ymax)

update(props)#

Update this artist’s properties from the dict props.

props : dict

update_from(other)#: Copy properties from other to self.

class holoviews.plotting.mpl.annotation.AnnotationPlot(annotation, **params)[source]#

Bases: holoviews.plotting.mpl.element.ElementPlot

AnnotationPlot handles the display of all annotation elements.

Parameters inherited from:

show_legend = param.Boolean(bounds=(0, 1), default=False, label=’Show legend’): Whether to show legend for the plot.

anim(start=0, stop=None, fps=30)#: Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()#: Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)#: Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

get_aspect(xspan, yspan)#: Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined', xdim=None, ydim=None, zdim=None)#

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

‘data’: Just the data ranges
‘extents’: Element.extents
‘soft’: Dimension.soft_range values
‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)#: Computes padding along the axes taking into account the plot aspect.

get_zorder(overlay, key, el)#: Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)#: Initializes the artist based on the plot method declared on the plot.

initialize_plot(*args, **kwargs)#: Initialize the matplotlib figure.

matches(spec)#: Matches a specification against the current Plot.

push()#: Pushes plot updates to the frontend.

refresh(**kwargs)#: Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

set_root(root)#: Sets the root model on all subplots.

property state#: The plotting state that gets updated via the update method and used by the renderer to generate output.

teardown_handles()#: If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)#: Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)#: Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_frame(*args, **kwargs)#

Set the plot(s) to the given frame number. Operates by manipulating the matplotlib objects held in the self._handles dictionary.

If n is greater than the number of available frames, update using the last available frame.

update_handles(key, axis, annotation, ranges, style)[source]#: Update the elements of the plot.

class holoviews.plotting.mpl.annotation.ArrowPlot(annotation, **params)[source]#

Bases: holoviews.plotting.mpl.annotation.AnnotationPlot

Draw an arrow using the information supplied to the Arrow annotation

Parameters inherited from:

anim(start=0, stop=None, fps=30)#: Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()#: Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)#: Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

get_aspect(xspan, yspan)#: Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined', xdim=None, ydim=None, zdim=None)#

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

‘data’: Just the data ranges
‘extents’: Element.extents
‘soft’: Dimension.soft_range values
‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)#: Computes padding along the axes taking into account the plot aspect.

get_zorder(overlay, key, el)#: Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)#: Initializes the artist based on the plot method declared on the plot.

initialize_plot(*args, **kwargs)#: Initialize the matplotlib figure.

matches(spec)#: Matches a specification against the current Plot.

push()#: Pushes plot updates to the frontend.

refresh(**kwargs)#: Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

set_root(root)#: Sets the root model on all subplots.

property state#: The plotting state that gets updated via the update method and used by the renderer to generate output.

teardown_handles()#: If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)#: Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)#: Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_frame(*args, **kwargs)#

Set the plot(s) to the given frame number. Operates by manipulating the matplotlib objects held in the self._handles dictionary.

If n is greater than the number of available frames, update using the last available frame.

update_handles(key, axis, annotation, ranges, style)#: Update the elements of the plot.

class holoviews.plotting.mpl.annotation.HLinePlot(annotation, **params)[source]#

Bases: holoviews.plotting.mpl.annotation.AnnotationPlot

Draw a horizontal line on the axis

Parameters inherited from:

anim(start=0, stop=None, fps=30)#: Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()#: Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)#: Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

draw_annotation(axis, position, opts)[source]#: Draw a horizontal line on the axis

get_aspect(xspan, yspan)#: Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined', xdim=None, ydim=None, zdim=None)#

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

‘data’: Just the data ranges
‘extents’: Element.extents
‘soft’: Dimension.soft_range values
‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)#: Computes padding along the axes taking into account the plot aspect.

get_zorder(overlay, key, el)#: Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)#: Initializes the artist based on the plot method declared on the plot.

initialize_plot(*args, **kwargs)#: Initialize the matplotlib figure.

matches(spec)#: Matches a specification against the current Plot.

push()#: Pushes plot updates to the frontend.

refresh(**kwargs)#: Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

set_root(root)#: Sets the root model on all subplots.

property state#: The plotting state that gets updated via the update method and used by the renderer to generate output.

teardown_handles()#: If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)#: Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)#: Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_frame(*args, **kwargs)#

Set the plot(s) to the given frame number. Operates by manipulating the matplotlib objects held in the self._handles dictionary.

If n is greater than the number of available frames, update using the last available frame.

update_handles(key, axis, annotation, ranges, style)#: Update the elements of the plot.

class holoviews.plotting.mpl.annotation.HSpanPlot(annotation, **params)[source]#

Bases: holoviews.plotting.mpl.annotation.AnnotationPlot

Draw a horizontal span on the axis

Parameters inherited from:

anim(start=0, stop=None, fps=30)#: Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()#: Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)#: Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

draw_annotation(axis, positions, opts)[source]#: Draw a horizontal span on the axis

get_aspect(xspan, yspan)#: Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined', xdim=None, ydim=None, zdim=None)#

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

‘data’: Just the data ranges
‘extents’: Element.extents
‘soft’: Dimension.soft_range values
‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)#: Computes padding along the axes taking into account the plot aspect.

get_zorder(overlay, key, el)#: Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)#: Initializes the artist based on the plot method declared on the plot.

initialize_plot(*args, **kwargs)#: Initialize the matplotlib figure.

matches(spec)#: Matches a specification against the current Plot.

push()#: Pushes plot updates to the frontend.

refresh(**kwargs)#: Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

set_root(root)#: Sets the root model on all subplots.

property state#: The plotting state that gets updated via the update method and used by the renderer to generate output.

teardown_handles()#: If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)#: Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)#: Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_frame(*args, **kwargs)#

Set the plot(s) to the given frame number. Operates by manipulating the matplotlib objects held in the self._handles dictionary.

If n is greater than the number of available frames, update using the last available frame.

update_handles(key, axis, annotation, ranges, style)#: Update the elements of the plot.

class holoviews.plotting.mpl.annotation.LabelsPlot(*args, **kwargs)[source]#

Bases: holoviews.plotting.mpl.element.ColorbarPlot

Parameters inherited from:

color_index = param.ClassSelector(allow_None=True, class_=(<class ‘str’>, <class ‘int’>), label=’Color index’): Index of the dimension from which the color will the drawn
xoffset = param.Number(allow_None=True, inclusive_bounds=(True, True), label=’Xoffset’): Amount of offset to apply to labels along x-axis.
yoffset = param.Number(allow_None=True, inclusive_bounds=(True, True), label=’Yoffset’): Amount of offset to apply to labels along x-axis.

anim(start=0, stop=None, fps=30)#: Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()#: Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)#: Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

get_aspect(xspan, yspan)#: Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined', xdim=None, ydim=None, zdim=None)#

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

‘data’: Just the data ranges
‘extents’: Element.extents
‘soft’: Dimension.soft_range values
‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)#: Computes padding along the axes taking into account the plot aspect.

get_zorder(overlay, key, el)#: Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)[source]#: Initializes the artist based on the plot method declared on the plot.

initialize_plot(*args, **kwargs)#: Initialize the matplotlib figure.

matches(spec)#: Matches a specification against the current Plot.

push()#: Pushes plot updates to the frontend.

refresh(**kwargs)#: Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

set_root(root)#: Sets the root model on all subplots.

property state#: The plotting state that gets updated via the update method and used by the renderer to generate output.

teardown_handles()[source]#: If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)#: Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)#: Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_frame(*args, **kwargs)#

Set the plot(s) to the given frame number. Operates by manipulating the matplotlib objects held in the self._handles dictionary.

If n is greater than the number of available frames, update using the last available frame.

update_handles(key, axis, element, ranges, style)#: Update the elements of the plot.

class holoviews.plotting.mpl.annotation.SlopePlot(annotation, **params)[source]#

Bases: holoviews.plotting.mpl.annotation.AnnotationPlot

Parameters inherited from:

anim(start=0, stop=None, fps=30)#: Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()#: Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)#: Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

draw_annotation(axis, position, opts)[source]#: Draw a horizontal line on the axis

get_aspect(xspan, yspan)#: Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined', xdim=None, ydim=None, zdim=None)#

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

‘data’: Just the data ranges
‘extents’: Element.extents
‘soft’: Dimension.soft_range values
‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)#: Computes padding along the axes taking into account the plot aspect.

get_zorder(overlay, key, el)#: Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)#: Initializes the artist based on the plot method declared on the plot.

initialize_plot(*args, **kwargs)#: Initialize the matplotlib figure.

matches(spec)#: Matches a specification against the current Plot.

push()#: Pushes plot updates to the frontend.

refresh(**kwargs)#: Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

set_root(root)#: Sets the root model on all subplots.

property state#: The plotting state that gets updated via the update method and used by the renderer to generate output.

teardown_handles()#: If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)#: Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)#: Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_frame(*args, **kwargs)#

Set the plot(s) to the given frame number. Operates by manipulating the matplotlib objects held in the self._handles dictionary.

If n is greater than the number of available frames, update using the last available frame.

update_handles(key, axis, annotation, ranges, style)#: Update the elements of the plot.

class holoviews.plotting.mpl.annotation.SplinePlot(annotation, **params)[source]#

Bases: holoviews.plotting.mpl.annotation.AnnotationPlot

Draw the supplied Spline annotation (see Spline docstring)

Parameters inherited from:

anim(start=0, stop=None, fps=30)#: Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()#: Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)#: Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

get_aspect(xspan, yspan)#: Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined', xdim=None, ydim=None, zdim=None)#

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

‘data’: Just the data ranges
‘extents’: Element.extents
‘soft’: Dimension.soft_range values
‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)#: Computes padding along the axes taking into account the plot aspect.

get_zorder(overlay, key, el)#: Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)#: Initializes the artist based on the plot method declared on the plot.

initialize_plot(*args, **kwargs)#: Initialize the matplotlib figure.

matches(spec)#: Matches a specification against the current Plot.

push()#: Pushes plot updates to the frontend.

refresh(**kwargs)#: Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

set_root(root)#: Sets the root model on all subplots.

property state#: The plotting state that gets updated via the update method and used by the renderer to generate output.

teardown_handles()#: If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)#: Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)#: Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_frame(*args, **kwargs)#

Set the plot(s) to the given frame number. Operates by manipulating the matplotlib objects held in the self._handles dictionary.

If n is greater than the number of available frames, update using the last available frame.

update_handles(key, axis, annotation, ranges, style)#: Update the elements of the plot.

class holoviews.plotting.mpl.annotation.TextPlot(annotation, **params)[source]#

Bases: holoviews.plotting.mpl.annotation.AnnotationPlot

Draw the Text annotation object

Parameters inherited from:

anim(start=0, stop=None, fps=30)#: Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()#: Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)#: Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

get_aspect(xspan, yspan)#: Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined', xdim=None, ydim=None, zdim=None)#

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

‘data’: Just the data ranges
‘extents’: Element.extents
‘soft’: Dimension.soft_range values
‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)#: Computes padding along the axes taking into account the plot aspect.

get_zorder(overlay, key, el)#: Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)#: Initializes the artist based on the plot method declared on the plot.

initialize_plot(*args, **kwargs)#: Initialize the matplotlib figure.

matches(spec)#: Matches a specification against the current Plot.

push()#: Pushes plot updates to the frontend.

refresh(**kwargs)#: Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

set_root(root)#: Sets the root model on all subplots.

property state#: The plotting state that gets updated via the update method and used by the renderer to generate output.

teardown_handles()#: If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)#: Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)#: Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_frame(*args, **kwargs)#

Set the plot(s) to the given frame number. Operates by manipulating the matplotlib objects held in the self._handles dictionary.

If n is greater than the number of available frames, update using the last available frame.

update_handles(key, axis, annotation, ranges, style)#: Update the elements of the plot.

class holoviews.plotting.mpl.annotation.VLinePlot(annotation, **params)[source]#

Bases: holoviews.plotting.mpl.annotation.AnnotationPlot

Draw a vertical line on the axis

Parameters inherited from:

anim(start=0, stop=None, fps=30)#: Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()#: Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)#: Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

get_aspect(xspan, yspan)#: Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined', xdim=None, ydim=None, zdim=None)#

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

‘data’: Just the data ranges
‘extents’: Element.extents
‘soft’: Dimension.soft_range values
‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)#: Computes padding along the axes taking into account the plot aspect.

get_zorder(overlay, key, el)#: Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)#: Initializes the artist based on the plot method declared on the plot.

initialize_plot(*args, **kwargs)#: Initialize the matplotlib figure.

matches(spec)#: Matches a specification against the current Plot.

push()#: Pushes plot updates to the frontend.

refresh(**kwargs)#: Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

set_root(root)#: Sets the root model on all subplots.

property state#: The plotting state that gets updated via the update method and used by the renderer to generate output.

teardown_handles()#: If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)#: Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)#: Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_frame(*args, **kwargs)#

Set the plot(s) to the given frame number. Operates by manipulating the matplotlib objects held in the self._handles dictionary.

If n is greater than the number of available frames, update using the last available frame.

update_handles(key, axis, annotation, ranges, style)#: Update the elements of the plot.

class holoviews.plotting.mpl.annotation.VSpanPlot(annotation, **params)[source]#

Bases: holoviews.plotting.mpl.annotation.AnnotationPlot

Draw a vertical span on the axis

Parameters inherited from:

anim(start=0, stop=None, fps=30)#: Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()#: Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)#: Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

draw_annotation(axis, positions, opts)[source]#: Draw a vertical span on the axis

get_aspect(xspan, yspan)#: Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined', xdim=None, ydim=None, zdim=None)#

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

‘data’: Just the data ranges
‘extents’: Element.extents
‘soft’: Dimension.soft_range values
‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)#: Computes padding along the axes taking into account the plot aspect.

get_zorder(overlay, key, el)#: Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)#: Initializes the artist based on the plot method declared on the plot.

initialize_plot(*args, **kwargs)#: Initialize the matplotlib figure.

matches(spec)#: Matches a specification against the current Plot.

push()#: Pushes plot updates to the frontend.

refresh(**kwargs)#: Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

set_root(root)#: Sets the root model on all subplots.

property state#: The plotting state that gets updated via the update method and used by the renderer to generate output.

teardown_handles()#: If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)#: Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)#: Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_frame(*args, **kwargs)#

Set the plot(s) to the given frame number. Operates by manipulating the matplotlib objects held in the self._handles dictionary.

If n is greater than the number of available frames, update using the last available frame.

update_handles(key, axis, annotation, ranges, style)#: Update the elements of the plot.

`chart` Module#

Inheritance diagram of holoviews.plotting.mpl.chart

class holoviews.plotting.mpl.chart.AreaPlot(element, **params)[source]#

Bases: holoviews.plotting.mixins.AreaMixin, holoviews.plotting.mpl.chart.ChartPlot

Parameters inherited from:

padding = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=(0, 0.1), label=’Padding’): Fraction by which to increase auto-ranged extents to make datapoints more visible around borders. To compute padding, the axis whose screen size is largest is chosen, and the range of that axis is increased by the specified fraction along each axis. Other axes are then padded ensuring that the amount of screen space devoted to padding is equal for all axes. If specified as a tuple, the int or float values in the tuple will be used for padding in each axis, in order (x,y or x,y,z). For example, for padding=0.2 on a 800x800-pixel plot, an x-axis with the range [0,10] will be padded by 20% to be [-1,11], while a y-axis with a range [0,1000] will be padded to be [-100,1100], which should make the padding be approximately the same number of pixels. But if the same plot is changed to have a height of only 200, the y-range will then be [-400,1400] so that the y-axis padding will still match that of the x-axis. It is also possible to declare non-equal padding value for the lower and upper bound of an axis by supplying nested tuples, e.g. padding=(0.1, (0, 0.1)) will pad the x-axis lower and upper bound as well as the y-axis upper bound by a fraction of 0.1 while the y-axis lower bound is not padded at all.
show_legend = param.Boolean(bounds=(0, 1), default=False, label=’Show legend’): Whether to show legend for the plot.

anim(start=0, stop=None, fps=30)#: Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()#: Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)#: Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

get_aspect(xspan, yspan)#: Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined')#

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

‘data’: Just the data ranges
‘extents’: Element.extents
‘soft’: Dimension.soft_range values
‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)#: Computes padding along the axes taking into account the plot aspect.

get_zorder(overlay, key, el)#: Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_data, plot_kwargs)[source]#: Initializes the artist based on the plot method declared on the plot.

initialize_plot(*args, **kwargs)#: Initialize the matplotlib figure.

matches(spec)#: Matches a specification against the current Plot.

push()#: Pushes plot updates to the frontend.

refresh(**kwargs)#: Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

set_root(root)#: Sets the root model on all subplots.

property state#: The plotting state that gets updated via the update method and used by the renderer to generate output.

teardown_handles()#: If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)#: Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)#: Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_frame(*args, **kwargs)#

Set the plot(s) to the given frame number. Operates by manipulating the matplotlib objects held in the self._handles dictionary.

If n is greater than the number of available frames, update using the last available frame.

update_handles(key, axis, element, ranges, style)#: Update the elements of the plot.

class holoviews.plotting.mpl.chart.BarPlot(*args, **kwargs)[source]#

Bases: holoviews.plotting.mixins.BarsMixin, holoviews.plotting.mpl.element.ColorbarPlot, holoviews.plotting.mpl.element.LegendPlot

Parameters inherited from:

show_legend = param.Boolean(bounds=(0, 1), default=True, label=’Show legend’): Whether to show legend for the plot.
bar_padding = param.Number(default=0.2, inclusive_bounds=(True, True), label=’Bar padding’): Defines the padding between groups.
multi_level = param.Boolean(bounds=(0, 1), default=True, label=’Multi level’): Whether the Bars should be grouped into a second categorical axis level.
stacked = param.Boolean(bounds=(0, 1), default=False, label=’Stacked’): Whether the bars should be stacked or grouped.

anim(start=0, stop=None, fps=30)#: Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()#: Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)#: Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

get_aspect(xspan, yspan)#: Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined')#: Make adjustments to plot extents by computing stacked bar heights, adjusting the bar baseline and forcing the x-axis to be categorical.

get_padding(obj, extents)#: Computes padding along the axes taking into account the plot aspect.

get_zorder(overlay, key, el)#: Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)#: Initializes the artist based on the plot method declared on the plot.

initialize_plot(*args, **kwargs)#: Initialize the matplotlib figure.

matches(spec)#: Matches a specification against the current Plot.

push()#: Pushes plot updates to the frontend.

refresh(**kwargs)#: Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

set_root(root)#: Sets the root model on all subplots.

property state#: The plotting state that gets updated via the update method and used by the renderer to generate output.

teardown_handles()#: If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)#: Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)#: Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_frame(*args, **kwargs)#

Set the plot(s) to the given frame number. Operates by manipulating the matplotlib objects held in the self._handles dictionary.

If n is greater than the number of available frames, update using the last available frame.

update_handles(key, axis, element, ranges, style)#: Update the elements of the plot.

class holoviews.plotting.mpl.chart.ChartPlot(element, **params)[source]#

Bases: holoviews.plotting.mpl.element.ElementPlot

Baseclass to plot Chart elements.

Parameters inherited from:

anim(start=0, stop=None, fps=30)#: Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()#: Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)#: Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

get_aspect(xspan, yspan)#: Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined', xdim=None, ydim=None, zdim=None)#

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

‘data’: Just the data ranges
‘extents’: Element.extents
‘soft’: Dimension.soft_range values
‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)#: Computes padding along the axes taking into account the plot aspect.

get_zorder(overlay, key, el)#: Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)#: Initializes the artist based on the plot method declared on the plot.

initialize_plot(*args, **kwargs)#: Initialize the matplotlib figure.

matches(spec)#: Matches a specification against the current Plot.

push()#: Pushes plot updates to the frontend.

refresh(**kwargs)#: Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

set_root(root)#: Sets the root model on all subplots.

property state#: The plotting state that gets updated via the update method and used by the renderer to generate output.

teardown_handles()#: If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)#: Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)#: Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_frame(*args, **kwargs)#

Set the plot(s) to the given frame number. Operates by manipulating the matplotlib objects held in the self._handles dictionary.

If n is greater than the number of available frames, update using the last available frame.

update_handles(key, axis, element, ranges, style)#: Update the elements of the plot.

class holoviews.plotting.mpl.chart.CurvePlot(element, **params)[source]#

Bases: holoviews.plotting.mpl.chart.ChartPlot

CurvePlot can plot Curve and ViewMaps of Curve, which can be displayed as a single frame or animation. Axes, titles and legends are automatically generated from dim_info.

If the dimension is set to cyclic in the dim_info it will rotate the curve so that minimum y values are at the minimum x value to make the plots easier to interpret.

Parameters inherited from:

padding = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=(0, 0.1), label=’Padding’): Fraction by which to increase auto-ranged extents to make datapoints more visible around borders. To compute padding, the axis whose screen size is largest is chosen, and the range of that axis is increased by the specified fraction along each axis. Other axes are then padded ensuring that the amount of screen space devoted to padding is equal for all axes. If specified as a tuple, the int or float values in the tuple will be used for padding in each axis, in order (x,y or x,y,z). For example, for padding=0.2 on a 800x800-pixel plot, an x-axis with the range [0,10] will be padded by 20% to be [-1,11], while a y-axis with a range [0,1000] will be padded to be [-100,1100], which should make the padding be approximately the same number of pixels. But if the same plot is changed to have a height of only 200, the y-range will then be [-400,1400] so that the y-axis padding will still match that of the x-axis. It is also possible to declare non-equal padding value for the lower and upper bound of an axis by supplying nested tuples, e.g. padding=(0.1, (0, 0.1)) will pad the x-axis lower and upper bound as well as the y-axis upper bound by a fraction of 0.1 while the y-axis lower bound is not padded at all.
show_legend = param.Boolean(bounds=(0, 1), default=True, label=’Show legend’): Whether to show legend for the plot.
show_grid = param.Boolean(bounds=(0, 1), default=False, label=’Show grid’): Enable axis grid.
autotick = param.Boolean(bounds=(0, 1), default=False, label=’Autotick’): Whether to let matplotlib automatically compute tick marks or to allow the user to control tick marks.
interpolation = param.ObjectSelector(default=’linear’, label=’Interpolation’, objects=[‘linear’, ‘steps-mid’, ‘steps-pre’, ‘steps-post’]): Defines how the samples of the Curve are interpolated, default is ‘linear’, other options include ‘steps-mid’, ‘steps-pre’ and ‘steps-post’.
relative_labels = param.Boolean(bounds=(0, 1), default=False, label=’Relative labels’): If plotted quantity is cyclic and center_cyclic is enabled, will compute tick labels relative to the center.

anim(start=0, stop=None, fps=30)#: Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()#: Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)#: Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

get_aspect(xspan, yspan)#: Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined', xdim=None, ydim=None, zdim=None)#

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

‘data’: Just the data ranges
‘extents’: Element.extents
‘soft’: Dimension.soft_range values
‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)#: Computes padding along the axes taking into account the plot aspect.

get_zorder(overlay, key, el)#: Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)[source]#: Initializes the artist based on the plot method declared on the plot.

initialize_plot(*args, **kwargs)#: Initialize the matplotlib figure.

matches(spec)#: Matches a specification against the current Plot.

push()#: Pushes plot updates to the frontend.

refresh(**kwargs)#: Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

set_root(root)#: Sets the root model on all subplots.

property state#: The plotting state that gets updated via the update method and used by the renderer to generate output.

teardown_handles()#: If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)#: Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)#: Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_frame(*args, **kwargs)#

Set the plot(s) to the given frame number. Operates by manipulating the matplotlib objects held in the self._handles dictionary.

If n is greater than the number of available frames, update using the last available frame.

update_handles(key, axis, element, ranges, style)[source]#: Update the elements of the plot.

class holoviews.plotting.mpl.chart.ErrorPlot(*args, **kwargs)[source]#

Bases: holoviews.plotting.mpl.element.ColorbarPlot

ErrorPlot plots the ErrorBar Element type and supporting both horizontal and vertical error bars via the ‘horizontal’ plot option.

Parameters inherited from:

anim(start=0, stop=None, fps=30)#: Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()#: Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)#: Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

get_aspect(xspan, yspan)#: Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined', xdim=None, ydim=None, zdim=None)#

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

‘data’: Just the data ranges
‘extents’: Element.extents
‘soft’: Dimension.soft_range values
‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)#: Computes padding along the axes taking into account the plot aspect.

get_zorder(overlay, key, el)#: Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_data, plot_kwargs)[source]#: Initializes the artist based on the plot method declared on the plot.

initialize_plot(*args, **kwargs)#: Initialize the matplotlib figure.

matches(spec)#: Matches a specification against the current Plot.

push()#: Pushes plot updates to the frontend.

refresh(**kwargs)#: Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

set_root(root)#: Sets the root model on all subplots.

property state#: The plotting state that gets updated via the update method and used by the renderer to generate output.

teardown_handles()#: If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)#: Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)#: Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_frame(*args, **kwargs)#

Set the plot(s) to the given frame number. Operates by manipulating the matplotlib objects held in the self._handles dictionary.

If n is greater than the number of available frames, update using the last available frame.

update_handles(key, axis, element, ranges, style)[source]#: Update the elements of the plot.

class holoviews.plotting.mpl.chart.HistogramPlot(histograms, **params)[source]#

Bases: holoviews.plotting.mpl.element.ColorbarPlot

HistogramPlot can plot DataHistograms and ViewMaps of DataHistograms, which can be displayed as a single frame or animation.

Parameters inherited from:

anim(start=0, stop=None, fps=30)#: Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()#: Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)#: Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

get_aspect(xspan, yspan)#: Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined')[source]#

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

‘data’: Just the data ranges
‘extents’: Element.extents
‘soft’: Dimension.soft_range values
‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)#: Computes padding along the axes taking into account the plot aspect.

get_zorder(overlay, key, el)#: Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)#: Initializes the artist based on the plot method declared on the plot.

initialize_plot(*args, **kwargs)#: Initialize the matplotlib figure.

matches(spec)#: Matches a specification against the current Plot.

push()#: Pushes plot updates to the frontend.

refresh(**kwargs)#: Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

set_root(root)#: Sets the root model on all subplots.

property state#: The plotting state that gets updated via the update method and used by the renderer to generate output.

teardown_handles()#: If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)#: Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)#: Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_frame(*args, **kwargs)#

Set the plot(s) to the given frame number. Operates by manipulating the matplotlib objects held in the self._handles dictionary.

If n is greater than the number of available frames, update using the last available frame.

update_handles(key, axis, element, ranges, style)[source]#: Update the elements of the plot.

class holoviews.plotting.mpl.chart.PointPlot(*args, **kwargs)[source]#

Bases: holoviews.plotting.mpl.chart.ChartPlot, holoviews.plotting.mpl.element.ColorbarPlot, holoviews.plotting.mpl.element.LegendPlot

Note that the ‘cmap’, ‘vmin’ and ‘vmax’ style arguments control how point magnitudes are rendered to different colors.

Parameters inherited from:

show_grid = param.Boolean(bounds=(0, 1), default=False, label=’Show grid’): Whether to draw grid lines at the tick positions.
color_index = param.ClassSelector(allow_None=True, class_=(<class ‘str’>, <class ‘int’>), label=’Color index’): Deprecated in favor of color style mapping, e.g. color=dim(‘color’)
size_index = param.ClassSelector(allow_None=True, class_=(<class ‘str’>, <class ‘int’>), label=’Size index’): Deprecated in favor of size style mapping, e.g. size=dim(‘size’)
scaling_method = param.ObjectSelector(default=’area’, label=’Scaling method’, objects=[‘width’, ‘area’]): Deprecated in favor of size style mapping, e.g. size=dim(‘size’)**2.
scaling_factor = param.Number(bounds=(0, None), default=1, inclusive_bounds=(True, True), label=’Scaling factor’): Scaling factor which is applied to either the width or area of each point, depending on the value of scaling_method.
size_fn = param.Callable(default=<ufunc ‘absolute’>, label=’Size fn’): Function applied to size values before applying scaling, to remove values lower than zero.

anim(start=0, stop=None, fps=30)#: Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()#: Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)#: Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

get_aspect(xspan, yspan)#: Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined', xdim=None, ydim=None, zdim=None)#

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

‘data’: Just the data ranges
‘extents’: Element.extents
‘soft’: Dimension.soft_range values
‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)#: Computes padding along the axes taking into account the plot aspect.

get_zorder(overlay, key, el)#: Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)#: Initializes the artist based on the plot method declared on the plot.

initialize_plot(*args, **kwargs)#: Initialize the matplotlib figure.

matches(spec)#: Matches a specification against the current Plot.

push()#: Pushes plot updates to the frontend.

refresh(**kwargs)#: Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

set_root(root)#: Sets the root model on all subplots.

size_fn = <ufunc 'absolute'>#

property state#: The plotting state that gets updated via the update method and used by the renderer to generate output.

teardown_handles()#: If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)#: Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)#: Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_frame(*args, **kwargs)#

Set the plot(s) to the given frame number. Operates by manipulating the matplotlib objects held in the self._handles dictionary.

If n is greater than the number of available frames, update using the last available frame.

update_handles(key, axis, element, ranges, style)[source]#: Update the elements of the plot.

class holoviews.plotting.mpl.chart.SideAreaPlot(element, **params)[source]#

Bases: holoviews.plotting.mpl.plot.AdjoinedPlot, holoviews.plotting.mpl.chart.AreaPlot

Parameters inherited from:

bgcolor = param.Parameter(default=(1, 1, 1, 0), label=’Bgcolor’): Make plot background invisible.
xaxis = param.ObjectSelector(default=’bare’, label=’Xaxis’, objects=[‘top’, ‘bottom’, ‘bare’, ‘top-bare’, ‘bottom-bare’, None]): Whether and where to display the xaxis, bare options allow suppressing all axis labels including ticks and xlabel. Valid options are ‘top’, ‘bottom’, ‘bare’, ‘top-bare’ and ‘bottom-bare’.
yaxis = param.ObjectSelector(default=’bare’, label=’Yaxis’, objects=[‘left’, ‘right’, ‘bare’, ‘left-bare’, ‘right-bare’, None]): Whether and where to display the yaxis, bare options allow suppressing all axis labels including ticks and ylabel. Valid options are ‘left’, ‘right’, ‘bare’ ‘left-bare’ and ‘right-bare’.
border_size = param.Number(default=0, inclusive_bounds=(True, True), label=’Border size’): The size of the border expressed as a fraction of the main plot.

anim(start=0, stop=None, fps=30)#: Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()#: Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)#: Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

get_aspect(xspan, yspan)#: Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined')#

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

‘data’: Just the data ranges
‘extents’: Element.extents
‘soft’: Dimension.soft_range values
‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)#: Computes padding along the axes taking into account the plot aspect.

get_zorder(overlay, key, el)#: Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_data, plot_kwargs)#: Initializes the artist based on the plot method declared on the plot.

initialize_plot(*args, **kwargs)#: Initialize the matplotlib figure.

matches(spec)#: Matches a specification against the current Plot.

push()#: Pushes plot updates to the frontend.

refresh(**kwargs)#: Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

set_root(root)#: Sets the root model on all subplots.

property state#: The plotting state that gets updated via the update method and used by the renderer to generate output.

teardown_handles()#: If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)#: Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)#: Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_frame(*args, **kwargs)#

Set the plot(s) to the given frame number. Operates by manipulating the matplotlib objects held in the self._handles dictionary.

If n is greater than the number of available frames, update using the last available frame.

update_handles(key, axis, element, ranges, style)#: Update the elements of the plot.

class holoviews.plotting.mpl.chart.SideHistogramPlot(histograms, **params)[source]#

Bases: holoviews.plotting.mpl.plot.AdjoinedPlot, holoviews.plotting.mpl.chart.HistogramPlot

Parameters inherited from:

bgcolor = param.Parameter(default=(1, 1, 1, 0), label=’Bgcolor’): Make plot background invisible.
show_grid = param.Boolean(bounds=(0, 1), default=False, label=’Show grid’): Whether to overlay a grid on the axis.
offset = param.Number(bounds=(0, 1), default=0.2, inclusive_bounds=(True, True), label=’Offset’): Histogram value offset for a colorbar.

anim(start=0, stop=None, fps=30)#: Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()#: Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)#: Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

get_aspect(xspan, yspan)#: Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined')#

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

‘data’: Just the data ranges
‘extents’: Element.extents
‘soft’: Dimension.soft_range values
‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)#: Computes padding along the axes taking into account the plot aspect.

get_zorder(overlay, key, el)#: Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)#: Initializes the artist based on the plot method declared on the plot.

initialize_plot(*args, **kwargs)#: Initialize the matplotlib figure.

matches(spec)#: Matches a specification against the current Plot.

push()#: Pushes plot updates to the frontend.

refresh(**kwargs)#: Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

set_root(root)#: Sets the root model on all subplots.

property state#: The plotting state that gets updated via the update method and used by the renderer to generate output.

teardown_handles()#: If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)#: Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)#: Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_frame(*args, **kwargs)#

Set the plot(s) to the given frame number. Operates by manipulating the matplotlib objects held in the self._handles dictionary.

If n is greater than the number of available frames, update using the last available frame.

update_handles(key, axis, element, ranges, style)#: Update the elements of the plot.

class holoviews.plotting.mpl.chart.SideSpikesPlot(*args, **kwargs)[source]#

Bases: holoviews.plotting.mpl.plot.AdjoinedPlot, holoviews.plotting.mpl.chart.SpikesPlot

Parameters inherited from:

show_frame = param.Boolean(bounds=(0, 1), default=True, label=’Show frame’): Whether or not to show a complete frame around the plot.
bgcolor = param.Parameter(default=(1, 1, 1, 0), label=’Bgcolor’): Make plot background invisible.
xaxis = param.ObjectSelector(default=’bare’, label=’Xaxis’, objects=[‘top’, ‘bottom’, ‘bare’, ‘top-bare’, ‘bottom-bare’, None]): Whether and where to display the xaxis, bare options allow suppressing all axis labels including ticks and xlabel. Valid options are ‘top’, ‘bottom’, ‘bare’, ‘top-bare’ and ‘bottom-bare’.
yaxis = param.ObjectSelector(default=’bare’, label=’Yaxis’, objects=[‘left’, ‘right’, ‘bare’, ‘left-bare’, ‘right-bare’, None]): Whether and where to display the yaxis, bare options allow suppressing all axis labels including ticks and ylabel. Valid options are ‘left’, ‘right’, ‘bare’ ‘left-bare’ and ‘right-bare’.
spike_length = param.Number(default=1, inclusive_bounds=(True, True), label=’Spike length’): The length of each spike if Spikes object is one dimensional.
border_size = param.Number(default=0, inclusive_bounds=(True, True), label=’Border size’): The size of the border expressed as a fraction of the main plot.
subplot_size = param.Number(default=0.1, inclusive_bounds=(True, True), label=’Subplot size’): The size subplots as expressed as a fraction of the main plot.

anim(start=0, stop=None, fps=30)#: Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()#: Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)#: Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

get_aspect(xspan, yspan)#: Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined')#

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

‘data’: Just the data ranges
‘extents’: Element.extents
‘soft’: Dimension.soft_range values
‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)#: Computes padding along the axes taking into account the plot aspect.

get_zorder(overlay, key, el)#: Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)#: Initializes the artist based on the plot method declared on the plot.

initialize_plot(*args, **kwargs)#: Initialize the matplotlib figure.

matches(spec)#: Matches a specification against the current Plot.

push()#: Pushes plot updates to the frontend.

refresh(**kwargs)#: Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

set_root(root)#: Sets the root model on all subplots.

property state#: The plotting state that gets updated via the update method and used by the renderer to generate output.

teardown_handles()#: If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)#: Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)#: Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_frame(*args, **kwargs)#

Set the plot(s) to the given frame number. Operates by manipulating the matplotlib objects held in the self._handles dictionary.

If n is greater than the number of available frames, update using the last available frame.

update_handles(key, axis, element, ranges, style)#: Update the elements of the plot.

class holoviews.plotting.mpl.chart.SpikesPlot(*args, **kwargs)[source]#

Bases: holoviews.plotting.mixins.SpikesMixin, holoviews.plotting.mpl.path.PathPlot, holoviews.plotting.mpl.element.ColorbarPlot

Parameters inherited from:

padding = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=(0, 0.1), label=’Padding’): Fraction by which to increase auto-ranged extents to make datapoints more visible around borders. To compute padding, the axis whose screen size is largest is chosen, and the range of that axis is increased by the specified fraction along each axis. Other axes are then padded ensuring that the amount of screen space devoted to padding is equal for all axes. If specified as a tuple, the int or float values in the tuple will be used for padding in each axis, in order (x,y or x,y,z). For example, for padding=0.2 on a 800x800-pixel plot, an x-axis with the range [0,10] will be padded by 20% to be [-1,11], while a y-axis with a range [0,1000] will be padded to be [-100,1100], which should make the padding be approximately the same number of pixels. But if the same plot is changed to have a height of only 200, the y-range will then be [-400,1400] so that the y-axis padding will still match that of the x-axis. It is also possible to declare non-equal padding value for the lower and upper bound of an axis by supplying nested tuples, e.g. padding=(0.1, (0, 0.1)) will pad the x-axis lower and upper bound as well as the y-axis upper bound by a fraction of 0.1 while the y-axis lower bound is not padded at all.
aspect = param.Parameter(default=’square’, label=’Aspect’): The aspect ratio mode of the plot. Allows setting an explicit aspect ratio as width/height as well as ‘square’ and ‘equal’ options.
color_index = param.ClassSelector(allow_None=True, class_=(<class ‘str’>, <class ‘int’>), label=’Color index’): Index of the dimension from which the color will the drawn
spike_length = param.Number(default=0.1, inclusive_bounds=(True, True), label=’Spike length’): The length of each spike if Spikes object is one dimensional.
position = param.Number(default=0.0, inclusive_bounds=(True, True), label=’Position’): The position of the lower end of each spike.

anim(start=0, stop=None, fps=30)#: Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()#: Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)#: Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

get_aspect(xspan, yspan)#: Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined')#

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

‘data’: Just the data ranges
‘extents’: Element.extents
‘soft’: Dimension.soft_range values
‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)#: Computes padding along the axes taking into account the plot aspect.

get_zorder(overlay, key, el)#: Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)[source]#: Initializes the artist based on the plot method declared on the plot.

initialize_plot(*args, **kwargs)#: Initialize the matplotlib figure.

matches(spec)#: Matches a specification against the current Plot.

push()#: Pushes plot updates to the frontend.

refresh(**kwargs)#: Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

set_root(root)#: Sets the root model on all subplots.

property state#: The plotting state that gets updated via the update method and used by the renderer to generate output.

teardown_handles()#: If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)#: Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)#: Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_frame(*args, **kwargs)#

Set the plot(s) to the given frame number. Operates by manipulating the matplotlib objects held in the self._handles dictionary.

If n is greater than the number of available frames, update using the last available frame.

update_handles(key, axis, element, ranges, style)[source]#: Update the elements of the plot.

class holoviews.plotting.mpl.chart.SpreadPlot(element, **params)[source]#

Bases: holoviews.plotting.mpl.chart.AreaPlot

SpreadPlot plots the Spread Element type.

Parameters inherited from:

padding = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=(0, 0.1), label=’Padding’): Fraction by which to increase auto-ranged extents to make datapoints more visible around borders. To compute padding, the axis whose screen size is largest is chosen, and the range of that axis is increased by the specified fraction along each axis. Other axes are then padded ensuring that the amount of screen space devoted to padding is equal for all axes. If specified as a tuple, the int or float values in the tuple will be used for padding in each axis, in order (x,y or x,y,z). For example, for padding=0.2 on a 800x800-pixel plot, an x-axis with the range [0,10] will be padded by 20% to be [-1,11], while a y-axis with a range [0,1000] will be padded to be [-100,1100], which should make the padding be approximately the same number of pixels. But if the same plot is changed to have a height of only 200, the y-range will then be [-400,1400] so that the y-axis padding will still match that of the x-axis. It is also possible to declare non-equal padding value for the lower and upper bound of an axis by supplying nested tuples, e.g. padding=(0.1, (0, 0.1)) will pad the x-axis lower and upper bound as well as the y-axis upper bound by a fraction of 0.1 while the y-axis lower bound is not padded at all.
show_legend = param.Boolean(bounds=(0, 1), default=False, label=’Show legend’): Whether to show legend for the plot.

anim(start=0, stop=None, fps=30)#: Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()#: Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)#: Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

get_aspect(xspan, yspan)#: Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined')[source]#

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

‘data’: Just the data ranges
‘extents’: Element.extents
‘soft’: Dimension.soft_range values
‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)#: Computes padding along the axes taking into account the plot aspect.

get_zorder(overlay, key, el)#: Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_data, plot_kwargs)#: Initializes the artist based on the plot method declared on the plot.

initialize_plot(*args, **kwargs)#: Initialize the matplotlib figure.

matches(spec)#: Matches a specification against the current Plot.

push()#: Pushes plot updates to the frontend.

refresh(**kwargs)#: Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

set_root(root)#: Sets the root model on all subplots.

property state#: The plotting state that gets updated via the update method and used by the renderer to generate output.

teardown_handles()#: If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)#: Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)#: Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_frame(*args, **kwargs)#

Set the plot(s) to the given frame number. Operates by manipulating the matplotlib objects held in the self._handles dictionary.

If n is greater than the number of available frames, update using the last available frame.

update_handles(key, axis, element, ranges, style)#: Update the elements of the plot.

class holoviews.plotting.mpl.chart.VectorFieldPlot(*args, **kwargs)[source]#

Bases: holoviews.plotting.mpl.element.ColorbarPlot

Renders vector fields in sheet coordinates. The vectors are expressed in polar coordinates and may be displayed according to angle alone (with some common, arbitrary arrow length) or may be true polar vectors.

The color or magnitude can be mapped onto any dimension using the color_index and size_index.

The length of the arrows is controlled by the ‘scale’ style option. The scaling of the arrows may also be controlled via the normalize_lengths and rescale_lengths plot option, which will normalize the lengths to a maximum of 1 and scale them according to the minimum distance respectively.

Parameters inherited from:

padding = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=0.05, label=’Padding’): Fraction by which to increase auto-ranged extents to make datapoints more visible around borders. To compute padding, the axis whose screen size is largest is chosen, and the range of that axis is increased by the specified fraction along each axis. Other axes are then padded ensuring that the amount of screen space devoted to padding is equal for all axes. If specified as a tuple, the int or float values in the tuple will be used for padding in each axis, in order (x,y or x,y,z). For example, for padding=0.2 on a 800x800-pixel plot, an x-axis with the range [0,10] will be padded by 20% to be [-1,11], while a y-axis with a range [0,1000] will be padded to be [-100,1100], which should make the padding be approximately the same number of pixels. But if the same plot is changed to have a height of only 200, the y-range will then be [-400,1400] so that the y-axis padding will still match that of the x-axis. It is also possible to declare non-equal padding value for the lower and upper bound of an axis by supplying nested tuples, e.g. padding=(0.1, (0, 0.1)) will pad the x-axis lower and upper bound as well as the y-axis upper bound by a fraction of 0.1 while the y-axis lower bound is not padded at all.
arrow_heads = param.Boolean(bounds=(0, 1), default=True, label=’Arrow heads’): Whether or not to draw arrow heads. If arrowheads are enabled, they may be customized with the ‘headlength’ and ‘headaxislength’ style options.
magnitude = param.ClassSelector(allow_None=True, class_=(<class ‘str’>, <class ‘holoviews.util.transform.dim’>), label=’Magnitude’): Dimension or dimension value transform that declares the magnitude of each vector. Magnitude is expected to be scaled between 0-1, by default the magnitudes are rescaled relative to the minimum distance between vectors, this can be disabled with the rescale_lengths option.
rescale_lengths = param.Boolean(bounds=(0, 1), default=True, label=’Rescale lengths’): Whether the lengths will be rescaled to take into account the smallest non-zero distance between two vectors.
color_index = param.ClassSelector(allow_None=True, class_=(<class ‘str’>, <class ‘int’>), label=’Color index’): Deprecated in favor of dimension value transform on color option, e.g. color=dim(‘Magnitude’).
size_index = param.ClassSelector(allow_None=True, class_=(<class ‘str’>, <class ‘int’>), label=’Size index’): Deprecated in favor of the magnitude option, e.g. magnitude=dim(‘Magnitude’).
normalize_lengths = param.Boolean(bounds=(0, 1), default=True, label=’Normalize lengths’): Deprecated in favor of rescaling length using dimension value transforms using the magnitude option, e.g. dim(‘Magnitude’).norm().

anim(start=0, stop=None, fps=30)#: Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()#: Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)#: Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

get_aspect(xspan, yspan)#: Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined', xdim=None, ydim=None, zdim=None)#

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

‘data’: Just the data ranges
‘extents’: Element.extents
‘soft’: Dimension.soft_range values
‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)#: Computes padding along the axes taking into account the plot aspect.

get_zorder(overlay, key, el)#: Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)#: Initializes the artist based on the plot method declared on the plot.

initialize_plot(*args, **kwargs)#: Initialize the matplotlib figure.

matches(spec)#: Matches a specification against the current Plot.

push()#: Pushes plot updates to the frontend.

refresh(**kwargs)#: Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

set_root(root)#: Sets the root model on all subplots.

property state#: The plotting state that gets updated via the update method and used by the renderer to generate output.

teardown_handles()#: If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)#: Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)#: Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_frame(*args, **kwargs)#

Set the plot(s) to the given frame number. Operates by manipulating the matplotlib objects held in the self._handles dictionary.

If n is greater than the number of available frames, update using the last available frame.

update_handles(key, axis, element, ranges, style)[source]#: Update the elements of the plot.

`chart3d` Module#

Inheritance diagram of holoviews.plotting.mpl.chart3d

class holoviews.plotting.mpl.chart3d.Path3DPlot(*args, **kwargs)[source]#

Bases: holoviews.plotting.mpl.chart3d.Plot3D, holoviews.plotting.mpl.path.PathPlot

Allows plotting paths on a 3D axis.

Parameters inherited from:

anim(start=0, stop=None, fps=30)#: Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()#: Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)#: Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

get_aspect(xspan, yspan)#: Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined', xdim=None, ydim=None, zdim=None)#

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

‘data’: Just the data ranges
‘extents’: Element.extents
‘soft’: Dimension.soft_range values
‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)#: Computes padding along the axes taking into account the plot aspect.

get_zorder(overlay, key, el)#: Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)[source]#: Initializes the artist based on the plot method declared on the plot.

initialize_plot(*args, **kwargs)#: Initialize the matplotlib figure.

matches(spec)#: Matches a specification against the current Plot.

push()#: Pushes plot updates to the frontend.

refresh(**kwargs)#: Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

set_root(root)#: Sets the root model on all subplots.

property state#: The plotting state that gets updated via the update method and used by the renderer to generate output.

teardown_handles()#: If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)#: Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)#: Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_frame(*args, **kwargs)#

Set the plot(s) to the given frame number. Operates by manipulating the matplotlib objects held in the self._handles dictionary.

If n is greater than the number of available frames, update using the last available frame.

update_handles(key, axis, element, ranges, style)[source]#: Update the elements of the plot.

class holoviews.plotting.mpl.chart3d.Plot3D(*args, **kwargs)[source]#

Bases: holoviews.plotting.mpl.element.ColorbarPlot

Plot3D provides a common baseclass for mplot3d based plots.

Parameters inherited from:

projection = param.ObjectSelector(allow_None=True, default=’3d’, label=’Projection’, objects=[‘3d’]): The projection of the matplotlib axis.
bgcolor = param.String(default=’white’, label=’Bgcolor’): Background color of the axis.
show_grid = param.Boolean(bounds=(0, 1), default=True, label=’Show grid’): Whether to draw a grid in the figure.
xaxis = param.ObjectSelector(default=’fixed’, label=’Xaxis’, objects=[‘fixed’, None]): Whether and where to display the xaxis.
yaxis = param.ObjectSelector(default=’fixed’, label=’Yaxis’, objects=[‘fixed’, None]): Whether and where to display the yaxis.
labelled = param.List(bounds=(0, None), default=[‘x’, ‘y’, ‘z’], label=’Labelled’): Whether to plot the ‘x’, ‘y’ and ‘z’ labels.
zaxis = param.ObjectSelector(default=’fixed’, label=’Zaxis’, objects=[‘fixed’, None]): Whether and where to display the yaxis.
azimuth = param.Integer(bounds=(-180, 180), default=-60, inclusive_bounds=(True, True), label=’Azimuth’): Azimuth angle in the x,y plane.
elevation = param.Integer(bounds=(0, 180), default=30, inclusive_bounds=(True, True), label=’Elevation’): Elevation angle in the z-axis.
distance = param.Integer(bounds=(7, 15), default=10, inclusive_bounds=(True, True), label=’Distance’): Distance from the plotted object.
disable_axes = param.Boolean(bounds=(0, 1), default=False, label=’Disable axes’): Disable all axes.

anim(start=0, stop=None, fps=30)#: Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()#: Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)#: Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

get_aspect(xspan, yspan)#: Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined', xdim=None, ydim=None, zdim=None)#

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

‘data’: Just the data ranges
‘extents’: Element.extents
‘soft’: Dimension.soft_range values
‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)#: Computes padding along the axes taking into account the plot aspect.

get_zorder(overlay, key, el)#: Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)#: Initializes the artist based on the plot method declared on the plot.

initialize_plot(*args, **kwargs)#: Initialize the matplotlib figure.

matches(spec)#: Matches a specification against the current Plot.

push()#: Pushes plot updates to the frontend.

refresh(**kwargs)#: Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

set_root(root)#: Sets the root model on all subplots.

property state#: The plotting state that gets updated via the update method and used by the renderer to generate output.

teardown_handles()#: If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)#: Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)#: Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_frame(*args, **kwargs)#

Set the plot(s) to the given frame number. Operates by manipulating the matplotlib objects held in the self._handles dictionary.

If n is greater than the number of available frames, update using the last available frame.

update_handles(key, axis, element, ranges, style)#: Update the elements of the plot.

class holoviews.plotting.mpl.chart3d.Scatter3DPlot(*args, **kwargs)[source]#

Bases: holoviews.plotting.mpl.chart3d.Plot3D, holoviews.plotting.mpl.chart.PointPlot

Subclass of PointPlot allowing plotting of Points on a 3D axis, also allows mapping color and size onto a particular Dimension of the data.

Parameters inherited from:

color_index = param.ClassSelector(allow_None=True, class_=(<class ‘str’>, <class ‘int’>), label=’Color index’): Index of the dimension from which the color will the drawn
size_index = param.ClassSelector(allow_None=True, class_=(<class ‘str’>, <class ‘int’>), label=’Size index’): Index of the dimension from which the sizes will the drawn.

anim(start=0, stop=None, fps=30)#: Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()#: Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)#: Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

get_aspect(xspan, yspan)#: Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined', xdim=None, ydim=None, zdim=None)#

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

‘data’: Just the data ranges
‘extents’: Element.extents
‘soft’: Dimension.soft_range values
‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)#: Computes padding along the axes taking into account the plot aspect.

get_zorder(overlay, key, el)#: Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)#: Initializes the artist based on the plot method declared on the plot.

initialize_plot(*args, **kwargs)#: Initialize the matplotlib figure.

matches(spec)#: Matches a specification against the current Plot.

push()#: Pushes plot updates to the frontend.

refresh(**kwargs)#: Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

set_root(root)#: Sets the root model on all subplots.

size_fn = <ufunc 'absolute'>#

property state#: The plotting state that gets updated via the update method and used by the renderer to generate output.

teardown_handles()#: If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)#: Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)#: Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_frame(*args, **kwargs)#

Set the plot(s) to the given frame number. Operates by manipulating the matplotlib objects held in the self._handles dictionary.

If n is greater than the number of available frames, update using the last available frame.

update_handles(key, axis, element, ranges, style)[source]#: Update the elements of the plot.

class holoviews.plotting.mpl.chart3d.SurfacePlot(*args, **kwargs)[source]#

Bases: holoviews.plotting.mpl.chart3d.Plot3D

Plots surfaces wireframes and contours in 3D space. Provides options to switch the display type via the plot_type parameter has support for a number of styling options including strides and colors.

Parameters inherited from:

colorbar = param.Boolean(bounds=(0, 1), default=False, label=’Colorbar’): Whether to add a colorbar to the plot.
plot_type = param.ObjectSelector(default=’surface’, label=’Plot type’, objects=[‘surface’, ‘wireframe’, ‘contour’]): Specifies the type of visualization for the Surface object. Valid values are ‘surface’, ‘wireframe’ and ‘contour’.

anim(start=0, stop=None, fps=30)#: Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()#: Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)#: Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

get_aspect(xspan, yspan)#: Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined', xdim=None, ydim=None, zdim=None)#

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

‘data’: Just the data ranges
‘extents’: Element.extents
‘soft’: Dimension.soft_range values
‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)#: Computes padding along the axes taking into account the plot aspect.

get_zorder(overlay, key, el)#: Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_data, plot_kwargs)[source]#: Initializes the artist based on the plot method declared on the plot.

initialize_plot(*args, **kwargs)#: Initialize the matplotlib figure.

matches(spec)#: Matches a specification against the current Plot.

push()#: Pushes plot updates to the frontend.

refresh(**kwargs)#: Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

set_root(root)#: Sets the root model on all subplots.

property state#: The plotting state that gets updated via the update method and used by the renderer to generate output.

teardown_handles()#: If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)#: Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)#: Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_frame(*args, **kwargs)#

Set the plot(s) to the given frame number. Operates by manipulating the matplotlib objects held in the self._handles dictionary.

If n is greater than the number of available frames, update using the last available frame.

update_handles(key, axis, element, ranges, style)#: Update the elements of the plot.

class holoviews.plotting.mpl.chart3d.TriSurfacePlot(*args, **kwargs)[source]#

Bases: holoviews.plotting.mpl.chart3d.Plot3D

Plots a trisurface given a TriSurface element, containing X, Y and Z coordinates.

Parameters inherited from:

colorbar = param.Boolean(bounds=(0, 1), default=False, label=’Colorbar’): Whether to add a colorbar to the plot.

anim(start=0, stop=None, fps=30)#: Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()#: Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)#: Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

get_aspect(xspan, yspan)#: Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined', xdim=None, ydim=None, zdim=None)#

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

‘data’: Just the data ranges
‘extents’: Element.extents
‘soft’: Dimension.soft_range values
‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)#: Computes padding along the axes taking into account the plot aspect.

get_zorder(overlay, key, el)#: Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)#: Initializes the artist based on the plot method declared on the plot.

initialize_plot(*args, **kwargs)#: Initialize the matplotlib figure.

matches(spec)#: Matches a specification against the current Plot.

push()#: Pushes plot updates to the frontend.

refresh(**kwargs)#: Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

set_root(root)#: Sets the root model on all subplots.

property state#: The plotting state that gets updated via the update method and used by the renderer to generate output.

teardown_handles()#: If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)#: Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)#: Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_frame(*args, **kwargs)#

Set the plot(s) to the given frame number. Operates by manipulating the matplotlib objects held in the self._handles dictionary.

If n is greater than the number of available frames, update using the last available frame.

update_handles(key, axis, element, ranges, style)#: Update the elements of the plot.

`element` Module#

Inheritance diagram of holoviews.plotting.mpl.element

class holoviews.plotting.mpl.element.ColorbarPlot(*args, **kwargs)[source]#

Bases: holoviews.plotting.mpl.element.ElementPlot

Parameters inherited from:

clabel = param.String(allow_None=True, label=’Clabel’): An explicit override of the color bar label, if set takes precedence over the title key in colorbar_opts.
clim = param.Tuple(default=(nan, nan), label=’Clim’, length=2): User-specified colorbar axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.
clim_percentile = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘bool’>), default=False, label=’Clim percentile’): Percentile value to compute colorscale robust to outliers. If True, uses 2nd and 98th percentile; otherwise uses the specified numerical percentile value.
cformatter = param.ClassSelector(allow_None=True, class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>), label=’Cformatter’): Formatter for ticks along the colorbar axis.
colorbar = param.Boolean(bounds=(0, 1), default=False, label=’Colorbar’): Whether to draw a colorbar.
colorbar_opts = param.Dict(class_=<class ‘dict’>, default={}, label=’Colorbar opts’): Allows setting specific styling options for the colorbar.
color_levels = param.ClassSelector(allow_None=True, class_=(<class ‘int’>, <class ‘list’>), label=’Color levels’): Number of discrete colors to use when colormapping or a set of color intervals defining the range of values to map each color to.
cnorm = param.ObjectSelector(default=’linear’, label=’Cnorm’, objects=[‘linear’, ‘log’, ‘eq_hist’]): Color normalization to be applied during colormapping.
clipping_colors = param.Dict(class_=<class ‘dict’>, default={}, label=’Clipping colors’): Dictionary to specify colors for clipped values, allows setting color for NaN values and for values above and below the min and max value. The min, max or NaN color may specify an RGB(A) color as a color hex string of the form #FFFFFF or #FFFFFFFF or a length 3 or length 4 tuple specifying values in the range 0-1 or a named HTML color.
cbar_padding = param.Number(default=0.01, inclusive_bounds=(True, True), label=’Cbar padding’): Padding between colorbar and other plots.
cbar_ticks = param.Parameter(allow_None=True, label=’Cbar ticks’): Ticks along colorbar-axis specified as an integer, explicit list of tick locations, list of tuples containing the locations and labels or a matplotlib tick locator object. If set to None default matplotlib ticking behavior is applied.
cbar_width = param.Number(default=0.05, inclusive_bounds=(True, True), label=’Cbar width’): Width of the colorbar as a fraction of the main plot
cbar_extend = param.ObjectSelector(label=’Cbar extend’, objects=[‘neither’, ‘both’, ‘min’, ‘max’]): If not ‘neither’, make pointed end(s) for out-of- range values.
rescale_discrete_levels = param.Boolean(bounds=(0, 1), default=True, label=’Rescale discrete levels’): If cnorm='eq_hist and there are only a few discrete values, then rescale_discrete_levels=True decreases the lower limit of the autoranged span so that the values are rendering towards the (more visible) top of the palette, thus avoiding washout of the lower values. Has no effect if cnorm!=`eq_hist. Set this value to False if you need to match historical unscaled behavior, prior to HoloViews 1.14.4.
symmetric = param.Boolean(bounds=(0, 1), default=False, label=’Symmetric’): Whether to make the colormap symmetric around zero.

anim(start=0, stop=None, fps=30)#: Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()#: Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)#: Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

get_aspect(xspan, yspan)#: Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined', xdim=None, ydim=None, zdim=None)#

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

‘data’: Just the data ranges
‘extents’: Element.extents
‘soft’: Dimension.soft_range values
‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)#: Computes padding along the axes taking into account the plot aspect.

get_zorder(overlay, key, el)#: Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)#: Initializes the artist based on the plot method declared on the plot.

initialize_plot(*args, **kwargs)#: Initialize the matplotlib figure.

matches(spec)#: Matches a specification against the current Plot.

push()#: Pushes plot updates to the frontend.

refresh(**kwargs)#: Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

set_root(root)#: Sets the root model on all subplots.

property state#: The plotting state that gets updated via the update method and used by the renderer to generate output.

teardown_handles()#: If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)#: Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)#: Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_frame(*args, **kwargs)#

Set the plot(s) to the given frame number. Operates by manipulating the matplotlib objects held in the self._handles dictionary.

If n is greater than the number of available frames, update using the last available frame.

update_handles(key, axis, element, ranges, style)#: Update the elements of the plot.

class holoviews.plotting.mpl.element.ElementPlot(element, **params)[source]#

Bases: holoviews.plotting.plot.GenericElementPlot, holoviews.plotting.mpl.plot.MPLPlot

Parameters inherited from:

apply_ticks = param.Boolean(bounds=(0, 1), default=True, label=’Apply ticks’): Whether to apply custom ticks.
aspect = param.Parameter(default=’square’, label=’Aspect’): The aspect ratio mode of the plot. By default, a plot may select its own appropriate aspect ratio but sometimes it may be necessary to force a square aspect ratio (e.g. to display the plot as an element of a grid). The modes ‘auto’ and ‘equal’ correspond to the axis modes of the same name in matplotlib, a numeric value specifying the ratio between plot width and height may also be passed. To control the aspect ratio between the axis scales use the data_aspect option instead.
data_aspect = param.Number(allow_None=True, inclusive_bounds=(True, True), label=’Data aspect’): Defines the aspect of the axis scaling, i.e. the ratio of y-unit to x-unit.
invert_zaxis = param.Boolean(bounds=(0, 1), default=False, label=’Invert zaxis’): Whether to invert the plot z-axis.
labelled = param.List(bounds=(0, None), default=[‘x’, ‘y’], label=’Labelled’): Whether to plot the ‘x’ and ‘y’ labels.
logz = param.Boolean(bounds=(0, 1), default=False, label=’Logz’): Whether to apply log scaling to the y-axis of the Chart.
xformatter = param.ClassSelector(allow_None=True, class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>), label=’Xformatter’): Formatter for ticks along the x-axis.
yformatter = param.ClassSelector(allow_None=True, class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>), label=’Yformatter’): Formatter for ticks along the y-axis.
zformatter = param.ClassSelector(allow_None=True, class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>), label=’Zformatter’): Formatter for ticks along the z-axis.
zaxis = param.Boolean(bounds=(0, 1), default=True, label=’Zaxis’): Whether to display the z-axis.
zlabel = param.String(allow_None=True, label=’Zlabel’): An explicit override of the z-axis label, if set takes precedence over the dimension label.
zrotation = param.Integer(bounds=(0, 360), default=0, inclusive_bounds=(True, True), label=’Zrotation’): Rotation angle of the zticks.
zticks = param.Parameter(allow_None=True, label=’Zticks’): Ticks along z-axis specified as an integer, explicit list of tick locations, list of tuples containing the locations and labels or a matplotlib tick locator object. If set to None default matplotlib ticking behavior is applied.

anim(start=0, stop=None, fps=30)#: Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()#: Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)#: Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

get_aspect(xspan, yspan)[source]#: Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined', xdim=None, ydim=None, zdim=None)#

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

‘data’: Just the data ranges
‘extents’: Element.extents
‘soft’: Dimension.soft_range values
‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)#: Computes padding along the axes taking into account the plot aspect.

get_zorder(overlay, key, el)#: Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)[source]#: Initializes the artist based on the plot method declared on the plot.

initialize_plot(*args, **kwargs)#: Initialize the matplotlib figure.

matches(spec)#: Matches a specification against the current Plot.

push()#: Pushes plot updates to the frontend.

refresh(**kwargs)#: Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

set_root(root)#: Sets the root model on all subplots.

property state#: The plotting state that gets updated via the update method and used by the renderer to generate output.

teardown_handles()[source]#: If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)#: Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)#: Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_frame(*args, **kwargs)#

Set the plot(s) to the given frame number. Operates by manipulating the matplotlib objects held in the self._handles dictionary.

If n is greater than the number of available frames, update using the last available frame.

update_handles(key, axis, element, ranges, style)[source]#: Update the elements of the plot.

class holoviews.plotting.mpl.element.LegendPlot(element, **params)[source]#

Bases: holoviews.plotting.mpl.element.ElementPlot

Parameters inherited from:

show_legend = param.Boolean(bounds=(0, 1), default=True, label=’Show legend’): Whether to show legend for the plot.
legend_cols = param.Integer(allow_None=True, inclusive_bounds=(True, True), label=’Legend cols’): Number of legend columns in the legend.
legend_labels = param.Dict(class_=<class ‘dict’>, default={}, label=’Legend labels’): A mapping that allows overriding legend labels.
legend_position = param.ObjectSelector(default=’inner’, label=’Legend position’, objects=[‘inner’, ‘right’, ‘bottom’, ‘top’, ‘left’, ‘best’, ‘top_right’, ‘top_left’, ‘bottom_left’, ‘bottom_right’]): Allows selecting between a number of predefined legend position options. The predefined options may be customized in the legend_specs class attribute. By default, ‘inner’, ‘right’, ‘bottom’, ‘top’, ‘left’, ‘best’, ‘top_right’, ‘top_left’, ‘bottom_right’ and ‘bottom_left’ are supported.
legend_opts = param.Dict(class_=<class ‘dict’>, default={}, label=’Legend opts’): Allows setting specific styling options for the colorbar.

anim(start=0, stop=None, fps=30)#: Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()#: Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)#: Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

get_aspect(xspan, yspan)#: Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined', xdim=None, ydim=None, zdim=None)#

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

‘data’: Just the data ranges
‘extents’: Element.extents
‘soft’: Dimension.soft_range values
‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)#: Computes padding along the axes taking into account the plot aspect.

get_zorder(overlay, key, el)#: Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)#: Initializes the artist based on the plot method declared on the plot.

initialize_plot(*args, **kwargs)#: Initialize the matplotlib figure.

matches(spec)#: Matches a specification against the current Plot.

push()#: Pushes plot updates to the frontend.

refresh(**kwargs)#: Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

set_root(root)#: Sets the root model on all subplots.

property state#: The plotting state that gets updated via the update method and used by the renderer to generate output.

teardown_handles()#: If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)#: Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)#: Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_frame(*args, **kwargs)#

Set the plot(s) to the given frame number. Operates by manipulating the matplotlib objects held in the self._handles dictionary.

If n is greater than the number of available frames, update using the last available frame.

update_handles(key, axis, element, ranges, style)#: Update the elements of the plot.

class holoviews.plotting.mpl.element.OverlayPlot(overlay, ranges=None, **params)[source]#

Bases: holoviews.plotting.mpl.element.LegendPlot, holoviews.plotting.plot.GenericOverlayPlot

OverlayPlot supports compositors processing of Overlays across maps.

Parameters inherited from:

anim(start=0, stop=None, fps=30)#: Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()#: Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)#: Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

get_aspect(xspan, yspan)#: Computes the aspect ratio of the plot

get_extents(overlay, ranges, range_type='combined')#

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

‘data’: Just the data ranges
‘extents’: Element.extents
‘soft’: Dimension.soft_range values
‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)#: Computes padding along the axes taking into account the plot aspect.

get_zorder(overlay, key, el)#: Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)#: Initializes the artist based on the plot method declared on the plot.

initialize_plot(*args, **kwargs)#: Initialize the matplotlib figure.

matches(spec)#: Matches a specification against the current Plot.

push()#: Pushes plot updates to the frontend.

refresh(**kwargs)#: Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

set_root(root)#: Sets the root model on all subplots.

property state#: The plotting state that gets updated via the update method and used by the renderer to generate output.

teardown_handles()#: If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)#: Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)#: Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_frame(*args, **kwargs)#

Set the plot(s) to the given frame number. Operates by manipulating the matplotlib objects held in the self._handles dictionary.

If n is greater than the number of available frames, update using the last available frame.

update_handles(key, axis, element, ranges, style)#: Update the elements of the plot.

`geometry` Module#

Inheritance diagram of holoviews.plotting.mpl.geometry

class holoviews.plotting.mpl.geometry.RectanglesPlot(*args, **kwargs)[source]#

Bases: holoviews.plotting.mixins.GeomMixin, holoviews.plotting.mpl.element.ColorbarPlot

Rectanlges are polygons in 2D space where the key dimensions represent the bottom-left and top-right corner of the rectangle.

Parameters inherited from:

anim(start=0, stop=None, fps=30)#: Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()#: Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)#: Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

get_aspect(xspan, yspan)#: Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined')#: Use first two key dimensions to set names, and all four to set the data range.

get_padding(obj, extents)#: Computes padding along the axes taking into account the plot aspect.

get_zorder(overlay, key, el)#: Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)[source]#: Initializes the artist based on the plot method declared on the plot.

initialize_plot(*args, **kwargs)#: Initialize the matplotlib figure.

matches(spec)#: Matches a specification against the current Plot.

push()#: Pushes plot updates to the frontend.

refresh(**kwargs)#: Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

set_root(root)#: Sets the root model on all subplots.

property state#: The plotting state that gets updated via the update method and used by the renderer to generate output.

teardown_handles()#: If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)#: Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)#: Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_frame(*args, **kwargs)#

Set the plot(s) to the given frame number. Operates by manipulating the matplotlib objects held in the self._handles dictionary.

If n is greater than the number of available frames, update using the last available frame.

update_handles(key, axis, element, ranges, style)#: Update the elements of the plot.

class holoviews.plotting.mpl.geometry.SegmentPlot(*args, **kwargs)[source]#

Bases: holoviews.plotting.mixins.GeomMixin, holoviews.plotting.mpl.element.ColorbarPlot

Segments are lines in 2D space where each two key dimensions specify a (x, y) node of the line.

Parameters inherited from:

anim(start=0, stop=None, fps=30)#: Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()#: Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)#: Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

get_aspect(xspan, yspan)#: Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined')#: Use first two key dimensions to set names, and all four to set the data range.

get_padding(obj, extents)#: Computes padding along the axes taking into account the plot aspect.

get_zorder(overlay, key, el)#: Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)[source]#: Initializes the artist based on the plot method declared on the plot.

initialize_plot(*args, **kwargs)#: Initialize the matplotlib figure.

matches(spec)#: Matches a specification against the current Plot.

push()#: Pushes plot updates to the frontend.

refresh(**kwargs)#: Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

set_root(root)#: Sets the root model on all subplots.

property state#: The plotting state that gets updated via the update method and used by the renderer to generate output.

teardown_handles()#: If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)#: Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)#: Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_frame(*args, **kwargs)#

Set the plot(s) to the given frame number. Operates by manipulating the matplotlib objects held in the self._handles dictionary.

If n is greater than the number of available frames, update using the last available frame.

update_handles(key, axis, element, ranges, style)#: Update the elements of the plot.

`graphs` Module#

Inheritance diagram of holoviews.plotting.mpl.graphs

class holoviews.plotting.mpl.graphs.ChordPlot(*args, **kwargs)[source]#

Bases: holoviews.plotting.mixins.ChordMixin, holoviews.plotting.mpl.graphs.GraphPlot

Parameters inherited from:

labels = param.ClassSelector(allow_None=True, class_=(<class ‘str’>, <class ‘holoviews.util.transform.dim’>), label=’Labels’): The dimension or dimension value transform used to draw labels from.
label_index = param.ClassSelector(allow_None=True, class_=(<class ‘str’>, <class ‘int’>), label=’Label index’): Index of the dimension from which the node labels will be drawn

anim(start=0, stop=None, fps=30)#: Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()#: Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)#: Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

get_aspect(xspan, yspan)#: Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined')#: A Chord plot is always drawn on a unit circle.

get_padding(obj, extents)#: Computes padding along the axes taking into account the plot aspect.

get_zorder(overlay, key, el)#: Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)[source]#: Initializes the artist based on the plot method declared on the plot.

initialize_plot(*args, **kwargs)#: Initialize the matplotlib figure.

matches(spec)#: Matches a specification against the current Plot.

push()#: Pushes plot updates to the frontend.

refresh(**kwargs)#: Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

set_root(root)#: Sets the root model on all subplots.

property state#: The plotting state that gets updated via the update method and used by the renderer to generate output.

teardown_handles()#: If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)#: Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)#: Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_frame(*args, **kwargs)#

Set the plot(s) to the given frame number. Operates by manipulating the matplotlib objects held in the self._handles dictionary.

If n is greater than the number of available frames, update using the last available frame.

update_handles(key, axis, element, ranges, style)[source]#: Update the elements of the plot.

class holoviews.plotting.mpl.graphs.GraphPlot(*args, **kwargs)[source]#

Bases: holoviews.plotting.mpl.element.ColorbarPlot

Parameters inherited from:

arrowhead_length = param.Number(default=0.025, inclusive_bounds=(True, True), label=’Arrowhead length’): If directed option is enabled this determines the length of the arrows as fraction of the overall extent of the graph.
directed = param.Boolean(bounds=(0, 1), default=False, label=’Directed’): Whether to draw arrows on the graph edges to indicate the directionality of each edge.
color_index = param.ClassSelector(allow_None=True, class_=(<class ‘str’>, <class ‘int’>), label=’Color index’): Deprecated in favor of color style mapping, e.g. node_color=dim(‘color’)
edge_color_index = param.ClassSelector(allow_None=True, class_=(<class ‘str’>, <class ‘int’>), label=’Edge color index’): Deprecated in favor of color style mapping, e.g. edge_color=dim(‘color’)

anim(start=0, stop=None, fps=30)#: Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()#: Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)#: Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

get_aspect(xspan, yspan)#: Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined')[source]#

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

‘data’: Just the data ranges
‘extents’: Element.extents
‘soft’: Dimension.soft_range values
‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)#: Computes padding along the axes taking into account the plot aspect.

get_zorder(overlay, key, el)#: Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)[source]#: Initializes the artist based on the plot method declared on the plot.

initialize_plot(*args, **kwargs)#: Initialize the matplotlib figure.

matches(spec)#: Matches a specification against the current Plot.

push()#: Pushes plot updates to the frontend.

refresh(**kwargs)#: Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

set_root(root)#: Sets the root model on all subplots.

property state#: The plotting state that gets updated via the update method and used by the renderer to generate output.

teardown_handles()#: If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)#: Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)#: Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_frame(*args, **kwargs)#

Set the plot(s) to the given frame number. Operates by manipulating the matplotlib objects held in the self._handles dictionary.

If n is greater than the number of available frames, update using the last available frame.

update_handles(key, axis, element, ranges, style)[source]#: Update the elements of the plot.

class holoviews.plotting.mpl.graphs.TriMeshPlot(*args, **kwargs)[source]#

Bases: holoviews.plotting.mpl.graphs.GraphPlot

Parameters inherited from:

filled = param.Boolean(bounds=(0, 1), default=False, label=’Filled’): Whether the triangles should be drawn as filled.

anim(start=0, stop=None, fps=30)#: Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()#: Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)#: Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

get_aspect(xspan, yspan)#: Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined')#

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

‘data’: Just the data ranges
‘extents’: Element.extents
‘soft’: Dimension.soft_range values
‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)#: Computes padding along the axes taking into account the plot aspect.

get_zorder(overlay, key, el)#: Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)#: Initializes the artist based on the plot method declared on the plot.

initialize_plot(*args, **kwargs)#: Initialize the matplotlib figure.

matches(spec)#: Matches a specification against the current Plot.

push()#: Pushes plot updates to the frontend.

refresh(**kwargs)#: Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

set_root(root)#: Sets the root model on all subplots.

property state#: The plotting state that gets updated via the update method and used by the renderer to generate output.

teardown_handles()#: If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)#: Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)#: Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_frame(*args, **kwargs)#

Set the plot(s) to the given frame number. Operates by manipulating the matplotlib objects held in the self._handles dictionary.

If n is greater than the number of available frames, update using the last available frame.

update_handles(key, axis, element, ranges, style)#: Update the elements of the plot.

`heatmap` Module#

Inheritance diagram of holoviews.plotting.mpl.heatmap

class holoviews.plotting.mpl.heatmap.HeatMapPlot(*args, **kwargs)[source]#

Bases: holoviews.plotting.mixins.HeatMapMixin, holoviews.plotting.mpl.raster.QuadMeshPlot

Parameters inherited from:

padding = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=0, label=’Padding’): Fraction by which to increase auto-ranged extents to make datapoints more visible around borders. To compute padding, the axis whose screen size is largest is chosen, and the range of that axis is increased by the specified fraction along each axis. Other axes are then padded ensuring that the amount of screen space devoted to padding is equal for all axes. If specified as a tuple, the int or float values in the tuple will be used for padding in each axis, in order (x,y or x,y,z). For example, for padding=0.2 on a 800x800-pixel plot, an x-axis with the range [0,10] will be padded by 20% to be [-1,11], while a y-axis with a range [0,1000] will be padded to be [-100,1100], which should make the padding be approximately the same number of pixels. But if the same plot is changed to have a height of only 200, the y-range will then be [-400,1400] so that the y-axis padding will still match that of the x-axis. It is also possible to declare non-equal padding value for the lower and upper bound of an axis by supplying nested tuples, e.g. padding=(0.1, (0, 0.1)) will pad the x-axis lower and upper bound as well as the y-axis upper bound by a fraction of 0.1 while the y-axis lower bound is not padded at all.
xticks = param.Parameter(default=20, label=’Xticks’): Ticks along x-axis/segments specified as an integer, explicit list of ticks or function. If None, no ticks are shown.
yticks = param.Parameter(default=20, label=’Yticks’): Ticks along y-axis/annulars specified as an integer, explicit list of ticks or function. If None, no ticks are shown.
clipping_colors = param.Dict(class_=<class ‘dict’>, default={‘NaN’: ‘white’}, label=’Clipping colors’): Dictionary to specify colors for clipped values, allows setting color for NaN values and for values above and below the min and max value. The min, max or NaN color may specify an RGB(A) color as a color hex string of the form #FFFFFF or #FFFFFFFF or a length 3 or length 4 tuple specifying values in the range 0-1 or a named HTML color.
radial = param.Boolean(bounds=(0, 1), default=False, label=’Radial’): Whether the HeatMap should be radial
show_values = param.Boolean(bounds=(0, 1), default=False, label=’Show values’): Whether to annotate each pixel with its value.
xmarks = param.Parameter(allow_None=True, label=’Xmarks’): Add separation lines to the heatmap for better readability. By default, does not show any separation lines. If parameter is of type integer, draws the given amount of separations lines spread across heatmap. If parameter is of type list containing integers, show separation lines at given indices. If parameter is of type tuple, draw separation lines at given categorical values. If parameter is of type function, draw separation lines where function returns True for passed heatmap category.
ymarks = param.Parameter(allow_None=True, label=’Ymarks’): Add separation lines to the heatmap for better readability. By default, does not show any separation lines. If parameter is of type integer, draws the given amount of separations lines spread across heatmap. If parameter is of type list containing integers, show separation lines at given indices. If parameter is of type tuple, draw separation lines at given categorical values. If parameter is of type function, draw separation lines where function returns True for passed heatmap category.

anim(start=0, stop=None, fps=30)#: Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()#: Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)#: Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

get_aspect(xspan, yspan)#: Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined')#

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

‘data’: Just the data ranges
‘extents’: Element.extents
‘soft’: Dimension.soft_range values
‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)#: Computes padding along the axes taking into account the plot aspect.

get_zorder(overlay, key, el)#: Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)[source]#: Initializes the artist based on the plot method declared on the plot.

initialize_plot(*args, **kwargs)#: Initialize the matplotlib figure.

matches(spec)#: Matches a specification against the current Plot.

push()#: Pushes plot updates to the frontend.

refresh(**kwargs)#: Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

set_root(root)#: Sets the root model on all subplots.

property state#: The plotting state that gets updated via the update method and used by the renderer to generate output.

teardown_handles()#: If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)#: Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)#: Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_frame(*args, **kwargs)#

Set the plot(s) to the given frame number. Operates by manipulating the matplotlib objects held in the self._handles dictionary.

If n is greater than the number of available frames, update using the last available frame.

update_handles(key, axis, element, ranges, style)#: Update the elements of the plot.

class holoviews.plotting.mpl.heatmap.RadialHeatMapPlot(*args, **kwargs)[source]#

Bases: holoviews.plotting.mpl.element.ColorbarPlot

Parameters inherited from:

projection = param.ObjectSelector(allow_None=True, default=’polar’, label=’Projection’, objects=[‘polar’]): The projection of the plot axis, default of None is equivalent to 2D plot, ‘3d’ and ‘polar’ are also supported by matplotlib by default. May also supply a custom projection that is either a matplotlib projection type or implements the _as_mpl_axes method.
xticks = param.Parameter(default=4, label=’Xticks’): Ticks along x-axis/segments specified as an integer, explicit list of ticks or function. If None, no ticks are shown.
yticks = param.Parameter(default=4, label=’Yticks’): Ticks along y-axis/annulars specified as an integer, explicit list of ticks or function. If None, no ticks are shown.
start_angle = param.Number(default=1.5707963267948966, inclusive_bounds=(True, True), label=’Start angle’): Define starting angle of the first annulars. By default, beings at 12 o clock.
max_radius = param.Number(default=0.5, inclusive_bounds=(True, True), label=’Max radius’): Define the maximum radius which is used for the x and y range extents.
radius_inner = param.Number(bounds=(0, 0.5), default=0.1, inclusive_bounds=(True, True), label=’Radius inner’): Define the radius fraction of inner, empty space.
radius_outer = param.Number(bounds=(0, 1), default=0.05, inclusive_bounds=(True, True), label=’Radius outer’): Define the radius fraction of outer space including the labels.
radial = param.Boolean(bounds=(0, 1), default=True, label=’Radial’): Whether the HeatMap should be radial
show_values = param.Boolean(bounds=(0, 1), default=False, label=’Show values’): Whether to annotate each pixel with its value.
xmarks = param.Parameter(allow_None=True, label=’Xmarks’): Add separation lines between segments for better readability. By default, does not show any separation lines. If parameter is of type integer, draws the given amount of separations lines spread across radial heatmap. If parameter is of type list containing integers, show separation lines at given indices. If parameter is of type tuple, draw separation lines at given segment values. If parameter is of type function, draw separation lines where function returns True for passed segment value.
ymarks = param.Parameter(allow_None=True, label=’Ymarks’): Add separation lines between annulars for better readability. By default, does not show any separation lines. If parameter is of type integer, draws the given amount of separations lines spread across radial heatmap. If parameter is of type list containing integers, show separation lines at given indices. If parameter is of type tuple, draw separation lines at given annular values. If parameter is of type function, draw separation lines where function returns True for passed annular value.

anim(start=0, stop=None, fps=30)#: Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()#: Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)#: Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

get_aspect(xspan, yspan)#: Computes the aspect ratio of the plot

get_extents(view, ranges, range_type='combined')[source]#

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

‘data’: Just the data ranges
‘extents’: Element.extents
‘soft’: Dimension.soft_range values
‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)#: Computes padding along the axes taking into account the plot aspect.

get_zorder(overlay, key, el)#: Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)[source]#: Initializes the artist based on the plot method declared on the plot.

initialize_plot(*args, **kwargs)#: Initialize the matplotlib figure.

matches(spec)#: Matches a specification against the current Plot.

push()#: Pushes plot updates to the frontend.

refresh(**kwargs)#: Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

set_root(root)#: Sets the root model on all subplots.

property state#: The plotting state that gets updated via the update method and used by the renderer to generate output.

teardown_handles()#: If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)#: Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)#: Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_frame(*args, **kwargs)#

Set the plot(s) to the given frame number. Operates by manipulating the matplotlib objects held in the self._handles dictionary.

If n is greater than the number of available frames, update using the last available frame.

update_handles(key, axis, element, ranges, style)#: Update the elements of the plot.

`hex_tiles` Module#

Inheritance diagram of holoviews.plotting.mpl.hex_tiles

class holoviews.plotting.mpl.hex_tiles.HexTilesPlot(*args, **kwargs)[source]#

Bases: holoviews.plotting.mpl.element.ColorbarPlot

Parameters inherited from:

aggregator = param.Callable(label=’Aggregator’): Aggregation function used to compute bin values. Any NumPy reduction is allowed, defaulting to np.size to count the number of values in each bin.
gridsize = param.ClassSelector(class_=(<class ‘int’>, <class ‘tuple’>), default=50, label=’Gridsize’): Number of hexagonal bins along x- and y-axes. Defaults to uniform sampling along both axes when setting and integer but independent bin sampling can be specified a tuple of integers corresponding to the number of bins along each axis.
max_scale = param.Number(bounds=(0, None), default=0.9, inclusive_bounds=(True, True), label=’Max scale’): When size_index is enabled this defines the maximum size of each bin relative to uniform tile size, i.e. for a value of 1, the largest bin will match the size of bins when scaling is disabled. Setting value larger than 1 will result in overlapping bins.
min_count = param.Number(allow_None=True, inclusive_bounds=(True, True), label=’Min count’): The display threshold before a bin is shown, by default bins with a count of less than 1 are hidden.

aggregator(axis=None)#

Return the number of elements along a given axis.

aarray_like: Input data.
axisint, optional: Axis along which the elements are counted. By default, give the total number of elements.

element_countint: Number of elements along the specified axis.

shape : dimensions of array ndarray.shape : dimensions of array ndarray.size : number of elements in array

>>> a = np.array([[1,2,3],[4,5,6]])
>>> np.size(a)
6
>>> np.size(a,1)
3
>>> np.size(a,0)
2

anim(start=0, stop=None, fps=30)#: Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()#: Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)#: Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

get_aspect(xspan, yspan)#: Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined', xdim=None, ydim=None, zdim=None)#

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

‘data’: Just the data ranges
‘extents’: Element.extents
‘soft’: Dimension.soft_range values
‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)#: Computes padding along the axes taking into account the plot aspect.

get_zorder(overlay, key, el)#: Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)#: Initializes the artist based on the plot method declared on the plot.

initialize_plot(*args, **kwargs)#: Initialize the matplotlib figure.

matches(spec)#: Matches a specification against the current Plot.

push()#: Pushes plot updates to the frontend.

refresh(**kwargs)#: Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

set_root(root)#: Sets the root model on all subplots.

property state#: The plotting state that gets updated via the update method and used by the renderer to generate output.

teardown_handles()#: If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)#: Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)#: Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_frame(*args, **kwargs)#

Set the plot(s) to the given frame number. Operates by manipulating the matplotlib objects held in the self._handles dictionary.

If n is greater than the number of available frames, update using the last available frame.

update_handles(key, axis, element, ranges, style)#: Update the elements of the plot.

`path` Module#

Inheritance diagram of holoviews.plotting.mpl.path

class holoviews.plotting.mpl.path.ContourPlot(*args, **kwargs)[source]#

Bases: holoviews.plotting.mpl.path.PathPlot

Parameters inherited from:

color_index = param.ClassSelector(allow_None=True, class_=(<class ‘str’>, <class ‘int’>), default=0, label=’Color index’): Index of the dimension from which the color will the drawn

anim(start=0, stop=None, fps=30)#: Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()#: Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)#: Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

get_aspect(xspan, yspan)#: Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined', xdim=None, ydim=None, zdim=None)#

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

‘data’: Just the data ranges
‘extents’: Element.extents
‘soft’: Dimension.soft_range values
‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)#: Computes padding along the axes taking into account the plot aspect.

get_zorder(overlay, key, el)#: Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)#: Initializes the artist based on the plot method declared on the plot.

initialize_plot(*args, **kwargs)#: Initialize the matplotlib figure.

matches(spec)#: Matches a specification against the current Plot.

push()#: Pushes plot updates to the frontend.

refresh(**kwargs)#: Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

set_root(root)#: Sets the root model on all subplots.

property state#: The plotting state that gets updated via the update method and used by the renderer to generate output.

teardown_handles()#: If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)#: Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)#: Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_frame(*args, **kwargs)#

Set the plot(s) to the given frame number. Operates by manipulating the matplotlib objects held in the self._handles dictionary.

If n is greater than the number of available frames, update using the last available frame.

update_handles(key, axis, element, ranges, style)#: Update the elements of the plot.

class holoviews.plotting.mpl.path.PathPlot(*args, **kwargs)[source]#

Bases: holoviews.plotting.mpl.element.ColorbarPlot

Parameters inherited from:

show_legend = param.Boolean(bounds=(0, 1), default=False, label=’Show legend’): Whether to show legend for the plot.
aspect = param.Parameter(default=’square’, label=’Aspect’): PathPlots axes usually define single space so aspect of Paths follows aspect in data coordinates by default.
color_index = param.ClassSelector(allow_None=True, class_=(<class ‘str’>, <class ‘int’>), label=’Color index’): Index of the dimension from which the color will the drawn

anim(start=0, stop=None, fps=30)#: Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()#: Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)#: Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

get_aspect(xspan, yspan)#: Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined', xdim=None, ydim=None, zdim=None)#

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

‘data’: Just the data ranges
‘extents’: Element.extents
‘soft’: Dimension.soft_range values
‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)#: Computes padding along the axes taking into account the plot aspect.

get_zorder(overlay, key, el)#: Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)[source]#: Initializes the artist based on the plot method declared on the plot.

initialize_plot(*args, **kwargs)#: Initialize the matplotlib figure.

matches(spec)#: Matches a specification against the current Plot.

push()#: Pushes plot updates to the frontend.

refresh(**kwargs)#: Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

set_root(root)#: Sets the root model on all subplots.

property state#: The plotting state that gets updated via the update method and used by the renderer to generate output.

teardown_handles()#: If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)#: Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)#: Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_frame(*args, **kwargs)#

Set the plot(s) to the given frame number. Operates by manipulating the matplotlib objects held in the self._handles dictionary.

If n is greater than the number of available frames, update using the last available frame.

update_handles(key, axis, element, ranges, style)[source]#: Update the elements of the plot.

class holoviews.plotting.mpl.path.PolygonPlot(*args, **kwargs)[source]#

Bases: holoviews.plotting.mpl.path.ContourPlot

PolygonPlot draws the polygon paths in the supplied Polygons object. If the Polygon has an associated value the color of Polygons will be drawn from the supplied cmap, otherwise the supplied facecolor will apply. Facecolor also determines the color for non-finite values.

Parameters inherited from:

show_legend = param.Boolean(bounds=(0, 1), default=False, label=’Show legend’): Whether to show legend for the plot.

anim(start=0, stop=None, fps=30)#: Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()#: Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)#: Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

get_aspect(xspan, yspan)#: Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined', xdim=None, ydim=None, zdim=None)#

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

‘data’: Just the data ranges
‘extents’: Element.extents
‘soft’: Dimension.soft_range values
‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)#: Computes padding along the axes taking into account the plot aspect.

get_zorder(overlay, key, el)#: Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)#: Initializes the artist based on the plot method declared on the plot.

initialize_plot(*args, **kwargs)#: Initialize the matplotlib figure.

matches(spec)#: Matches a specification against the current Plot.

push()#: Pushes plot updates to the frontend.

refresh(**kwargs)#: Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

set_root(root)#: Sets the root model on all subplots.

property state#: The plotting state that gets updated via the update method and used by the renderer to generate output.

teardown_handles()#: If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)#: Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)#: Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_frame(*args, **kwargs)#

Set the plot(s) to the given frame number. Operates by manipulating the matplotlib objects held in the self._handles dictionary.

If n is greater than the number of available frames, update using the last available frame.

update_handles(key, axis, element, ranges, style)#: Update the elements of the plot.

`plot` Module#

Inheritance diagram of holoviews.plotting.mpl.plot

class holoviews.plotting.mpl.plot.AdjoinedPlot(keys=None, dimensions=None, layout_dimensions=None, uniform=True, subplot=False, adjoined=None, layout_num=0, style=None, subplots=None, dynamic=False, **params)[source]#

Bases: holoviews.plotting.plot.DimensionedPlot

Parameters inherited from:

show_title = param.Boolean(bounds=(0, 1), default=False, label=’Show title’): Titles should be disabled on all SidePlots to avoid clutter.
aspect = param.Parameter(default=’auto’, label=’Aspect’): Aspect ratios on SideHistogramPlot should be determined by the AdjointLayoutPlot.
bgcolor = param.Parameter(default=(1, 1, 1, 0), label=’Bgcolor’): Make plot background invisible.
border_size = param.Number(default=0.25, inclusive_bounds=(True, True), label=’Border size’): The size of the border expressed as a fraction of the main plot.
subplot_size = param.Number(default=0.25, inclusive_bounds=(True, True), label=’Subplot size’): The size subplots as expressed as a fraction of the main plot.
show_xlabel = param.Boolean(bounds=(0, 1), default=False, label=’Show xlabel’): Whether to show the x-label of the plot. Disabled by default because plots are often too cramped to fit the title correctly.

cleanup()#: Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)#: Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

initialize_plot(ranges=None)#: Initialize the matplotlib figure.

matches(spec)#: Matches a specification against the current Plot.

push()#: Pushes plot updates to the frontend.

refresh(**kwargs)#: Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

set_root(root)#: Sets the root model on all subplots.

property state#: The plotting state that gets updated via the update method and used by the renderer to generate output.

traverse(fn=None, specs=None, full_breadth=True)#: Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)#: Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

class holoviews.plotting.mpl.plot.AdjointLayoutPlot(layout, layout_type, subaxes, subplots, **params)[source]#

Bases: holoviews.plotting.mpl.plot.MPLPlot, holoviews.plotting.plot.GenericAdjointLayoutPlot

Initially, a AdjointLayoutPlot computes an appropriate layout based for the number of Views in the AdjointLayout object it has been given, but when embedded in a NdLayout, it can recompute the layout to match the number of rows and columns as part of a larger grid.

Parameters inherited from:

adjust_positions(redraw=True)[source]#

Make adjustments to the positions of subplots (if available) relative to the main plot axes as required.

This method is called by LayoutPlot after an initial pass used to position all the Layouts together. This method allows LayoutPlots to make final adjustments to the axis positions.

anim(start=0, stop=None, fps=30)#: Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()#: Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)#: Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

initialize_plot(*args, **kwargs)[source]#: Initialize the matplotlib figure.

matches(spec)#: Matches a specification against the current Plot.

push()#: Pushes plot updates to the frontend.

refresh(**kwargs)#: Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

set_root(root)#: Sets the root model on all subplots.

property state#: The plotting state that gets updated via the update method and used by the renderer to generate output.

traverse(fn=None, specs=None, full_breadth=True)#: Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)#: Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

class holoviews.plotting.mpl.plot.CompositePlot(layout, keys=None, dimensions=None, **params)[source]#

Bases: holoviews.plotting.plot.GenericCompositePlot, holoviews.plotting.mpl.plot.MPLPlot

CompositePlot provides a baseclass for plots coordinate multiple subplots to form a Layout.

Parameters inherited from:

shared_axes = param.Boolean(bounds=(0, 1), default=True, label=’Shared axes’): Whether axes ranges should be shared across the layout, if disabled switches axiswise normalization option on globally.

anim(start=0, stop=None, fps=30)#: Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()#: Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)#: Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

initialize_plot(ranges=None)#: Initialize the matplotlib figure.

matches(spec)#: Matches a specification against the current Plot.

push()#: Pushes plot updates to the frontend.

refresh(**kwargs)#: Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

set_root(root)#: Sets the root model on all subplots.

property state#: The plotting state that gets updated via the update method and used by the renderer to generate output.

traverse(fn=None, specs=None, full_breadth=True)#: Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)#: Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

class holoviews.plotting.mpl.plot.GridPlot(layout, axis=None, create_axes=True, ranges=None, layout_num=1, keys=None, **params)[source]#

Bases: holoviews.plotting.mpl.plot.CompositePlot

Plot a group of elements in a grid layout based on a GridSpace element object.

Parameters inherited from:

aspect = param.Parameter(default=’equal’, label=’Aspect’): Aspect ratios on GridPlot should be automatically determined.
padding = param.Number(default=0.1, inclusive_bounds=(True, True), label=’Padding’): The amount of padding as a fraction of the total Grid size
shared_xaxis = param.Boolean(bounds=(0, 1), default=False, label=’Shared xaxis’): If enabled the x-axes of the GridSpace will be drawn from the objects inside the Grid rather than the GridSpace dimensions.
shared_yaxis = param.Boolean(bounds=(0, 1), default=False, label=’Shared yaxis’): If enabled the x-axes of the GridSpace will be drawn from the objects inside the Grid rather than the GridSpace dimensions.
show_legend = param.Boolean(bounds=(0, 1), default=False, label=’Show legend’): Legends add to much clutter in a grid and are disabled by default.
xaxis = param.ObjectSelector(default=’bottom’, label=’Xaxis’, objects=[‘bottom’, ‘top’, None]): Whether and where to display the xaxis, supported options are ‘bottom’, ‘top’ and None.
yaxis = param.ObjectSelector(default=’left’, label=’Yaxis’, objects=[‘left’, ‘right’, None]): Whether and where to display the yaxis, supported options are ‘left’, ‘right’ and None.
xrotation = param.Integer(bounds=(0, 360), default=0, inclusive_bounds=(True, True), label=’Xrotation’): Rotation angle of the xticks.
yrotation = param.Integer(bounds=(0, 360), default=0, inclusive_bounds=(True, True), label=’Yrotation’): Rotation angle of the yticks.

anim(start=0, stop=None, fps=30)#: Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()#: Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)#: Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

initialize_plot(*args, **kwargs)[source]#: Initialize the matplotlib figure.

matches(spec)#: Matches a specification against the current Plot.

push()#: Pushes plot updates to the frontend.

refresh(**kwargs)#: Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

set_root(root)#: Sets the root model on all subplots.

property state#: The plotting state that gets updated via the update method and used by the renderer to generate output.

traverse(fn=None, specs=None, full_breadth=True)#: Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)#: Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

class holoviews.plotting.mpl.plot.LayoutPlot(layout, keys=None, **params)[source]#

Bases: holoviews.plotting.plot.GenericLayoutPlot, holoviews.plotting.mpl.plot.CompositePlot

A LayoutPlot accepts either a Layout or a NdLayout and displays the elements in a cartesian grid in scanline order.

Parameters inherited from:

fontsize = param.Parameter(allow_None=True, default={‘title’: 16}, label=’Fontsize’): Specifies various font sizes of the displayed text. Finer control is available by supplying a dictionary where any unmentioned keys revert to the default sizes, e.g: {‘ticks’:20, ‘title’:15, ‘ylabel’:5, ‘xlabel’:5, ‘zlabel’:5, ‘legend’:8, ‘legend_title’:13} You can set the font size of ‘zlabel’, ‘ylabel’ and ‘xlabel’ together using the ‘labels’ key.
fig_bounds = param.NumericTuple(default=(0.05, 0.05, 0.95, 0.95), label=’Fig bounds’, length=4): The bounds of the figure as a 4-tuple of the form (left, bottom, right, top), defining the size of the border around the subplots.
absolute_scaling = param.ObjectSelector(default=False, label=’Absolute scaling’, objects=[]): If aspect_weight is enabled absolute_scaling determines whe

holoviews.mpl Package#

mpl Package#

annotation Module#

chart Module#

chart3d Module#

element Module#

geometry Module#

graphs Module#

heatmap Module#

hex_tiles Module#

path Module#

plot Module#

`mpl` Package#

`annotation` Module#

`chart` Module#

`chart3d` Module#

`element` Module#

`geometry` Module#

`graphs` Module#

`heatmap` Module#

`hex_tiles` Module#

`path` Module#

`plot` Module#