class BqplotImageLayerState(ImageLayerState): c_min = DDCProperty(docstring='The lower level used for the contours') c_max = DDCProperty(docstring='The upper level used for the contours') level_mode = DDSCProperty(0, docstring='How to distribute the contour levels') n_levels = DDCProperty(5, docstring='The number of levels, in Linear mode') levels = CallbackProperty(docstring='List of values where to create the contour lines') labels = CallbackProperty(docstring='List of labels for each contour') contour_percentile = DDSCProperty(docstring='The percentile value used to ' 'automatically calculate levels for ' 'the contour') contour_colors = CallbackProperty(["red", "orange", "yellow", "green", "blue"]) bitmap_visible = CallbackProperty(True, 'whether to show the image as a bitmap') contour_visible = CallbackProperty(False, 'whether to show the image as contours') def __init__(self, *args, **kwargs): super(BqplotImageLayerState, self).__init__(*args, **kwargs) BqplotImageLayerState.level_mode.set_choices(self, ['Linear', 'Custom']) percentile_display = {100: 'Min/Max', 99.5: '99.5%', 99: '99%', 95: '95%', 90: '90%', 'Custom': 'Custom'} BqplotImageLayerState.contour_percentile.set_choices(self, [100, 99.5, 99, 95, 90, 'Custom']) BqplotImageLayerState.contour_percentile.set_display_func(self, percentile_display.get) self.contour_lim_helper = StateAttributeLimitsHelper(self, attribute='attribute', percentile='contour_percentile', lower='c_min', upper='c_max') self.add_callback('n_levels', self._update_levels) self.add_callback('c_min', self._update_levels) self.add_callback('c_max', self._update_levels) self.add_callback('level_mode', self._update_levels) self.add_callback('levels', self._update_labels) self._update_levels() def _update_priority(self, name): # if levels and level_mode get modified at the same time # make sure externally 'levels' is set first, so we then # can overwrite levels when we switch to Linear mode # this is tested in test_contour_state if name == 'levels': return 10 return 0 def _update_levels(self, ignore=None): if self.level_mode == "Linear": # TODO: this is exclusive begin/end point, is that a good choise? self.levels = np.linspace(self.c_min, self.c_max, self.n_levels+2)[1:-1].tolist() def _update_labels(self, ignore=None): # TODO: we may want to have ways to configure this in the future self.labels = ["{0:.4g}".format(level) for level in self.levels]
class CubevizImageLayerState(ImageLayerState): """ Sub-class of ImageLayerState that includes the ability to include smoothing on-the-fly. """ preview_function = None # Override glue default global_sync = DDCProperty(False) def get_sliced_data(self, view=None, bounds=None): """ Override and modify ImageLayerState.get_sliced_data so that if CubevizImageLayerState.preview_function is defined, it is applied to the data before return. """ self._cache = None if self.preview_function is None: return super(CubevizImageLayerState, self).get_sliced_data(view=view) else: image = super(CubevizImageLayerState, self).get_sliced_data() image = self.preview_function(image) if view is not None: image = image[view] return image
class TutorialLayerState(MatplotlibLayerState): # cmap is stuff used for colormap linewidth = CallbackProperty(1, docstring='line width') cmap_mode = DDSCProperty( docstring="Whether to use color to encode an attribute") cmap_att = DDSCProperty(docstring="The attribute to use for the color") cmap_vmin = DDCProperty(docstring="The lower level for the colormap") cmap_vmax = DDCProperty(docstring="The upper level for the colormap") cmap = DDCProperty(docstring="The colormap to use (when in colormap mode)") def __init__(self, viewer_state=None, layer=None, **kwargs): super(TutorialLayerState, self).__init__(viewer_state=viewer_state, layer=layer) # set choices basically poplutes drop down menus TutorialLayerState.cmap_mode.set_choices(self, ['Fixed', 'Linear']) self.cmap_att_helper = ComponentIDComboHelper(self, 'cmap_att', numeric=True, categorical=False) self.add_callback('layer', self._on_layers_change) # kind of initializing. not having this line # made errors for cmap initialization- didn't pull # up linear part # thanks tom self._on_layers_change() def _on_layers_change(self, layer=None): # not exactly sure of this with delay_callback(self, 'cmap_vmin', 'cmap_vmax'): self.cmap_att_helper.set_multiple_data([self.layer]) # not having this line threw None resulting in an error- can't # iterate over None.... # this initializes some colormap # thanks tom self.cmap = colormaps.members[0][1]
class DendrogramLayerState(MatplotlibLayerState): """ A state class that includes all the attributes for layers in a dendrogram plot. """ linewidth = DDCProperty(1, docstring="The line width") def __init__(self, viewer_state=None, **kwargs): super(DendrogramLayerState, self).__init__(viewer_state=viewer_state, **kwargs) self.linewidth = self.layer.style.linewidth self._sync_linewidth = keep_in_sync(self, 'linewidth', self.layer.style, 'linewidth')
class TutorialViewerState(MatplotlibDataViewerState): # x is parent; y is height. x_att = SelectionCallbackProperty( docstring='The attribute to use on the x-axis') y_att = SelectionCallbackProperty( docstring='The attribute to use on the y-axis') # change to parent and height # Tom is awesome! orientation = SelectionCallbackProperty(docstring='The orientation ....') sort_by = SelectionCallbackProperty(docstring='Sort by option ....') select_substruct = DDCProperty(True) def __init__(self, *args, **kwargs): # provides dropdown, parent, height etc. for plot options super(TutorialViewerState, self).__init__(*args, **kwargs) self._x_att_helper = ComponentIDComboHelper(self, 'x_att') self._y_att_helper = ComponentIDComboHelper(self, 'y_att') self.add_callback('layers', self._on_layers_change) self.add_callback('x_att', self._on_attribute_change) self.add_callback('y_att', self._on_attribute_change) TutorialViewerState.orientation.set_choices( self, ['bottom-up', 'left-right', 'top-down', 'right-left']) self.add_callback('orientation', self._on_attribute_change) TutorialViewerState.sort_by.set_choices(self, ['parent', 'height']) self.add_callback('sort_by', self._on_attribute_change) def _on_layers_change(self, value): # populates attributes self._x_att_helper.set_multiple_data(self.layers_data) self._y_att_helper.set_multiple_data(self.layers_data) def _on_attribute_change(self, value): if self.y_att is not None: # used for labels and axes depedning on orientation if (self.orientation == 'bottom-up') or (self.orientation == 'top-down'): self.x_axislabel = '' self.y_axislabel = self.y_att.label elif (self.orientation == 'left-right') or (self.orientation == 'right-left'): self.x_axislabel = self.y_att.label self.y_axislabel = ''
class ProfileViewerState(MatplotlibDataViewerState): """ A state class that includes all the attributes for a Profile viewer. """ reference_data = DDSCProperty( docstring='The dataset that is used to define the ' 'available pixel/world components, and ' 'which defines the coordinate frame in ' 'which the images are shown') x_att = DDSCProperty(docstring='The data component to use for the x-axis ' 'of the profile (should be a pixel component)') function = DDSCProperty( docstring='The function to use for collapsing data') normalize = DDCProperty(False, docstring='Whether to normalize all profiles ' 'to the [0:1] range') # TODO: add function to use def __init__(self, **kwargs): super(ProfileViewerState, self).__init__() self.ref_data_helper = ManualDataComboHelper(self, 'reference_data') self.x_lim_helper = StateAttributeLimitsHelper(self, 'x_att', lower='x_min', upper='x_max') self.add_callback('layers', self._layers_changed) self.add_callback('reference_data', self._reference_data_changed) self.add_callback('normalize', self._reset_y_limits) self.x_att_helper = ComponentIDComboHelper(self, 'x_att', numeric=False, categorical=False, world_coord=True, pixel_coord=True) ProfileViewerState.function.set_choices(self, list(FUNCTIONS)) ProfileViewerState.function.set_display_func(self, FUNCTIONS.get) self.update_from_dict(kwargs) def _update_combo_ref_data(self): self.ref_data_helper.set_multiple_data(self.layers_data) def reset_limits(self): with delay_callback(self, 'x_min', 'x_max', 'y_min', 'y_max'): self.x_lim_helper.percentile = 100 self.x_lim_helper.update_values(force=True) self._reset_y_limits() def _reset_y_limits(self, *event): if self.normalize: self.y_min = -0.1 self.y_max = +1.1 def _update_priority(self, name): if name == 'layers': return 2 elif name.endswith(('_min', '_max')): return 0 else: return 1 def flip_x(self): """ Flip the x_min/x_max limits. """ self.x_lim_helper.flip_limits() @defer_draw def _layers_changed(self, *args): self._update_combo_ref_data() @defer_draw def _reference_data_changed(self, *args): if self.reference_data is None: self.x_att_helper.set_multiple_data([]) else: self.x_att_helper.set_multiple_data([self.reference_data]) if type(self.reference_data.coords) == Coordinates: self.x_att = self.reference_data.pixel_component_ids[0] else: self.x_att = self.reference_data.world_component_ids[0]
class ProfileLayerState(MatplotlibLayerState): """ A state class that includes all the attributes for layers in a Profile plot. """ linewidth = DDCProperty(1, docstring='The width of the line') attribute = DDSCProperty(docstring='The attribute shown in the layer') v_min = DDCProperty(docstring='The lower level shown') v_max = DDCProperty(docstring='The upper leven shown') percentile = DDSCProperty(docstring='The percentile value used to ' 'automatically calculate levels') def __init__(self, layer=None, viewer_state=None, **kwargs): super(ProfileLayerState, self).__init__(layer=layer, viewer_state=viewer_state) self.attribute_att_helper = ComponentIDComboHelper(self, 'attribute', numeric=True, categorical=False) percentile_display = { 100: 'Min/Max', 99.5: '99.5%', 99: '99%', 95: '95%', 90: '90%', 'Custom': 'Custom' } ProfileLayerState.percentile.set_choices( self, [100, 99.5, 99, 95, 90, 'Custom']) ProfileLayerState.percentile.set_display_func(self, percentile_display.get) self.add_callback('layer', self._update_attribute, priority=1000) self.add_callback('layer', self._update_profile, priority=1000) self.add_callback('attribute', self._update_profile, priority=1000) if layer is not None: self._update_attribute() self.update_from_dict(kwargs) def _update_attribute(self, *args): if self.layer is not None: self.attribute_att_helper.set_multiple_data([self.layer]) @property def independent_x_att(self): return is_convertible_to_single_pixel_cid( self.layer, self.viewer_state.x_att) is not None def normalize_values(self, values): return (np.asarray(values) - self.v_min) / (self.v_max - self.v_min) @property def viewer_state(self): return self._viewer_state @viewer_state.setter def viewer_state(self, viewer_state): self._viewer_state = viewer_state if viewer_state is not None: self._viewer_state.add_callback('x_att', self._update_profile, priority=1000) self._viewer_state.add_callback('function', self._update_profile, priority=1000) self._update_profile() @property def profile(self): return self._profile def _update_profile(self, *event): if self.viewer_state is None or self.viewer_state.x_att is None or self.attribute is None: self._profile = None, None return # Check what pixel axis in the current dataset x_att corresponds to pix_cid = is_convertible_to_single_pixel_cid(self.layer, self.viewer_state.x_att) if pix_cid is None: self._profile = None, None return # If we get here, then x_att does correspond to a single pixel axis in # the cube, so we now prepare a list of axes to collapse over. axes = tuple(i for i in range(self.layer.ndim) if i != pix_cid.axis) # We now get the y values for the data # TODO: in future we should optimize the case where the mask is much # smaller than the data to just average the relevant 'spaxels' in the # data rather than collapsing the whole cube. try: if isinstance(self.layer, Data): data = self.layer data_values = data[self.attribute] else: data = self.layer.data if isinstance(self.layer.subset_state, SliceSubsetState): data_values = self.layer.subset_state.to_array( self.layer.data, self.attribute) else: # We need to force a copy *and* convert to float just in case data_values = np.array(data[self.attribute], dtype=float) mask = self.layer.to_mask() if np.sum(mask) == 0: self._profile = [], [] return data_values[~mask] = np.nan except IncompatibleAttribute: self._profile = None, None return # Collapse along all dimensions except x_att if self.layer.ndim > 1: with warnings.catch_warnings(): warnings.simplefilter("ignore", category=RuntimeWarning) profile_values = self.viewer_state.function(data_values, axis=axes) else: profile_values = data_values # Finally, we get the coordinate values for the requested axis axis_view = [0] * data.ndim axis_view[pix_cid.axis] = slice(None) axis_values = data[self.viewer_state.x_att, axis_view] with delay_callback(self, 'v_min', 'v_max'): self._profile = axis_values, profile_values self.v_min = nanmin(profile_values) self.v_max = nanmax(profile_values)
class ScatterLayerState(MatplotlibLayerState): """ A state class that includes all the attributes for layers in a scatter plot. """ # Color cmap_mode = DDSCProperty( docstring="Whether to use color to encode an attribute") cmap_att = DDSCProperty(docstring="The attribute to use for the color") cmap_vmin = DDCProperty(docstring="The lower level for the colormap") cmap_vmax = DDCProperty(docstring="The upper level for the colormap") cmap = DDCProperty(docstring="The colormap to use (when in colormap mode)") # Points points_mode = DDSCProperty( docstring='Whether to use markers or a density map') # Markers markers_visible = DDCProperty(True, docstring="Whether to show markers") size = DDCProperty(docstring="The size of the markers") size_mode = DDSCProperty( docstring="Whether to use size to encode an attribute") size_att = DDSCProperty(docstring="The attribute to use for the size") size_vmin = DDCProperty(docstring="The lower level for the size mapping") size_vmax = DDCProperty(docstring="The upper level for the size mapping") size_scaling = DDCProperty(1, docstring="Relative scaling of the size") fill = DDCProperty(True, docstring="Whether to fill the markers") # Density map density_map = DDCProperty( False, docstring="Whether to show the points as a density map") stretch = DDSCProperty(default='log', docstring='The stretch used to render the layer, ' 'which should be one of ``linear``, ' '``sqrt``, ``log``, or ``arcsinh``') density_contrast = DDCProperty( 1, docstring="The dynamic range of the density map") # Note that we keep the dpi in the viewer state since we want it to always # be in sync between layers. # Line line_visible = DDCProperty( False, docstring="Whether to show a line connecting all positions") linewidth = DDCProperty(1, docstring="The line width") linestyle = DDSCProperty(docstring="The line style") # Errorbars xerr_visible = DDCProperty(False, docstring="Whether to show x error bars") yerr_visible = DDCProperty(False, docstring="Whether to show y error bars") xerr_att = DDSCProperty( docstring="The attribute to use for the x error bars") yerr_att = DDSCProperty( docstring="The attribute to use for the y error bars") # Vectors vector_visible = DDCProperty(False, docstring="Whether to show vector plot") vx_att = DDSCProperty( docstring="The attribute to use for the x vector arrow") vy_att = DDSCProperty( docstring="The attribute to use for the y vector arrow") vector_arrowhead = DDCProperty(False, docstring="Whether to show vector arrow") vector_mode = DDSCProperty( default_index=0, docstring="Whether to plot the vectors in cartesian or polar mode") vector_origin = DDSCProperty( default_index=1, docstring= "Whether to place the vector so that the origin is at the tail, middle, or tip" ) vector_scaling = DDCProperty( 1, docstring="The relative scaling of the arrow length") def __init__(self, viewer_state=None, layer=None, **kwargs): super(ScatterLayerState, self).__init__(viewer_state=viewer_state, layer=layer) self.limits_cache = {} self.cmap_lim_helper = StateAttributeLimitsHelper( self, attribute='cmap_att', lower='cmap_vmin', upper='cmap_vmax', limits_cache=self.limits_cache) self.size_lim_helper = StateAttributeLimitsHelper( self, attribute='size_att', lower='size_vmin', upper='size_vmax', limits_cache=self.limits_cache) self.cmap_att_helper = ComponentIDComboHelper(self, 'cmap_att', numeric=True, categorical=False) self.size_att_helper = ComponentIDComboHelper(self, 'size_att', numeric=True, categorical=False) self.xerr_att_helper = ComponentIDComboHelper(self, 'xerr_att', numeric=True, categorical=False) self.yerr_att_helper = ComponentIDComboHelper(self, 'yerr_att', numeric=True, categorical=False) self.vx_att_helper = ComponentIDComboHelper(self, 'vx_att', numeric=True, categorical=False) self.vy_att_helper = ComponentIDComboHelper(self, 'vy_att', numeric=True, categorical=False) points_mode_display = { 'auto': 'Density map or markers (auto)', 'markers': 'Markers', 'density': 'Density map' } ScatterLayerState.points_mode.set_choices( self, ['auto', 'markers', 'density']) ScatterLayerState.points_mode.set_display_func(self, points_mode_display.get) self.add_callback('points_mode', self._update_density_map_mode) ScatterLayerState.cmap_mode.set_choices(self, ['Fixed', 'Linear']) ScatterLayerState.size_mode.set_choices(self, ['Fixed', 'Linear']) linestyle_display = { 'solid': '–––––––', 'dashed': '– – – – –', 'dotted': '· · · · · · · ·', 'dashdot': '– · – · – ·' } ScatterLayerState.linestyle.set_choices( self, ['solid', 'dashed', 'dotted', 'dashdot']) ScatterLayerState.linestyle.set_display_func(self, linestyle_display.get) ScatterLayerState.vector_mode.set_choices(self, ['Cartesian', 'Polar']) vector_origin_display = { 'tail': 'Tail of vector', 'middle': 'Middle of vector', 'tip': 'Tip of vector' } ScatterLayerState.vector_origin.set_choices(self, ['tail', 'middle', 'tip']) ScatterLayerState.vector_origin.set_display_func( self, vector_origin_display.get) stretch_display = { 'linear': 'Linear', 'sqrt': 'Square Root', 'arcsinh': 'Arcsinh', 'log': 'Logarithmic' } ScatterLayerState.stretch.set_choices( self, ['linear', 'sqrt', 'arcsinh', 'log']) ScatterLayerState.stretch.set_display_func(self, stretch_display.get) self.add_callback('layer', self._on_layer_change) if layer is not None: self._on_layer_change() self.cmap = colormaps.members[0][1] self.size = self.layer.style.markersize self._sync_size = keep_in_sync(self, 'size', self.layer.style, 'markersize') self.update_from_dict(kwargs) def _on_layer_change(self, layer=None): with delay_callback(self, 'cmap_vmin', 'cmap_vmax', 'size_vmin', 'size_vmax', 'density_map'): self._update_density_map_mode() if self.layer is None: self.cmap_att_helper.set_multiple_data([]) self.size_att_helper.set_multiple_data([]) else: self.cmap_att_helper.set_multiple_data([self.layer]) self.size_att_helper.set_multiple_data([self.layer]) if self.layer is None: self.xerr_att_helper.set_multiple_data([]) self.yerr_att_helper.set_multiple_data([]) else: self.xerr_att_helper.set_multiple_data([self.layer]) self.yerr_att_helper.set_multiple_data([self.layer]) if self.layer is None: self.vx_att_helper.set_multiple_data([]) self.vy_att_helper.set_multiple_data([]) else: self.vx_att_helper.set_multiple_data([self.layer]) self.vy_att_helper.set_multiple_data([self.layer]) def _update_density_map_mode(self, *args): if self.points_mode == 'auto': if self.layer.size > 100000: self.density_map = True else: self.density_map = False elif self.points_mode == 'density': self.density_map = True else: self.density_map = False def flip_cmap(self): """ Flip the cmap_vmin/cmap_vmax limits. """ self.cmap_lim_helper.flip_limits() def flip_size(self): """ Flip the size_vmin/size_vmax limits. """ self.size_lim_helper.flip_limits() @property def cmap_name(self): return colormaps.name_from_cmap(self.cmap) @classmethod def __setgluestate__(cls, rec, context): # Patch for glue files produced with glue v0.11 if 'style' in rec['values']: style = context.object(rec['values'].pop('style')) if style == 'Scatter': rec['values']['markers_visible'] = True rec['values']['line_visible'] = False elif style == 'Line': rec['values']['markers_visible'] = False rec['values']['line_visible'] = True return super(ScatterLayerState, cls).__setgluestate__(rec, context)
class ImageViewerState(MatplotlibDataViewerState): """ A state class that includes all the attributes for an image viewer. """ x_att = DDCProperty( docstring='The component ID giving the pixel component ' 'shown on the x axis') y_att = DDCProperty( docstring='The component ID giving the pixel component ' 'shown on the y axis') x_att_world = DDSCProperty( docstring='The component ID giving the world component ' 'shown on the x axis', default_index=-1) y_att_world = DDSCProperty( docstring='The component ID giving the world component ' 'shown on the y axis', default_index=-2) aspect = DDSCProperty( 0, docstring='Whether to enforce square pixels (``equal``) ' 'or fill the axes (``auto``)') reference_data = DDSCProperty( docstring='The dataset that is used to define the ' 'available pixel/world components, and ' 'which defines the coordinate frame in ' 'which the images are shown') slices = DDCProperty(docstring='The current slice along all dimensions') color_mode = DDSCProperty(0, docstring='Whether each layer can have ' 'its own colormap (``Colormaps``) or ' 'whether each layer is assigned ' 'a single color (``One color per layer``)') dpi = DDCProperty( 72, docstring= 'The resolution (in dots per inch) of density maps, if present') def __init__(self, **kwargs): super(ImageViewerState, self).__init__() self.limits_cache = {} # NOTE: we don't need to use StateAttributeLimitsHelper here because # we can simply call reset_limits below when x/y attributes change. # Using StateAttributeLimitsHelper makes things a lot slower. self.ref_data_helper = ManualDataComboHelper(self, 'reference_data') self.xw_att_helper = ComponentIDComboHelper(self, 'x_att_world', numeric=False, categorical=False) self.yw_att_helper = ComponentIDComboHelper(self, 'y_att_world', numeric=False, categorical=False) self.add_callback('reference_data', self._reference_data_changed, priority=1000) self.add_callback('layers', self._layers_changed, priority=1000) self.add_callback('x_att', self._on_xatt_change, priority=500) self.add_callback('y_att', self._on_yatt_change, priority=500) self.add_callback('x_att_world', self._update_att, priority=500) self.add_callback('y_att_world', self._update_att, priority=500) self.add_callback('x_att_world', self._on_xatt_world_change, priority=1000) self.add_callback('y_att_world', self._on_yatt_world_change, priority=1000) aspect_display = {'equal': 'Square Pixels', 'auto': 'Automatic'} ImageViewerState.aspect.set_choices(self, ['equal', 'auto']) ImageViewerState.aspect.set_display_func(self, aspect_display.get) ImageViewerState.color_mode.set_choices( self, ['Colormaps', 'One color per layer']) self.update_from_dict(kwargs) def reset_limits(self): if self.reference_data is None or self.x_att is None or self.y_att is None: return nx = self.reference_data.shape[self.x_att.axis] ny = self.reference_data.shape[self.y_att.axis] with delay_callback(self, 'x_min', 'x_max', 'y_min', 'y_max'): self.x_min = -0.5 self.x_max = nx - 0.5 self.y_min = -0.5 self.y_max = ny - 0.5 # We need to adjust the limits in here to avoid triggering all # the update events then changing the limits again. self._adjust_limits_aspect() @property def _display_world(self): return isinstance(getattr(self.reference_data, 'coords', None), Coordinates) def _reference_data_changed(self, *args): # This signal can get emitted if just the choices but not the actual # reference data change, so we check here that the reference data has # actually changed if self.reference_data is not getattr(self, '_last_reference_data', None): self._last_reference_data = self.reference_data with delay_callback(self, 'x_att_world', 'y_att_world', 'slices'): if self._display_world: self.xw_att_helper.pixel_coord = False self.yw_att_helper.pixel_coord = False self.xw_att_helper.world_coord = True self.yw_att_helper.world_coord = True else: self.xw_att_helper.pixel_coord = True self.yw_att_helper.pixel_coord = True self.xw_att_helper.world_coord = False self.yw_att_helper.world_coord = False self._update_combo_att() self._set_default_slices() def _layers_changed(self, *args): # The layers callback gets executed if anything in the layers changes, # but we only care about whether the actual set of 'layer' attributes # for all layers change. layers_data = self.layers_data layers_data_cache = getattr(self, '_layers_data_cache', []) if layers_data == layers_data_cache: return self._update_combo_ref_data() self._set_reference_data() self._update_syncing() self._layers_data_cache = layers_data def _update_syncing(self): # If there are multiple layers for a given dataset, we disable the # syncing by default. layer_state_by_data = defaultdict(list) for layer_state in self.layers: if isinstance(layer_state.layer, BaseData): layer_state_by_data[layer_state.layer].append(layer_state) for data, layer_states in layer_state_by_data.items(): if len(layer_states) > 1: for layer_state in layer_states: # Scatter layers don't have global_sync so we need to be # careful here and make sure we return a default value if getattr(layer_state, 'global_sync', False): layer_state.global_sync = False def _update_combo_ref_data(self): self.ref_data_helper.set_multiple_data(self.layers_data) def _update_combo_att(self): with delay_callback(self, 'x_att_world', 'y_att_world'): if self.reference_data is None: self.xw_att_helper.set_multiple_data([]) self.yw_att_helper.set_multiple_data([]) else: self.xw_att_helper.set_multiple_data([self.reference_data]) self.yw_att_helper.set_multiple_data([self.reference_data]) def _update_priority(self, name): if name == 'layers': return 3 elif name == 'reference_data': return 2 elif name.endswith(('_min', '_max')): return 0 else: return 1 @defer_draw def _update_att(self, *args): # Need to delay the callbacks here to make sure that we get a chance to # update both x_att and y_att otherwise could end up triggering image # slicing with two pixel components that are the same. with delay_callback(self, 'x_att', 'y_att'): if self.x_att_world is not None: if self._display_world: index = self.reference_data.world_component_ids.index( self.x_att_world) self.x_att = self.reference_data.pixel_component_ids[index] else: self.x_att = self.x_att_world if self.y_att_world is not None: if self._display_world: index = self.reference_data.world_component_ids.index( self.y_att_world) self.y_att = self.reference_data.pixel_component_ids[index] else: self.y_att = self.y_att_world @defer_draw def _on_xatt_change(self, *args): if self.x_att is not None: if self._display_world: self.x_att_world = self.reference_data.world_component_ids[ self.x_att.axis] else: self.x_att_world = self.x_att @defer_draw def _on_yatt_change(self, *args): if self.y_att is not None: if self._display_world: self.y_att_world = self.reference_data.world_component_ids[ self.y_att.axis] else: self.y_att_world = self.y_att @defer_draw def _on_xatt_world_change(self, *args): if self.x_att_world is not None and self.x_att_world == self.y_att_world: world_ids = self.reference_data.world_component_ids if self.x_att_world == world_ids[-1]: self.y_att_world = world_ids[-2] else: self.y_att_world = world_ids[-1] @defer_draw def _on_yatt_world_change(self, *args): if self.y_att_world is not None and self.y_att_world == self.x_att_world: world_ids = self.reference_data.world_component_ids if self.y_att_world == world_ids[-1]: self.x_att_world = world_ids[-2] else: self.x_att_world = world_ids[-1] def _set_reference_data(self): if self.reference_data is None: for layer in self.layers: if isinstance(layer.layer, BaseData): self.reference_data = layer.layer return def _set_default_slices(self): # Need to make sure this gets called immediately when reference_data is changed if self.reference_data is None: self.slices = () else: self.slices = (0, ) * self.reference_data.ndim @property def numpy_slice_aggregation_transpose(self): """ Returns slicing information usable by Numpy. This returns two objects: the first is an object that can be used to slice Numpy arrays and return a 2D array, and the second object is a boolean indicating whether to transpose the result. """ if self.reference_data is None: return None slices = [] agg_func = [] for i in range(self.reference_data.ndim): if i == self.x_att.axis or i == self.y_att.axis: slices.append(slice(None)) agg_func.append(None) else: if isinstance(self.slices[i], AggregateSlice): slices.append(self.slices[i].slice) agg_func.append(self.slices[i].function) else: slices.append(self.slices[i]) transpose = self.y_att.axis > self.x_att.axis return slices, agg_func, transpose @property def wcsaxes_slice(self): """ Returns slicing information usable by WCSAxes. This returns an iterable of slices, and including ``'x'`` and ``'y'`` for the dimensions along which we are not slicing. """ if self.reference_data is None: return None slices = [] for i in range(self.reference_data.ndim): if i == self.x_att.axis: slices.append('x') elif i == self.y_att.axis: slices.append('y') else: if isinstance(self.slices[i], AggregateSlice): slices.append(self.slices[i].center) else: slices.append(self.slices[i]) return slices[::-1] def flip_x(self): """ Flip the x_min/x_max limits. """ with delay_callback(self, 'x_min', 'x_max'): self.x_min, self.x_max = self.x_max, self.x_min def flip_y(self): """ Flip the y_min/y_max limits. """ with delay_callback(self, 'y_min', 'y_max'): self.y_min, self.y_max = self.y_max, self.y_min
class DendrogramViewerState(MatplotlibDataViewerState): """ A state class that includes all the attributes for a dendrogram viewer. """ height_att = DDSCProperty() parent_att = DDSCProperty() order_att = DDSCProperty() y_log = DDCProperty(False) select_substruct = DDCProperty(True) reference_data = DDCProperty() _layout = DDCProperty() def __init__(self, **kwargs): super(DendrogramViewerState, self).__init__() self.add_callback('layers', self._layers_changed) self.height_att_helper = ComponentIDComboHelper(self, 'height_att') self.parent_att_helper = ComponentIDComboHelper(self, 'parent_att') self.order_att_helper = ComponentIDComboHelper(self, 'order_att') self.add_callback('height_att', self._update_layout) self.add_callback('parent_att', self._update_layout) self.add_callback('order_att', self._update_layout) self.add_callback('reference_data', self._on_reference_data_change) self.update_from_dict(kwargs) def _on_reference_data_change(self, data): if self.reference_data is None: return self.height_att = self.reference_data.find_component_id('height') self.parent_att = self.reference_data.find_component_id('parent') self.order_att = self.height_att def _update_layout(self, att): if self.height_att is None or self.parent_att is None or self.order_att is None or self.reference_data is None: self._layout = None else: height = self.reference_data[self.height_att].ravel() parent = self.reference_data[self.parent_att].astype(int).ravel() order = self.reference_data[self.order_att].ravel() x, y = dendrogram_layout(parent, height, order) self._layout = Layout(x, y) def _layers_changed(self, *args): layers_data = self.layers_data layers_data_cache = getattr(self, '_layers_data_cache', []) if layers_data == layers_data_cache: return self.height_att_helper.set_multiple_data(layers_data) self.parent_att_helper.set_multiple_data(layers_data) self.order_att_helper.set_multiple_data(layers_data) for layer in layers_data: if isinstance(layer, Data): self.reference_data = layer break self._layers_data_cache = layers_data
class ProfileViewerState(MatplotlibDataViewerState): """ A state class that includes all the attributes for a Profile viewer. """ x_att_pixel = DDCProperty( docstring='The component ID giving the pixel component ' 'shown on the x axis') x_att = DDSCProperty( docstring='The component ID giving the pixel or world component ' 'shown on the x axis') reference_data = DDSCProperty( docstring='The dataset that is used to define the ' 'available pixel/world components, and ' 'which defines the coordinate frame in ' 'which the images are shown') function = DDSCProperty( docstring='The function to use for collapsing data') normalize = DDCProperty(False, docstring='Whether to normalize all profiles ' 'to the [0:1] range') # TODO: add function to use def __init__(self, **kwargs): super(ProfileViewerState, self).__init__() self.ref_data_helper = ManualDataComboHelper(self, 'reference_data') self.add_callback('layers', self._layers_changed) self.add_callback('reference_data', self._reference_data_changed) self.add_callback('x_att', self._update_att) self.add_callback('normalize', self._reset_y_limits) self.x_att_helper = ComponentIDComboHelper(self, 'x_att', numeric=False, categorical=False, pixel_coord=True) ProfileViewerState.function.set_choices(self, list(FUNCTIONS)) ProfileViewerState.function.set_display_func(self, FUNCTIONS.get) self.update_from_dict(kwargs) def _update_combo_ref_data(self): self.ref_data_helper.set_multiple_data(self.layers_data) def reset_limits(self): with delay_callback(self, 'x_min', 'x_max', 'y_min', 'y_max'): self._reset_x_limits() self._reset_y_limits() @property def _display_world(self): return (isinstance(getattr(self.reference_data, 'coords', None), Coordinates) and type(self.reference_data.coords) != Coordinates) @defer_draw def _update_att(self, *args): if self.x_att is not None: if self._display_world: if self.x_att in self.reference_data.pixel_component_ids: self.x_att_pixel = self.x_att else: index = self.reference_data.world_component_ids.index( self.x_att) self.x_att_pixel = self.reference_data.pixel_component_ids[ index] else: self.x_att_pixel = self.x_att self._reset_x_limits() def _reset_x_limits(self, *event): # NOTE: we don't use AttributeLimitsHelper because we need to avoid # trying to get the minimum of *all* the world coordinates in the # dataset. Instead, we use the same approach as in the layer state below # and in the case of world coordinates we use online the spine of the # data. if self.reference_data is None or self.x_att_pixel is None: return data = self.reference_data if self.x_att in data.pixel_component_ids: x_min, x_max = -0.5, data.shape[self.x_att.axis] - 0.5 else: axis = data.world_component_ids.index(self.x_att) axis_view = [0] * data.ndim axis_view[axis] = slice(None) axis_values = data[self.x_att, tuple(axis_view)] x_min, x_max = np.nanmin(axis_values), np.nanmax(axis_values) with delay_callback(self, 'x_min', 'x_max'): self.x_min = x_min self.x_max = x_max def _reset_y_limits(self, *event): if self.normalize: with delay_callback(self, 'y_min', 'y_max'): self.y_min = -0.1 self.y_max = +1.1 def flip_x(self): """ Flip the x_min/x_max limits. """ with delay_callback(self, 'x_min', 'x_max'): self.x_min, self.x_max = self.x_max, self.x_min @defer_draw def _layers_changed(self, *args): self._update_combo_ref_data() @defer_draw def _reference_data_changed(self, *args): # This signal can get emitted if just the choices but not the actual # reference data change, so we check here that the reference data has # actually changed if self.reference_data is not getattr(self, '_last_reference_data', None): self._last_reference_data = self.reference_data if self.reference_data is None: self.x_att_helper.set_multiple_data([]) else: self.x_att_helper.set_multiple_data([self.reference_data]) if self._display_world: self.x_att_helper.world_coord = True self.x_att = self.reference_data.world_component_ids[0] else: self.x_att_helper.world_coord = False self.x_att = self.reference_data.pixel_component_ids[0]
class ScatterViewerState(MatplotlibDataViewerState): """ A state class that includes all the attributes for a scatter viewer. """ x_att = DDSCProperty(docstring='The attribute to show on the x-axis', default_index=0) y_att = DDSCProperty(docstring='The attribute to show on the y-axis', default_index=1) dpi = DDCProperty( 72, docstring= 'The resolution (in dots per inch) of density maps, if present') plot_mode = DDSCProperty( docstring= "Whether to plot the data in cartesian, polar or another projection") angle_unit = DDSCProperty( docstring= "When plotting in polar mode, whether to use radians or degrees for the angles" ) def __init__(self, **kwargs): super(ScatterViewerState, self).__init__() self.limits_cache = {} self.x_lim_helper = StateAttributeLimitsHelper( self, attribute='x_att', lower='x_min', upper='x_max', log='x_log', margin=0.04, limits_cache=self.limits_cache) self.y_lim_helper = StateAttributeLimitsHelper( self, attribute='y_att', lower='y_min', upper='y_max', log='y_log', margin=0.04, limits_cache=self.limits_cache) self.add_callback('layers', self._layers_changed) self.x_att_helper = ComponentIDComboHelper(self, 'x_att', pixel_coord=True, world_coord=True) self.y_att_helper = ComponentIDComboHelper(self, 'y_att', pixel_coord=True, world_coord=True) self.plot_mode_helper = ComboHelper(self, 'plot_mode') self.plot_mode_helper.choices = [ proj for proj in get_projection_names() if proj not in ['3d', 'scatter_density'] ] self.plot_mode_helper.selection = 'rectilinear' self.angle_unit_helper = ComboHelper(self, 'angle_unit') self.angle_unit_helper.choices = ['radians', 'degrees'] self.angle_unit_helper.selection = 'radians' self.update_from_dict(kwargs) self.add_callback('x_log', self._reset_x_limits) self.add_callback('y_log', self._reset_y_limits) if self.using_polar: self.full_circle() def _reset_x_limits(self, *args): if self.x_att is None: return self.x_lim_helper.percentile = 100 self.x_lim_helper.update_values(force=True) def _reset_y_limits(self, *args): if self.y_att is None: return self.y_lim_helper.percentile = 100 self.y_lim_helper.update_values(force=True) def reset_limits(self): if not self.using_polar: self._reset_x_limits() self._reset_y_limits() def flip_x(self): """ Flip the x_min/x_max limits. """ self.x_lim_helper.flip_limits() def flip_y(self): """ Flip the y_min/y_max limits. """ self.y_lim_helper.flip_limits() @property def using_polar(self): return self.plot_mode == 'polar' @property def using_degrees(self): return self.using_polar and self.angle_unit == 'degrees' @property def using_radians(self): return self.using_polar and self.angle_unit == 'radians' def full_circle(self): if not self.using_polar: return self.x_min = 0 self.x_max = 2 * np.pi @property def x_categories(self): return self._categories(self.x_att) @property def y_categories(self): return self._categories(self.y_att) def _categories(self, cid): categories = [] for layer_state in self.layers: if isinstance(layer_state.layer, BaseData): layer = layer_state.layer else: layer = layer_state.layer.data try: if layer.data.get_kind(cid) == 'categorical': categories.append(layer.data.get_data(cid).categories) except IncompatibleAttribute: pass if len(categories) == 0: return None else: return np.unique(np.hstack(categories)) @property def x_kinds(self): return self._component_kinds(self.x_att) @property def y_kinds(self): return self._component_kinds(self.y_att) def _component_kinds(self, cid): # Construct list of component kinds over all layers kinds = set() for layer_state in self.layers: if isinstance(layer_state.layer, BaseData): layer = layer_state.layer else: layer = layer_state.layer.data try: kinds.add(layer.data.get_kind(cid)) except IncompatibleAttribute: pass return kinds def _layers_changed(self, *args): layers_data = self.layers_data layers_data_cache = getattr(self, '_layers_data_cache', []) if layers_data == layers_data_cache: return self.x_att_helper.set_multiple_data(self.layers_data) self.y_att_helper.set_multiple_data(self.layers_data) self._layers_data_cache = layers_data
class HistogramViewerState(MatplotlibDataViewerState): """ A state class that includes all the attributes for a histogram viewer. """ x_att = DDSCProperty( docstring='The attribute to compute the histograms for') cumulative = DDCProperty(False, docstring='Whether to show the histogram as ' 'a cumulative histogram') normalize = DDCProperty(False, docstring='Whether to normalize the histogram ' '(based on the total sum)') hist_x_min = DDCProperty(docstring='The minimum value used to compute the ' 'histogram') hist_x_max = DDCProperty(docstring='The maxumum value used to compute the ' 'histogram') hist_n_bin = DDCProperty(docstring='The number of bins in the histogram') common_n_bin = DDCProperty(True, docstring='The number of bins to use for ' 'all numerical components') def __init__(self, **kwargs): super(HistogramViewerState, self).__init__() self.hist_helper = StateAttributeHistogramHelper( self, 'x_att', lower='hist_x_min', upper='hist_x_max', n_bin='hist_n_bin', common_n_bin='common_n_bin') self.x_lim_helper = StateAttributeLimitsHelper(self, 'x_att', lower='x_min', upper='x_max', log='x_log') self.add_callback('layers', self._layers_changed) self.x_att_helper = ComponentIDComboHelper(self, 'x_att') self.update_from_dict(kwargs) def _update_priority(self, name): if name == 'layers': return 2 elif name.endswith('_log'): return 0.5 elif name.endswith(('_min', '_max', '_bin')): return 0 else: return 1 def flip_x(self): """ Flip the x_min/x_max limits. """ self.x_lim_helper.flip_limits() def update_bins_to_view(self): """ Update the bins to match the current view. """ with delay_callback(self, 'hist_x_min', 'hist_x_max'): if self.x_max > self.x_min: self.hist_x_min = self.x_min self.hist_x_max = self.x_max else: self.hist_x_min = self.x_max self.hist_x_max = self.x_min def _get_x_components(self): if self.x_att is None: return [] # Construct list of components over all layers components = [] for layer_state in self.layers: if isinstance(layer_state.layer, Data): layer = layer_state.layer else: layer = layer_state.layer.data try: components.append(layer.get_component(self.x_att)) except IncompatibleAttribute: pass return components @property def bins(self): """ The position of the bins for the histogram based on the current state. """ if self.x_log: return np.logspace(np.log10(self.hist_x_min), np.log10(self.hist_x_max), self.hist_n_bin + 1) else: return np.linspace(self.hist_x_min, self.hist_x_max, self.hist_n_bin + 1) @defer_draw def _layers_changed(self, *args): self.x_att_helper.set_multiple_data(self.layers_data)
class HistogramViewerState(MatplotlibDataViewerState): """ A state class that includes all the attributes for a histogram viewer. """ x_att = DDSCProperty( docstring='The attribute to compute the histograms for') cumulative = DDCProperty(False, docstring='Whether to show the histogram as ' 'a cumulative histogram') normalize = DDCProperty(False, docstring='Whether to normalize the histogram ' '(based on the total sum)') hist_x_min = DDCProperty(docstring='The minimum value used to compute the ' 'histogram') hist_x_max = DDCProperty(docstring='The maxumum value used to compute the ' 'histogram') hist_n_bin = DDCProperty(docstring='The number of bins in the histogram') common_n_bin = DDCProperty(True, docstring='The number of bins to use for ' 'all numerical components') def __init__(self, **kwargs): super(HistogramViewerState, self).__init__() self.hist_helper = StateAttributeHistogramHelper( self, 'x_att', lower='hist_x_min', upper='hist_x_max', n_bin='hist_n_bin', common_n_bin='common_n_bin') self.x_lim_helper = StateAttributeLimitsHelper(self, 'x_att', lower='x_min', upper='x_max', log='x_log') self.add_callback('layers', self._layers_changed) self.x_att_helper = ComponentIDComboHelper(self, 'x_att', pixel_coord=True, world_coord=True) self.update_from_dict(kwargs) # This should be added after update_from_dict since we don't want to # influence the restoring of sessions. self.add_callback('hist_x_min', self.update_view_to_bins) self.add_callback('hist_x_max', self.update_view_to_bins) self.add_callback('x_log', self._reset_x_limits, priority=1000) def _reset_x_limits(self, *args): with delay_callback(self, 'hist_x_min', 'hist_x_max', 'x_min', 'x_max', 'x_log'): self.x_lim_helper.percentile = 100 self.x_lim_helper.update_values(force=True) self.update_bins_to_view() def reset_limits(self): self._reset_x_limits() self.y_min = min( getattr(layer, '_y_min', np.inf) for layer in self.layers) self.y_max = max(getattr(layer, '_y_max', 0) for layer in self.layers) def _update_priority(self, name): if name == 'layers': return 2 elif name.endswith('_log'): return 0.5 elif name.endswith(('_min', '_max', '_bin')): return 0 else: return 1 def flip_x(self): """ Flip the x_min/x_max limits. """ self.x_lim_helper.flip_limits() @avoid_circular def update_bins_to_view(self, *args): """ Update the bins to match the current view. """ with delay_callback(self, 'hist_x_min', 'hist_x_max'): if self.x_max > self.x_min: self.hist_x_min = self.x_min self.hist_x_max = self.x_max else: self.hist_x_min = self.x_max self.hist_x_max = self.x_min @avoid_circular def update_view_to_bins(self, *args): """ Update the view to match the histogram interval """ with delay_callback(self, 'x_min', 'x_max'): self.x_min = self.hist_x_min self.x_max = self.hist_x_max @property def x_categories(self): return self._categories(self.x_att) def _categories(self, cid): categories = [] for layer_state in self.layers: if isinstance(layer_state.layer, BaseData): layer = layer_state.layer else: layer = layer_state.layer.data try: if layer.data.get_kind(cid) == 'categorical': categories.append(layer.data.get_data(cid).categories) except IncompatibleAttribute: pass if len(categories) == 0: return None else: return np.unique(np.hstack(categories)) @property def x_kinds(self): return self._component_kinds(self.x_att) def _component_kinds(self, cid): # Construct list of component kinds over all layers kinds = set() for layer_state in self.layers: if isinstance(layer_state.layer, BaseData): layer = layer_state.layer else: layer = layer_state.layer.data try: kinds.add(layer.data.get_kind(cid)) except IncompatibleAttribute: pass return kinds @property def bins(self): """ The position of the bins for the histogram based on the current state. """ if self.hist_x_min is None or self.hist_x_max is None or self.hist_n_bin is None: return None if self.x_log: return np.logspace(np.log10(self.hist_x_min), np.log10(self.hist_x_max), self.hist_n_bin + 1) elif isinstance(self.hist_x_min, np.datetime64): x_min = self.hist_x_min.astype(int) x_max = self.hist_x_max.astype(self.hist_x_min.dtype).astype(int) return np.linspace(x_min, x_max, self.hist_n_bin + 1).astype( self.hist_x_min.dtype) else: return np.linspace(self.hist_x_min, self.hist_x_max, self.hist_n_bin + 1) @defer_draw def _layers_changed(self, *args): self.x_att_helper.set_multiple_data(self.layers_data)
class ImageViewerState(MatplotlibDataViewerState): """ A state class that includes all the attributes for an image viewer. """ x_att = DDCProperty( docstring='The component ID giving the pixel component ' 'shown on the x axis') y_att = DDCProperty( docstring='The component ID giving the pixel component ' 'shown on the y axis') x_att_world = DDSCProperty( docstring='The component ID giving the world component ' 'shown on the x axis', default_index=-1) y_att_world = DDSCProperty( docstring='The component ID giving the world component ' 'shown on the y axis', default_index=-2) aspect = DDCProperty( 'equal', docstring='Whether to enforce square pixels (``equal``) ' 'or fill the axes (``auto``)') reference_data = DDSCProperty( docstring='The dataset that is used to define the ' 'available pixel/world components, and ' 'which defines the coordinate frame in ' 'which the images are shown') slices = DDCProperty(docstring='The current slice along all dimensions') color_mode = DDCProperty('Colormaps', docstring='Whether each layer can have ' 'its own colormap (``Colormaps``) or ' 'whether each layer is assigned ' 'a single color (``One color per layer``)') def __init__(self, **kwargs): super(ImageViewerState, self).__init__() self.limits_cache = {} self.x_lim_helper = StateAttributeLimitsHelper( self, attribute='x_att', lower='x_min', upper='x_max', limits_cache=self.limits_cache) self.y_lim_helper = StateAttributeLimitsHelper( self, attribute='y_att', lower='y_min', upper='y_max', limits_cache=self.limits_cache) self.ref_data_helper = ManualDataComboHelper(self, 'reference_data') self.xw_att_helper = ComponentIDComboHelper(self, 'x_att_world', numeric=False, categorical=False, visible=False, world_coord=True) self.yw_att_helper = ComponentIDComboHelper(self, 'y_att_world', numeric=False, categorical=False, visible=False, world_coord=True) self.add_callback('reference_data', self._reference_data_changed, priority=1000) self.add_callback('layers', self._layers_changed, priority=1000) self.add_callback('x_att', self._on_xatt_change, priority=500) self.add_callback('y_att', self._on_yatt_change, priority=500) self.add_callback('x_att_world', self._update_att, priority=500) self.add_callback('y_att_world', self._update_att, priority=500) self.add_callback('x_att_world', self._on_xatt_world_change, priority=1000) self.add_callback('y_att_world', self._on_yatt_world_change, priority=1000) self.update_from_dict(kwargs) def _reference_data_changed(self, *args): with delay_callback(self, 'x_att_world', 'y_att_world', 'slices'): self._update_combo_att() self._set_default_slices() def _layers_changed(self, *args): # The layers callback gets executed if anything in the layers changes, # but we only care about whether the actual set of 'layer' attributes # for all layers change. layers_data = self.layers_data layers_data_cache = getattr(self, '_layers_data_cache', []) if layers_data == layers_data_cache: return self._update_combo_ref_data() self._set_reference_data() self._update_syncing() self._layers_data_cache = layers_data def _update_syncing(self): # If there are multiple layers for a given dataset, we disable the # syncing by default. layer_state_by_data = defaultdict(list) for layer_state in self.layers: if isinstance(layer_state.layer, Data): layer_state_by_data[layer_state.layer].append(layer_state) for data, layer_states in layer_state_by_data.items(): if len(layer_states) > 1: for layer_state in layer_states: if layer_state.global_sync: layer_state.global_sync = False def _update_combo_ref_data(self): self.ref_data_helper.set_multiple_data(self.layers_data) def _update_combo_att(self): with delay_callback(self, 'x_att_world', 'y_att_world'): if self.reference_data is None: self.xw_att_helper.set_multiple_data([]) self.yw_att_helper.set_multiple_data([]) else: self.xw_att_helper.set_multiple_data([self.reference_data]) self.yw_att_helper.set_multiple_data([self.reference_data]) def _update_priority(self, name): if name == 'layers': return 3 elif name == 'reference_data': return 2 elif name.endswith(('_min', '_max')): return 0 else: return 1 @defer_draw def _update_att(self, *args): # Need to delay the callbacks here to make sure that we get a chance to # update both x_att and y_att otherwise could end up triggering image # slicing with two pixel components that are the same. with delay_callback(self, 'x_att', 'y_att'): if self.x_att_world is not None: index = self.reference_data.world_component_ids.index( self.x_att_world) self.x_att = self.reference_data.pixel_component_ids[index] if self.y_att_world is not None: index = self.reference_data.world_component_ids.index( self.y_att_world) self.y_att = self.reference_data.pixel_component_ids[index] @defer_draw def _on_xatt_change(self, *args): if self.x_att is not None: self.x_att_world = self.reference_data.world_component_ids[ self.x_att.axis] @defer_draw def _on_yatt_change(self, *args): if self.y_att is not None: self.y_att_world = self.reference_data.world_component_ids[ self.y_att.axis] @defer_draw def _on_xatt_world_change(self, *args): if self.x_att_world is not None and self.x_att_world == self.y_att_world: world_ids = self.reference_data.world_component_ids if self.x_att_world == world_ids[-1]: self.y_att_world = world_ids[-2] else: self.y_att_world = world_ids[-1] @defer_draw def _on_yatt_world_change(self, *args): if self.y_att_world is not None and self.y_att_world == self.x_att_world: world_ids = self.reference_data.world_component_ids if self.y_att_world == world_ids[-1]: self.x_att_world = world_ids[-2] else: self.x_att_world = world_ids[-1] def _set_reference_data(self): if self.reference_data is None: for layer in self.layers: if isinstance(layer.layer, Data): self.reference_data = layer.layer return def _set_default_slices(self): # Need to make sure this gets called immediately when reference_data is changed if self.reference_data is None: self.slices = () else: self.slices = (0, ) * self.reference_data.ndim @property def numpy_slice_aggregation_transpose(self): """ Returns slicing information usable by Numpy. This returns two objects: the first is an object that can be used to slice Numpy arrays and return a 2D array, and the second object is a boolean indicating whether to transpose the result. """ if self.reference_data is None: return None slices = [] agg_func = [] for i in range(self.reference_data.ndim): if i == self.x_att.axis or i == self.y_att.axis: slices.append(slice(None)) agg_func.append(None) else: if isinstance(self.slices[i], AggregateSlice): slices.append(self.slices[i].slice) agg_func.append(self.slices[i].function) else: slices.append(self.slices[i]) transpose = self.y_att.axis > self.x_att.axis return slices, agg_func, transpose @property def wcsaxes_slice(self): """ Returns slicing information usable by WCSAxes. This returns an iterable of slices, and including ``'x'`` and ``'y'`` for the dimensions along which we are not slicing. """ if self.reference_data is None: return None slices = [] for i in range(self.reference_data.ndim): if i == self.x_att.axis: slices.append('x') elif i == self.y_att.axis: slices.append('y') else: if isinstance(self.slices[i], AggregateSlice): slices.append(self.slices[i].center) else: slices.append(self.slices[i]) return slices[::-1] def flip_x(self): """ Flip the x_min/x_max limits. """ self.x_lim_helper.flip_limits() def flip_y(self): """ Flip the y_min/y_max limits. """ self.y_lim_helper.flip_limits()
class ScatterViewerState(MatplotlibDataViewerState): """ A state class that includes all the attributes for a scatter viewer. """ x_att = DDSCProperty(docstring='The attribute to show on the x-axis', default_index=0) y_att = DDSCProperty(docstring='The attribute to show on the y-axis', default_index=1) dpi = DDCProperty( 72, docstring= 'The resolution (in dots per inch) of density maps, if present') def __init__(self, **kwargs): super(ScatterViewerState, self).__init__() self.limits_cache = {} self.x_lim_helper = StateAttributeLimitsHelper( self, attribute='x_att', lower='x_min', upper='x_max', log='x_log', margin=0.04, limits_cache=self.limits_cache) self.y_lim_helper = StateAttributeLimitsHelper( self, attribute='y_att', lower='y_min', upper='y_max', log='y_log', margin=0.04, limits_cache=self.limits_cache) self.add_callback('layers', self._layers_changed) self.x_att_helper = ComponentIDComboHelper(self, 'x_att', pixel_coord=True, world_coord=True) self.y_att_helper = ComponentIDComboHelper(self, 'y_att', pixel_coord=True, world_coord=True) self.update_from_dict(kwargs) self.add_callback('x_log', self._reset_x_limits) self.add_callback('y_log', self._reset_y_limits) def _reset_x_limits(self, *args): if self.x_att is None: return self.x_lim_helper.percentile = 100 self.x_lim_helper.update_values(force=True) def _reset_y_limits(self, *args): if self.y_att is None: return self.y_lim_helper.percentile = 100 self.y_lim_helper.update_values(force=True) def reset_limits(self): self._reset_x_limits() self._reset_y_limits() def flip_x(self): """ Flip the x_min/x_max limits. """ self.x_lim_helper.flip_limits() def flip_y(self): """ Flip the y_min/y_max limits. """ self.y_lim_helper.flip_limits() @property def x_categories(self): return self._categories(self.x_att) @property def y_categories(self): return self._categories(self.y_att) def _categories(self, cid): categories = [] for layer_state in self.layers: if isinstance(layer_state.layer, BaseData): layer = layer_state.layer else: layer = layer_state.layer.data try: if layer.data.get_kind(cid) == 'categorical': categories.append(layer.data.get_data(cid).categories) except IncompatibleAttribute: pass if len(categories) == 0: return None else: return np.unique(np.hstack(categories)) @property def x_kinds(self): return self._component_kinds(self.x_att) @property def y_kinds(self): return self._component_kinds(self.y_att) def _component_kinds(self, cid): # Construct list of component kinds over all layers kinds = set() for layer_state in self.layers: if isinstance(layer_state.layer, BaseData): layer = layer_state.layer else: layer = layer_state.layer.data try: kinds.add(layer.data.get_kind(cid)) except IncompatibleAttribute: pass return kinds def _layers_changed(self, *args): layers_data = self.layers_data layers_data_cache = getattr(self, '_layers_data_cache', []) if layers_data == layers_data_cache: return self.x_att_helper.set_multiple_data(self.layers_data) self.y_att_helper.set_multiple_data(self.layers_data) self._layers_data_cache = layers_data
class ImageLayerState(BaseImageLayerState): """ A state class that includes all the attributes for data layers in an image plot. """ attribute = DDCProperty(docstring='The attribute shown in the layer') v_min = DDCProperty(docstring='The lower level shown') v_max = DDCProperty(docstring='The upper leven shown') percentile = DDCProperty(100, docstring='The percentile value used to ' 'automatically calculate levels') contrast = DDCProperty(1, docstring='The contrast of the layer') bias = DDCProperty(0.5, docstring='A constant value that is added to the ' 'layer before rendering') cmap = DDCProperty(docstring='The colormap used to render the layer') stretch = DDCProperty('linear', docstring='The stretch used to render the layer, ' 'which should be one of ``linear``, ' '``sqrt``, ``log``, or ``arcsinh``') global_sync = DDCProperty(True, docstring='Whether the color and transparency ' 'should be synced with the global ' 'color and transparency for the data') def __init__(self, layer=None, viewer_state=None, **kwargs): super(ImageLayerState, self).__init__(layer=layer, viewer_state=viewer_state) self.attribute_helper = StateAttributeLimitsHelper( self, attribute='attribute', percentile='percentile', lower='v_min', upper='v_max') self.add_callback('global_sync', self._update_syncing) self.add_callback('layer', self._update_attribute) self._update_syncing() if layer is not None: self._update_attribute() self.update_from_dict(kwargs) if self.cmap is None: self.cmap = colormaps.members[0][1] def _update_attribute(self, *args): if self.layer is not None: self.attribute = self.layer.visible_components[0] def _update_priority(self, name): if name == 'layer': return 3 elif name == 'attribute': return 2 elif name == 'global_sync': return 1.5 elif name.endswith(('_min', '_max')): return 0 else: return 1 def _update_syncing(self, *args): if self.global_sync: self._sync_color.enable_syncing() self._sync_alpha.enable_syncing() else: self._sync_color.disable_syncing() self._sync_alpha.disable_syncing() def _get_image(self, view=None): return self.layer[self.attribute, view] def flip_limits(self): """ Flip the image levels. """ self.attribute_helper.flip_limits() def reset_contrast_bias(self): with delay_callback(self, 'contrast', 'bias'): self.contrast = 1 self.bias = 0.5
class DendrogramLayerState(MatplotlibLayerState): """ A state class that includes all the attributes for layers in a dendrogram plot. """ linewidth = DDCProperty(1, docstring="The line width")
class ProfileLayerState(MatplotlibLayerState): """ A state class that includes all the attributes for layers in a Profile plot. """ linewidth = DDCProperty(1, docstring='The width of the line') attribute = DDSCProperty(docstring='The attribute shown in the layer') v_min = DDCProperty(docstring='The lower level shown') v_max = DDCProperty(docstring='The upper level shown') percentile = DDSCProperty(docstring='The percentile value used to ' 'automatically calculate levels') _viewer_callbacks_set = False _profile_cache = None def __init__(self, layer=None, viewer_state=None, **kwargs): super(ProfileLayerState, self).__init__(layer=layer, viewer_state=viewer_state) self.attribute_att_helper = ComponentIDComboHelper(self, 'attribute', numeric=True, categorical=False) percentile_display = {100: 'Min/Max', 99.5: '99.5%', 99: '99%', 95: '95%', 90: '90%', 'Custom': 'Custom'} ProfileLayerState.percentile.set_choices(self, [100, 99.5, 99, 95, 90, 'Custom']) ProfileLayerState.percentile.set_display_func(self, percentile_display.get) self.add_callback('layer', self._update_attribute, priority=1000) if layer is not None: self._update_attribute() self.update_from_dict(kwargs) def _update_attribute(self, *args): if self.layer is not None: self.attribute_att_helper.set_multiple_data([self.layer]) @property def independent_x_att(self): return is_convertible_to_single_pixel_cid(self.layer, self.viewer_state.x_att) is not None def normalize_values(self, values): return (np.asarray(values) - self.v_min) / (self.v_max - self.v_min) def reset_cache(self, *args): self._profile_cache = None @property def viewer_state(self): return self._viewer_state @viewer_state.setter def viewer_state(self, viewer_state): self._viewer_state = viewer_state @property def profile(self): self.update_profile() return self._profile_cache def update_profile(self, update_limits=True): if self._profile_cache is not None: return self._profile_cache if not self.visible: return if not self._viewer_callbacks_set: self.viewer_state.add_callback('x_att', self.reset_cache, priority=100000) self.viewer_state.add_callback('function', self.reset_cache, priority=100000) if self.is_callback_property('attribute'): self.add_callback('attribute', self.reset_cache, priority=100000) self._viewer_callbacks_set = True if self.viewer_state is None or self.viewer_state.x_att is None or self.attribute is None: raise IncompatibleDataException() # Check what pixel axis in the current dataset x_att corresponds to pix_cid = is_convertible_to_single_pixel_cid(self.layer, self.viewer_state.x_att_pixel) if pix_cid is None: raise IncompatibleDataException() # If we get here, then x_att does correspond to a single pixel axis in # the cube, so we now prepare a list of axes to collapse over. axes = tuple(i for i in range(self.layer.ndim) if i != pix_cid.axis) # We now get the y values for the data # TODO: in future we should optimize the case where the mask is much # smaller than the data to just average the relevant 'spaxels' in the # data rather than collapsing the whole cube. if isinstance(self.layer, Subset): data = self.layer.data subset_state = self.layer.subset_state else: data = self.layer subset_state = None profile_values = data.compute_statistic(self.viewer_state.function, self.attribute, axis=axes, subset_state=subset_state) if np.all(np.isnan(profile_values)): self._profile_cache = [], [] else: axis_view = [0] * data.ndim axis_view[pix_cid.axis] = slice(None) axis_values = data[self.viewer_state.x_att, tuple(axis_view)] self._profile_cache = axis_values, profile_values if update_limits: self.update_limits(update_profile=False) def update_limits(self, update_profile=True): with delay_callback(self, 'v_min', 'v_max'): if update_profile: self.update_profile(update_limits=False) if self._profile_cache is not None and len(self._profile_cache[1]) > 0: self.v_min = np.nanmin(self._profile_cache[1]) self.v_max = np.nanmax(self._profile_cache[1])
class ImageLayerState(BaseImageLayerState): """ A state class that includes all the attributes for data layers in an image plot. """ attribute = DDSCProperty(docstring='The attribute shown in the layer') v_min = DDCProperty(docstring='The lower level shown') v_max = DDCProperty(docstring='The upper level shown') percentile = DDSCProperty(docstring='The percentile value used to ' 'automatically calculate levels') contrast = DDCProperty(1, docstring='The contrast of the layer') bias = DDCProperty(0.5, docstring='A constant value that is added to the ' 'layer before rendering') cmap = DDCProperty(docstring='The colormap used to render the layer') stretch = DDSCProperty(docstring='The stretch used to render the layer, ' 'which should be one of ``linear``, ' '``sqrt``, ``log``, or ``arcsinh``') global_sync = DDCProperty(True, docstring='Whether the color and transparency ' 'should be synced with the global ' 'color and transparency for the data') def __init__(self, layer=None, viewer_state=None, **kwargs): super(ImageLayerState, self).__init__(layer=layer, viewer_state=viewer_state) self.attribute_lim_helper = StateAttributeLimitsHelper( self, attribute='attribute', percentile='percentile', lower='v_min', upper='v_max') self.attribute_att_helper = ComponentIDComboHelper(self, 'attribute', numeric=True, categorical=False) percentile_display = { 100: 'Min/Max', 99.5: '99.5%', 99: '99%', 95: '95%', 90: '90%', 'Custom': 'Custom' } ImageLayerState.percentile.set_choices( self, [100, 99.5, 99, 95, 90, 'Custom']) ImageLayerState.percentile.set_display_func(self, percentile_display.get) stretch_display = { 'linear': 'Linear', 'sqrt': 'Square Root', 'arcsinh': 'Arcsinh', 'log': 'Logarithmic' } ImageLayerState.stretch.set_choices( self, ['linear', 'sqrt', 'arcsinh', 'log']) ImageLayerState.stretch.set_display_func(self, stretch_display.get) self.add_callback('global_sync', self._update_syncing) self.add_callback('layer', self._update_attribute) self._update_syncing() if layer is not None: self._update_attribute() self.update_from_dict(kwargs) if self.cmap is None: self.cmap = colormaps.members[0][1] def _update_attribute(self, *args): if self.layer is not None: self.attribute_att_helper.set_multiple_data([self.layer]) self.attribute = self.layer.main_components[0] def _update_priority(self, name): if name == 'layer': return 3 elif name == 'attribute': return 2 elif name == 'global_sync': return 1.5 elif name.endswith(('_min', '_max')): return 0 else: return 1 def _update_syncing(self, *args): if self.global_sync: self._sync_color.enable_syncing() self._sync_alpha.enable_syncing() else: self._sync_color.disable_syncing() self._sync_alpha.disable_syncing() def _get_image(self, view=None): return self.layer[self.attribute, view] def flip_limits(self): """ Flip the image levels. """ self.attribute_lim_helper.flip_limits() def reset_contrast_bias(self): with delay_callback(self, 'contrast', 'bias'): self.contrast = 1 self.bias = 0.5
class ProfileViewerState(MatplotlibDataViewerState): """ A state class that includes all the attributes for a Profile viewer. """ x_att_pixel = DDCProperty(docstring='The component ID giving the pixel component ' 'shown on the x axis') x_att = DDSCProperty(docstring='The component ID giving the pixel or world component ' 'shown on the x axis') reference_data = DDSCProperty(docstring='The dataset that is used to define the ' 'available pixel/world components, and ' 'which defines the coordinate frame in ' 'which the images are shown') function = DDSCProperty(docstring='The function to use for collapsing data') normalize = DDCProperty(False, docstring='Whether to normalize all profiles ' 'to the [0:1] range') # TODO: add function to use def __init__(self, **kwargs): super(ProfileViewerState, self).__init__() self.ref_data_helper = ManualDataComboHelper(self, 'reference_data') self.add_callback('layers', self._layers_changed) self.add_callback('reference_data', self._reference_data_changed, echo_old=True) self.add_callback('x_att', self._update_att) self.add_callback('normalize', self._reset_y_limits) self.x_att_helper = ComponentIDComboHelper(self, 'x_att', numeric=False, datetime=False, categorical=False, pixel_coord=True) ProfileViewerState.function.set_choices(self, list(FUNCTIONS)) ProfileViewerState.function.set_display_func(self, FUNCTIONS.get) self.update_from_dict(kwargs) def _update_combo_ref_data(self): self.ref_data_helper.set_multiple_data(self.layers_data) def reset_limits(self): with delay_callback(self, 'x_min', 'x_max', 'y_min', 'y_max'): self._reset_x_limits() self._reset_y_limits() @property def _display_world(self): return getattr(self.reference_data, 'coords', None) is not None @defer_draw def _update_att(self, *args): if self.x_att is not None: if self._display_world: if self.x_att in self.reference_data.pixel_component_ids: self.x_att_pixel = self.x_att else: index = self.reference_data.world_component_ids.index(self.x_att) self.x_att_pixel = self.reference_data.pixel_component_ids[index] else: self.x_att_pixel = self.x_att self._reset_x_limits() def _reset_x_limits(self, *event): # NOTE: we don't use AttributeLimitsHelper because we need to avoid # trying to get the minimum of *all* the world coordinates in the # dataset. Instead, we use the same approach as in the layer state below # and in the case of world coordinates we use online the spine of the # data. if self.reference_data is None or self.x_att_pixel is None: return data = self.reference_data if self.x_att in data.pixel_component_ids: x_min, x_max = -0.5, data.shape[self.x_att.axis] - 0.5 else: axis = data.world_component_ids.index(self.x_att) axis_view = [0] * data.ndim axis_view[axis] = slice(None) axis_values = data[self.x_att, tuple(axis_view)] x_min, x_max = np.nanmin(axis_values), np.nanmax(axis_values) with delay_callback(self, 'x_min', 'x_max'): self.x_min = x_min self.x_max = x_max def _reset_y_limits(self, *event): if self.normalize: with delay_callback(self, 'y_min', 'y_max'): self.y_min = -0.1 self.y_max = +1.1 else: y_min, y_max = np.inf, -np.inf for layer in self.layers: try: profile = layer.profile except Exception: # e.g. incompatible subset continue if profile is not None: x, y = profile if len(y) > 0: y_min = min(y_min, np.nanmin(y)) y_max = max(y_max, np.nanmax(y)) with delay_callback(self, 'y_min', 'y_max'): if y_max > y_min: self.y_min = y_min self.y_max = y_max else: self.y_min = 0 self.y_max = 1 def flip_x(self): """ Flip the x_min/x_max limits. """ with delay_callback(self, 'x_min', 'x_max'): self.x_min, self.x_max = self.x_max, self.x_min @defer_draw def _layers_changed(self, *args): self._update_combo_ref_data() @defer_draw def _reference_data_changed(self, before=None, after=None): # A callback event for reference_data is triggered if the choices change # but the actual selection doesn't - so we avoid resetting the WCS in # this case. if before is after: return for layer in self.layers: layer.reset_cache() # This signal can get emitted if just the choices but not the actual # reference data change, so we check here that the reference data has # actually changed if self.reference_data is not getattr(self, '_last_reference_data', None): self._last_reference_data = self.reference_data with delay_callback(self, 'x_att'): if self.reference_data is None: self.x_att_helper.set_multiple_data([]) else: self.x_att_helper.set_multiple_data([self.reference_data]) if self._display_world: self.x_att_helper.world_coord = True self.x_att = self.reference_data.world_component_ids[0] else: self.x_att_helper.world_coord = False self.x_att = self.reference_data.pixel_component_ids[0] self._update_att() self.reset_limits() def _update_priority(self, name): if name == 'layers': return 2 elif name == 'reference_data': return 1.5 elif name.endswith(('_min', '_max')): return 0 else: return 1
class ScatterViewerState(MatplotlibDataViewerState): """ A state class that includes all the attributes for a scatter viewer. """ x_att = DDSCProperty(docstring='The attribute to show on the x-axis', default_index=0) y_att = DDSCProperty(docstring='The attribute to show on the y-axis', default_index=1) dpi = DDCProperty( 72, docstring= 'The resolution (in dots per inch) of density maps, if present') def __init__(self, **kwargs): super(ScatterViewerState, self).__init__() self.limits_cache = {} self.x_lim_helper = StateAttributeLimitsHelper( self, attribute='x_att', lower='x_min', upper='x_max', log='x_log', margin=0.05, limits_cache=self.limits_cache) self.y_lim_helper = StateAttributeLimitsHelper( self, attribute='y_att', lower='y_min', upper='y_max', log='y_log', margin=0.05, limits_cache=self.limits_cache) self.add_callback('layers', self._layers_changed) self.x_att_helper = ComponentIDComboHelper(self, 'x_att', pixel_coord=True, world_coord=True) self.y_att_helper = ComponentIDComboHelper(self, 'y_att', pixel_coord=True, world_coord=True) self.update_from_dict(kwargs) self.add_callback('x_log', self._reset_x_limits) self.add_callback('y_log', self._reset_y_limits) def _reset_x_limits(self, *args): self.x_lim_helper.percentile = 100 self.x_lim_helper.update_values(force=True) def _reset_y_limits(self, *args): self.y_lim_helper.percentile = 100 self.y_lim_helper.update_values(force=True) def reset_limits(self): self._reset_x_limits() self._reset_y_limits() def _update_priority(self, name): if name == 'layers': return 2 elif name.endswith('_log'): return 0.5 elif name.endswith(('_min', '_max')): return 0 else: return 1 def flip_x(self): """ Flip the x_min/x_max limits. """ self.x_lim_helper.flip_limits() def flip_y(self): """ Flip the y_min/y_max limits. """ self.y_lim_helper.flip_limits() def _get_x_components(self): return self._get_components(self.x_att) def _get_y_components(self): return self._get_components(self.y_att) def _get_components(self, cid): # Construct list of components over all layers components = [] for layer_state in self.layers: if isinstance(layer_state.layer, Data): layer = layer_state.layer else: layer = layer_state.layer.data try: components.append(layer.data.get_component(cid)) except IncompatibleAttribute: pass return components def _layers_changed(self, *args): layers_data = self.layers_data layers_data_cache = getattr(self, '_layers_data_cache', []) if layers_data == layers_data_cache: return self.x_att_helper.set_multiple_data(self.layers_data) self.y_att_helper.set_multiple_data(self.layers_data) self._layers_data_cache = layers_data
class ScatterLayerState(MatplotlibLayerState): """ A state class that includes all the attributes for layers in a scatter plot. """ # General properties style = DDSCProperty(docstring="The layer style") size = DDCProperty(docstring="The size of the markers") # Scatter layer cmap_mode = DDSCProperty( docstring="Whether to use color to encode an attribute") cmap_att = DDSCProperty(docstring="The attribute to use for the color") cmap_vmin = DDCProperty(docstring="The lower level for the colormap") cmap_vmax = DDCProperty(docstring="The upper level for the colormap") cmap = DDCProperty(docstring="The colormap to use (when in colormap mode)") size_mode = DDSCProperty( docstring="Whether to use size to encode an attribute") size_att = DDSCProperty(docstring="The attribute to use for the size") size_vmin = DDCProperty(docstring="The lower level for the size mapping") size_vmax = DDCProperty(docstring="The upper level for the size mapping") size_scaling = DDCProperty(1, docstring="Relative scaling of the size") xerr_visible = DDCProperty(False, docstring="Whether to show x error bars") yerr_visible = DDCProperty(False, docstring="Whether to show y error bars") xerr_att = DDSCProperty( docstring="The attribute to use for the x error bars") yerr_att = DDSCProperty( docstring="The attribute to use for the y error bars") # Line plot layer linewidth = DDCProperty(1, docstring="The line width") linestyle = DDSCProperty(docstring="The line style") def __init__(self, viewer_state=None, layer=None, **kwargs): super(ScatterLayerState, self).__init__(viewer_state=viewer_state, layer=layer) self.limits_cache = {} self.cmap_lim_helper = StateAttributeLimitsHelper( self, attribute='cmap_att', lower='cmap_vmin', upper='cmap_vmax', limits_cache=self.limits_cache) self.size_lim_helper = StateAttributeLimitsHelper( self, attribute='size_att', lower='size_vmin', upper='size_vmax', limits_cache=self.limits_cache) self.cmap_att_helper = ComponentIDComboHelper(self, 'cmap_att', numeric=True, categorical=False) self.size_att_helper = ComponentIDComboHelper(self, 'size_att', numeric=True, categorical=False) self.xerr_att_helper = ComponentIDComboHelper(self, 'xerr_att', numeric=True, categorical=False) self.yerr_att_helper = ComponentIDComboHelper(self, 'yerr_att', numeric=True, categorical=False) ScatterLayerState.style.set_choices(self, ['Scatter', 'Line']) ScatterLayerState.cmap_mode.set_choices(self, ['Fixed', 'Linear']) ScatterLayerState.size_mode.set_choices(self, ['Fixed', 'Linear']) linestyle_display = { 'solid': '–––––––', 'dashed': '– – – – –', 'dotted': '· · · · · · · ·', 'dashdot': '– · – · – ·' } ScatterLayerState.linestyle.set_choices( self, ['solid', 'dashed', 'dotted', 'dashdot']) ScatterLayerState.linestyle.set_display_func(self, linestyle_display.get) self.add_callback('layer', self._on_layer_change) if layer is not None: self._on_layer_change() self.cmap = colormaps.members[0][1] self.size = self.layer.style.markersize self._sync_size = keep_in_sync(self, 'size', self.layer.style, 'markersize') self.update_from_dict(kwargs) def _on_layer_change(self, layer=None): with delay_callback(self, 'cmap_vmin', 'cmap_vmax', 'size_vmin', 'size_vmax'): if self.layer is None: self.cmap_att_helper.set_multiple_data([]) self.size_att_helper.set_multiple_data([]) else: self.cmap_att_helper.set_multiple_data([self.layer]) self.size_att_helper.set_multiple_data([self.layer]) if self.layer is None: self.xerr_att_helper.set_multiple_data([]) self.yerr_att_helper.set_multiple_data([]) else: self.xerr_att_helper.set_multiple_data([self.layer]) self.yerr_att_helper.set_multiple_data([self.layer]) def flip_cmap(self): """ Flip the cmap_vmin/cmap_vmax limits. """ self.cmap_lim_helper.flip_limits() def flip_size(self): """ Flip the size_vmin/size_vmax limits. """ self.size_lim_helper.flip_limits()