def __init__(self, axes_list):
super(AxesManager, self).__init__()
self.events = Events()
self.events.indices_changed = Event("""
Event that triggers when the indices of the `AxesManager` changes
Triggers after the internal state of the `AxesManager` has been
updated.
Arguments:
----------
obj : The AxesManager that the event belongs to.
""", arguments=['obj'])
self.events.any_axis_changed = Event("""
Event that trigger when the space defined by the axes transforms.
Specifically, it triggers when one or more of the folloing
attributes changes on one or more of the axes:
`offset`, `size`, `scale`
Arguments:
----------
obj : The AxesManager that the event belongs to.
""", arguments=['obj'])
self.create_axes(axes_list)
# set_signal_dimension is called only if there is no current
# view. It defaults to spectrum
navigates = [i.navigate for i in self._axes]
if t.Undefined in navigates:
# Default to Signal1D view if the view is not fully defined
self.set_signal_dimension(len(axes_list))
self._update_attributes()
self._update_trait_handlers()
self._index = None # index for the iterator
def test_interactive_function_return_None(self):
e = Event()
def function_return_None():
print('function called')
hs.interactive(function_return_None, e)
e.trigger()
def test_interactive_sum(self):
s = self.s
e = Event()
ss = hs.interactive(s.sum, e, axis=0)
np.testing.assert_array_equal(ss.data, np.sum(s.data, axis=0))
s.data += 3.2
nt.assert_false(np.allclose(ss.data, np.sum(s.data, axis=0)))
e.trigger()
np.testing.assert_array_equal(ss.data, np.sum(s.data, axis=0))
def test_interactive_sum(self):
s = self.s
e = Event()
ss = hs.interactive(s.sum, e, axis=0)
np.testing.assert_array_equal(ss.data, np.sum(s.data, axis=0))
s.data += 3.2
assert not np.allclose(ss.data, np.sum(s.data, axis=0))
e.trigger()
np.testing.assert_array_equal(ss.data, np.sum(s.data, axis=0))
def __init__(self,
size,
index_in_array=None,
name=t.Undefined,
scale=1.,
offset=0.,
units=t.Undefined,
navigate=t.Undefined):
super(DataAxis, self).__init__()
self.events = Events()
self.events.index_changed = Event("""
Event that triggers when the index of the `DataAxis` changes
Triggers after the internal state of the `DataAxis` has been
updated.
Arguments:
---------
obj : The DataAxis that the event belongs to.
index : The new index
""",
arguments=["obj", 'index'])
self.events.value_changed = Event("""
Event that triggers when the value of the `DataAxis` changes
Triggers after the internal state of the `DataAxis` has been
updated.
Arguments:
---------
obj : The DataAxis that the event belongs to.
value : The new value
""",
arguments=["obj", 'value'])
self._suppress_value_changed_trigger = False
self._suppress_update_value = False
self.name = name
self.units = units
self.scale = scale
self.offset = offset
self.size = size
self.high_index = self.size - 1
self.low_index = 0
self.index = 0
self.update_axis()
self.navigate = navigate
self.axes_manager = None
self.on_trait_change(self.update_axis, ['scale', 'offset', 'size'])
self.on_trait_change(self._update_slice, 'navigate')
self.on_trait_change(self.update_index_bounds, 'size')
# The slice must be updated even if the default value did not
# change to correctly set its value.
self._update_slice(self.navigate)
def test_interactive_sum_no_out(self):
s = self.s
def sumf(axis):
return s.sum(axis=axis)
e = Event()
ss = hs.interactive(sumf, e, axis=0)
np.testing.assert_array_equal(ss.data, np.sum(s.data, axis=0))
s.data += 3.2
assert not np.allclose(ss.data, np.sum(s.data, axis=0))
e.trigger()
np.testing.assert_array_equal(ss.data, np.sum(s.data, axis=0))
def test_interactive_sum_no_out(self):
s = self.s
def sumf(axis):
return s.sum(axis=axis)
e = Event()
ss = hs.interactive(sumf, e, axis=0)
np.testing.assert_array_equal(ss.data, np.sum(s.data, axis=0))
s.data += 3.2
nt.assert_false(np.allclose(ss.data, np.sum(s.data, axis=0)))
e.trigger()
np.testing.assert_array_equal(ss.data, np.sum(s.data, axis=0))
def test_chained_interactive(self):
s = self.s
e1, e2 = Event(), Event()
ss = hs.interactive(s.sum, e1, axis=0)
sss = hs.interactive(ss.sum, e2, axis=0)
np.testing.assert_allclose(sss.data, np.sum(s.data, axis=(0, 1)))
s.data += 3.2
nt.assert_false(np.allclose(ss.data, np.sum(s.data, axis=(1))))
e1.trigger()
np.testing.assert_allclose(ss.data, np.sum(s.data, axis=(1)))
nt.assert_false(np.allclose(sss.data, np.sum(s.data, axis=(0, 1))))
e2.trigger()
np.testing.assert_allclose(sss.data, np.sum(s.data, axis=(0, 1)))
def test_chained_interactive(self):
s = self.s
e1, e2 = Event(), Event()
ss = hs.interactive(s.sum, e1, axis=0)
sss = hs.interactive(ss.sum, e2, axis=0)
np.testing.assert_allclose(sss.data, np.sum(s.data, axis=(0, 1)))
s.data += 3.2
assert not np.allclose(ss.data, np.sum(s.data, axis=(1)))
e1.trigger()
np.testing.assert_allclose(ss.data, np.sum(s.data, axis=(1)))
assert not np.allclose(sss.data, np.sum(s.data, axis=(0, 1)))
e2.trigger()
np.testing.assert_allclose(sss.data, np.sum(s.data, axis=(0, 1)))
def __init__(self, ax, **kwargs):
onselect = kwargs.pop('onselect', self.dummy)
direction = kwargs.pop('direction', 'horizontal')
useblit = kwargs.pop('useblit', ax.figure.canvas.supports_blit)
SpanSelector.__init__(self,
ax,
onselect,
direction=direction,
useblit=useblit,
span_stays=False,
**kwargs)
# The tolerance in points to pick the rectangle sizes
self.tolerance = preferences.Plot.pick_tolerance
self.on_move_cid = None
self._range = None
self.step_ax = None
self.bounds_check = False
self._button_down = False
self.snap_size = False
self.snap_position = False
self.events = Events()
self.events.changed = Event(doc="""
Event that triggers when the widget was changed.
Arguments:
----------
obj:
The widget that changed
""",
arguments=['obj'])
self.events.moved = Event(doc="""
Event that triggers when the widget was moved.
Arguments:
----------
obj:
The widget that changed
""",
arguments=['obj'])
self.events.resized = Event(doc="""
Event that triggers when the widget was resized.
Arguments:
----------
obj:
The widget that changed
""",
arguments=['obj'])
self.can_switch = False
def __init__(self):
self.events = Events()
self.events.closed = Event("""
Event that triggers when the line is closed.
Arguments:
obj: Signal1DLine instance
The instance that triggered the event.
""",
arguments=["obj"])
self.sf_lines = None
self.ax = None
# Data attributes
self.data_function = None
# args to pass to `__call__`
self.data_function_kwargs = {}
self.axis = None
self.axes_manager = None
self._plot_imag = False
self.norm = 'linear'
# Properties
self.auto_update = True
self.autoscale = 'v'
self._y_min = np.nan
self._y_max = np.nan
self.line = None
self.plot_indices = False
self.text = None
self.text_position = (
-0.1,
1.05,
)
self._line_properties = {}
self.type = "line"
def __init__(self):
self.events = Events()
self.events.closed = Event("""
Event that triggers when the line is closed.
Arguments:
obj: Signal1DLine instance
The instance that triggered the event.
""", arguments=["obj"])
self.sf_lines = None
self.ax = None
# Data attributes
self.data_function = None
self.axis = None
self.axes_manager = None
self.auto_update = True
self.get_complex = False
# Properties
self.line = None
self.autoscale = False
self.plot_indices = False
self.text = None
self.text_position = (-0.1, 1.05,)
self._line_properties = {}
self.type = "line"
def __init__(self, axes_manager, **kwargs):
super(DraggableWidgetBase, self).__init__(axes_manager, **kwargs)
self.events.moved = Event(doc="""
Event that triggers when the widget was moved.
The event triggers after the internal state of the widget has been
updated. This event does not differentiate on how the position of
the widget was changed, so it is the responsibility of the user
to suppress events as neccessary to avoid closed loops etc.
Arguments:
----------
obj:
The widget that was moved.
""",
arguments=['obj'])
self._snap_position = True
# Set default axes
if self.axes_manager is not None:
if self.axes_manager.navigation_dimension > 0:
self.axes = self.axes_manager.navigation_axes[0:1]
else:
self.axes = self.axes_manager.signal_axes[0:1]
else:
self._pos = np.array([0.])
def __init__(self):
# Data attributes
self.data = None
self.axes_manager = None
self.ax = None
self.auto_update = True
# Properties
self.marker = None
self._marker_properties = {}
self.signal = None
self._plot_on_signal = True
self.name = ''
self.plot_marker = True
# Events
self.events = Events()
self.events.closed = Event("""
Event triggered when a marker is closed.
Arguments
---------
marker : Marker
The marker that was closed.
""", arguments=['obj'])
self._closing = False
def __init__(self, ax, **kwargs):
onsel = kwargs.pop('onselect', self.dummy)
matplotlib.widgets.SpanSelector.__init__(self,
ax,
onsel,
direction='horizontal',
useblit=False,
**kwargs)
# The tolerance in points to pick the rectangle sizes
self.tolerance = 1
self.on_move_cid = None
self._range = None
self.step_ax = None
self.bounds_check = False
self.buttonDown = False
self.snap_size = False
self.snap_position = False
self.events = Events()
self.events.changed = Event(doc="""
Event that triggers when the widget was changed.
Arguments:
----------
obj:
The widget that changed
""",
arguments=['obj'])
self.events.moved = Event(doc="""
Event that triggers when the widget was moved.
Arguments:
----------
obj:
The widget that changed
""",
arguments=['obj'])
self.events.resized = Event(doc="""
Event that triggers when the widget was resized.
Arguments:
----------
obj:
The widget that changed
""",
arguments=['obj'])
self.can_switch = False
def test_recompute(self):
s = self.s
e1 = Event()
e2 = Event()
ss = hs.interactive(s.sum, e1, recompute_out_event=e2, axis=0)
# Check eveything as normal first
np.testing.assert_equal(ss.data, np.sum(s.data, axis=1))
# Modify axes and data in-place
s.crop(1, 1) # data shape (2, 3, 50)
# Check that data is no longer comparable
nt.assert_not_equal(ss.data.shape, np.sum(s.data, axis=1).shape)
# Check that normal event raises an exception due to the invalid shape
nt.assert_raises(ValueError, e1.trigger)
# Check that recompute event fixes issue
e2.trigger()
np.testing.assert_equal(ss.data, np.sum(s.data, axis=1))
# Finally, check that axes are updated as they should
nt.assert_equal(ss.axes_manager.navigation_axes[0].offset, 1)
def test_recompute(self):
s = self.s
e1 = Event()
e2 = Event()
ss = hs.interactive(s.sum, e1, recompute_out_event=e2, axis=0)
# Check eveything as normal first
np.testing.assert_equal(ss.data, np.sum(s.data, axis=1))
# Modify axes and data in-place
s.crop(1, 1) # data shape (2, 3, 50)
# Check that data is no longer comparable
nt.assert_not_equal(ss.data.shape, np.sum(s.data, axis=1).shape)
# Check that normal event raises an exception due to the invalid shape
nt.assert_raises(ValueError, e1.trigger)
# Check that recompute event fixes issue
e2.trigger()
np.testing.assert_equal(ss.data, np.sum(s.data, axis=1))
# Finally, check that axes are updated as they should
nt.assert_equal(ss.axes_manager.navigation_axes[0].offset, 1)
def __init__(self):
self.events = Events()
self.events.closed = Event("""
Event that triggers when the figure window is closed.
Arguments:
obj: SpectrumFigure instances
The instance that triggered the event.
""", arguments=["obj"])
def __init__(self, axes_manager=None, color='red', alpha=1.0, **kwargs):
self.axes_manager = axes_manager
self._axes = list()
self.ax = None
self.picked = False
self.selected = False
self._selected_artist = None
self._size = 1.
self._pos = np.array([0.])
self.__is_on = True
self.background = None
self.patch = []
self.color = color
self.alpha = alpha
self.cids = list()
self.blit = True
self.events = Events()
self.events.changed = Event(doc="""
Event that triggers when the widget has a significant change.
The event triggers after the internal state of the widget has been
updated.
Arguments:
----------
widget:
The widget that changed
""",
arguments=['obj'])
self.events.closed = Event(doc="""
Event that triggers when the widget closed.
The event triggers after the widget has already been closed.
Arguments:
----------
widget:
The widget that closed
""",
arguments=['obj'])
self._navigating = False
super(WidgetBase, self).__init__(**kwargs)
def test_two_recompute_events(self):
s = self.s
e1 = Event()
e2 = Event()
ss = hs.interactive(s.sum,
event=None,
recompute_out_event=(e1, e2),
axis=0)
s.data[:] = 0
e1.trigger()
np.testing.assert_equal(ss.data, np.sum(s.data, axis=1))
s.data[:] = 1
e2.trigger()
np.testing.assert_equal(ss.data, np.sum(s.data, axis=1))
def __init__(self):
self._draw_event_cid = None
self._background = None
self.events = Events()
self.events.closed = Event("""
Event that triggers when the figure window is closed.
Arguments:
obj: SpectrumFigure instances
The instance that triggered the event.
""", arguments=["obj"])
self.title = ""
self.ax_markers = list()
def __init__(self):
"""Sets up events.changed event, and inits HasTraits.
"""
super(BaseROI, self).__init__()
self.events = Events()
self.events.changed = Event("""
Event that triggers when the ROI has changed.
What constitues a change varies from ROI to ROI, but in general it
should correspond to the region selected by the ROI has changed.
Arguments:
----------
roi :
The ROI that was changed.
""", arguments=['roi'])
self.signal_map = dict()
def __init__(self, parameter_name_list):
self.events = Events()
self.events.active_changed = Event("""
Event that triggers when the `Component.active` changes.
The event triggers after the internal state of the `Component` has
been updated.
Arguments
---------
obj : Component
The `Component` that the event belongs to
active : bool
The new active state
""",
arguments=["obj", 'active'])
self.parameters = []
self.init_parameters(parameter_name_list)
self._update_free_parameters()
self.active = True
self._active_array = None
self.isbackground = False
self.convolved = True
self.parameters = tuple(self.parameters)
self._id_name = self.__class__.__name__
self._id_version = '1.0'
self._position = None
self.model = None
self.name = ''
self._whitelist = {
'_id_name': None,
'name': None,
'active_is_multidimensional': None,
'_active_array': None,
'active': None
}
self._slicing_whitelist = {'_active_array': 'inav'}
self._slicing_order = (
'active',
'active_is_multidimensional',
'_active_array',
)
def __init__(self):
self._twins = set()
self.events = Events()
self.events.value_changed = Event("""
Event that triggers when the `Parameter.value` changes.
The event triggers after the internal state of the `Parameter` has
been updated.
Arguments
---------
obj : Parameter
The `Parameter` that the event belongs to
value : {float | array}
The new value of the parameter
""",
arguments=["obj", 'value'])
self.std = None
self.component = None
self.grad = None
self.name = ''
self.units = ''
self._linear = False
self.map = None
self.model = None
self._whitelist = {
'_id_name': None,
'value': None,
'std': None,
'free': None,
'units': None,
'map': None,
'_bounds': None,
'ext_bounded': None,
'name': None,
'_linear': None,
'ext_force_positive': None,
'twin_function_expr': None,
'twin_inverse_function_expr': None,
'self': ('id', None),
}
self._slicing_whitelist = {'map': 'inav'}
def __init__(self, axes_manager, **kwargs):
super(ResizableDraggableWidgetBase, self).__init__(
axes_manager, **kwargs)
if not self.axes:
self._size = np.array([1])
self.size_step = 1 # = one step in index space
self._snap_size = True
self.events.resized = Event(doc="""
Event that triggers when the widget was resized.
The event triggers after the internal state of the widget has been
updated. This event does not differentiate on how the size of
the widget was changed, so it is the responsibility of the user
to suppress events as neccessary to avoid closed loops etc.
Arguments:
----------
obj:
The widget that was resized.
""", arguments=['obj'])
self.no_events_while_dragging = False
self._drag_store = None
def test_two_update_events(self):
s = self.s
e1 = Event()
e2 = Event()
ss = hs.interactive(
s.sum,
event=(
e1,
e2),
recompute_out_event=None,
axis=0)
s.data[:] = 0
e1.trigger()
np.testing.assert_equal(ss.data, np.sum(s.data, axis=1))
s.data[:] = 1
e2.trigger()
np.testing.assert_equal(ss.data, np.sum(s.data, axis=1))
