Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
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)
"""
output_type = Image
group = param.String(default='Transform', doc="""
The group assigned to the result after applying the
transform.""")
operator = param.Callable(doc="""
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.""")
def _process(self, img, key=None):
processed = (img.data if not self.p.operator
else self.p.operator(img.data))
return img.clone(processed, group=self.p.group)
class image_overlay(Operation):
"""
Operation to build a overlay of images to a specification from a
subset of the required elements.
step_offset = param.Number(default=0, doc="""
The number of steps to offset the sweeper by.""")
reset_period = param.Number(default=4,bounds=(0,None),doc="""
Period between generating each new translation episode.""")
speed = param.Number(default=2.0/24.0,bounds=(0.0,None),doc="""
The speed with which the pattern should move,
in sheet coordinates per time_fn unit.""")
relative_motion_orientation = param.Number(default=pi/2.0,bounds=(0,2*pi),doc="""
The direction in which the pattern should be moved, relative
to the orientation of the supplied generator""")
time_fn = param.Callable(default=param.Dynamic.time_fn,doc="""
Function to generate the time used as a base for translation.""")
def num_channels(self):
return self.generator.num_channels()
def function(self, p):
motion_time_fn = OffsetTimeFn(offset=p.time_offset,
reset_period=p.reset_period,
time_fn=p.time_fn)
pg = p.generator
pg.set_dynamic_time_fn(motion_time_fn)
motion_orientation = pg.orientation + p.relative_motion_orientation
step = int(p.time_fn() % p.reset_period) + p.step_offset
class CrossSelector(CompositeWidget, MultiSelect):
"""
A composite widget which allows selecting from a list of items
by moving them between two lists. Supports filtering values by
name to select them in bulk.
"""
width = param.Integer(default=600, allow_None=True, doc="""
The number of options shown at once (note this is the
only way to control the height of this widget)""")
height = param.Integer(default=200, allow_None=True, doc="""
The number of options shown at once (note this is the
only way to control the height of this widget)""")
filter_fn = param.Callable(default=re.search, doc="""
The filter function applied when querying using the text
fields, defaults to re.search. Function is two arguments, the
query or pattern and the item label.""")
size = param.Integer(default=10, doc="""
The number of options shown at once (note this is the only way
to control the height of this widget)""")
definition_order = param.Integer(default=True, doc="""
Whether to preserve definition order after filtering. Disable
to allow the order of selection to define the order of the
selected list.""")
def __init__(self, **params):
super(CrossSelector, self).__init__(**params)
# Compute selected and unselected values
mode must be supported.""")
size=param.Integer(100, doc="""
The rendered size as a percentage size""")
widget_mode = param.ObjectSelector(default='embed', objects=['embed', 'live'], doc="""
The widget mode determining whether frames are embedded or generated
'live' when interacting with the widget.""")
css = param.Dict(default={},
doc="Dictionary of CSS attributes and values to apply to HTML output")
info_fn = param.Callable(None, allow_None=True, constant=True, doc="""
Renderers do not support the saving of object info metadata""")
key_fn = param.Callable(None, allow_None=True, constant=True, doc="""
Renderers do not support the saving of object key metadata""")
post_render_hooks = param.Dict(default={'svg':[], 'png':[]}, doc="""
Optional dictionary of hooks that are applied to the rendered
data (according to the output format) before it is returned.
Each hook is passed the rendered data and the object that is
being rendered. These hooks allow post-processing of rendered
data before output is saved to file or displayed.""")
# Defines the valid output formats for each mode.
mode_formats = {'fig': {'default': [None, 'auto']},
'holomap': {'default': [None, 'auto']}}
# Define comms class and message handler for each mode
# The Comm opens a communication channel and the message
def estimate_label_width(labels):
"""
Given a list of labels, estimate the width in pixels
and return in a format accepted by CSS.
Necessarily an approximation, since the font is unknown
and is usually proportionally spaced.
"""
max_length = max([len(l) for l in labels])
return "{0}px".format(max(60,int(max_length*7.5)))
class Widgets(param.ParameterizedFunction):
callback = param.Callable(default=None, doc="""
Custom callable to execute on button press
(if `button`) else whenever a widget is changed,
Should accept a Parameterized object argument.""")
view_position = param.ObjectSelector(default='below',
objects=['below', 'right', 'left', 'above'],
doc="""
Layout position of any View parameter widgets.""")
next_n = param.Parameter(default=0, doc="""
When executing cells, integer number to execute (or 'all').
A value of zero means not to control cell execution.""")
on_init = param.Boolean(default=False, doc="""
Whether to do the action normally taken (executing cells
and/or calling a callable) when first instantiating this
A very short, identifiable human-readable string that
meaningfully describes the batch to be executed. Should not
include spaces as it may be used in filenames.''')
description = param.String(default='', doc='''
A short description of the purpose of the current set of tasks.''')
metadata = param.Dict(default={}, doc='''
Metadata information to add to the info file.''')
max_concurrency = param.Integer(default=2, allow_None=True, doc='''
Concurrency limit to impose on the launch. As the current class
uses subprocess locally, multiple processes are possible at
once. Set to None for no limit (eg. for clusters)''')
reduction_fn = param.Callable(default=None, doc='''
A callable that will be invoked when the Launcher has completed
all tasks. For example, this could inform the user of completion
(eg. send an e-mail) among other possibilities.''')
timestamp = param.NumericTuple(default=(0,)*9, doc='''
Optional override of timestamp (default timestamp set on launch
call) in Python struct_time 9-tuple format. Useful when you
need to have a known root_directory path (see root_directory
documentation) before launch. For example, you should store
state related to analysis (eg. pickles) in the same location as
everything else.''')
timestamp_format = param.String(default='%Y-%m-%d_%H%M', allow_None=True, doc='''
The timestamp format for the root directories in python datetime
format. If None, the timestamp is omitted from root directory
name.''')
#==================#
# Other operations #
#==================#
class collapse(Operation):
"""
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.
"""
fn = param.Callable(default=np.mean, doc="""
The function that is used to collapse the curve y-values for
each x-value.""")
def _process(self, overlay, key=None):
if isinstance(overlay, NdOverlay):
collapse_map = HoloMap(overlay)
else:
collapse_map = HoloMap({i: el for i, el in enumerate(overlay)})
return collapse_map.collapse(function=self.p.fn)
class gridmatrix(param.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
This class is designed to run commands that take a single numeric
argument that acts additively. Namely, it is expected that a slow
running command 'run_hook(X+Y)' can be arbitrarily broken up into
multiple, faster executing calls 'run_hook(X)' and 'run_hook(Y)'
without affecting the overall result.
For instance, this is suitable for simulations where the numeric
argument is the simulated time - typically, advancing 10 simulated
seconds takes about twice as long as advancing by 5 seconds.
"""
interval = param.Number(default=100, doc="""
The run interval used to break up updates to the progress bar.""")
run_hook = param.Callable(default=param.Dynamic.time_fn.advance, doc="""
By default updates time in param which is very fast and does
not need a progress bar. Should be set to some slower running
callable where display of progress level is desired.""")
def __init__(self, **params):
super(RunProgress,self).__init__(**params)
def __call__(self, value):
"""
Execute the run_hook to a total of value, breaking up progress
updates by the value specified by interval.
"""
completed = 0
while (value - completed) >= self.interval:
self.run_hook(self.interval)