def apply_roi(self, roi):
# TODO: move this to state class?
# TODO: add back command stack here so as to be able to undo?
# cmd = command.ApplyROI(client=self.client, roi=roi)
# self._session.command_stack.do(cmd)
# TODO Does subset get applied to all data or just visible data?
bins = self.state.bins
x = roi.to_polygon()[0]
lo, hi = min(x), max(x)
if lo >= bins.min():
lo = bins[bins <= lo].max()
if hi <= bins.max():
hi = bins[bins >= hi].min()
roi_new = RangeROI(min=lo, max=hi, orientation='x')
for layer_artist in self._layer_artist_container:
if not isinstance(layer_artist.layer, Data):
continue
x_comp = layer_artist.layer.get_component(self.state.x_att)
subset_state = x_comp.subset_from_roi(self.state.x_att, roi_new,
coord='x')
mode = EditSubsetMode()
mode.update(self._data, subset_state, focus_data=layer_artist.layer)
def update_selection(selection, viewer):
"""Called after an ImageJ selection keypress. Assumes first dataset contains the
'x' and 'y' components. Builds a Glue SubsetState and applies it using Glue's current settings.
Selection consists of (xmin, xmax, ymin, ymax)
"""
xmin, xmax, ymin, ymax = selection
roi = RectangularROI(xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax)
xatt = lasagna.config.app.data_collection[0].data.find_component_id('x')
yatt = lasagna.config.app.data_collection[0].data.find_component_id('y')
xy_state = RoiSubsetState(xatt=xatt, yatt=yatt, roi=roi)
file_state = CategorySubsetState(viewer.source_id, viewer.source_val)
# selection only applies to data in displayed file
subset_state = AndState(xy_state, file_state)
data_collection = lasagna.config.app.data_collection
# if no subset groups selected, make a new one
layers = (lasagna.config.app._layer_widget.selected_layers())
subset_groups = [s for s in layers if isinstance(s, SubsetGroup)]
if len(subset_groups) == 0:
global fiji_label
new_label = 'Fiji %d' % fiji_label
fiji_label += 1
data_collection.new_subset_group(label=new_label,
subset_state=subset_state)
else:
edit_mode = EditSubsetMode()
edit_mode.update(data_collection, subset_state)
def apply_roi(self, roi):
x, _ = roi.to_polygon()
lo = min(x)
hi = max(x)
# expand roi to match bin edges
bins = self.bins
if lo >= bins.min():
lo = bins[bins <= lo].max()
if hi <= bins.max():
hi = bins[bins >= hi].min()
if self.xlog:
lo = 10 ** lo
hi = 10 ** hi
comp = list(self._get_data_components('x'))
if comp:
comp = comp[0]
if comp.categorical:
state = CategoricalRoiSubsetState.from_range(comp, self.component,
lo, hi)
else:
state = RangeSubsetState(lo, hi)
state.att = self.component
mode = EditSubsetMode()
visible = [d for d in self.data if self.is_layer_visible(d)]
focus = visible[0] if len(visible) > 0 else None
mode.update(self.data, state, focus_data=focus)
def mark_selected_dict(self, indices_dict):
subset_state = MultiElementSubsetState(indices_dict=indices_dict)
mode = EditSubsetMode()
if len(indices_dict) > 0:
mode.update(self.viewer._data,
subset_state,
focus_data=list(indices_dict)[0])
def apply_roi(self, roi):
# every editable subset is updated
# using specified ROI
if isinstance(roi, RangeROI):
lo, hi = roi.range()
att = self.xatt if roi.ori == 'x' else self.yatt
if self._check_categorical(att):
comp = list(self._get_data_components(roi.ori))
if comp:
subset_state = CategoricalRoiSubsetState.from_range(comp[0], att, lo, hi)
else:
subset_state = None
else:
subset_state = RangeSubsetState(lo, hi, att)
else:
if self._check_categorical(self.xatt) or self._check_categorical(self.yatt):
subset_state = self._process_categorical_roi(roi)
else:
subset_state = RoiSubsetState()
subset_state.xatt = self.xatt
subset_state.yatt = self.yatt
x, y = roi.to_polygon()
subset_state.roi = PolygonalROI(x, y)
mode = EditSubsetMode()
visible = [d for d in self._data if self.is_visible(d)]
focus = visible[0] if len(visible) > 0 else None
mode.update(self._data, subset_state, focus_data=focus)
def do(self, session):
self.old_states = {}
for data in self.data_collection:
for subset in data.subsets:
self.old_states[subset] = subset.subset_state
mode = EditSubsetMode()
mode.update(self.data_collection, self.subset_state)
def do(self, session):
self.old_states = {}
for data in self.data_collection:
for subset in data.subsets:
self.old_states[subset] = subset.subset_state
mode = EditSubsetMode()
mode.update(self.data_collection, self.subset_state)
def apply_roi(self, roi):
subset_state = RoiSubsetState()
xroi, yroi = roi.to_polygon()
x, y = self._get_plot_attributes()
subset_state.xatt = x
subset_state.yatt = y
subset_state.roi = PolygonalROI(xroi, yroi)
mode = EditSubsetMode()
mode.update(self.data, subset_state, focus_data=self.display_data)
def apply_roi(self, roi):
subset_state = RoiSubsetState()
xroi, yroi = roi.to_polygon()
x, y = self._get_plot_attributes()
subset_state.xatt = x
subset_state.yatt = y
subset_state.roi = PolygonalROI(xroi, yroi)
mode = EditSubsetMode()
mode.update(self.data, subset_state, focus_data=self.display_data)
def mark_selected(self, mask, data):
# We now make a subset state. For scatter plots we'll want to use an
# ElementSubsetState, while for cubes, we'll need to change to a
# MaskSubsetState.
subset_state = ElementSubsetState(indices=np.where(mask)[0], data=data)
# We now check what the selection mode is, and update the selection as
# needed (this is delegated to the correct subset mode).
mode = EditSubsetMode()
mode.update(self.viewer._data, subset_state, focus_data=data)
def _broadcast_selection(self):
if self.data is not None:
model = self.ui.table.selectionModel()
self.selected_rows = [self.model.order[x.row()] for x in model.selectedRows()]
subset_state = ElementSubsetState(self.selected_rows)
mode = EditSubsetMode()
mode.update(self.data, subset_state, focus_data=self.data)
def mark_selected(self, mask, data):
# We now make a subset state. For scatter plots we'll want to use an
# ElementSubsetState, while for cubes, we'll need to change to a
# MaskSubsetState.
subset_state = ElementSubsetState(indices=np.where(mask)[0], data=data)
# We now check what the selection mode is, and update the selection as
# needed (this is delegated to the correct subset mode).
mode = EditSubsetMode()
mode.update(self.viewer._data, subset_state, focus_data=data)
def mark_selected(self, mask, visible_data):
# We now make a subset state. For scatter plots we'll want to use an
# ElementSubsetState, while for cubes, we'll need to change to a
# MaskSubsetState.
subset_state = ElementSubsetState(np.where(mask)[0])
# We now check what the selection mode is, and update the selection as
# needed (this is delegated to the correct subset mode).
mode = EditSubsetMode()
focus = visible_data[0] if len(visible_data) > 0 else None
mode.update(self._data_collection, subset_state, focus_data=focus)
def mark_selected(self, mask, visible_data):
# We now make a subset state. For scatter plots we'll want to use an
# ElementSubsetState, while for cubes, we'll need to change to a
# MaskSubsetState.
subset_state = ElementSubsetState(np.where(mask)[0])
# We now check what the selection mode is, and update the selection as
# needed (this is delegated to the correct subset mode).
mode = EditSubsetMode()
focus = visible_data[0] if len(visible_data) > 0 else None
mode.update(self._data_collection, subset_state, focus_data=focus)
def _apply_roi(self, roi):
x_comp = self.state.x_att.parent.get_component(self.state.x_att)
y_comp = self.state.y_att.parent.get_component(self.state.y_att)
subset_state = x_comp.subset_from_roi(self.state.x_att, roi,
other_comp=y_comp,
other_att=self.state.y_att,
coord='x')
mode = EditSubsetMode()
mode.update(self._data, subset_state)
def finalize_selection(self, clear=True):
model = self.ui.table.selectionModel()
selected_rows = [self.model.order[x.row()] for x in model.selectedRows()]
subset_state = ElementSubsetState(indices=selected_rows, data=self.data)
mode = EditSubsetMode()
mode.update(self._data, subset_state, focus_data=self.data)
if clear:
# We block the signals here to make sure that we don't update
# the subset again once the selection is cleared.
self.ui.table.blockSignals(True)
self.ui.table.clearSelection()
self.ui.table.blockSignals(False)
def finalize_selection(self, clear=True):
model = self.ui.table.selectionModel()
selected_rows = [self.model.order[x.row()] for x in model.selectedRows()]
subset_state = ElementSubsetState(indices=selected_rows, data=self.data)
mode = EditSubsetMode()
mode.update(self._data, subset_state, focus_data=self.data)
if clear:
# We block the signals here to make sure that we don't update
# the subset again once the selection is cleared.
self.ui.table.blockSignals(True)
self.ui.table.clearSelection()
self.ui.table.blockSignals(False)
def _broadcast_selection(self):
if self.data is not None:
model = self.ui.table.selectionModel()
self.selected_rows = [
self.model.order[x.row()] for x in model.selectedRows()
]
subset_state = ElementSubsetState(self.selected_rows)
mode = EditSubsetMode()
mode.update(self.data, subset_state, focus_data=self.data)
def _apply_roi(self, roi):
x_comp = self.state.x_att.parent.get_component(self.state.x_att)
y_comp = self.state.y_att.parent.get_component(self.state.y_att)
subset_state = x_comp.subset_from_roi(self.state.x_att,
roi,
other_comp=y_comp,
other_att=self.state.y_att,
coord='x')
mode = EditSubsetMode()
mode.update(self._data, subset_state)
def _apply_roi(self, roi):
# TODO Does subset get applied to all data or just visible data?
x_comp = self.state.x_att.parent.get_component(self.state.x_att)
y_comp = self.state.y_att.parent.get_component(self.state.y_att)
subset_state = x_comp.subset_from_roi(self.state.x_att, roi,
other_comp=y_comp,
other_att=self.state.y_att,
coord='x')
mode = EditSubsetMode()
mode.update(self._data, subset_state)
def apply_roi(self, roi):
# every editable subset is updated
# using specified ROI
for x_comp, y_comp in zip(self._get_data_components('x'),
self._get_data_components('y')):
subset_state = x_comp.subset_from_roi(self.xatt, roi,
other_comp=y_comp,
other_att=self.yatt,
coord='x')
mode = EditSubsetMode()
visible = [d for d in self._data if self.is_visible(d)]
focus = visible[0] if len(visible) > 0 else None
mode.update(self._data, subset_state, focus_data=focus)
def _apply_roi(self, roi):
# TODO Does subset get applied to all data or just visible data?
x_comp = self.state.x_att.parent.get_component(self.state.x_att)
y_comp = self.state.y_att.parent.get_component(self.state.y_att)
subset_state = x_comp.subset_from_roi(self.state.x_att, roi,
other_comp=y_comp,
other_att=self.state.y_att,
coord='x')
mode = EditSubsetMode()
mode.update(self._data, subset_state)
def apply_roi(self, roi):
# every editable subset is updated
# using specified ROI
for x_comp, y_comp in zip(self._get_data_components('x'),
self._get_data_components('y')):
subset_state = x_comp.subset_from_roi(self.xatt,
roi,
other_comp=y_comp,
other_att=self.yatt,
coord='x')
mode = EditSubsetMode()
visible = [d for d in self._data if self.is_visible(d)]
focus = visible[0] if len(visible) > 0 else None
mode.update(self._data, subset_state, focus_data=focus)
def _floodfill_roi(self, mode):
"""
Callback for FloodfillMode.
"""
if mode._start_event is None or mode._end_event is None:
return
data = self.widget.client.display_data
att = self.widget.client.display_attribute
if data is None or att is None:
return
if data.size > WARN_THRESH and not self.widget._confirm_large_image(
data):
return
# Determine length of dragging action in units relative to the figure
width, height = mode._start_event.canvas.get_width_height()
dx = (mode._end_event.x - mode._start_event.x) / width
dy = (mode._end_event.y - mode._start_event.y) / height
length = np.hypot(dx, dy)
# Make sure the coordinates are converted to the nearest integer
x = int(round(mode._start_event.xdata))
y = int(round(mode._start_event.ydata))
if data.ndim == 2:
start_coord = (y, x)
else:
z = int(round(self.widget.client.slice[self.profile_axis]))
start_coord = (z, y, x)
# We convert the length in relative figure units to a threshold - we make
# it so that moving by 0.1 produces a threshold of 1.1, 0.2 -> 2, 0.3 -> 11
# etc
threshold = 1 + 10**(length / 0.1 - 1)
# coordinate should be integers as index for array
values = np.asarray(data[att], dtype=float)
mask = floodfill_scipy(values, start_coord, threshold)
if mask is not None:
cids = data.pixel_component_ids
subset_state = MaskSubsetState(mask, cids)
mode = EditSubsetMode()
mode.update(data, subset_state, focus_data=data)
def _floodfill_roi(self, mode):
"""
Callback for FloodfillMode.
"""
if mode._start_event is None or mode._end_event is None:
return
data = self.widget.client.display_data
att = self.widget.client.display_attribute
if data is None or att is None:
return
if data.size > WARN_THRESH and not self.widget._confirm_large_image(data):
return
# Determine length of dragging action in units relative to the figure
width, height = mode._start_event.canvas.get_width_height()
dx = (mode._end_event.x - mode._start_event.x) / width
dy = (mode._end_event.y - mode._start_event.y) / height
length = np.hypot(dx, dy)
# Make sure the coordinates are converted to the nearest integer
x = int(round(mode._start_event.xdata))
y = int(round(mode._start_event.ydata))
if data.ndim == 2:
start_coord = (y, x)
else:
z = int(round(self.widget.client.slice[self.profile_axis]))
start_coord = (z, y, x)
# We convert the length in relative figure units to a threshold - we make
# it so that moving by 0.1 produces a threshold of 1.1, 0.2 -> 2, 0.3 -> 11
# etc
threshold = 1 + 10 ** (length / 0.1 - 1)
# coordinate should be integers as index for array
values = np.asarray(data[att], dtype=float)
mask = floodfill_scipy(values, start_coord, threshold)
if mask is not None:
cids = data.pixel_component_ids
subset_state = MaskSubsetState(mask, cids)
mode = EditSubsetMode()
mode.update(data, subset_state, focus_data=data)
def _apply_roi(self, roi):
# TODO Does subset get applied to all data or just visible data?
bins = self.state.bins
x = roi.to_polygon()[0]
lo, hi = min(x), max(x)
if lo >= bins.min():
lo = bins[bins <= lo].max()
if hi <= bins.max():
hi = bins[bins >= hi].min()
roi_new = RangeROI(min=lo, max=hi, orientation='x')
x_comp = self.state.x_att.parent.get_component(self.state.x_att)
subset_state = x_comp.subset_from_roi(self.state.x_att, roi_new,
coord='x')
mode = EditSubsetMode()
mode.update(self._data, subset_state)
def apply_roi(self, roi):
x, _ = roi.to_polygon()
lo = min(x)
hi = max(x)
# expand roi to match bin edges
bins = self.bins
if lo >= bins.min():
lo = bins[bins <= lo].max()
if hi <= bins.max():
hi = bins[bins >= hi].min()
if self.xlog:
lo = 10 ** lo
hi = 10 ** hi
nroi = RangeROI(min=lo, max=hi, orientation='x')
for comp in self._get_data_components('x'):
state = comp.subset_from_roi(self.component, nroi, coord='x')
mode = EditSubsetMode()
visible = [d for d in self.data if self.is_layer_visible(d)]
focus = visible[0] if len(visible) > 0 else None
mode.update(self.data, state, focus_data=focus)
def apply_roi(self, roi):
x, _ = roi.to_polygon()
lo = min(x)
hi = max(x)
# expand roi to match bin edges
bins = self.bins
if lo >= bins.min():
lo = bins[bins <= lo].max()
if hi <= bins.max():
hi = bins[bins >= hi].min()
if self.xlog:
lo = 10**lo
hi = 10**hi
nroi = RangeROI(min=lo, max=hi, orientation='x')
for comp in self._get_data_components('x'):
state = comp.subset_from_roi(self.component, nroi, coord='x')
mode = EditSubsetMode()
visible = [d for d in self.data if self.is_layer_visible(d)]
focus = visible[0] if len(visible) > 0 else None
mode.update(self.data, state, focus_data=focus)
def _apply_roi(self, roi):
# TODO Does subset get applied to all data or just visible data?
bins = self.state.bins
x = roi.to_polygon()[0]
lo, hi = min(x), max(x)
if lo >= bins.min():
lo = bins[bins <= lo].max()
if hi <= bins.max():
hi = bins[bins >= hi].min()
roi_new = RangeROI(min=lo, max=hi, orientation='x')
x_comp = self.state.x_att.parent.get_component(self.state.x_att)
subset_state = x_comp.subset_from_roi(self.state.x_att,
roi_new,
coord='x')
mode = EditSubsetMode()
mode.update(self._data, subset_state)
def mark_selected_dict(self, mask_dict):
subset_state = MultiMaskSubsetState(mask_dict=mask_dict)
mode = EditSubsetMode()
if len(mask_dict) > 0:
mode.update(self.viewer._data, subset_state, focus_data=list(mask_dict)[0])
def mark_selected_dict(self, indices_dict):
subset_state = MultiElementSubsetState(indices_dict=indices_dict)
mode = EditSubsetMode()
if len(indices_dict) > 0:
mode.update(self.viewer._data, subset_state, focus_data=list(indices_dict)[0])
def receive_message(self, private_key, sender_id, msg_id, mtype, params,
extra):
logger.info(
'SAMP: received message - sender_id={0} msg_id={1} mtype={2} '
'params={3} extra={4}'.format(sender_id, msg_id, mtype, params,
extra))
if mtype.startswith('table.load'):
if self.table_id_exists(params['table-id']):
logger.info('SAMP: table with table-id={0} has already '
'been read in'.format(params['table-id']))
return
logger.info('SAMP: loading table with table-id={0}'.format(
params['table-id']))
if mtype == 'table.load.votable':
data = astropy_tabular_data_votable(params['url'])
elif mtype == 'table.load.fits':
data = astropy_tabular_data_fits(params['url'])
else:
logger.info('SAMP: unknown format {0}'.format(
mtype.split('.')[-1]))
return
data.label = params['name']
data.meta['samp-table-id'] = params['table-id']
self.data_collection.append(data)
elif mtype.startswith('image.load'):
if self.image_id_exists(params['image-id']):
logger.info('SAMP: image with image-id={0} has already '
'been read in'.format(params['image-id']))
return
logger.info('SAMP: loading image with image-id={0}'.format(
params['image-id']))
if mtype == 'image.load.fits':
data = fits_reader(params['url'])
else:
logger.info('SAMP: unknown format {0}'.format(
mtype.split('.')[-1]))
return
data.label = params['name']
data.meta['samp-image-id'] = params['image-id']
self.data_collection.append(data)
elif self.state.highlight_is_selection and mtype == 'table.highlight.row':
data = self.data_from_table_id(params['table-id'])
len(self.data_collection.subset_groups)
subset_state = ElementSubsetState(indices=[params['row']],
data=data)
mode = EditSubsetMode()
mode.update(self.data_collection, subset_state)
elif mtype == 'table.select.rowList':
data = self.data_from_table_id(params['table-id'])
len(self.data_collection.subset_groups)
rows = np.asarray(params['row-list'], dtype=int)
subset_state = ElementSubsetState(indices=rows, data=data)
mode = EditSubsetMode()
mode.update(self.data_collection, subset_state)
elif mtype == 'samp.hub.event.register' or mtype == 'samp.hub.event.unregister':
self.state.on_client_change()
