# holoviews.operation Package¶

## operation Package¶

class holoviews.operation.image_overlay(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

Operation to build a overlay of images to a specification from a subset of the required elements.

This is useful for reordering the elements of an overlay, duplicating layers of an overlay or creating blank image elements in the appropriate positions.

For instance, image_overlay may build a three layered input suitable for the RGB factory operation even if supplied with one or two of the required channels (creating blank channels for the missing elements).

Note that if there is any ambiguity regarding the match, the strongest match will be used. In the case of a tie in match strength, the first layer in the input is used. One successful match is always required.

group = param.String(default=’Transform’)

The group assigned to the resulting overlay.

dynamic = param.ObjectSelector(default=’default’, objects=[‘default’, True, False])

Whether the operation should be applied dynamically when a specific frame is requested, specified as a Boolean. If set to ‘default’ the mode will be determined based on the input type, i.e. if the data is a DynamicMap it will stay dynamic.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=False)

If the operation is dynamic, whether or not linked streams should be transferred from the operation inputs for backends that support linked streams. For example if an operation is applied to a DynamicMap with an RangeXY, this switch determines whether the corresponding visualization should update this stream with range changes originating from the newly generated axes.

streams = param.List(bounds=(0, None), default=[])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

spec = param.String(default=’’)

Specification of the output Overlay structure. For instance: Image.R * Image.G * Image.B Will ensure an overlay of this structure is created even if (for instance) only (Image.R * Image.B) is supplied. Elements in the input overlay that match are placed in the appropriate positions and unavailable specification elements are created with the specified fill group.

fill = param.Number(default=0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

default_range = param.Tuple(default=(0, 1), length=2)

The default range that will be set on the value_dimension of any automatically created blank image elements.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.image_overlay'>)
classmethod get_overlay_bounds(overlay)

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.image_overlay'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.image_overlay'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.image_overlay'>)
instance = functools.partial(<function ParameterizedFunction.instance>, <class 'holoviews.operation.element.image_overlay'>)
message(**kwargs)

Inspect .param.message method for the full docstring

output_type
params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.image_overlay'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)

The process_element method allows a single element to be operated on given an externally supplied key.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.image_overlay'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.image_overlay'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.gradient(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

Compute the gradient plot of the supplied Image.

If the Image value dimension is cyclic, the smallest step is taken considered the cyclic range

group = param.String(default=’Gradient’)

The group assigned to the output gradient matrix.

dynamic = param.ObjectSelector(default=’default’, objects=[‘default’, True, False])

Whether the operation should be applied dynamically when a specific frame is requested, specified as a Boolean. If set to ‘default’ the mode will be determined based on the input type, i.e. if the data is a DynamicMap it will stay dynamic.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=False)

If the operation is dynamic, whether or not linked streams should be transferred from the operation inputs for backends that support linked streams. For example if an operation is applied to a DynamicMap with an RangeXY, this switch determines whether the corresponding visualization should update this stream with range changes originating from the newly generated axes.

streams = param.List(bounds=(0, None), default=[])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.gradient'>)
classmethod get_overlay_bounds(overlay)

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.gradient'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.gradient'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.gradient'>)
instance = functools.partial(<function ParameterizedFunction.instance>, <class 'holoviews.operation.element.gradient'>)
message(**kwargs)

Inspect .param.message method for the full docstring

output_type
params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.gradient'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)

The process_element method allows a single element to be operated on given an externally supplied key.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.gradient'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.gradient'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.contours(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

Given a Image with a single channel, annotate it with contour lines for a given set of contour levels.

The return is an NdOverlay with a Contours layer for each given level, overlaid on top of the input Image.

group = param.String(default=’Level’)

The group assigned to the output contours.

dynamic = param.ObjectSelector(default=’default’, objects=[‘default’, True, False])

Whether the operation should be applied dynamically when a specific frame is requested, specified as a Boolean. If set to ‘default’ the mode will be determined based on the input type, i.e. if the data is a DynamicMap it will stay dynamic.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=False)

If the operation is dynamic, whether or not linked streams should be transferred from the operation inputs for backends that support linked streams. For example if an operation is applied to a DynamicMap with an RangeXY, this switch determines whether the corresponding visualization should update this stream with range changes originating from the newly generated axes.

streams = param.List(bounds=(0, None), default=[])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

levels = param.ClassSelector(class_=(<class ‘list’>, <class ‘int’>), default=10)

A list of scalar values used to specify the contour levels.

filled = param.Boolean(bounds=(0, 1), default=False)

Whether to generate filled contours

overlaid = param.Boolean(bounds=(0, 1), default=False)

Whether to overlay the contour on the supplied Element.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.contours'>)
classmethod get_overlay_bounds(overlay)

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.contours'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.contours'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.contours'>)
instance = functools.partial(<function ParameterizedFunction.instance>, <class 'holoviews.operation.element.contours'>)
message(**kwargs)

Inspect .param.message method for the full docstring

output_type
params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.contours'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)

The process_element method allows a single element to be operated on given an externally supplied key.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.contours'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.contours'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.convolve(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

Apply a convolution to an overlay using the top layer as the kernel for convolving the bottom layer. Both Image elements in the input overlay should have a single value dimension.

group = param.String(default=’Convolution’)

The group assigned to the convolved output.

dynamic = param.ObjectSelector(default=’default’, objects=[‘default’, True, False])

Whether the operation should be applied dynamically when a specific frame is requested, specified as a Boolean. If set to ‘default’ the mode will be determined based on the input type, i.e. if the data is a DynamicMap it will stay dynamic.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=False)

If the operation is dynamic, whether or not linked streams should be transferred from the operation inputs for backends that support linked streams. For example if an operation is applied to a DynamicMap with an RangeXY, this switch determines whether the corresponding visualization should update this stream with range changes originating from the newly generated axes.

streams = param.List(bounds=(0, None), default=[])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

kernel_roi = param.NumericTuple(default=(0, 0, 0, 0), length=4)

A 2-dimensional slice of the kernel layer to use in the convolution in lbrt (left, bottom, right, top) format. By default, no slicing is applied.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.convolve'>)
classmethod get_overlay_bounds(overlay)

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.convolve'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.convolve'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.convolve'>)
instance = functools.partial(<function ParameterizedFunction.instance>, <class 'holoviews.operation.element.convolve'>)
message(**kwargs)

Inspect .param.message method for the full docstring

output_type
params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.convolve'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)

The process_element method allows a single element to be operated on given an externally supplied key.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.convolve'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.convolve'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.operation(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

The most generic operation that wraps any callable into an Operation. The callable needs to accept an HoloViews component and a key (that may be ignored) and must return a new HoloViews component.

This class may be useful for turning a HoloViews method into an operation to define as compositor operation. For instance, the following definition:

operation.instance(op=lambda x, k: x.collapse(np.subtract))

Could be used to implement a collapse operation to subtracts the data between Rasters in an Overlay.

group = param.String(default=’Operation’)

The group assigned to the result after having applied the operator.

dynamic = param.ObjectSelector(default=’default’, objects=[‘default’, True, False])

Whether the operation should be applied dynamically when a specific frame is requested, specified as a Boolean. If set to ‘default’ the mode will be determined based on the input type, i.e. if the data is a DynamicMap it will stay dynamic.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=False)

If the operation is dynamic, whether or not linked streams should be transferred from the operation inputs for backends that support linked streams. For example if an operation is applied to a DynamicMap with an RangeXY, this switch determines whether the corresponding visualization should update this stream with range changes originating from the newly generated axes.

streams = param.List(bounds=(0, None), default=[])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

output_type = param.Parameter()

The output element type which may be None to disable type checking. May be used to declare useful information to other code in HoloViews e.g required for tab-completion support of operations registered with compositors.

op = param.Callable()

The operation used to generate a new HoloViews object returned by the operation. By default, the identity operation is applied.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.operation'>)
classmethod get_overlay_bounds(overlay)

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.operation'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.operation'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.operation'>)
instance = functools.partial(<function ParameterizedFunction.instance>, <class 'holoviews.operation.element.operation'>)
message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.operation'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)

The process_element method allows a single element to be operated on given an externally supplied key.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.operation'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.operation'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.factory(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

Simple operation that constructs any element that accepts some other element as input. For instance, RGB and HSV elements can be created from overlays of Image elements.

group = param.String(default=’Operation’)

The group string used to identify the output of the Operation. By default this should match the operation name.

dynamic = param.ObjectSelector(default=’default’, objects=[‘default’, True, False])

Whether the operation should be applied dynamically when a specific frame is requested, specified as a Boolean. If set to ‘default’ the mode will be determined based on the input type, i.e. if the data is a DynamicMap it will stay dynamic.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=False)

If the operation is dynamic, whether or not linked streams should be transferred from the operation inputs for backends that support linked streams. For example if an operation is applied to a DynamicMap with an RangeXY, this switch determines whether the corresponding visualization should update this stream with range changes originating from the newly generated axes.

streams = param.List(bounds=(0, None), default=[])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

output_type = param.Parameter(default=<class ‘holoviews.element.raster.RGB’>)

The output type of the factor operation. By default, if three overlaid Images elements are supplied, the corresponding RGB element will be returned.

args = param.List(bounds=(0, None), default=[])

The list of positional argument to pass to the factory

kwargs = param.Dict(class_=<class ‘dict’>, default={})

The dict of keyword arguments to pass to the factory

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.factory'>)
classmethod get_overlay_bounds(overlay)

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.factory'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.factory'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.factory'>)
instance = functools.partial(<function ParameterizedFunction.instance>, <class 'holoviews.operation.element.factory'>)
message(**kwargs)

Inspect .param.message method for the full docstring

output_type
params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.factory'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)

The process_element method allows a single element to be operated on given an externally supplied key.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.factory'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.factory'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.interpolate_curve(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

Resamples a Curve using the defined interpolation method, e.g. to represent changes in y-values as steps.

group = param.String(default=’Operation’)

The group string used to identify the output of the Operation. By default this should match the operation name.

dynamic = param.ObjectSelector(default=’default’, objects=[‘default’, True, False])

Whether the operation should be applied dynamically when a specific frame is requested, specified as a Boolean. If set to ‘default’ the mode will be determined based on the input type, i.e. if the data is a DynamicMap it will stay dynamic.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=False)

If the operation is dynamic, whether or not linked streams should be transferred from the operation inputs for backends that support linked streams. For example if an operation is applied to a DynamicMap with an RangeXY, this switch determines whether the corresponding visualization should update this stream with range changes originating from the newly generated axes.

streams = param.List(bounds=(0, None), default=[])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

interpolation = param.ObjectSelector(default=’steps-mid’, objects=[‘steps-pre’, ‘steps-mid’, ‘steps-post’, ‘linear’])

Controls the transition point of the step along the x-axis.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.interpolate_curve'>)
classmethod get_overlay_bounds(overlay)

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.interpolate_curve'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.interpolate_curve'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.interpolate_curve'>)
instance = functools.partial(<function ParameterizedFunction.instance>, <class 'holoviews.operation.element.interpolate_curve'>)
message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.interpolate_curve'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)

The process_element method allows a single element to be operated on given an externally supplied key.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.interpolate_curve'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.interpolate_curve'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.Operation(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

Bases: param.parameterized.ParameterizedFunction

An Operation process an Element or HoloMap at the level of individual elements or overlays. If a holomap is passed in as input, a processed holomap is returned as output where the individual elements have been transformed accordingly. An Operation may turn overlays in new elements or vice versa.

An Operation can be set to be dynamic, which will return a DynamicMap with a callback that will apply the operation dynamically. An Operation may also supply a list of Stream classes on a streams parameter, which can allow dynamic control over the parameters on the operation.

group = param.String(default=’Operation’)

The group string used to identify the output of the Operation. By default this should match the operation name.

dynamic = param.ObjectSelector(default=’default’, objects=[‘default’, True, False])

Whether the operation should be applied dynamically when a specific frame is requested, specified as a Boolean. If set to ‘default’ the mode will be determined based on the input type, i.e. if the data is a DynamicMap it will stay dynamic.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=False)

If the operation is dynamic, whether or not linked streams should be transferred from the operation inputs for backends that support linked streams. For example if an operation is applied to a DynamicMap with an RangeXY, this switch determines whether the corresponding visualization should update this stream with range changes originating from the newly generated axes.

streams = param.List(bounds=(0, None), default=[])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.core.operation.Operation'>)
classmethod get_overlay_bounds(overlay)[source]

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')[source]

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.core.operation.Operation'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.core.operation.Operation'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.core.operation.Operation'>)
instance = functools.partial(<function ParameterizedFunction.instance>, <class 'holoviews.core.operation.Operation'>)
message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.core.operation.Operation'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)[source]

The process_element method allows a single element to be operated on given an externally supplied key.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)[source]

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.core.operation.Operation'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.core.operation.Operation'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.chain(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

Defining an Operation chain is an easy way to define a new Operation from a series of existing ones. The argument is a list of Operation (or Operation instances) that are called in sequence to generate the returned element.

This operation can accept an Image instance and would first compute the gradient before thresholding the result at a level of 2.0.

Instances are only required when arguments need to be passed to individual operations so the resulting object is a function over a single argument.

group = param.String(default=’’)

The group assigned to the result after having applied the chain. Defaults to the group produced by the last operation in the chain

dynamic = param.ObjectSelector(default=’default’, objects=[‘default’, True, False])

Whether the operation should be applied dynamically when a specific frame is requested, specified as a Boolean. If set to ‘default’ the mode will be determined based on the input type, i.e. if the data is a DynamicMap it will stay dynamic.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=False)

If the operation is dynamic, whether or not linked streams should be transferred from the operation inputs for backends that support linked streams. For example if an operation is applied to a DynamicMap with an RangeXY, this switch determines whether the corresponding visualization should update this stream with range changes originating from the newly generated axes.

streams = param.List(bounds=(0, None), default=[])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

output_type = param.Parameter(default=<class ‘holoviews.element.raster.Image’>)

The output type of the chain operation. Must be supplied if the chain is to be used as a channel operation.

operations = param.List(bounds=(0, None), class_=<class ‘holoviews.core.operation.Operation’>, default=[])

A list of Operations (or Operation instances) that are applied on the input from left to right..

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.chain'>)
classmethod get_overlay_bounds(overlay)

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.chain'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.chain'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.chain'>)
instance = functools.partial(<function ParameterizedFunction.instance>, <class 'holoviews.operation.element.chain'>)
message(**kwargs)

Inspect .param.message method for the full docstring

output_type
params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.chain'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)

The process_element method allows a single element to be operated on given an externally supplied key.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.chain'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.chain'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.collapse(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

Given an overlay of Element types, collapse into single Element object using supplied function. Collapsing aggregates over the key dimensions of each object applying the supplied fn to each group.

This is an example of an Operation that does not involve any Raster types.

group = param.String(default=’Operation’)

The group string used to identify the output of the Operation. By default this should match the operation name.

dynamic = param.ObjectSelector(default=’default’, objects=[‘default’, True, False])

Whether the operation should be applied dynamically when a specific frame is requested, specified as a Boolean. If set to ‘default’ the mode will be determined based on the input type, i.e. if the data is a DynamicMap it will stay dynamic.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=False)

If the operation is dynamic, whether or not linked streams should be transferred from the operation inputs for backends that support linked streams. For example if an operation is applied to a DynamicMap with an RangeXY, this switch determines whether the corresponding visualization should update this stream with range changes originating from the newly generated axes.

streams = param.List(bounds=(0, None), default=[])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

fn = param.Callable()

The function that is used to collapse the curve y-values for each x-value.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

fn(axis=None, dtype=None, out=None, keepdims=<no value>)

Compute the arithmetic mean along the specified axis.

Returns the average of the array elements. The average is taken over the flattened array by default, otherwise over the specified axis. float64 intermediate and return values are used for integer inputs.

aarray_like

Array containing numbers whose mean is desired. If a is not an array, a conversion is attempted.

axisNone or int or tuple of ints, optional

Axis or axes along which the means are computed. The default is to compute the mean of the flattened array.

New in version 1.7.0.

If this is a tuple of ints, a mean is performed over multiple axes, instead of a single axis or all the axes as before.

dtypedata-type, optional

Type to use in computing the mean. For integer inputs, the default is float64; for floating point inputs, it is the same as the input dtype.

outndarray, optional

Alternate output array in which to place the result. The default is None; if provided, it must have the same shape as the expected output, but the type will be cast if necessary. See ufuncs-output-type for more details.

keepdimsbool, optional

If this is set to True, the axes which are reduced are left in the result as dimensions with size one. With this option, the result will broadcast correctly against the input array.

If the default value is passed, then keepdims will not be passed through to the mean method of sub-classes of ndarray, however any non-default value will be. If the sub-class’ method does not implement keepdims any exceptions will be raised.

mndarray, see dtype parameter above

If out=None, returns a new array containing the mean values, otherwise a reference to the output array is returned.

average : Weighted average std, var, nanmean, nanstd, nanvar

The arithmetic mean is the sum of the elements along the axis divided by the number of elements.

Note that for floating-point input, the mean is computed using the same precision the input has. Depending on the input data, this can cause the results to be inaccurate, especially for float32 (see example below). Specifying a higher-precision accumulator using the dtype keyword can alleviate this issue.

By default, float16 results are computed using float32 intermediates for extra precision.

>>> a = np.array([[1, 2], [3, 4]])
>>> np.mean(a)
2.5
>>> np.mean(a, axis=0)
array([2., 3.])
>>> np.mean(a, axis=1)
array([1.5, 3.5])


In single precision, mean can be inaccurate:

>>> a = np.zeros((2, 512*512), dtype=np.float32)
>>> a[0, :] = 1.0
>>> a[1, :] = 0.1
>>> np.mean(a)
0.54999924


Computing the mean in float64 is more accurate:

>>> np.mean(a, dtype=np.float64)
0.55000000074505806 # may vary

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.collapse'>)
classmethod get_overlay_bounds(overlay)

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.collapse'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.collapse'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.collapse'>)
instance = functools.partial(<function ParameterizedFunction.instance>, <class 'holoviews.operation.element.collapse'>)
message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.collapse'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)

The process_element method allows a single element to be operated on given an externally supplied key.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.collapse'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.collapse'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.function(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]
group = param.String(default=’Operation’)

The group string used to identify the output of the Operation. By default this should match the operation name.

dynamic = param.ObjectSelector(default=’default’, objects=[‘default’, True, False])

Whether the operation should be applied dynamically when a specific frame is requested, specified as a Boolean. If set to ‘default’ the mode will be determined based on the input type, i.e. if the data is a DynamicMap it will stay dynamic.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=False)

If the operation is dynamic, whether or not linked streams should be transferred from the operation inputs for backends that support linked streams. For example if an operation is applied to a DynamicMap with an RangeXY, this switch determines whether the corresponding visualization should update this stream with range changes originating from the newly generated axes.

streams = param.List(bounds=(0, None), default=[])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

output_type = param.ClassSelector(class_=<class ‘type’>)

The output type of the method operation

input_type = param.ClassSelector(class_=<class ‘type’>)

The object type the method is defined on

fn = param.Callable()

The function to apply.

args = param.List(bounds=(0, None), default=[])

The list of positional argument to pass to the method

kwargs = param.Dict(class_=<class ‘dict’>, default={})

The dict of keyword arguments to pass to the method

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.function'>)
classmethod get_overlay_bounds(overlay)

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.function'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.function'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.function'>)
instance = functools.partial(<function ParameterizedFunction.instance>, <class 'holoviews.operation.element.function'>)
message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.function'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)

The process_element method allows a single element to be operated on given an externally supplied key.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.function'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.function'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.transform(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

Generic Operation to transform an input Image or RGBA element into an output Image. The transformation is defined by the supplied callable that accepts the data of the input Image (typically a numpy array) and returns the transformed data of the output Image.

This operator is extremely versatile; for instance, you could implement an alternative to the explicit threshold operator with:

operator=lambda x: np.clip(x, 0, 0.5)

Alternatively, you can implement a transform computing the 2D autocorrelation using the scipy library with:

operator=lambda x: scipy.signal.correlate2d(x, x)

group = param.String(default=’Transform’)

The group assigned to the result after applying the transform.

dynamic = param.ObjectSelector(default=’default’, objects=[‘default’, True, False])

Whether the operation should be applied dynamically when a specific frame is requested, specified as a Boolean. If set to ‘default’ the mode will be determined based on the input type, i.e. if the data is a DynamicMap it will stay dynamic.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=False)

If the operation is dynamic, whether or not linked streams should be transferred from the operation inputs for backends that support linked streams. For example if an operation is applied to a DynamicMap with an RangeXY, this switch determines whether the corresponding visualization should update this stream with range changes originating from the newly generated axes.

streams = param.List(bounds=(0, None), default=[])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

operator = param.Callable()

Function of one argument that transforms the data in the input Image to the data in the output Image. By default, acts as the identity function such that the output matches the input.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.transform'>)
classmethod get_overlay_bounds(overlay)

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.transform'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.transform'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.transform'>)
instance = functools.partial(<function ParameterizedFunction.instance>, <class 'holoviews.operation.element.transform'>)
message(**kwargs)

Inspect .param.message method for the full docstring

output_type
params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.transform'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)

The process_element method allows a single element to be operated on given an externally supplied key.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.transform'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.transform'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.categorical_aggregate2d(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

Generates a gridded Dataset of 2D aggregate arrays indexed by the first two dimensions of the passed Element, turning all remaining dimensions into value dimensions. The key dimensions of the gridded array are treated as categorical indices. Useful for data indexed by two independent categorical variables such as a table of population values indexed by country and year. Data that is indexed by continuous dimensions should be binned before aggregation. The aggregation will retain the global sorting order of both dimensions.

>> table = Table([(‘USA’, 2000, 282.2), (‘UK’, 2005, 58.89)],

kdims=[‘Country’, ‘Year’], vdims=[‘Population’])

>> categorical_aggregate2d(table) Dataset({‘Country’: [‘USA’, ‘UK’], ‘Year’: [2000, 2005],

‘Population’: [[ 282.2 , np.NaN], [np.NaN, 58.89]]},

kdims=[‘Country’, ‘Year’], vdims=[‘Population’])

group = param.String(default=’Operation’)

The group string used to identify the output of the Operation. By default this should match the operation name.

dynamic = param.ObjectSelector(default=’default’, objects=[‘default’, True, False])

Whether the operation should be applied dynamically when a specific frame is requested, specified as a Boolean. If set to ‘default’ the mode will be determined based on the input type, i.e. if the data is a DynamicMap it will stay dynamic.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=False)

If the operation is dynamic, whether or not linked streams should be transferred from the operation inputs for backends that support linked streams. For example if an operation is applied to a DynamicMap with an RangeXY, this switch determines whether the corresponding visualization should update this stream with range changes originating from the newly generated axes.

streams = param.List(bounds=(0, None), default=[])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

datatype = param.List(bounds=(0, None), default=[‘xarray’, ‘grid’])

The grid interface types to use when constructing the gridded Dataset.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.element.util.categorical_aggregate2d'>)
classmethod get_overlay_bounds(overlay)

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.element.util.categorical_aggregate2d'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.element.util.categorical_aggregate2d'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.element.util.categorical_aggregate2d'>)
instance = functools.partial(<function ParameterizedFunction.instance>, <class 'holoviews.element.util.categorical_aggregate2d'>)
message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.element.util.categorical_aggregate2d'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)

The process_element method allows a single element to be operated on given an externally supplied key.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.element.util.categorical_aggregate2d'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.element.util.categorical_aggregate2d'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.histogram(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

Returns a Histogram of the input element data, binned into num_bins over the bin_range (if specified) along the specified dimension.

group = param.String(default=’Operation’)

The group string used to identify the output of the Operation. By default this should match the operation name.

dynamic = param.ObjectSelector(default=’default’, objects=[‘default’, True, False])

Whether the operation should be applied dynamically when a specific frame is requested, specified as a Boolean. If set to ‘default’ the mode will be determined based on the input type, i.e. if the data is a DynamicMap it will stay dynamic.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=False)

If the operation is dynamic, whether or not linked streams should be transferred from the operation inputs for backends that support linked streams. For example if an operation is applied to a DynamicMap with an RangeXY, this switch determines whether the corresponding visualization should update this stream with range changes originating from the newly generated axes.

streams = param.List(bounds=(0, None), default=[])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

bin_range = param.NumericTuple(length=2)

Specifies the range within which to compute the bins.

bins = param.ClassSelector(class_=(<class ‘numpy.ndarray’>, <class ‘list’>, <class ‘tuple’>))

An explicit set of bin edges.

cumulative = param.Boolean(bounds=(0, 1), default=False)

Whether to compute the cumulative histogram

dimension = param.String()

Along which dimension of the Element to compute the histogram.

frequency_label = param.String()

Format string defining the label of the frequency dimension of the Histogram.

groupby = param.ClassSelector(class_=(<class ‘str’>, <class ‘holoviews.core.dimension.Dimension’>))

Defines a dimension to group the Histogram returning an NdOverlay of Histograms.

log = param.Boolean(bounds=(0, 1), default=False)

Whether to use base 10 logarithmic samples for the bin edges.

mean_weighted = param.Boolean(bounds=(0, 1), default=False)

Whether the weighted frequencies are averaged.

normed = param.ObjectSelector(default=True, objects=[True, False, ‘integral’, ‘height’])

Controls normalization behavior. If True or ‘integral’, then density=True is passed to np.histogram, and the distribution is normalized such that the integral is unity. If False, then the frequencies will be raw counts. If ‘height’, then the frequencies are normalized such that the max bin height is unity.

nonzero = param.Boolean(bounds=(0, 1), default=False)

Whether to use only nonzero values when computing the histogram

num_bins = param.Integer(default=20, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Number of bins in the histogram .

weight_dimension = param.String()

Name of the dimension the weighting should be drawn from

style_prefix = param.String()

Used for setting a common style for histograms in a HoloMap or AdjointLayout.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.histogram'>)
classmethod get_overlay_bounds(overlay)

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.histogram'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.histogram'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.histogram'>)
instance = functools.partial(<function ParameterizedFunction.instance>, <class 'holoviews.operation.element.histogram'>)
message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.histogram'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)

The process_element method allows a single element to be operated on given an externally supplied key.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.histogram'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.histogram'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.decimate(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

Decimates any column based Element to a specified number of random rows if the current element defined by the x_range and y_range contains more than max_samples. By default the operation returns a DynamicMap with a RangeXY stream allowing dynamic downsampling.

group = param.String(default=’Operation’)

The group string used to identify the output of the Operation. By default this should match the operation name.

dynamic = param.Boolean(bounds=(0, 1), default=True)

Enables dynamic processing by default.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=True)

By default, the link_inputs parameter is set to True so that when applying shade, backends that support linked streams update RangeXY streams on the inputs of the shade operation.

streams = param.List(bounds=(0, None), default=[<class ‘holoviews.streams.RangeXY’>])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

max_samples = param.Integer(default=5000, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Maximum number of samples to display at the same time.

random_seed = param.Integer(default=42, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Seed used to initialize randomization.

x_range = param.NumericTuple(length=2)

The x_range as a tuple of min and max x-value. Auto-ranges if set to None.

y_range = param.NumericTuple(length=2)

The x_range as a tuple of min and max y-value. Auto-ranges if set to None.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.decimate'>)
classmethod get_overlay_bounds(overlay)

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.decimate'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.decimate'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.decimate'>)
instance = functools.partial(<function ParameterizedFunction.instance>, <class 'holoviews.operation.element.decimate'>)
message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.decimate'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)

The process_element method allows a single element to be operated on given an externally supplied key.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.decimate'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.decimate'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.method(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

Operation that wraps a method call

group = param.String(default=’Operation’)

The group string used to identify the output of the Operation. By default this should match the operation name.

dynamic = param.ObjectSelector(default=’default’, objects=[‘default’, True, False])

Whether the operation should be applied dynamically when a specific frame is requested, specified as a Boolean. If set to ‘default’ the mode will be determined based on the input type, i.e. if the data is a DynamicMap it will stay dynamic.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=False)

If the operation is dynamic, whether or not linked streams should be transferred from the operation inputs for backends that support linked streams. For example if an operation is applied to a DynamicMap with an RangeXY, this switch determines whether the corresponding visualization should update this stream with range changes originating from the newly generated axes.

streams = param.List(bounds=(0, None), default=[])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

output_type = param.ClassSelector(class_=<class ‘type’>)

The output type of the method operation

input_type = param.ClassSelector(class_=<class ‘type’>)

The object type the method is defined on

method_name = param.String(default=’__call__’)

The method name

args = param.List(bounds=(0, None), default=[])

The list of positional argument to pass to the method

kwargs = param.Dict(class_=<class ‘dict’>, default={})

The dict of keyword arguments to pass to the method

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.method'>)
classmethod get_overlay_bounds(overlay)

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.method'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.method'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.method'>)
instance = functools.partial(<function ParameterizedFunction.instance>, <class 'holoviews.operation.element.method'>)
message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.method'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)

The process_element method allows a single element to be operated on given an externally supplied key.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.method'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.method'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.threshold(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

Threshold a given Image whereby all values higher than a given level map to the specified high value and all values lower than that level map to the specified low value.

group = param.String(default=’Threshold’)

The group assigned to the thresholded output.

dynamic = param.ObjectSelector(default=’default’, objects=[‘default’, True, False])

Whether the operation should be applied dynamically when a specific frame is requested, specified as a Boolean. If set to ‘default’ the mode will be determined based on the input type, i.e. if the data is a DynamicMap it will stay dynamic.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=False)

If the operation is dynamic, whether or not linked streams should be transferred from the operation inputs for backends that support linked streams. For example if an operation is applied to a DynamicMap with an RangeXY, this switch determines whether the corresponding visualization should update this stream with range changes originating from the newly generated axes.

streams = param.List(bounds=(0, None), default=[])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

level = param.Number(default=0.5, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

The value at which the threshold is applied. Values lower than the threshold map to the ‘low’ value and values above map to the ‘high’ value.

high = param.Number(default=1.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

The value given to elements greater than (or equal to) the threshold.

low = param.Number(default=0.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

The value given to elements below the threshold.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.threshold'>)
classmethod get_overlay_bounds(overlay)

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.threshold'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.threshold'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.threshold'>)
instance = functools.partial(<function ParameterizedFunction.instance>, <class 'holoviews.operation.element.threshold'>)
message(**kwargs)

Inspect .param.message method for the full docstring

output_type
params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.threshold'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)

The process_element method allows a single element to be operated on given an externally supplied key.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.threshold'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.threshold'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.Compositor(pattern, operation, group, mode, transfer_options=False, transfer_parameters=False, output_type=None, backends=None, **kwargs)[source]

Bases: param.parameterized.Parameterized

A Compositor is a way of specifying an operation to be automatically applied to Overlays that match a specified pattern upon display.

Any Operation that takes an Overlay as input may be used to define a compositor.

For instance, a compositor may be defined to automatically display three overlaid monochrome matrices as an RGB image as long as the values names of those matrices match ‘R’, ‘G’ and ‘B’.

mode = param.ObjectSelector(default=’data’, objects=[‘data’, ‘display’])

The mode of the Compositor object which may be either ‘data’ or ‘display’.

backends = param.List(bounds=(0, None), default=[])

Defines which backends to apply the Compositor for.

operation = param.Parameter()

The Operation to apply when collapsing overlays.

pattern = param.String(default=’’)

The overlay pattern to be processed. An overlay pattern is a sequence of elements specified by dotted paths separated by * . For instance the following pattern specifies three overlayed matrices with values of ‘RedChannel’, ‘GreenChannel’ and ‘BlueChannel’ respectively: ‘Image.RedChannel * Image.GreenChannel * Image.BlueChannel. This pattern specification could then be associated with the RGB operation that returns a single RGB matrix for display.

group = param.String(default=’’)

The group identifier for the output of this particular compositor

kwargs = param.Dict(class_=<class ‘dict’>)

Optional set of parameters to pass to the operation.

transfer_options = param.Boolean(bounds=(0, 1), default=False)

Whether to transfer the options from the input to the output.

transfer_parameters = param.Boolean(bounds=(0, 1), default=False)

Whether to transfer plot options which match to the operation.

apply(value, input_ranges, backend=None)[source]

Apply the compositor on the input with the given input ranges.

classmethod collapse(holomap, ranges=None, mode='data')[source]

Given a map of Overlays, apply all applicable compositors.

classmethod collapse_element(overlay, ranges=None, mode='data', backend=None)[source]

Finds any applicable compositor and applies it.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.core.options.Compositor'>)
get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.core.options.Compositor'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.core.options.Compositor'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.core.options.Compositor'>)
classmethod map(obj, mode='data', backend=None)[source]

Applies compositor operations to any HoloViews element or container using the map method.

match_level(overlay)[source]

Given an overlay, return the match level and applicable slice of the overall overlay. The level an integer if there is a match or None if there is no match.

The level integer is the number of matching components. Higher values indicate a stronger match.

message(**kwargs)

Inspect .param.message method for the full docstring

property output_type

Returns the operation output_type unless explicitly overridden in the kwargs.

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.core.options.Compositor'>)
pprint(imports=None, prefix=' ', unknown_value='<?>', qualify=False, separator='')

(Experimental) Pretty printed representation that may be evaluated with eval. See pprint() function for more details.

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

script_repr(imports=[], prefix=' ')

Variant of __repr__ designed for generating a runnable script.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.core.options.Compositor'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.core.options.Compositor'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

classmethod strongest_match(overlay, mode, backend=None)[source]

Returns the single strongest matching compositor operation given an overlay. If no matches are found, None is returned.

The best match is defined as the compositor operation with the highest match value as returned by the match_level method.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

## datashader Module¶

class holoviews.operation.datashader.AggregationOperation(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

AggregationOperation extends the ResamplingOperation defining an aggregator parameter used to define a datashader Reduction.

group = param.String(default=’Operation’)

The group string used to identify the output of the Operation. By default this should match the operation name.

dynamic = param.Boolean(bounds=(0, 1), default=True)

Enables dynamic processing by default.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=True)

By default, the link_inputs parameter is set to True so that when applying an operation, backends that support linked streams update RangeXY streams on the inputs of the operation. Disable when you do not want the resulting plot to be interactive, e.g. when trying to display an interactive plot a second time.

streams = param.List(bounds=(0, None), default=[<class ‘holoviews.streams.PlotSize’>, <class ‘holoviews.streams.RangeXY’>])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

expand = param.Boolean(bounds=(0, 1), default=True)

Whether the x_range and y_range should be allowed to expand beyond the extent of the data. Setting this value to True is useful for the case where you want to ensure a certain size of output grid, e.g. if you are doing masking or other arithmetic on the grids. A value of False ensures that the grid is only just as large as it needs to be to contain the data, which will be faster and use less memory if the resulting aggregate is being overlaid on a much larger background.

height = param.Integer(default=400, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

The height of the output image in pixels.

width = param.Integer(default=400, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

The width of the output image in pixels.

x_range = param.Tuple(length=2)

The x_range as a tuple of min and max x-value. Auto-ranges if set to None.

y_range = param.Tuple(length=2)

The y-axis range as a tuple of min and max y value. Auto-ranges if set to None.

x_sampling = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Specifies the smallest allowed sampling interval along the x axis.

y_sampling = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Specifies the smallest allowed sampling interval along the y axis.

target = param.ClassSelector(class_=<class ‘holoviews.core.data.Dataset’>)

A target Dataset which defines the desired x_range, y_range, width and height.

element_type = param.ClassSelector(class_=(<class ‘holoviews.core.data.Dataset’>,), default=<class ‘holoviews.element.raster.Image’>)

The type of the returned Elements, must be a 2D Dataset type.

precompute = param.Boolean(bounds=(0, 1), default=False)

Whether to apply precomputing operations. Precomputing can speed up resampling operations by avoiding unnecessary recomputation if the supplied element does not change between calls. The cost of enabling this option is that the memory used to represent this internal state is not freed between calls.

aggregator = param.ClassSelector(class_=(<class ‘datashader.reductions.Reduction’>, <class ‘str’>), default=<datashader.reductions.count object at 0x7ff9072ff0d0>)

Datashader reduction function used for aggregating the data. The aggregator may also define a column to aggregate; if no column is defined the first value dimension of the element will be used. May also be defined as a string.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

element_type
force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.AggregationOperation'>)
classmethod get_overlay_bounds(overlay)

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.AggregationOperation'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.AggregationOperation'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.AggregationOperation'>)
message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.AggregationOperation'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)

The process_element method allows a single element to be operated on given an externally supplied key.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.AggregationOperation'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.AggregationOperation'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.datashader.LinkableOperation(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

Abstract baseclass for operations supporting linked inputs.

group = param.String(default=’Operation’)

The group string used to identify the output of the Operation. By default this should match the operation name.

dynamic = param.ObjectSelector(default=’default’, objects=[‘default’, True, False])

Whether the operation should be applied dynamically when a specific frame is requested, specified as a Boolean. If set to ‘default’ the mode will be determined based on the input type, i.e. if the data is a DynamicMap it will stay dynamic.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=True)

By default, the link_inputs parameter is set to True so that when applying an operation, backends that support linked streams update RangeXY streams on the inputs of the operation. Disable when you do not want the resulting plot to be interactive, e.g. when trying to display an interactive plot a second time.

streams = param.List(bounds=(0, None), default=[])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.LinkableOperation'>)
classmethod get_overlay_bounds(overlay)

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.LinkableOperation'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.LinkableOperation'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.LinkableOperation'>)
instance = functools.partial(<function ParameterizedFunction.instance>, <class 'holoviews.operation.datashader.LinkableOperation'>)
message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.LinkableOperation'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)

The process_element method allows a single element to be operated on given an externally supplied key.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.LinkableOperation'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.LinkableOperation'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.datashader.ResamplingOperation(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

Abstract baseclass for resampling operations

group = param.String(default=’Operation’)

The group string used to identify the output of the Operation. By default this should match the operation name.

dynamic = param.Boolean(bounds=(0, 1), default=True)

Enables dynamic processing by default.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=True)

By default, the link_inputs parameter is set to True so that when applying an operation, backends that support linked streams update RangeXY streams on the inputs of the operation. Disable when you do not want the resulting plot to be interactive, e.g. when trying to display an interactive plot a second time.

streams = param.List(bounds=(0, None), default=[<class ‘holoviews.streams.PlotSize’>, <class ‘holoviews.streams.RangeXY’>])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

expand = param.Boolean(bounds=(0, 1), default=True)

Whether the x_range and y_range should be allowed to expand beyond the extent of the data. Setting this value to True is useful for the case where you want to ensure a certain size of output grid, e.g. if you are doing masking or other arithmetic on the grids. A value of False ensures that the grid is only just as large as it needs to be to contain the data, which will be faster and use less memory if the resulting aggregate is being overlaid on a much larger background.

height = param.Integer(default=400, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

The height of the output image in pixels.

width = param.Integer(default=400, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

The width of the output image in pixels.

x_range = param.Tuple(length=2)

The x_range as a tuple of min and max x-value. Auto-ranges if set to None.

y_range = param.Tuple(length=2)

The y-axis range as a tuple of min and max y value. Auto-ranges if set to None.

x_sampling = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Specifies the smallest allowed sampling interval along the x axis.

y_sampling = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Specifies the smallest allowed sampling interval along the y axis.

target = param.ClassSelector(class_=<class ‘holoviews.core.data.Dataset’>)

A target Dataset which defines the desired x_range, y_range, width and height.

element_type = param.ClassSelector(class_=(<class ‘holoviews.core.data.Dataset’>,), default=<class ‘holoviews.element.raster.Image’>)

The type of the returned Elements, must be a 2D Dataset type.

precompute = param.Boolean(bounds=(0, 1), default=False)

Whether to apply precomputing operations. Precomputing can speed up resampling operations by avoiding unnecessary recomputation if the supplied element does not change between calls. The cost of enabling this option is that the memory used to represent this internal state is not freed between calls.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

element_type
force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.ResamplingOperation'>)
classmethod get_overlay_bounds(overlay)

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.ResamplingOperation'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.ResamplingOperation'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.ResamplingOperation'>)
message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.ResamplingOperation'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)

The process_element method allows a single element to be operated on given an externally supplied key.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.ResamplingOperation'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.ResamplingOperation'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.datashader.SpreadingOperation(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

Spreading expands each pixel in an Image based Element a certain number of pixels on all sides according to a given shape, merging pixels using a specified compositing operator. This can be useful to make sparse plots more visible.

group = param.String(default=’Operation’)

The group string used to identify the output of the Operation. By default this should match the operation name.

dynamic = param.ObjectSelector(default=’default’, objects=[‘default’, True, False])

Whether the operation should be applied dynamically when a specific frame is requested, specified as a Boolean. If set to ‘default’ the mode will be determined based on the input type, i.e. if the data is a DynamicMap it will stay dynamic.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=True)

By default, the link_inputs parameter is set to True so that when applying an operation, backends that support linked streams update RangeXY streams on the inputs of the operation. Disable when you do not want the resulting plot to be interactive, e.g. when trying to display an interactive plot a second time.

streams = param.List(bounds=(0, None), default=[])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

how = param.ObjectSelector(default=’source’, objects=[‘source’, ‘over’, ‘saturate’, ‘add’])

The name of the compositing operator to use when combining pixels.

shape = param.ObjectSelector(default=’circle’, objects=[‘circle’, ‘square’])

The shape to spread by. Options are ‘circle’ [default] or ‘square’.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.SpreadingOperation'>)
classmethod get_overlay_bounds(overlay)

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.SpreadingOperation'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.SpreadingOperation'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.SpreadingOperation'>)
instance = functools.partial(<function ParameterizedFunction.instance>, <class 'holoviews.operation.datashader.SpreadingOperation'>)
message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.SpreadingOperation'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)

The process_element method allows a single element to be operated on given an externally supplied key.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.SpreadingOperation'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.SpreadingOperation'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.datashader.aggregate(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

aggregate implements 2D binning for any valid HoloViews Element type using datashader. I.e., this operation turns a HoloViews Element or overlay of Elements into an Image or an overlay of Images by rasterizing it. This allows quickly aggregating large datasets computing a fixed-sized representation independent of the original dataset size.

By default it will simply count the number of values in each bin but other aggregators can be supplied implementing mean, max, min and other reduction operations.

The bins of the aggregate are defined by the width and height and the x_range and y_range. If x_sampling or y_sampling are supplied the operation will ensure that a bin is no smaller than the minimum sampling distance by reducing the width and height when zoomed in beyond the minimum sampling distance.

By default, the PlotSize stream is applied when this operation is used dynamically, which means that the height and width will automatically be set to match the inner dimensions of the linked plot.

group = param.String(default=’Operation’)

The group string used to identify the output of the Operation. By default this should match the operation name.

dynamic = param.Boolean(bounds=(0, 1), default=True)

Enables dynamic processing by default.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=True)

By default, the link_inputs parameter is set to True so that when applying an operation, backends that support linked streams update RangeXY streams on the inputs of the operation. Disable when you do not want the resulting plot to be interactive, e.g. when trying to display an interactive plot a second time.

streams = param.List(bounds=(0, None), default=[<class ‘holoviews.streams.PlotSize’>, <class ‘holoviews.streams.RangeXY’>])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

expand = param.Boolean(bounds=(0, 1), default=True)

Whether the x_range and y_range should be allowed to expand beyond the extent of the data. Setting this value to True is useful for the case where you want to ensure a certain size of output grid, e.g. if you are doing masking or other arithmetic on the grids. A value of False ensures that the grid is only just as large as it needs to be to contain the data, which will be faster and use less memory if the resulting aggregate is being overlaid on a much larger background.

height = param.Integer(default=400, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

The height of the output image in pixels.

width = param.Integer(default=400, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

The width of the output image in pixels.

x_range = param.Tuple(length=2)

The x_range as a tuple of min and max x-value. Auto-ranges if set to None.

y_range = param.Tuple(length=2)

The y-axis range as a tuple of min and max y value. Auto-ranges if set to None.

x_sampling = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Specifies the smallest allowed sampling interval along the x axis.

y_sampling = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Specifies the smallest allowed sampling interval along the y axis.

target = param.ClassSelector(class_=<class ‘holoviews.core.data.Dataset’>)

A target Dataset which defines the desired x_range, y_range, width and height.

element_type = param.ClassSelector(class_=(<class ‘holoviews.core.data.Dataset’>,), default=<class ‘holoviews.element.raster.Image’>)

The type of the returned Elements, must be a 2D Dataset type.

precompute = param.Boolean(bounds=(0, 1), default=False)

Whether to apply precomputing operations. Precomputing can speed up resampling operations by avoiding unnecessary recomputation if the supplied element does not change between calls. The cost of enabling this option is that the memory used to represent this internal state is not freed between calls.

aggregator = param.ClassSelector(class_=(<class ‘datashader.reductions.Reduction’>, <class ‘str’>), default=<datashader.reductions.count object at 0x7ff9072ff0d0>)

Datashader reduction function used for aggregating the data. The aggregator may also define a column to aggregate; if no column is defined the first value dimension of the element will be used. May also be defined as a string.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

element_type
force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.aggregate'>)
classmethod get_agg_data(obj, category=None)[source]

Reduces any Overlay or NdOverlay of Elements into a single xarray Dataset that can be aggregated.

classmethod get_overlay_bounds(overlay)

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.aggregate'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.aggregate'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.aggregate'>)
message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.aggregate'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)

The process_element method allows a single element to be operated on given an externally supplied key.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.aggregate'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.aggregate'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.datashader.area_aggregate(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

Aggregates Area elements by filling the area between zero and the y-values if only one value dimension is defined and the area between the curves if two are provided.

group = param.String(default=’Operation’)

The group string used to identify the output of the Operation. By default this should match the operation name.

dynamic = param.Boolean(bounds=(0, 1), default=True)

Enables dynamic processing by default.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=True)

By default, the link_inputs parameter is set to True so that when applying an operation, backends that support linked streams update RangeXY streams on the inputs of the operation. Disable when you do not want the resulting plot to be interactive, e.g. when trying to display an interactive plot a second time.

streams = param.List(bounds=(0, None), default=[<class ‘holoviews.streams.PlotSize’>, <class ‘holoviews.streams.RangeXY’>])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

expand = param.Boolean(bounds=(0, 1), default=True)

Whether the x_range and y_range should be allowed to expand beyond the extent of the data. Setting this value to True is useful for the case where you want to ensure a certain size of output grid, e.g. if you are doing masking or other arithmetic on the grids. A value of False ensures that the grid is only just as large as it needs to be to contain the data, which will be faster and use less memory if the resulting aggregate is being overlaid on a much larger background.

height = param.Integer(default=400, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

The height of the output image in pixels.

width = param.Integer(default=400, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

The width of the output image in pixels.

x_range = param.Tuple(length=2)

The x_range as a tuple of min and max x-value. Auto-ranges if set to None.

y_range = param.Tuple(length=2)

The y-axis range as a tuple of min and max y value. Auto-ranges if set to None.

x_sampling = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Specifies the smallest allowed sampling interval along the x axis.

y_sampling = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Specifies the smallest allowed sampling interval along the y axis.

target = param.ClassSelector(class_=<class ‘holoviews.core.data.Dataset’>)

A target Dataset which defines the desired x_range, y_range, width and height.

element_type = param.ClassSelector(class_=(<class ‘holoviews.core.data.Dataset’>,), default=<class ‘holoviews.element.raster.Image’>)

The type of the returned Elements, must be a 2D Dataset type.

precompute = param.Boolean(bounds=(0, 1), default=False)

Whether to apply precomputing operations. Precomputing can speed up resampling operations by avoiding unnecessary recomputation if the supplied element does not change between calls. The cost of enabling this option is that the memory used to represent this internal state is not freed between calls.

aggregator = param.ClassSelector(class_=(<class ‘datashader.reductions.Reduction’>, <class ‘str’>), default=<datashader.reductions.count object at 0x7ff9072ff0d0>)

Datashader reduction function used for aggregating the data. The aggregator may also define a column to aggregate; if no column is defined the first value dimension of the element will be used. May also be defined as a string.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

element_type
force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.area_aggregate'>)
classmethod get_overlay_bounds(overlay)

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.area_aggregate'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.area_aggregate'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.area_aggregate'>)
message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.area_aggregate'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)

The process_element method allows a single element to be operated on given an externally supplied key.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.area_aggregate'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.area_aggregate'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.datashader.bundle_graph(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

Bases: holoviews.operation.datashader._connect_edges, datashader.bundling.hammer_bundle

Iteratively group edges and return as paths suitable for datashading.

Breaks each edge into a path with multiple line segments, and iteratively curves this path to bundle edges into groups.

x = param.String(default=’x’)

Column name for each node’s x coordinate.

y = param.String(default=’y’)

Column name for each node’s y coordinate.

source = param.String(default=’source’)

Column name for each edge’s source.

target = param.String(default=’target’)

Column name for each edge’s target.

weight = param.String(default=’weight’)

Column name for each edge weight. If None, weights are ignored.

include_edge_id = param.Boolean(bounds=(0, 1), default=False)

Include edge IDs in bundled dataframe

initial_bandwidth = param.Number(bounds=(0.0, None), default=0.05, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Initial value of the bandwidth….

decay = param.Number(bounds=(0.0, 1.0), default=0.7, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rate of decay in the bandwidth value, with 1.0 indicating no decay.

iterations = param.Integer(bounds=(1, None), default=4, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Number of passes for the smoothing algorithm

batch_size = param.Integer(bounds=(1, None), default=20000, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Number of edges to process together

tension = param.Number(bounds=(0, None), default=0.3, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Exponential smoothing factor to use when smoothing

accuracy = param.Integer(bounds=(1, None), default=500, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Number of entries in table for…

advect_iterations = param.Integer(bounds=(0, None), default=50, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Number of iterations to move edges along gradients

min_segment_length = param.Number(bounds=(0, None), default=0.008, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Minimum length (in data space?) for an edge segment

max_segment_length = param.Number(bounds=(0, None), default=0.016, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Maximum length (in data space?) for an edge segment

group = param.String(default=’Operation’)

The group string used to identify the output of the Operation. By default this should match the operation name.

dynamic = param.ObjectSelector(default=’default’, objects=[‘default’, True, False])

Whether the operation should be applied dynamically when a specific frame is requested, specified as a Boolean. If set to ‘default’ the mode will be determined based on the input type, i.e. if the data is a DynamicMap it will stay dynamic.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=False)

If the operation is dynamic, whether or not linked streams should be transferred from the operation inputs for backends that support linked streams. For example if an operation is applied to a DynamicMap with an RangeXY, this switch determines whether the corresponding visualization should update this stream with range changes originating from the newly generated axes.

streams = param.List(bounds=(0, None), default=[])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

split = param.Boolean(bounds=(0, 1), default=False)

Determines whether bundled edges will be split into individual edges or concatenated with NaN separators.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.bundle_graph'>)
classmethod get_overlay_bounds(overlay)

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.bundle_graph'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.bundle_graph'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.bundle_graph'>)
instance = functools.partial(<function ParameterizedFunction.instance>, <class 'holoviews.operation.datashader.bundle_graph'>)
message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.bundle_graph'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)

The process_element method allows a single element to be operated on given an externally supplied key.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.bundle_graph'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.bundle_graph'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.datashader.contours_rasterize(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

Rasterizes the Contours element by weighting the aggregation by the iso-contour levels if a value dimension is defined, otherwise default to any aggregator.

group = param.String(default=’Operation’)

The group string used to identify the output of the Operation. By default this should match the operation name.

dynamic = param.Boolean(bounds=(0, 1), default=True)

Enables dynamic processing by default.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=True)

By default, the link_inputs parameter is set to True so that when applying an operation, backends that support linked streams update RangeXY streams on the inputs of the operation. Disable when you do not want the resulting plot to be interactive, e.g. when trying to display an interactive plot a second time.

streams = param.List(bounds=(0, None), default=[<class ‘holoviews.streams.PlotSize’>, <class ‘holoviews.streams.RangeXY’>])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

expand = param.Boolean(bounds=(0, 1), default=True)

Whether the x_range and y_range should be allowed to expand beyond the extent of the data. Setting this value to True is useful for the case where you want to ensure a certain size of output grid, e.g. if you are doing masking or other arithmetic on the grids. A value of False ensures that the grid is only just as large as it needs to be to contain the data, which will be faster and use less memory if the resulting aggregate is being overlaid on a much larger background.

height = param.Integer(default=400, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

The height of the output image in pixels.

width = param.Integer(default=400, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

The width of the output image in pixels.

x_range = param.Tuple(length=2)

The x_range as a tuple of min and max x-value. Auto-ranges if set to None.

y_range = param.Tuple(length=2)

The y-axis range as a tuple of min and max y value. Auto-ranges if set to None.

x_sampling = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Specifies the smallest allowed sampling interval along the x axis.

y_sampling = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Specifies the smallest allowed sampling interval along the y axis.

target = param.ClassSelector(class_=<class ‘holoviews.core.data.Dataset’>)

A target Dataset which defines the desired x_range, y_range, width and height.

element_type = param.ClassSelector(class_=(<class ‘holoviews.core.data.Dataset’>,), default=<class ‘holoviews.element.raster.Image’>)

The type of the returned Elements, must be a 2D Dataset type.

precompute = param.Boolean(bounds=(0, 1), default=False)

Whether to apply precomputing operations. Precomputing can speed up resampling operations by avoiding unnecessary recomputation if the supplied element does not change between calls. The cost of enabling this option is that the memory used to represent this internal state is not freed between calls.

aggregator = param.ClassSelector(class_=(<class ‘datashader.reductions.Reduction’>, <class ‘str’>), default=<datashader.reductions.mean object at 0x7ff905602990>)

Datashader reduction function used for aggregating the data. The aggregator may also define a column to aggregate; if no column is defined the first value dimension of the element will be used. May also be defined as a string.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

element_type
force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.contours_rasterize'>)
classmethod get_agg_data(obj, category=None)

Reduces any Overlay or NdOverlay of Elements into a single xarray Dataset that can be aggregated.

classmethod get_overlay_bounds(overlay)

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.contours_rasterize'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.contours_rasterize'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.contours_rasterize'>)
message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.contours_rasterize'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)

The process_element method allows a single element to be operated on given an externally supplied key.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.contours_rasterize'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.contours_rasterize'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.datashader.datashade(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

Applies the aggregate and shade operations, aggregating all elements in the supplied object and then applying normalization and colormapping the aggregated data returning RGB elements.

See aggregate and shade operations for more details.

group = param.String(default=’Operation’)

The group string used to identify the output of the Operation. By default this should match the operation name.

dynamic = param.Boolean(bounds=(0, 1), default=True)

Enables dynamic processing by default.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=True)

By default, the link_inputs parameter is set to True so that when applying an operation, backends that support linked streams update RangeXY streams on the inputs of the operation. Disable when you do not want the resulting plot to be interactive, e.g. when trying to display an interactive plot a second time.

streams = param.List(bounds=(0, None), default=[<class ‘holoviews.streams.PlotSize’>, <class ‘holoviews.streams.RangeXY’>])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

alpha = param.Integer(bounds=(0, 255), default=255, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Value between 0 - 255 representing the alpha value to use for colormapped pixels that contain data (i.e. non-NaN values). Regardless of this value, NaN values are set to be fully transparent when doing colormapping.

cmap = param.ClassSelector(class_=(<class ‘collections.abc.Iterable’>, <class ‘collections.abc.Callable’>, <class ‘dict’>))

Iterable or callable which returns colors as hex colors or web color names (as defined by datashader), to be used for the colormap of single-layer datashader output. Callable type must allow mapping colors between 0 and 1. The default value of None reverts to Datashader’s default colormap.

color_key = param.ClassSelector(class_=(<class ‘collections.abc.Iterable’>, <class ‘collections.abc.Callable’>, <class ‘dict’>))

Iterable or callable that returns colors as hex colors, to be used for the color key of categorical datashader output. Callable type must allow mapping colors for supplied values between 0 and 1.

normalization = param.ClassSelector(class_=(<class ‘str’>, <class ‘collections.abc.Callable’>), default=’eq_hist’)

The normalization operation applied before colormapping. Valid options include ‘linear’, ‘log’, ‘eq_hist’, ‘cbrt’, and any valid transfer function that accepts data, mask, nbins arguments.

clims = param.NumericTuple(length=2)

Min and max data values to use for colormap interpolation, when wishing to override autoranging.

min_alpha = param.Number(bounds=(0, 255), default=40, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

The minimum alpha value to use for non-empty pixels when doing colormapping, in [0, 255]. Use a higher value to avoid undersaturation, i.e. poorly visible low-value datapoints, at the expense of the overall dynamic range..

expand = param.Boolean(bounds=(0, 1), default=True)

Whether the x_range and y_range should be allowed to expand beyond the extent of the data. Setting this value to True is useful for the case where you want to ensure a certain size of output grid, e.g. if you are doing masking or other arithmetic on the grids. A value of False ensures that the grid is only just as large as it needs to be to contain the data, which will be faster and use less memory if the resulting aggregate is being overlaid on a much larger background.

height = param.Integer(default=400, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

The height of the output image in pixels.

width = param.Integer(default=400, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

The width of the output image in pixels.

x_range = param.Tuple(length=2)

The x_range as a tuple of min and max x-value. Auto-ranges if set to None.

y_range = param.Tuple(length=2)

The y-axis range as a tuple of min and max y value. Auto-ranges if set to None.

x_sampling = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Specifies the smallest allowed sampling interval along the x axis.

y_sampling = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Specifies the smallest allowed sampling interval along the y axis.

target = param.ClassSelector(class_=<class ‘holoviews.core.data.Dataset’>)

A target Dataset which defines the desired x_range, y_range, width and height.

element_type = param.ClassSelector(class_=(<class ‘holoviews.core.data.Dataset’>,), default=<class ‘holoviews.element.raster.Image’>)

The type of the returned Elements, must be a 2D Dataset type.

precompute = param.Boolean(bounds=(0, 1), default=False)

Whether to apply precomputing operations. Precomputing can speed up resampling operations by avoiding unnecessary recomputation if the supplied element does not change between calls. The cost of enabling this option is that the memory used to represent this internal state is not freed between calls.

aggregator = param.ClassSelector(class_=(<class ‘datashader.reductions.Reduction’>, <class ‘str’>), default=’default’)

Datashader reduction function used for aggregating the data. The aggregator may also define a column to aggregate; if no column is defined the first value dimension of the element will be used. May also be defined as a string.

interpolation = param.ObjectSelector(default=’default’, objects=[‘default’, ‘linear’, ‘nearest’, ‘bilinear’, None, False])

The interpolation method to apply during rasterization. Default depends on element type

classmethod concatenate(overlay)

Concatenates an NdOverlay of Image types into a single 3D xarray Dataset.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

element_type
force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.datashade'>)
classmethod get_overlay_bounds(overlay)

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.datashade'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.datashade'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.datashade'>)
message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.datashade'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)

The process_element method allows a single element to be operated on given an externally supplied key.

classmethod rgb2hex(rgb)

Convert RGB(A) tuple to hex.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.datashade'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.datashade'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

classmethod uint32_to_uint8(img)

Cast uint32 RGB image to 4 uint8 channels.

classmethod uint32_to_uint8_xr(img)

Cast uint32 xarray DataArray to 4 uint8 channels.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.datashader.directly_connect_edges(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

Bases: holoviews.operation.datashader._connect_edges, datashader.bundling.connect_edges

Given a Graph object will directly connect all nodes.

x = param.String(default=’x’)

Column name for each node’s x coordinate.

y = param.String(default=’y’)

Column name for each node’s y coordinate.

source = param.String(default=’source’)

Column name for each edge’s source.

target = param.String(default=’target’)

Column name for each edge’s target.

weight = param.String()

Column name for each edge weight. If None, weights are ignored.

include_edge_id = param.Boolean(bounds=(0, 1), default=False)

Include edge IDs in bundled dataframe

group = param.String(default=’Operation’)

The group string used to identify the output of the Operation. By default this should match the operation name.

dynamic = param.ObjectSelector(default=’default’, objects=[‘default’, True, False])

Whether the operation should be applied dynamically when a specific frame is requested, specified as a Boolean. If set to ‘default’ the mode will be determined based on the input type, i.e. if the data is a DynamicMap it will stay dynamic.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=False)

If the operation is dynamic, whether or not linked streams should be transferred from the operation inputs for backends that support linked streams. For example if an operation is applied to a DynamicMap with an RangeXY, this switch determines whether the corresponding visualization should update this stream with range changes originating from the newly generated axes.

streams = param.List(bounds=(0, None), default=[])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

split = param.Boolean(bounds=(0, 1), default=False)

Determines whether bundled edges will be split into individual edges or concatenated with NaN separators.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.directly_connect_edges'>)
classmethod get_overlay_bounds(overlay)

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.directly_connect_edges'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.directly_connect_edges'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.directly_connect_edges'>)
instance = functools.partial(<function ParameterizedFunction.instance>, <class 'holoviews.operation.datashader.directly_connect_edges'>)
message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.directly_connect_edges'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)

The process_element method allows a single element to be operated on given an externally supplied key.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.directly_connect_edges'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.directly_connect_edges'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.datashader.dynspread(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

Spreading expands each pixel in an Image based Element a certain number of pixels on all sides according to a given shape, merging pixels using a specified compositing operator. This can be useful to make sparse plots more visible. Dynamic spreading determines how many pixels to spread based on a density heuristic.

See the datashader documentation for more detail:

group = param.String(default=’Operation’)

The group string used to identify the output of the Operation. By default this should match the operation name.

dynamic = param.ObjectSelector(default=’default’, objects=[‘default’, True, False])

Whether the operation should be applied dynamically when a specific frame is requested, specified as a Boolean. If set to ‘default’ the mode will be determined based on the input type, i.e. if the data is a DynamicMap it will stay dynamic.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=True)

By default, the link_inputs parameter is set to True so that when applying an operation, backends that support linked streams update RangeXY streams on the inputs of the operation. Disable when you do not want the resulting plot to be interactive, e.g. when trying to display an interactive plot a second time.

streams = param.List(bounds=(0, None), default=[])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

how = param.ObjectSelector(default=’source’, objects=[‘source’, ‘over’, ‘saturate’, ‘add’])

The name of the compositing operator to use when combining pixels.

shape = param.ObjectSelector(default=’circle’, objects=[‘circle’, ‘square’])

The shape to spread by. Options are ‘circle’ [default] or ‘square’.

max_px = param.Integer(default=3, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Maximum number of pixels to spread on all sides.

threshold = param.Number(bounds=(0, 1), default=0.5, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

When spreading, determines how far to spread. Spreading starts at 1 pixel, and stops when the fraction of adjacent non-empty pixels reaches this threshold. Higher values give more spreading, up to the max_px allowed.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.dynspread'>)
classmethod get_overlay_bounds(overlay)

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.dynspread'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.dynspread'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.dynspread'>)
instance = functools.partial(<function ParameterizedFunction.instance>, <class 'holoviews.operation.datashader.dynspread'>)
message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.dynspread'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)

The process_element method allows a single element to be operated on given an externally supplied key.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.dynspread'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.dynspread'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.datashader.geometry_rasterize(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

Rasterizes geometries by converting them to spatialpandas.

group = param.String(default=’Operation’)

The group string used to identify the output of the Operation. By default this should match the operation name.

dynamic = param.Boolean(bounds=(0, 1), default=True)

Enables dynamic processing by default.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=True)

By default, the link_inputs parameter is set to True so that when applying an operation, backends that support linked streams update RangeXY streams on the inputs of the operation. Disable when you do not want the resulting plot to be interactive, e.g. when trying to display an interactive plot a second time.

streams = param.List(bounds=(0, None), default=[<class ‘holoviews.streams.PlotSize’>, <class ‘holoviews.streams.RangeXY’>])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

expand = param.Boolean(bounds=(0, 1), default=True)

Whether the x_range and y_range should be allowed to expand beyond the extent of the data. Setting this value to True is useful for the case where you want to ensure a certain size of output grid, e.g. if you are doing masking or other arithmetic on the grids. A value of False ensures that the grid is only just as large as it needs to be to contain the data, which will be faster and use less memory if the resulting aggregate is being overlaid on a much larger background.

height = param.Integer(default=400, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

The height of the output image in pixels.

width = param.Integer(default=400, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

The width of the output image in pixels.

x_range = param.Tuple(length=2)

The x_range as a tuple of min and max x-value. Auto-ranges if set to None.

y_range = param.Tuple(length=2)

The y-axis range as a tuple of min and max y value. Auto-ranges if set to None.

x_sampling = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Specifies the smallest allowed sampling interval along the x axis.

y_sampling = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Specifies the smallest allowed sampling interval along the y axis.

target = param.ClassSelector(class_=<class ‘holoviews.core.data.Dataset’>)

A target Dataset which defines the desired x_range, y_range, width and height.

element_type = param.ClassSelector(class_=(<class ‘holoviews.core.data.Dataset’>,), default=<class ‘holoviews.element.raster.Image’>)

The type of the returned Elements, must be a 2D Dataset type.

precompute = param.Boolean(bounds=(0, 1), default=False)

Whether to apply precomputing operations. Precomputing can speed up resampling operations by avoiding unnecessary recomputation if the supplied element does not change between calls. The cost of enabling this option is that the memory used to represent this internal state is not freed between calls.

aggregator = param.ClassSelector(class_=(<class ‘datashader.reductions.Reduction’>, <class ‘str’>), default=<datashader.reductions.mean object at 0x7ff905602f50>)

Datashader reduction function used for aggregating the data. The aggregator may also define a column to aggregate; if no column is defined the first value dimension of the element will be used. May also be defined as a string.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

element_type
force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.geometry_rasterize'>)
classmethod get_overlay_bounds(overlay)

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.geometry_rasterize'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.geometry_rasterize'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.geometry_rasterize'>)
message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.geometry_rasterize'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)

The process_element method allows a single element to be operated on given an externally supplied key.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.geometry_rasterize'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.geometry_rasterize'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.datashader.overlay_aggregate(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

Optimized aggregation for NdOverlay objects by aggregating each Element in an NdOverlay individually avoiding having to concatenate items in the NdOverlay. Works by summing sum and count aggregates and applying appropriate masking for NaN values. Mean aggregation is also supported by dividing sum and count aggregates. count_cat aggregates are grouped by the categorical dimension and a separate aggregate for each category is generated.

group = param.String(default=’Operation’)

The group string used to identify the output of the Operation. By default this should match the operation name.

dynamic = param.Boolean(bounds=(0, 1), default=True)

Enables dynamic processing by default.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=True)

By default, the link_inputs parameter is set to True so that when applying an operation, backends that support linked streams update RangeXY streams on the inputs of the operation. Disable when you do not want the resulting plot to be interactive, e.g. when trying to display an interactive plot a second time.

streams = param.List(bounds=(0, None), default=[<class ‘holoviews.streams.PlotSize’>, <class ‘holoviews.streams.RangeXY’>])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

expand = param.Boolean(bounds=(0, 1), default=True)

Whether the x_range and y_range should be allowed to expand beyond the extent of the data. Setting this value to True is useful for the case where you want to ensure a certain size of output grid, e.g. if you are doing masking or other arithmetic on the grids. A value of False ensures that the grid is only just as large as it needs to be to contain the data, which will be faster and use less memory if the resulting aggregate is being overlaid on a much larger background.

height = param.Integer(default=400, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

The height of the output image in pixels.

width = param.Integer(default=400, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

The width of the output image in pixels.

x_range = param.Tuple(length=2)

The x_range as a tuple of min and max x-value. Auto-ranges if set to None.

y_range = param.Tuple(length=2)

The y-axis range as a tuple of min and max y value. Auto-ranges if set to None.

x_sampling = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Specifies the smallest allowed sampling interval along the x axis.

y_sampling = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Specifies the smallest allowed sampling interval along the y axis.

target = param.ClassSelector(class_=<class ‘holoviews.core.data.Dataset’>)

A target Dataset which defines the desired x_range, y_range, width and height.

element_type = param.ClassSelector(class_=(<class ‘holoviews.core.data.Dataset’>,), default=<class ‘holoviews.element.raster.Image’>)

The type of the returned Elements, must be a 2D Dataset type.

precompute = param.Boolean(bounds=(0, 1), default=False)

Whether to apply precomputing operations. Precomputing can speed up resampling operations by avoiding unnecessary recomputation if the supplied element does not change between calls. The cost of enabling this option is that the memory used to represent this internal state is not freed between calls.

aggregator = param.ClassSelector(class_=(<class ‘datashader.reductions.Reduction’>, <class ‘str’>), default=<datashader.reductions.count object at 0x7ff9072ff0d0>)

Datashader reduction function used for aggregating the data. The aggregator may also define a column to aggregate; if no column is defined the first value dimension of the element will be used. May also be defined as a string.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

element_type
force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.overlay_aggregate'>)
classmethod get_agg_data(obj, category=None)

Reduces any Overlay or NdOverlay of Elements into a single xarray Dataset that can be aggregated.

classmethod get_overlay_bounds(overlay)

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.overlay_aggregate'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.overlay_aggregate'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.overlay_aggregate'>)
message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.overlay_aggregate'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)

The process_element method allows a single element to be operated on given an externally supplied key.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.overlay_aggregate'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.overlay_aggregate'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.datashader.quadmesh_rasterize(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

Rasterize the QuadMesh element using the supplied aggregator. Simply converts to a TriMesh and lets trimesh_rasterize handle the actual rasterization.

group = param.String(default=’Operation’)

The group string used to identify the output of the Operation. By default this should match the operation name.

dynamic = param.Boolean(bounds=(0, 1), default=True)

Enables dynamic processing by default.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=True)

By default, the link_inputs parameter is set to True so that when applying an operation, backends that support linked streams update RangeXY streams on the inputs of the operation. Disable when you do not want the resulting plot to be interactive, e.g. when trying to display an interactive plot a second time.

streams = param.List(bounds=(0, None), default=[<class ‘holoviews.streams.PlotSize’>, <class ‘holoviews.streams.RangeXY’>])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

expand = param.Boolean(bounds=(0, 1), default=True)

Whether the x_range and y_range should be allowed to expand beyond the extent of the data. Setting this value to True is useful for the case where you want to ensure a certain size of output grid, e.g. if you are doing masking or other arithmetic on the grids. A value of False ensures that the grid is only just as large as it needs to be to contain the data, which will be faster and use less memory if the resulting aggregate is being overlaid on a much larger background.

height = param.Integer(default=400, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

The height of the output image in pixels.

width = param.Integer(default=400, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

The width of the output image in pixels.

x_range = param.Tuple(length=2)

The x_range as a tuple of min and max x-value. Auto-ranges if set to None.

y_range = param.Tuple(length=2)

The y-axis range as a tuple of min and max y value. Auto-ranges if set to None.

x_sampling = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Specifies the smallest allowed sampling interval along the x axis.

y_sampling = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Specifies the smallest allowed sampling interval along the y axis.

target = param.ClassSelector(class_=<class ‘holoviews.core.data.Dataset’>)

A target Dataset which defines the desired x_range, y_range, width and height.

element_type = param.ClassSelector(class_=(<class ‘holoviews.core.data.Dataset’>,), default=<class ‘holoviews.element.raster.Image’>)

The type of the returned Elements, must be a 2D Dataset type.

precompute = param.Boolean(bounds=(0, 1), default=False)

Whether to apply precomputing operations. Precomputing can speed up resampling operations by avoiding unnecessary recomputation if the supplied element does not change between calls. The cost of enabling this option is that the memory used to represent this internal state is not freed between calls.

aggregator = param.ClassSelector(class_=(<class ‘datashader.reductions.Reduction’>, <class ‘str’>), default=<datashader.reductions.mean object at 0x7ff905602a50>)

Datashader reduction function used for aggregating the data. The aggregator may also define a column to aggregate; if no column is defined the first value dimension of the element will be used. May also be defined as a string.

interpolation = param.ObjectSelector(default=’bilinear’, objects=[‘bilinear’, ‘linear’, None, False])

The interpolation method to apply during rasterization.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

element_type
force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.quadmesh_rasterize'>)
classmethod get_agg_data(obj, category=None)

Reduces any Overlay or NdOverlay of Elements into a single xarray Dataset that can be aggregated.

classmethod get_overlay_bounds(overlay)

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.quadmesh_rasterize'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.quadmesh_rasterize'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.quadmesh_rasterize'>)
message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.quadmesh_rasterize'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)

The process_element method allows a single element to be operated on given an externally supplied key.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.quadmesh_rasterize'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.quadmesh_rasterize'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.datashader.rasterize(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

Rasterize is a high-level operation that will rasterize any Element or combination of Elements, aggregating them with the supplied aggregator and interpolation method.

The default aggregation method depends on the type of Element but usually defaults to the count of samples in each bin. Other aggregators can be supplied implementing mean, max, min and other reduction operations.

The bins of the aggregate are defined by the width and height and the x_range and y_range. If x_sampling or y_sampling are supplied the operation will ensure that a bin is no smaller than the minimum sampling distance by reducing the width and height when zoomed in beyond the minimum sampling distance.

By default, the PlotSize and RangeXY streams are applied when this operation is used dynamically, which means that the width, height, x_range and y_range will automatically be set to match the inner dimensions of the linked plot and the ranges of the axes.

group = param.String(default=’Operation’)

The group string used to identify the output of the Operation. By default this should match the operation name.

dynamic = param.Boolean(bounds=(0, 1), default=True)

Enables dynamic processing by default.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=True)

By default, the link_inputs parameter is set to True so that when applying an operation, backends that support linked streams update RangeXY streams on the inputs of the operation. Disable when you do not want the resulting plot to be interactive, e.g. when trying to display an interactive plot a second time.

streams = param.List(bounds=(0, None), default=[<class ‘holoviews.streams.PlotSize’>, <class ‘holoviews.streams.RangeXY’>])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

expand = param.Boolean(bounds=(0, 1), default=True)

Whether the x_range and y_range should be allowed to expand beyond the extent of the data. Setting this value to True is useful for the case where you want to ensure a certain size of output grid, e.g. if you are doing masking or other arithmetic on the grids. A value of False ensures that the grid is only just as large as it needs to be to contain the data, which will be faster and use less memory if the resulting aggregate is being overlaid on a much larger background.

height = param.Integer(default=400, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

The height of the output image in pixels.

width = param.Integer(default=400, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

The width of the output image in pixels.

x_range = param.Tuple(length=2)

The x_range as a tuple of min and max x-value. Auto-ranges if set to None.

y_range = param.Tuple(length=2)

The y-axis range as a tuple of min and max y value. Auto-ranges if set to None.

x_sampling = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Specifies the smallest allowed sampling interval along the x axis.

y_sampling = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Specifies the smallest allowed sampling interval along the y axis.

target = param.ClassSelector(class_=<class ‘holoviews.core.data.Dataset’>)

A target Dataset which defines the desired x_range, y_range, width and height.

element_type = param.ClassSelector(class_=(<class ‘holoviews.core.data.Dataset’>,), default=<class ‘holoviews.element.raster.Image’>)

The type of the returned Elements, must be a 2D Dataset type.

precompute = param.Boolean(bounds=(0, 1), default=False)

Whether to apply precomputing operations. Precomputing can speed up resampling operations by avoiding unnecessary recomputation if the supplied element does not change between calls. The cost of enabling this option is that the memory used to represent this internal state is not freed between calls.

aggregator = param.ClassSelector(class_=(<class ‘datashader.reductions.Reduction’>, <class ‘str’>), default=’default’)

Datashader reduction function used for aggregating the data. The aggregator may also define a column to aggregate; if no column is defined the first value dimension of the element will be used. May also be defined as a string.

interpolation = param.ObjectSelector(default=’default’, objects=[‘default’, ‘linear’, ‘nearest’, ‘bilinear’, None, False])

The interpolation method to apply during rasterization. Default depends on element type

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

element_type
force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.rasterize'>)
classmethod get_overlay_bounds(overlay)

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.rasterize'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.rasterize'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.rasterize'>)
message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.rasterize'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)

The process_element method allows a single element to be operated on given an externally supplied key.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.rasterize'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.rasterize'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.datashader.regrid(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

regrid allows resampling a HoloViews Image type using specified up- and downsampling functions defined using the aggregator and interpolation parameters respectively. By default upsampling is disabled to avoid unnecessarily upscaling an image that has to be sent to the browser. Also disables expanding the image beyond its original bounds avoiding unnecessarily padding the output array with NaN values.

group = param.String(default=’Operation’)

The group string used to identify the output of the Operation. By default this should match the operation name.

dynamic = param.Boolean(bounds=(0, 1), default=True)

Enables dynamic processing by default.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=True)

By default, the link_inputs parameter is set to True so that when applying an operation, backends that support linked streams update RangeXY streams on the inputs of the operation. Disable when you do not want the resulting plot to be interactive, e.g. when trying to display an interactive plot a second time.

streams = param.List(bounds=(0, None), default=[<class ‘holoviews.streams.PlotSize’>, <class ‘holoviews.streams.RangeXY’>])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

expand = param.Boolean(bounds=(0, 1), default=False)

Whether the x_range and y_range should be allowed to expand beyond the extent of the data. Setting this value to True is useful for the case where you want to ensure a certain size of output grid, e.g. if you are doing masking or other arithmetic on the grids. A value of False ensures that the grid is only just as large as it needs to be to contain the data, which will be faster and use less memory if the resulting aggregate is being overlaid on a much larger background.

height = param.Integer(default=400, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

The height of the output image in pixels.

width = param.Integer(default=400, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

The width of the output image in pixels.

x_range = param.Tuple(length=2)

The x_range as a tuple of min and max x-value. Auto-ranges if set to None.

y_range = param.Tuple(length=2)

The y-axis range as a tuple of min and max y value. Auto-ranges if set to None.

x_sampling = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Specifies the smallest allowed sampling interval along the x axis.

y_sampling = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Specifies the smallest allowed sampling interval along the y axis.

target = param.ClassSelector(class_=<class ‘holoviews.core.data.Dataset’>)

A target Dataset which defines the desired x_range, y_range, width and height.

element_type = param.ClassSelector(class_=(<class ‘holoviews.core.data.Dataset’>,), default=<class ‘holoviews.element.raster.Image’>)

The type of the returned Elements, must be a 2D Dataset type.

precompute = param.Boolean(bounds=(0, 1), default=False)

Whether to apply precomputing operations. Precomputing can speed up resampling operations by avoiding unnecessary recomputation if the supplied element does not change between calls. The cost of enabling this option is that the memory used to represent this internal state is not freed between calls.

aggregator = param.ClassSelector(class_=(<class ‘datashader.reductions.Reduction’>, <class ‘str’>), default=<datashader.reductions.mean object at 0x7ff9056025d0>)

Datashader reduction function used for aggregating the data. The aggregator may also define a column to aggregate; if no column is defined the first value dimension of the element will be used. May also be defined as a string.

interpolation = param.ObjectSelector(default=’nearest’, objects=[‘linear’, ‘nearest’, ‘bilinear’, None, False])

Interpolation method

upsample = param.Boolean(bounds=(0, 1), default=False)

Whether to allow upsampling if the source array is smaller than the requested array. Setting this value to True will enable upsampling using the interpolation method, when the requested width and height are larger than what is available on the source grid. If upsampling is disabled (the default) the width and height are clipped to what is available on the source array.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

element_type
force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.regrid'>)
classmethod get_overlay_bounds(overlay)

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.regrid'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.regrid'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.regrid'>)
message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.regrid'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)

The process_element method allows a single element to be operated on given an externally supplied key.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.regrid'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.regrid'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.datashader.segments_aggregate(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

Aggregates Segments elements.

group = param.String(default=’Operation’)

The group string used to identify the output of the Operation. By default this should match the operation name.

dynamic = param.Boolean(bounds=(0, 1), default=True)

Enables dynamic processing by default.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=True)

By default, the link_inputs parameter is set to True so that when applying an operation, backends that support linked streams update RangeXY streams on the inputs of the operation. Disable when you do not want the resulting plot to be interactive, e.g. when trying to display an interactive plot a second time.

streams = param.List(bounds=(0, None), default=[<class ‘holoviews.streams.PlotSize’>, <class ‘holoviews.streams.RangeXY’>])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

expand = param.Boolean(bounds=(0, 1), default=True)

Whether the x_range and y_range should be allowed to expand beyond the extent of the data. Setting this value to True is useful for the case where you want to ensure a certain size of output grid, e.g. if you are doing masking or other arithmetic on the grids. A value of False ensures that the grid is only just as large as it needs to be to contain the data, which will be faster and use less memory if the resulting aggregate is being overlaid on a much larger background.

height = param.Integer(default=400, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

The height of the output image in pixels.

width = param.Integer(default=400, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

The width of the output image in pixels.

x_range = param.Tuple(length=2)

The x_range as a tuple of min and max x-value. Auto-ranges if set to None.

y_range = param.Tuple(length=2)

The y-axis range as a tuple of min and max y value. Auto-ranges if set to None.

x_sampling = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Specifies the smallest allowed sampling interval along the x axis.

y_sampling = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Specifies the smallest allowed sampling interval along the y axis.

target = param.ClassSelector(class_=<class ‘holoviews.core.data.Dataset’>)

A target Dataset which defines the desired x_range, y_range, width and height.

element_type = param.ClassSelector(class_=(<class ‘holoviews.core.data.Dataset’>,), default=<class ‘holoviews.element.raster.Image’>)

The type of the returned Elements, must be a 2D Dataset type.

precompute = param.Boolean(bounds=(0, 1), default=False)

Whether to apply precomputing operations. Precomputing can speed up resampling operations by avoiding unnecessary recomputation if the supplied element does not change between calls. The cost of enabling this option is that the memory used to represent this internal state is not freed between calls.

aggregator = param.ClassSelector(class_=(<class ‘datashader.reductions.Reduction’>, <class ‘str’>), default=<datashader.reductions.count object at 0x7ff9072ff0d0>)

Datashader reduction function used for aggregating the data. The aggregator may also define a column to aggregate; if no column is defined the first value dimension of the element will be used. May also be defined as a string.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

element_type
force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.segments_aggregate'>)
classmethod get_overlay_bounds(overlay)

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.segments_aggregate'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.segments_aggregate'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.segments_aggregate'>)
message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.segments_aggregate'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)

The process_element method allows a single element to be operated on given an externally supplied key.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.segments_aggregate'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.segments_aggregate'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.datashader.shade(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

shade applies a normalization function followed by colormapping to an Image or NdOverlay of Images, returning an RGB Element. The data must be in the form of a 2D or 3D DataArray, but NdOverlays of 2D Images will be automatically converted to a 3D array.

In the 2D case data is normalized and colormapped, while a 3D array representing categorical aggregates will be supplied a color key for each category. The colormap (cmap) for the 2D case may be supplied as an Iterable or a Callable.

group = param.String(default=’Operation’)

The group string used to identify the output of the Operation. By default this should match the operation name.

dynamic = param.ObjectSelector(default=’default’, objects=[‘default’, True, False])

Whether the operation should be applied dynamically when a specific frame is requested, specified as a Boolean. If set to ‘default’ the mode will be determined based on the input type, i.e. if the data is a DynamicMap it will stay dynamic.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=True)

By default, the link_inputs parameter is set to True so that when applying an operation, backends that support linked streams update RangeXY streams on the inputs of the operation. Disable when you do not want the resulting plot to be interactive, e.g. when trying to display an interactive plot a second time.

streams = param.List(bounds=(0, None), default=[])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

alpha = param.Integer(bounds=(0, 255), default=255, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Value between 0 - 255 representing the alpha value to use for colormapped pixels that contain data (i.e. non-NaN values). Regardless of this value, NaN values are set to be fully transparent when doing colormapping.

cmap = param.ClassSelector(class_=(<class ‘collections.abc.Iterable’>, <class ‘collections.abc.Callable’>, <class ‘dict’>))

Iterable or callable which returns colors as hex colors or web color names (as defined by datashader), to be used for the colormap of single-layer datashader output. Callable type must allow mapping colors between 0 and 1. The default value of None reverts to Datashader’s default colormap.

color_key = param.ClassSelector(class_=(<class ‘collections.abc.Iterable’>, <class ‘collections.abc.Callable’>, <class ‘dict’>))

Iterable or callable that returns colors as hex colors, to be used for the color key of categorical datashader output. Callable type must allow mapping colors for supplied values between 0 and 1.

normalization = param.ClassSelector(class_=(<class ‘str’>, <class ‘collections.abc.Callable’>), default=’eq_hist’)

The normalization operation applied before colormapping. Valid options include ‘linear’, ‘log’, ‘eq_hist’, ‘cbrt’, and any valid transfer function that accepts data, mask, nbins arguments.

clims = param.NumericTuple(length=2)

Min and max data values to use for colormap interpolation, when wishing to override autoranging.

min_alpha = param.Number(bounds=(0, 255), default=40, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

The minimum alpha value to use for non-empty pixels when doing colormapping, in [0, 255]. Use a higher value to avoid undersaturation, i.e. poorly visible low-value datapoints, at the expense of the overall dynamic range..

classmethod concatenate(overlay)[source]

Concatenates an NdOverlay of Image types into a single 3D xarray Dataset.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.shade'>)
classmethod get_overlay_bounds(overlay)

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.shade'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.shade'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.shade'>)
instance = functools.partial(<function ParameterizedFunction.instance>, <class 'holoviews.operation.datashader.shade'>)
message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.shade'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)

The process_element method allows a single element to be operated on given an externally supplied key.

classmethod rgb2hex(rgb)[source]

Convert RGB(A) tuple to hex.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.shade'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.shade'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

classmethod uint32_to_uint8(img)[source]

Cast uint32 RGB image to 4 uint8 channels.

classmethod uint32_to_uint8_xr(img)[source]

Cast uint32 xarray DataArray to 4 uint8 channels.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.datashader.spikes_aggregate(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

Aggregates Spikes elements by drawing individual line segments over the entire y_range if no value dimension is defined and between zero and the y-value if one is defined.

group = param.String(default=’Operation’)

The group string used to identify the output of the Operation. By default this should match the operation name.

dynamic = param.Boolean(bounds=(0, 1), default=True)

Enables dynamic processing by default.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=True)

By default, the link_inputs parameter is set to True so that when applying an operation, backends that support linked streams update RangeXY streams on the inputs of the operation. Disable when you do not want the resulting plot to be interactive, e.g. when trying to display an interactive plot a second time.

streams = param.List(bounds=(0, None), default=[<class ‘holoviews.streams.PlotSize’>, <class ‘holoviews.streams.RangeXY’>])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

expand = param.Boolean(bounds=(0, 1), default=True)

Whether the x_range and y_range should be allowed to expand beyond the extent of the data. Setting this value to True is useful for the case where you want to ensure a certain size of output grid, e.g. if you are doing masking or other arithmetic on the grids. A value of False ensures that the grid is only just as large as it needs to be to contain the data, which will be faster and use less memory if the resulting aggregate is being overlaid on a much larger background.

height = param.Integer(default=400, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

The height of the output image in pixels.

width = param.Integer(default=400, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

The width of the output image in pixels.

x_range = param.Tuple(length=2)

The x_range as a tuple of min and max x-value. Auto-ranges if set to None.

y_range = param.Tuple(length=2)

The y-axis range as a tuple of min and max y value. Auto-ranges if set to None.

x_sampling = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Specifies the smallest allowed sampling interval along the x axis.

y_sampling = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Specifies the smallest allowed sampling interval along the y axis.

target = param.ClassSelector(class_=<class ‘holoviews.core.data.Dataset’>)

A target Dataset which defines the desired x_range, y_range, width and height.

element_type = param.ClassSelector(class_=(<class ‘holoviews.core.data.Dataset’>,), default=<class ‘holoviews.element.raster.Image’>)

The type of the returned Elements, must be a 2D Dataset type.

precompute = param.Boolean(bounds=(0, 1), default=False)

Whether to apply precomputing operations. Precomputing can speed up resampling operations by avoiding unnecessary recomputation if the supplied element does not change between calls. The cost of enabling this option is that the memory used to represent this internal state is not freed between calls.

aggregator = param.ClassSelector(class_=(<class ‘datashader.reductions.Reduction’>, <class ‘str’>), default=<datashader.reductions.count object at 0x7ff9072ff0d0>)

Datashader reduction function used for aggregating the data. The aggregator may also define a column to aggregate; if no column is defined the first value dimension of the element will be used. May also be defined as a string.

spike_length = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

If numeric, specifies the length of each spike, overriding the vdims values (if present).

offset = param.Number(default=0.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

The offset of the lower end of each spike.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

element_type
force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.spikes_aggregate'>)
classmethod get_overlay_bounds(overlay)

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.spikes_aggregate'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.spikes_aggregate'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.spikes_aggregate'>)
message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.spikes_aggregate'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)

The process_element method allows a single element to be operated on given an externally supplied key.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.spikes_aggregate'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.spikes_aggregate'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

holoviews.operation.datashader.split_dataframe(path_df)[source]

Splits a dataframe of paths separated by NaNs into individual dataframes.

class holoviews.operation.datashader.spread(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

Spreading expands each pixel in an Image based Element a certain number of pixels on all sides according to a given shape, merging pixels using a specified compositing operator. This can be useful to make sparse plots more visible.

See the datashader documentation for more detail:

group = param.String(default=’Operation’)

The group string used to identify the output of the Operation. By default this should match the operation name.

dynamic = param.ObjectSelector(default=’default’, objects=[‘default’, True, False])

Whether the operation should be applied dynamically when a specific frame is requested, specified as a Boolean. If set to ‘default’ the mode will be determined based on the input type, i.e. if the data is a DynamicMap it will stay dynamic.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=True)

By default, the link_inputs parameter is set to True so that when applying an operation, backends that support linked streams update RangeXY streams on the inputs of the operation. Disable when you do not want the resulting plot to be interactive, e.g. when trying to display an interactive plot a second time.

streams = param.List(bounds=(0, None), default=[])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

how = param.ObjectSelector(default=’source’, objects=[‘source’, ‘over’, ‘saturate’, ‘add’])

The name of the compositing operator to use when combining pixels.

shape = param.ObjectSelector(default=’circle’, objects=[‘circle’, ‘square’])

The shape to spread by. Options are ‘circle’ [default] or ‘square’.

px = param.Integer(default=1, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Number of pixels to spread on all sides.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.spread'>)
classmethod get_overlay_bounds(overlay)

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.spread'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.spread'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.spread'>)
instance = functools.partial(<function ParameterizedFunction.instance>, <class 'holoviews.operation.datashader.spread'>)
message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.spread'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)

The process_element method allows a single element to be operated on given an externally supplied key.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.spread'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.spread'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.datashader.spread_aggregate(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

Aggregates Spread elements by filling the area between the lower and upper error band.

group = param.String(default=’Operation’)

The group string used to identify the output of the Operation. By default this should match the operation name.

dynamic = param.Boolean(bounds=(0, 1), default=True)

Enables dynamic processing by default.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=True)

By default, the link_inputs parameter is set to True so that when applying an operation, backends that support linked streams update RangeXY streams on the inputs of the operation. Disable when you do not want the resulting plot to be interactive, e.g. when trying to display an interactive plot a second time.

streams = param.List(bounds=(0, None), default=[<class ‘holoviews.streams.PlotSize’>, <class ‘holoviews.streams.RangeXY’>])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

expand = param.Boolean(bounds=(0, 1), default=True)

Whether the x_range and y_range should be allowed to expand beyond the extent of the data. Setting this value to True is useful for the case where you want to ensure a certain size of output grid, e.g. if you are doing masking or other arithmetic on the grids. A value of False ensures that the grid is only just as large as it needs to be to contain the data, which will be faster and use less memory if the resulting aggregate is being overlaid on a much larger background.

height = param.Integer(default=400, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

The height of the output image in pixels.

width = param.Integer(default=400, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

The width of the output image in pixels.

x_range = param.Tuple(length=2)

The x_range as a tuple of min and max x-value. Auto-ranges if set to None.

y_range = param.Tuple(length=2)

The y-axis range as a tuple of min and max y value. Auto-ranges if set to None.

x_sampling = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Specifies the smallest allowed sampling interval along the x axis.

y_sampling = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Specifies the smallest allowed sampling interval along the y axis.

target = param.ClassSelector(class_=<class ‘holoviews.core.data.Dataset’>)

A target Dataset which defines the desired x_range, y_range, width and height.

element_type = param.ClassSelector(class_=(<class ‘holoviews.core.data.Dataset’>,), default=<class ‘holoviews.element.raster.Image’>)

The type of the returned Elements, must be a 2D Dataset type.

precompute = param.Boolean(bounds=(0, 1), default=False)

Whether to apply precomputing operations. Precomputing can speed up resampling operations by avoiding unnecessary recomputation if the supplied element does not change between calls. The cost of enabling this option is that the memory used to represent this internal state is not freed between calls.

aggregator = param.ClassSelector(class_=(<class ‘datashader.reductions.Reduction’>, <class ‘str’>), default=<datashader.reductions.count object at 0x7ff9072ff0d0>)

Datashader reduction function used for aggregating the data. The aggregator may also define a column to aggregate; if no column is defined the first value dimension of the element will be used. May also be defined as a string.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

element_type
force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.spread_aggregate'>)
classmethod get_overlay_bounds(overlay)

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.spread_aggregate'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.spread_aggregate'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.spread_aggregate'>)
message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.spread_aggregate'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)

The process_element method allows a single element to be operated on given an externally supplied key.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.spread_aggregate'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.spread_aggregate'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.datashader.stack(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

The stack operation allows compositing multiple RGB Elements using the defined compositing operator.

group = param.String(default=’Operation’)

The group string used to identify the output of the Operation. By default this should match the operation name.

dynamic = param.ObjectSelector(default=’default’, objects=[‘default’, True, False])

Whether the operation should be applied dynamically when a specific frame is requested, specified as a Boolean. If set to ‘default’ the mode will be determined based on the input type, i.e. if the data is a DynamicMap it will stay dynamic.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=False)

If the operation is dynamic, whether or not linked streams should be transferred from the operation inputs for backends that support linked streams. For example if an operation is applied to a DynamicMap with an RangeXY, this switch determines whether the corresponding visualization should update this stream with range changes originating from the newly generated axes.

streams = param.List(bounds=(0, None), default=[])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

compositor = param.ObjectSelector(default=’over’, objects=[‘add’, ‘over’, ‘saturate’, ‘source’])

Defines how the compositing operation combines the images

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.stack'>)
classmethod get_overlay_bounds(overlay)

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.stack'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.stack'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.stack'>)
instance = functools.partial(<function ParameterizedFunction.instance>, <class 'holoviews.operation.datashader.stack'>)
message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.stack'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)

The process_element method allows a single element to be operated on given an externally supplied key.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.stack'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.stack'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.datashader.trimesh_rasterize(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

Rasterize the TriMesh element using the supplied aggregator. If the TriMesh nodes or edges define a value dimension, will plot filled and shaded polygons; otherwise returns a wiremesh of the data.

group = param.String(default=’Operation’)

The group string used to identify the output of the Operation. By default this should match the operation name.

dynamic = param.Boolean(bounds=(0, 1), default=True)

Enables dynamic processing by default.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=True)

By default, the link_inputs parameter is set to True so that when applying an operation, backends that support linked streams update RangeXY streams on the inputs of the operation. Disable when you do not want the resulting plot to be interactive, e.g. when trying to display an interactive plot a second time.

streams = param.List(bounds=(0, None), default=[<class ‘holoviews.streams.PlotSize’>, <class ‘holoviews.streams.RangeXY’>])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

expand = param.Boolean(bounds=(0, 1), default=True)

Whether the x_range and y_range should be allowed to expand beyond the extent of the data. Setting this value to True is useful for the case where you want to ensure a certain size of output grid, e.g. if you are doing masking or other arithmetic on the grids. A value of False ensures that the grid is only just as large as it needs to be to contain the data, which will be faster and use less memory if the resulting aggregate is being overlaid on a much larger background.

height = param.Integer(default=400, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

The height of the output image in pixels.

width = param.Integer(default=400, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

The width of the output image in pixels.

x_range = param.Tuple(length=2)

The x_range as a tuple of min and max x-value. Auto-ranges if set to None.

y_range = param.Tuple(length=2)

The y-axis range as a tuple of min and max y value. Auto-ranges if set to None.

x_sampling = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Specifies the smallest allowed sampling interval along the x axis.

y_sampling = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Specifies the smallest allowed sampling interval along the y axis.

target = param.ClassSelector(class_=<class ‘holoviews.core.data.Dataset’>)

A target Dataset which defines the desired x_range, y_range, width and height.

element_type = param.ClassSelector(class_=(<class ‘holoviews.core.data.Dataset’>,), default=<class ‘holoviews.element.raster.Image’>)

The type of the returned Elements, must be a 2D Dataset type.

precompute = param.Boolean(bounds=(0, 1), default=False)

Whether to apply precomputing operations. Precomputing can speed up resampling operations by avoiding unnecessary recomputation if the supplied element does not change between calls. The cost of enabling this option is that the memory used to represent this internal state is not freed between calls.

aggregator = param.ClassSelector(class_=(<class ‘datashader.reductions.Reduction’>, <class ‘str’>), default=<datashader.reductions.mean object at 0x7ff905602a50>)

Datashader reduction function used for aggregating the data. The aggregator may also define a column to aggregate; if no column is defined the first value dimension of the element will be used. May also be defined as a string.

interpolation = param.ObjectSelector(default=’bilinear’, objects=[‘bilinear’, ‘linear’, None, False])

The interpolation method to apply during rasterization.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

element_type
force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.trimesh_rasterize'>)
classmethod get_agg_data(obj, category=None)

Reduces any Overlay or NdOverlay of Elements into a single xarray Dataset that can be aggregated.

classmethod get_overlay_bounds(overlay)

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.trimesh_rasterize'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.trimesh_rasterize'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.trimesh_rasterize'>)
message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.trimesh_rasterize'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)

The process_element method allows a single element to be operated on given an externally supplied key.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.trimesh_rasterize'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.datashader.trimesh_rasterize'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

## element Module¶

digraph inheritanceecf70b2a86 { fontsize=18; rankdir=LR; size="12.0, 12.0"; "holoviews.core.operation.Operation" [URL="holoviews.core.html#holoviews.core.operation.Operation",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top",tooltip="An Operation process an Element or HoloMap at the level of"]; "param.parameterized.ParameterizedFunction" -> "holoviews.core.operation.Operation" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.operation.element.apply_when" [URL="#holoviews.operation.element.apply_when",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top",tooltip="Applies a selection depending on the current zoom range. If the"]; "param.parameterized.ParameterizedFunction" -> "holoviews.operation.element.apply_when" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.operation.element.chain" [URL="#holoviews.operation.element.chain",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top",tooltip="Defining an Operation chain is an easy way to define a new"]; "holoviews.core.operation.Operation" -> "holoviews.operation.element.chain" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.operation.element.collapse" [URL="#holoviews.operation.element.collapse",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top",tooltip="Given an overlay of Element types, collapse into single Element"]; "holoviews.core.operation.Operation" -> "holoviews.operation.element.collapse" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.operation.element.contours" [URL="#holoviews.operation.element.contours",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top",tooltip="Given a Image with a single channel, annotate it with contour"]; "holoviews.core.operation.Operation" -> "holoviews.operation.element.contours" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.operation.element.convolve" [URL="#holoviews.operation.element.convolve",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top",tooltip="Apply a convolution to an overlay using the top layer as the"]; "holoviews.core.operation.Operation" -> "holoviews.operation.element.convolve" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.operation.element.decimate" [URL="#holoviews.operation.element.decimate",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top",tooltip="Decimates any column based Element to a specified number of random"]; "holoviews.core.operation.Operation" -> "holoviews.operation.element.decimate" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.operation.element.factory" [URL="#holoviews.operation.element.factory",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top",tooltip="Simple operation that constructs any element that accepts some"]; "holoviews.core.operation.Operation" -> "holoviews.operation.element.factory" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.operation.element.function" [URL="#holoviews.operation.element.function",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top"]; "holoviews.core.operation.Operation" -> "holoviews.operation.element.function" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.operation.element.gradient" [URL="#holoviews.operation.element.gradient",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top",tooltip="Compute the gradient plot of the supplied Image."]; "holoviews.core.operation.Operation" -> "holoviews.operation.element.gradient" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.operation.element.gridmatrix" [URL="#holoviews.operation.element.gridmatrix",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top",tooltip="The gridmatrix operation takes an Element or HoloMap"]; "param.parameterized.ParameterizedFunction" -> "holoviews.operation.element.gridmatrix" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.operation.element.histogram" [URL="#holoviews.operation.element.histogram",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top",tooltip="Returns a Histogram of the input element data, binned into"]; "holoviews.core.operation.Operation" -> "holoviews.operation.element.histogram" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.operation.element.image_overlay" [URL="#holoviews.operation.element.image_overlay",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top",tooltip="Operation to build a overlay of images to a specification from a"]; "holoviews.core.operation.Operation" -> "holoviews.operation.element.image_overlay" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.operation.element.interpolate_curve" [URL="#holoviews.operation.element.interpolate_curve",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top",tooltip="Resamples a Curve using the defined interpolation method, e.g."]; "holoviews.core.operation.Operation" -> "holoviews.operation.element.interpolate_curve" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.operation.element.method" [URL="#holoviews.operation.element.method",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top",tooltip="Operation that wraps a method call"]; "holoviews.core.operation.Operation" -> "holoviews.operation.element.method" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.operation.element.operation" [URL="#holoviews.operation.element.operation",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top",tooltip="The most generic operation that wraps any callable into an"]; "holoviews.core.operation.Operation" -> "holoviews.operation.element.operation" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.operation.element.threshold" [URL="#holoviews.operation.element.threshold",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top",tooltip="Threshold a given Image whereby all values higher than a given"]; "holoviews.core.operation.Operation" -> "holoviews.operation.element.threshold" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.operation.element.transform" [URL="#holoviews.operation.element.transform",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top",tooltip="Generic Operation to transform an input Image or RGBA"]; "holoviews.core.operation.Operation" -> "holoviews.operation.element.transform" [arrowsize=0.5,style="setlinewidth(0.5)"]; "param.parameterized.Parameterized" [fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",tooltip="params(name=String)"]; "param.parameterized.ParameterizedFunction" [fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",tooltip="params(name=String)"]; "param.parameterized.Parameterized" -> "param.parameterized.ParameterizedFunction" [arrowsize=0.5,style="setlinewidth(0.5)"]; }

Collection of either extremely generic or simple Operation examples.

class holoviews.operation.element.apply_when(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

Bases: param.parameterized.ParameterizedFunction

Applies a selection depending on the current zoom range. If the supplied predicate function returns a True it will apply the operation otherwise it will return the raw element after the selection. For example the following will apply datashading if the number of points in the current viewport exceed 1000 otherwise just returning the selected points element:

apply_when(points, operation=datashade, predicate=lambda x: x > 1000)

operation = param.Callable()

predicate = param.Callable()

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.apply_when'>)
get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.apply_when'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.apply_when'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.apply_when'>)
instance = functools.partial(<function ParameterizedFunction.instance>, <class 'holoviews.operation.element.apply_when'>)
message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.apply_when'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.apply_when'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.apply_when'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.element.chain(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

Defining an Operation chain is an easy way to define a new Operation from a series of existing ones. The argument is a list of Operation (or Operation instances) that are called in sequence to generate the returned element.

This operation can accept an Image instance and would first compute the gradient before thresholding the result at a level of 2.0.

Instances are only required when arguments need to be passed to individual operations so the resulting object is a function over a single argument.

group = param.String(default=’’)

The group assigned to the result after having applied the chain. Defaults to the group produced by the last operation in the chain

dynamic = param.ObjectSelector(default=’default’, objects=[‘default’, True, False])

Whether the operation should be applied dynamically when a specific frame is requested, specified as a Boolean. If set to ‘default’ the mode will be determined based on the input type, i.e. if the data is a DynamicMap it will stay dynamic.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=False)

If the operation is dynamic, whether or not linked streams should be transferred from the operation inputs for backends that support linked streams. For example if an operation is applied to a DynamicMap with an RangeXY, this switch determines whether the corresponding visualization should update this stream with range changes originating from the newly generated axes.

streams = param.List(bounds=(0, None), default=[])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

output_type = param.Parameter(default=<class ‘holoviews.element.raster.Image’>)

The output type of the chain operation. Must be supplied if the chain is to be used as a channel operation.

operations = param.List(bounds=(0, None), class_=<class ‘holoviews.core.operation.Operation’>, default=[])

A list of Operations (or Operation instances) that are applied on the input from left to right..

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.chain'>)
classmethod get_overlay_bounds(overlay)

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.chain'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.chain'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.chain'>)
instance = functools.partial(<function ParameterizedFunction.instance>, <class 'holoviews.operation.element.chain'>)
message(**kwargs)

Inspect .param.message method for the full docstring

output_type
params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.chain'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)

The process_element method allows a single element to be operated on given an externally supplied key.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.chain'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.chain'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.element.collapse(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

Given an overlay of Element types, collapse into single Element object using supplied function. Collapsing aggregates over the key dimensions of each object applying the supplied fn to each group.

This is an example of an Operation that does not involve any Raster types.

group = param.String(default=’Operation’)

The group string used to identify the output of the Operation. By default this should match the operation name.

dynamic = param.ObjectSelector(default=’default’, objects=[‘default’, True, False])

Whether the operation should be applied dynamically when a specific frame is requested, specified as a Boolean. If set to ‘default’ the mode will be determined based on the input type, i.e. if the data is a DynamicMap it will stay dynamic.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=False)

If the operation is dynamic, whether or not linked streams should be transferred from the operation inputs for backends that support linked streams. For example if an operation is applied to a DynamicMap with an RangeXY, this switch determines whether the corresponding visualization should update this stream with range changes originating from the newly generated axes.

streams = param.List(bounds=(0, None), default=[])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

fn = param.Callable()

The function that is used to collapse the curve y-values for each x-value.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

fn(axis=None, dtype=None, out=None, keepdims=<no value>)

Compute the arithmetic mean along the specified axis.

Returns the average of the array elements. The average is taken over the flattened array by default, otherwise over the specified axis. float64 intermediate and return values are used for integer inputs.

aarray_like

Array containing numbers whose mean is desired. If a is not an array, a conversion is attempted.

axisNone or int or tuple of ints, optional

Axis or axes along which the means are computed. The default is to compute the mean of the flattened array.

New in version 1.7.0.

If this is a tuple of ints, a mean is performed over multiple axes, instead of a single axis or all the axes as before.

dtypedata-type, optional

Type to use in computing the mean. For integer inputs, the default is float64; for floating point inputs, it is the same as the input dtype.

outndarray, optional

Alternate output array in which to place the result. The default is None; if provided, it must have the same shape as the expected output, but the type will be cast if necessary. See ufuncs-output-type for more details.

keepdimsbool, optional

If this is set to True, the axes which are reduced are left in the result as dimensions with size one. With this option, the result will broadcast correctly against the input array.

If the default value is passed, then keepdims will not be passed through to the mean method of sub-classes of ndarray, however any non-default value will be. If the sub-class’ method does not implement keepdims any exceptions will be raised.

mndarray, see dtype parameter above

If out=None, returns a new array containing the mean values, otherwise a reference to the output array is returned.

average : Weighted average std, var, nanmean, nanstd, nanvar

The arithmetic mean is the sum of the elements along the axis divided by the number of elements.

Note that for floating-point input, the mean is computed using the same precision the input has. Depending on the input data, this can cause the results to be inaccurate, especially for float32 (see example below). Specifying a higher-precision accumulator using the dtype keyword can alleviate this issue.

By default, float16 results are computed using float32 intermediates for extra precision.

>>> a = np.array([[1, 2], [3, 4]])
>>> np.mean(a)
2.5
>>> np.mean(a, axis=0)
array([2., 3.])
>>> np.mean(a, axis=1)
array([1.5, 3.5])


In single precision, mean can be inaccurate:

>>> a = np.zeros((2, 512*512), dtype=np.float32)
>>> a[0, :] = 1.0
>>> a[1, :] = 0.1
>>> np.mean(a)
0.54999924


Computing the mean in float64 is more accurate:

>>> np.mean(a, dtype=np.float64)
0.55000000074505806 # may vary

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.collapse'>)
classmethod get_overlay_bounds(overlay)

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.collapse'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.collapse'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.collapse'>)
instance = functools.partial(<function ParameterizedFunction.instance>, <class 'holoviews.operation.element.collapse'>)
message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.collapse'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)

The process_element method allows a single element to be operated on given an externally supplied key.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.collapse'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.collapse'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.element.contours(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

Given a Image with a single channel, annotate it with contour lines for a given set of contour levels.

The return is an NdOverlay with a Contours layer for each given level, overlaid on top of the input Image.

group = param.String(default=’Level’)

The group assigned to the output contours.

dynamic = param.ObjectSelector(default=’default’, objects=[‘default’, True, False])

Whether the operation should be applied dynamically when a specific frame is requested, specified as a Boolean. If set to ‘default’ the mode will be determined based on the input type, i.e. if the data is a DynamicMap it will stay dynamic.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=False)

If the operation is dynamic, whether or not linked streams should be transferred from the operation inputs for backends that support linked streams. For example if an operation is applied to a DynamicMap with an RangeXY, this switch determines whether the corresponding visualization should update this stream with range changes originating from the newly generated axes.

streams = param.List(bounds=(0, None), default=[])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

levels = param.ClassSelector(class_=(<class ‘list’>, <class ‘int’>), default=10)

A list of scalar values used to specify the contour levels.

filled = param.Boolean(bounds=(0, 1), default=False)

Whether to generate filled contours

overlaid = param.Boolean(bounds=(0, 1), default=False)

Whether to overlay the contour on the supplied Element.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.contours'>)
classmethod get_overlay_bounds(overlay)

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.contours'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.contours'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.contours'>)
instance = functools.partial(<function ParameterizedFunction.instance>, <class 'holoviews.operation.element.contours'>)
message(**kwargs)

Inspect .param.message method for the full docstring

output_type
params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.contours'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)

The process_element method allows a single element to be operated on given an externally supplied key.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.contours'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.contours'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.element.convolve(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

Apply a convolution to an overlay using the top layer as the kernel for convolving the bottom layer. Both Image elements in the input overlay should have a single value dimension.

group = param.String(default=’Convolution’)

The group assigned to the convolved output.

dynamic = param.ObjectSelector(default=’default’, objects=[‘default’, True, False])

Whether the operation should be applied dynamically when a specific frame is requested, specified as a Boolean. If set to ‘default’ the mode will be determined based on the input type, i.e. if the data is a DynamicMap it will stay dynamic.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=False)

If the operation is dynamic, whether or not linked streams should be transferred from the operation inputs for backends that support linked streams. For example if an operation is applied to a DynamicMap with an RangeXY, this switch determines whether the corresponding visualization should update this stream with range changes originating from the newly generated axes.

streams = param.List(bounds=(0, None), default=[])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

kernel_roi = param.NumericTuple(default=(0, 0, 0, 0), length=4)

A 2-dimensional slice of the kernel layer to use in the convolution in lbrt (left, bottom, right, top) format. By default, no slicing is applied.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.convolve'>)
classmethod get_overlay_bounds(overlay)

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.convolve'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.convolve'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.convolve'>)
instance = functools.partial(<function ParameterizedFunction.instance>, <class 'holoviews.operation.element.convolve'>)
message(**kwargs)

Inspect .param.message method for the full docstring

output_type
params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.convolve'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)

The process_element method allows a single element to be operated on given an externally supplied key.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.convolve'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.convolve'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.element.decimate(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

Decimates any column based Element to a specified number of random rows if the current element defined by the x_range and y_range contains more than max_samples. By default the operation returns a DynamicMap with a RangeXY stream allowing dynamic downsampling.

group = param.String(default=’Operation’)

The group string used to identify the output of the Operation. By default this should match the operation name.

dynamic = param.Boolean(bounds=(0, 1), default=True)

Enables dynamic processing by default.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=True)

By default, the link_inputs parameter is set to True so that when applying shade, backends that support linked streams update RangeXY streams on the inputs of the shade operation.

streams = param.List(bounds=(0, None), default=[<class ‘holoviews.streams.RangeXY’>])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

max_samples = param.Integer(default=5000, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Maximum number of samples to display at the same time.

random_seed = param.Integer(default=42, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Seed used to initialize randomization.

x_range = param.NumericTuple(length=2)

The x_range as a tuple of min and max x-value. Auto-ranges if set to None.

y_range = param.NumericTuple(length=2)

The x_range as a tuple of min and max y-value. Auto-ranges if set to None.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.decimate'>)
classmethod get_overlay_bounds(overlay)

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.decimate'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.decimate'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.decimate'>)
instance = functools.partial(<function ParameterizedFunction.instance>, <class 'holoviews.operation.element.decimate'>)
message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.decimate'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)

The process_element method allows a single element to be operated on given an externally supplied key.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.decimate'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.decimate'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.element.factory(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

Simple operation that constructs any element that accepts some other element as input. For instance, RGB and HSV elements can be created from overlays of Image elements.

group = param.String(default=’Operation’)

The group string used to identify the output of the Operation. By default this should match the operation name.

dynamic = param.ObjectSelector(default=’default’, objects=[‘default’, True, False])

Whether the operation should be applied dynamically when a specific frame is requested, specified as a Boolean. If set to ‘default’ the mode will be determined based on the input type, i.e. if the data is a DynamicMap it will stay dynamic.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=False)

If the operation is dynamic, whether or not linked streams should be transferred from the operation inputs for backends that support linked streams. For example if an operation is applied to a DynamicMap with an RangeXY, this switch determines whether the corresponding visualization should update this stream with range changes originating from the newly generated axes.

streams = param.List(bounds=(0, None), default=[])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

output_type = param.Parameter(default=<class ‘holoviews.element.raster.RGB’>)

The output type of the factor operation. By default, if three overlaid Images elements are supplied, the corresponding RGB element will be returned.

args = param.List(bounds=(0, None), default=[])

The list of positional argument to pass to the factory

kwargs = param.Dict(class_=<class ‘dict’>, default={})

The dict of keyword arguments to pass to the factory

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.factory'>)
classmethod get_overlay_bounds(overlay)

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.factory'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.factory'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.factory'>)
instance = functools.partial(<function ParameterizedFunction.instance>, <class 'holoviews.operation.element.factory'>)
message(**kwargs)

Inspect .param.message method for the full docstring

output_type
params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.factory'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)

The process_element method allows a single element to be operated on given an externally supplied key.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.factory'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.factory'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.element.function(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]
group = param.String(default=’Operation’)

The group string used to identify the output of the Operation. By default this should match the operation name.

dynamic = param.ObjectSelector(default=’default’, objects=[‘default’, True, False])

Whether the operation should be applied dynamically when a specific frame is requested, specified as a Boolean. If set to ‘default’ the mode will be determined based on the input type, i.e. if the data is a DynamicMap it will stay dynamic.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=False)

If the operation is dynamic, whether or not linked streams should be transferred from the operation inputs for backends that support linked streams. For example if an operation is applied to a DynamicMap with an RangeXY, this switch determines whether the corresponding visualization should update this stream with range changes originating from the newly generated axes.

streams = param.List(bounds=(0, None), default=[])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

output_type = param.ClassSelector(class_=<class ‘type’>)

The output type of the method operation

input_type = param.ClassSelector(class_=<class ‘type’>)

The object type the method is defined on

fn = param.Callable()

The function to apply.

args = param.List(bounds=(0, None), default=[])

The list of positional argument to pass to the method

kwargs = param.Dict(class_=<class ‘dict’>, default={})

The dict of keyword arguments to pass to the method

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.function'>)
classmethod get_overlay_bounds(overlay)

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.function'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.function'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.function'>)
instance = functools.partial(<function ParameterizedFunction.instance>, <class 'holoviews.operation.element.function'>)
message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.function'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)

The process_element method allows a single element to be operated on given an externally supplied key.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.function'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.function'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.element.gradient(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

Compute the gradient plot of the supplied Image.

If the Image value dimension is cyclic, the smallest step is taken considered the cyclic range

group = param.String(default=’Gradient’)

The group assigned to the output gradient matrix.

dynamic = param.ObjectSelector(default=’default’, objects=[‘default’, True, False])

Whether the operation should be applied dynamically when a specific frame is requested, specified as a Boolean. If set to ‘default’ the mode will be determined based on the input type, i.e. if the data is a DynamicMap it will stay dynamic.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=False)

If the operation is dynamic, whether or not linked streams should be transferred from the operation inputs for backends that support linked streams. For example if an operation is applied to a DynamicMap with an RangeXY, this switch determines whether the corresponding visualization should update this stream with range changes originating from the newly generated axes.

streams = param.List(bounds=(0, None), default=[])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.gradient'>)
classmethod get_overlay_bounds(overlay)

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.gradient'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.gradient'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.gradient'>)
instance = functools.partial(<function ParameterizedFunction.instance>, <class 'holoviews.operation.element.gradient'>)
message(**kwargs)

Inspect .param.message method for the full docstring

output_type
params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.gradient'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)

The process_element method allows a single element to be operated on given an externally supplied key.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.gradient'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.gradient'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.element.gridmatrix(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

Bases: param.parameterized.ParameterizedFunction

The gridmatrix operation takes an Element or HoloMap of Elements as input and creates a GridMatrix object, which plots each dimension in the Element against each other dimension. This provides a very useful overview of high-dimensional data and is inspired by pandas and seaborn scatter_matrix implementations.

chart_type = param.Parameter(default=<class ‘holoviews.element.chart.Scatter’>)

The Element type used to display bivariate distributions of the data.

diagonal_type = param.Parameter()

The Element type along the diagonal, may be a Histogram or any other plot type which can visualize a univariate distribution. This parameter overrides diagonal_operation.

diagonal_operation = param.Parameter(default=<class ‘holoviews.operation.element.histogram’>)

The operation applied along the diagonal, may be a histogram-operation or any other function which returns a viewable element.

overlay_dims = param.List(bounds=(0, None), default=[])

If a HoloMap is supplied this will allow overlaying one or more of it’s key dimensions.

chart_type
debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

diagonal_operation

alias of histogram

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.gridmatrix'>)
get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.gridmatrix'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.gridmatrix'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.gridmatrix'>)
instance = functools.partial(<function ParameterizedFunction.instance>, <class 'holoviews.operation.element.gridmatrix'>)
message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.gridmatrix'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.gridmatrix'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.gridmatrix'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.element.histogram(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

Returns a Histogram of the input element data, binned into num_bins over the bin_range (if specified) along the specified dimension.

group = param.String(default=’Operation’)

The group string used to identify the output of the Operation. By default this should match the operation name.

dynamic = param.ObjectSelector(default=’default’, objects=[‘default’, True, False])

Whether the operation should be applied dynamically when a specific frame is requested, specified as a Boolean. If set to ‘default’ the mode will be determined based on the input type, i.e. if the data is a DynamicMap it will stay dynamic.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=False)

If the operation is dynamic, whether or not linked streams should be transferred from the operation inputs for backends that support linked streams. For example if an operation is applied to a DynamicMap with an RangeXY, this switch determines whether the corresponding visualization should update this stream with range changes originating from the newly generated axes.

streams = param.List(bounds=(0, None), default=[])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

bin_range = param.NumericTuple(length=2)

Specifies the range within which to compute the bins.

bins = param.ClassSelector(class_=(<class ‘numpy.ndarray’>, <class ‘list’>, <class ‘tuple’>))

An explicit set of bin edges.

cumulative = param.Boolean(bounds=(0, 1), default=False)

Whether to compute the cumulative histogram

dimension = param.String()

Along which dimension of the Element to compute the histogram.

frequency_label = param.String()

Format string defining the label of the frequency dimension of the Histogram.

groupby = param.ClassSelector(class_=(<class ‘str’>, <class ‘holoviews.core.dimension.Dimension’>))

Defines a dimension to group the Histogram returning an NdOverlay of Histograms.

log = param.Boolean(bounds=(0, 1), default=False)

Whether to use base 10 logarithmic samples for the bin edges.

mean_weighted = param.Boolean(bounds=(0, 1), default=False)

Whether the weighted frequencies are averaged.

normed = param.ObjectSelector(default=True, objects=[True, False, ‘integral’, ‘height’])

Controls normalization behavior. If True or ‘integral’, then density=True is passed to np.histogram, and the distribution is normalized such that the integral is unity. If False, then the frequencies will be raw counts. If ‘height’, then the frequencies are normalized such that the max bin height is unity.

nonzero = param.Boolean(bounds=(0, 1), default=False)

Whether to use only nonzero values when computing the histogram

num_bins = param.Integer(default=20, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Number of bins in the histogram .

weight_dimension = param.String()

Name of the dimension the weighting should be drawn from

style_prefix = param.String()

Used for setting a common style for histograms in a HoloMap or AdjointLayout.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.histogram'>)
classmethod get_overlay_bounds(overlay)

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.histogram'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.histogram'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.histogram'>)
instance = functools.partial(<function ParameterizedFunction.instance>, <class 'holoviews.operation.element.histogram'>)
message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.histogram'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)

The process_element method allows a single element to be operated on given an externally supplied key.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.histogram'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.histogram'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.element.image_overlay(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

Operation to build a overlay of images to a specification from a subset of the required elements.

This is useful for reordering the elements of an overlay, duplicating layers of an overlay or creating blank image elements in the appropriate positions.

For instance, image_overlay may build a three layered input suitable for the RGB factory operation even if supplied with one or two of the required channels (creating blank channels for the missing elements).

Note that if there is any ambiguity regarding the match, the strongest match will be used. In the case of a tie in match strength, the first layer in the input is used. One successful match is always required.

group = param.String(default=’Transform’)

The group assigned to the resulting overlay.

dynamic = param.ObjectSelector(default=’default’, objects=[‘default’, True, False])

Whether the operation should be applied dynamically when a specific frame is requested, specified as a Boolean. If set to ‘default’ the mode will be determined based on the input type, i.e. if the data is a DynamicMap it will stay dynamic.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=False)

If the operation is dynamic, whether or not linked streams should be transferred from the operation inputs for backends that support linked streams. For example if an operation is applied to a DynamicMap with an RangeXY, this switch determines whether the corresponding visualization should update this stream with range changes originating from the newly generated axes.

streams = param.List(bounds=(0, None), default=[])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

spec = param.String(default=’’)

Specification of the output Overlay structure. For instance: Image.R * Image.G * Image.B Will ensure an overlay of this structure is created even if (for instance) only (Image.R * Image.B) is supplied. Elements in the input overlay that match are placed in the appropriate positions and unavailable specification elements are created with the specified fill group.

fill = param.Number(default=0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

default_range = param.Tuple(default=(0, 1), length=2)

The default range that will be set on the value_dimension of any automatically created blank image elements.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.image_overlay'>)
classmethod get_overlay_bounds(overlay)

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.image_overlay'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.image_overlay'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.image_overlay'>)
instance = functools.partial(<function ParameterizedFunction.instance>, <class 'holoviews.operation.element.image_overlay'>)
message(**kwargs)

Inspect .param.message method for the full docstring

output_type
params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.image_overlay'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)

The process_element method allows a single element to be operated on given an externally supplied key.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.image_overlay'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.image_overlay'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.element.interpolate_curve(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

Resamples a Curve using the defined interpolation method, e.g. to represent changes in y-values as steps.

group = param.String(default=’Operation’)

The group string used to identify the output of the Operation. By default this should match the operation name.

dynamic = param.ObjectSelector(default=’default’, objects=[‘default’, True, False])

Whether the operation should be applied dynamically when a specific frame is requested, specified as a Boolean. If set to ‘default’ the mode will be determined based on the input type, i.e. if the data is a DynamicMap it will stay dynamic.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=False)

If the operation is dynamic, whether or not linked streams should be transferred from the operation inputs for backends that support linked streams. For example if an operation is applied to a DynamicMap with an RangeXY, this switch determines whether the corresponding visualization should update this stream with range changes originating from the newly generated axes.

streams = param.List(bounds=(0, None), default=[])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

interpolation = param.ObjectSelector(default=’steps-mid’, objects=[‘steps-pre’, ‘steps-mid’, ‘steps-post’, ‘linear’])

Controls the transition point of the step along the x-axis.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.interpolate_curve'>)
classmethod get_overlay_bounds(overlay)

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.interpolate_curve'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.interpolate_curve'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.interpolate_curve'>)
instance = functools.partial(<function ParameterizedFunction.instance>, <class 'holoviews.operation.element.interpolate_curve'>)
message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.interpolate_curve'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)

The process_element method allows a single element to be operated on given an externally supplied key.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.interpolate_curve'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.interpolate_curve'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.element.method(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

Operation that wraps a method call

group = param.String(default=’Operation’)

The group string used to identify the output of the Operation. By default this should match the operation name.

dynamic = param.ObjectSelector(default=’default’, objects=[‘default’, True, False])

Whether the operation should be applied dynamically when a specific frame is requested, specified as a Boolean. If set to ‘default’ the mode will be determined based on the input type, i.e. if the data is a DynamicMap it will stay dynamic.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=False)

If the operation is dynamic, whether or not linked streams should be transferred from the operation inputs for backends that support linked streams. For example if an operation is applied to a DynamicMap with an RangeXY, this switch determines whether the corresponding visualization should update this stream with range changes originating from the newly generated axes.

streams = param.List(bounds=(0, None), default=[])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

output_type = param.ClassSelector(class_=<class ‘type’>)

The output type of the method operation

input_type = param.ClassSelector(class_=<class ‘type’>)

The object type the method is defined on

method_name = param.String(default=’__call__’)

The method name

args = param.List(bounds=(0, None), default=[])

The list of positional argument to pass to the method

kwargs = param.Dict(class_=<class ‘dict’>, default={})

The dict of keyword arguments to pass to the method

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.method'>)
classmethod get_overlay_bounds(overlay)

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.method'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.method'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.method'>)
instance = functools.partial(<function ParameterizedFunction.instance>, <class 'holoviews.operation.element.method'>)
message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.method'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)

The process_element method allows a single element to be operated on given an externally supplied key.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.method'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.method'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.element.operation(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

The most generic operation that wraps any callable into an Operation. The callable needs to accept an HoloViews component and a key (that may be ignored) and must return a new HoloViews component.

This class may be useful for turning a HoloViews method into an operation to define as compositor operation. For instance, the following definition:

operation.instance(op=lambda x, k: x.collapse(np.subtract))

Could be used to implement a collapse operation to subtracts the data between Rasters in an Overlay.

group = param.String(default=’Operation’)

The group assigned to the result after having applied the operator.

dynamic = param.ObjectSelector(default=’default’, objects=[‘default’, True, False])

Whether the operation should be applied dynamically when a specific frame is requested, specified as a Boolean. If set to ‘default’ the mode will be determined based on the input type, i.e. if the data is a DynamicMap it will stay dynamic.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=False)

If the operation is dynamic, whether or not linked streams should be transferred from the operation inputs for backends that support linked streams. For example if an operation is applied to a DynamicMap with an RangeXY, this switch determines whether the corresponding visualization should update this stream with range changes originating from the newly generated axes.

streams = param.List(bounds=(0, None), default=[])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

output_type = param.Parameter()

The output element type which may be None to disable type checking. May be used to declare useful information to other code in HoloViews e.g required for tab-completion support of operations registered with compositors.

op = param.Callable()

The operation used to generate a new HoloViews object returned by the operation. By default, the identity operation is applied.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.operation'>)
classmethod get_overlay_bounds(overlay)

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.operation'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.operation'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.operation'>)
instance = functools.partial(<function ParameterizedFunction.instance>, <class 'holoviews.operation.element.operation'>)
message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.operation'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)

The process_element method allows a single element to be operated on given an externally supplied key.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.operation'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.operation'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.element.threshold(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

Threshold a given Image whereby all values higher than a given level map to the specified high value and all values lower than that level map to the specified low value.

group = param.String(default=’Threshold’)

The group assigned to the thresholded output.

dynamic = param.ObjectSelector(default=’default’, objects=[‘default’, True, False])

Whether the operation should be applied dynamically when a specific frame is requested, specified as a Boolean. If set to ‘default’ the mode will be determined based on the input type, i.e. if the data is a DynamicMap it will stay dynamic.

input_ranges = param.ClassSelector(class_=(<class ‘dict’>, <class ‘tuple’>), default={})

Ranges to be used for input normalization (if applicable) in a format appropriate for the Normalization.ranges parameter. By default, no normalization is applied. If key-wise normalization is required, a 2-tuple may be supplied where the first component is a Normalization.ranges list and the second component is Normalization.keys.

link_inputs = param.Boolean(bounds=(0, 1), default=False)

If the operation is dynamic, whether or not linked streams should be transferred from the operation inputs for backends that support linked streams. For example if an operation is applied to a DynamicMap with an RangeXY, this switch determines whether the corresponding visualization should update this stream with range changes originating from the newly generated axes.

streams = param.List(bounds=(0, None), default=[])

List of streams that are applied if dynamic=True, allowing for dynamic interaction with the plot.

level = param.Number(default=0.5, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

The value at which the threshold is applied. Values lower than the threshold map to the ‘low’ value and values above map to the ‘high’ value.

high = param.Number(default=1.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

The value given to elements greater than (or equal to) the threshold.

low = param.Number(default=0.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

The value given to elements below the threshold.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.threshold'>)
classmethod get_overlay_bounds(overlay)

Returns the extents if all the elements of an overlay agree on a consistent extents, otherwise raises an exception.

classmethod get_overlay_label(overlay, default_label='')

Returns a label if all the elements of an overlay agree on a consistent label, otherwise returns the default label.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.threshold'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.threshold'>)
inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.threshold'>)
instance = functools.partial(<function ParameterizedFunction.instance>, <class 'holoviews.operation.element.threshold'>)
message(**kwargs)

Inspect .param.message method for the full docstring

output_type
params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.threshold'>)
pprint(imports=None, prefix='\n ', unknown_value='<?>', qualify=False, separator='')

Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

process_element(element, key, **params)

The process_element method allows a single element to be operated on given an externally supplied key.

script_repr(imports=[], prefix=' ')

Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y

classmethod search(element, pattern)

Helper method that returns a list of elements that match the given path pattern of form {type}.{group}.{label}.

The input may be a Layout, an Overlay type or a single Element.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.threshold'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.operation.element.threshold'>)
state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.operation.element.transform(*, fig, holomap, widgets, fps, max_frames, size, dpi, filename, info, css, widget_location)[source]

Bases: