def test_controller_misc():
    l, c = load()
    
    # Select three clusters
    clusters = [2, 4, 6]
    spikes = l.get_spikes(clusters=clusters)
    cluster_spikes = l.get_clusters(clusters=clusters)
    
    
    # Merge these clusters.
    action, output = c.merge_clusters(clusters)
    cluster_new = output['cluster_merged']
    assert np.array_equal(l.get_spikes(cluster_new), spikes)
    assert np.all(~np.in1d(clusters, get_indices(l.get_cluster_groups('all'))))
    
    
    # Undo.
    assert c.can_undo()
    c.undo()
    assert np.array_equal(l.get_spikes(cluster_new), [])
    assert np.all(np.in1d(clusters, get_indices(l.get_cluster_groups('all'))))
    assert np.array_equal(l.get_clusters(clusters=clusters), cluster_spikes)
    
    # Move clusters.
    action, output = c.move_clusters(clusters, 0)
    
    assert action == 'move_clusters'
    # assert np.array_equal(output['to_select'], [7])
    
    assert np.all(l.get_cluster_groups(clusters) == 0)
    
    assert c.can_undo()
    assert not c.can_redo()
    
    
    # Undo
    action, output = c.undo()
    
    assert action == 'move_clusters_undo'
    # assert np.array_equal(output['to_select'], clusters)
    
    assert np.all(l.get_cluster_groups(clusters) == 3)
    
    
    assert not c.can_undo()
    assert c.can_redo()
    
    # Merge clusters.
    c.merge_clusters(clusters)
    
    assert c.can_undo()
    assert not c.can_redo()
    
    l.close()
def test_controller_merge():
    l, c = load()
    
    # Select three clusters
    clusters = [2, 4, 6]
    spikes = l.get_spikes(clusters=clusters)
    cluster_spikes = l.get_clusters(clusters=clusters)
    # Select half of the spikes in these clusters.
    spikes_sample = spikes[::2]
    
    
    # Merge these clusters.
    action, output = c.merge_clusters(clusters)
    cluster_new = output['cluster_merged']
    
    assert action == 'merge_clusters'
    assert np.array_equal(output['cluster_merged'], cluster_new)
    assert np.array_equal(output['clusters_to_merge'], 
        sorted(set(clusters)))
        
    assert np.array_equal(l.get_spikes(cluster_new), spikes)
    assert np.all(~np.in1d(clusters, get_indices(l.get_cluster_groups('all'))))
    
    # Undo.
    assert c.can_undo()
    action, output = c.undo()
    
    assert action == 'merge_clusters_undo'
    assert np.array_equal(output['cluster_merged'], cluster_new)
    assert np.array_equal(output['clusters_to_merge'], 
        sorted(set(clusters)))
    
    assert np.array_equal(l.get_spikes(cluster_new), [])
    assert np.all(np.in1d(clusters, get_indices(l.get_cluster_groups('all'))))
    assert np.array_equal(l.get_clusters(clusters=clusters), cluster_spikes)
    
    # Redo.
    assert c.can_redo()
    action, output = c.redo()
    
    assert action == 'merge_clusters'
    assert np.array_equal(output['cluster_merged'], cluster_new)
    assert np.array_equal(output['clusters_to_merge'], 
        sorted(set(clusters)))
    
    assert np.array_equal(l.get_spikes(cluster_new), spikes)
    assert np.all(~np.in1d(clusters, get_indices(l.get_cluster_groups('all'))))
    
    l.close()
def test_clusterview():
    keys = ('cluster_groups,group_colors,group_names,'
            'cluster_sizes').split(',')
    data = get_data()
    kwargs = {k: data[k] for k in keys}

    kwargs['cluster_colors'] = data['cluster_colors_full']
    # kwargs['background'] = {5: 1, 7: 2}

    clusters = get_indices(data['cluster_sizes'])
    quality = pd.Series(np.random.rand(len(clusters)), index=clusters)

    kwargs['cluster_quality'] = quality

    kwargs['operators'] = [
        lambda self: self.view.set_quality(quality),
        lambda self: self.view.set_background({
            5: 1,
            7: 2
        }),
        lambda self: self.view.set_background({6: 3}),
        lambda self: self.view.set_background({}),
        lambda self: (self.close()
                      if USERPREF['test_auto_close'] != False else None),
    ]

    # Show the view.
    window = show_view(ClusterView, **kwargs)
    def set_data(
        self,
        similarity_matrix=None,
        cluster_colors_full=None,
        clusters_hidden=[],
    ):

        if similarity_matrix is None:
            similarity_matrix = np.zeros(0)
            cluster_colors_full = np.zeros(0)

        if similarity_matrix.size == 0:
            similarity_matrix = -np.ones((2, 2))
        elif similarity_matrix.shape[0] == 1:
            similarity_matrix = -np.ones((2, 2))

        self.similarity_matrix = similarity_matrix
        n = similarity_matrix.shape[0]

        self.texture = colormap(similarity_matrix)
        # similarity_matrix axes are originally (x, y) from the lower left corner
        # but when displayed, they are (i, j) from the upper left corner
        # so we need to transpose
        self.texture = np.swapaxes(self.texture, 0, 1)[::-1, :, :]

        # Hide some clusters.
        tex0 = self.texture.copy()
        for clu in clusters_hidden:
            # Inversion of axes in the y axis
            self.texture[-clu - 1, :, :] = tex0[-clu - 1, :, :] * .5
            self.texture[:, clu, :] = tex0[:, clu, :] * .5

        self.clusters_unique = get_indices(cluster_colors_full)
        self.cluster_colors = cluster_colors_full
        self.nclusters = len(self.clusters_unique)
示例#5
0
 def split_clusters(self, clusters, clusters_old, cluster_groups, 
     cluster_colors, clusters_new):
     if not hasattr(clusters, '__len__'):
         clusters = [clusters]
     spikes = get_indices(clusters_old)
     # Find groups and colors of old clusters.
     cluster_indices_old = np.unique(clusters_old)
     cluster_indices_new = np.unique(clusters_new)
     # Get group and color of the new clusters, from the old clusters.
     groups = self.loader.get_cluster_groups(cluster_indices_old)
     # colors = self.loader.get_cluster_colors(cluster_indices_old)
     # Add clusters.
     for cluster_new, group in zip(cluster_indices_new, 
             groups):
         self.loader.add_cluster(cluster_new, group, random_color())
     # Set the new clusters to the corresponding spikes.
     self.loader.set_cluster(spikes, clusters_new)
     # Remove empty clusters.
     clusters_empty = self.loader.remove_empty_clusters()
     self.loader.unselect()
     clusters_to_select = sorted(set(cluster_indices_old).union(
             set(cluster_indices_new)) - set(clusters_empty))
     return dict(clusters_to_split=clusters,
                 clusters_split=get_array(cluster_indices_new),
                 clusters_empty=clusters_empty)
 def set_data(self, similarity_matrix=None,
     cluster_colors_full=None,
     clusters_hidden=[],
     ):
     
     if similarity_matrix is None:
         similarity_matrix = np.zeros(0)
         cluster_colors_full = np.zeros(0)
     
     if similarity_matrix.size == 0:
         similarity_matrix = -np.ones((2, 2))
     elif similarity_matrix.shape[0] == 1:
         similarity_matrix = -np.ones((2, 2))
        
     self.similarity_matrix = similarity_matrix
     n = similarity_matrix.shape[0]
     
     self.texture = colormap(self.similarity_matrix.copy())
     # similarity_matrix axes are originally (x, y) from the lower left corner
     # but when displayed, they are (i, j) from the upper left corner
     # so we need to transpose
     self.texture = np.swapaxes(self.texture, 0, 1)[::-1, :, :]
     
     
     # Hide some clusters.
     tex0 = self.texture.copy()
     for clu in clusters_hidden:
         # Inversion of axes in the y axis
         self.texture[- clu - 1, :, :] = tex0[- clu - 1, :, :] * .5
         self.texture[:, clu, :] = tex0[:, clu, :] * .5
     
     self.clusters_unique = get_indices(cluster_colors_full)
     self.cluster_colors = cluster_colors_full
     self.nclusters = len(self.clusters_unique)
示例#7
0
 def split_clusters_undo(self, clusters, clusters_old, cluster_groups,
     cluster_colors, clusters_new):
     if not hasattr(clusters, '__len__'):
         clusters = [clusters]
     spikes = get_indices(clusters_old)
     # Find groups and colors of old clusters.
     cluster_indices_old = np.unique(clusters_old)
     cluster_indices_new = np.unique(clusters_new)
     # Add clusters that were removed after the split operation.
     clusters_empty = sorted(set(cluster_indices_old) -
         set(cluster_indices_new))
     self.loader.add_clusters(
         clusters_empty,
         select(cluster_groups, clusters_empty),
         # select(cluster_colors, clusters_empty),
         )
     # Set the new clusters to the corresponding spikes.
     self.loader.set_cluster(spikes, clusters_old)
     # Remove empty clusters.
     clusters_empty = self.loader.remove_empty_clusters()
     self.loader.unselect()
     return dict(clusters_to_split=clusters,
                 clusters_split=get_array(cluster_indices_new),
                 # clusters_empty=clusters_empty
                 )
示例#8
0
 def split_clusters_undo(self, clusters, clusters_old, cluster_groups,
                         cluster_colors, clusters_new):
     if not hasattr(clusters, '__len__'):
         clusters = [clusters]
     spikes = get_indices(clusters_old)
     # Find groups and colors of old clusters.
     cluster_indices_old = np.unique(clusters_old)
     cluster_indices_new = np.unique(clusters_new)
     # Add clusters that were removed after the split operation.
     clusters_empty = sorted(
         set(cluster_indices_old) - set(cluster_indices_new))
     self.loader.add_clusters(
         clusters_empty,
         select(cluster_groups, clusters_empty),
         # select(cluster_colors, clusters_empty),
     )
     # Set the new clusters to the corresponding spikes.
     self.loader.set_cluster(spikes, clusters_old)
     # Remove empty clusters.
     clusters_empty = self.loader.remove_empty_clusters()
     self.loader.unselect()
     return dict(
         clusters_to_split=clusters,
         clusters_split=get_array(cluster_indices_new),
         # clusters_empty=clusters_empty
     )
示例#9
0
 def split_clusters(self, clusters, clusters_old, cluster_groups, 
     cluster_colors, clusters_new):
     if not hasattr(clusters, '__len__'):
         clusters = [clusters]
     spikes = get_indices(clusters_old)
     # Find groups and colors of old clusters.
     cluster_indices_old = np.unique(clusters_old)
     cluster_indices_new = np.unique(clusters_new)
     # Get group and color of the new clusters, from the old clusters.
     groups = self.loader.get_cluster_groups(cluster_indices_old)
     # colors = self.loader.get_cluster_colors(cluster_indices_old)
     # Add clusters.
     self.loader.add_clusters(cluster_indices_new, 
         # HACK: take the group of the first cluster for all new clusters
         get_array(groups)[0]*np.ones(len(cluster_indices_new)),
         random_color(len(cluster_indices_new)))
     # Set the new clusters to the corresponding spikes.
     self.loader.set_cluster(spikes, clusters_new)
     # Remove empty clusters.
     clusters_empty = self.loader.remove_empty_clusters()
     self.loader.unselect()
     clusters_to_select = sorted(set(cluster_indices_old).union(
             set(cluster_indices_new)) - set(clusters_empty))
     return dict(clusters_to_split=clusters,
                 clusters_split=get_array(cluster_indices_new),
                 clusters_empty=clusters_empty)
def test_clusterview():
    keys = ('cluster_groups,group_colors,group_names,'
            'cluster_sizes').split(',')
    data = get_data()
    kwargs = {k: data[k] for k in keys}
    
    kwargs['cluster_colors'] = data['cluster_colors_full']
    # kwargs['background'] = {5: 1, 7: 2}
    
    clusters = get_indices(data['cluster_sizes'])
    quality = pd.Series(np.random.rand(len(clusters)), index=clusters)
    
    kwargs['cluster_quality'] = quality
    
    kwargs['operators'] = [
        lambda self: self.view.set_quality(quality),
        lambda self: self.view.set_background({5: 1, 7: 2}),
        lambda self: self.view.set_background({6: 3}),
        lambda self: self.view.set_background({}),
        lambda self: (self.close() 
            if USERPREF['test_auto_close'] != False else None),
    ]
    
    # Show the view.
    window = show_view(ClusterView, **kwargs)
    
    
    
示例#11
0
 def merge_clusters(self, clusters_old, cluster_groups, cluster_colors,
     cluster_merged):
     # Get spikes in clusters to merge.
     # spikes = self.loader.get_spikes(clusters=clusters_to_merge)
     spikes = get_indices(clusters_old)
     clusters_to_merge = get_indices(cluster_groups)
     group = np.max(get_array(cluster_groups))
     # color_old = get_array(cluster_colors)[0]
     color_new = random_color()
     self.loader.add_cluster(cluster_merged, group, color_new)
     # Set the new cluster to the corresponding spikes.
     self.loader.set_cluster(spikes, cluster_merged)
     # Remove old clusters.
     for cluster in clusters_to_merge:
         self.loader.remove_cluster(cluster)
     self.loader.unselect()
     return dict(clusters_to_merge=clusters_to_merge,
                 cluster_merged=cluster_merged,
                 cluster_merged_colors=(color_new, color_new),)
示例#12
0
 def merge_clusters(self, clusters_old, cluster_groups, cluster_colors,
     cluster_merged):
     # Get spikes in clusters to merge.
     # spikes = self.loader.get_spikes(clusters=clusters_to_merge)
     spikes = get_indices(clusters_old)
     clusters_to_merge = get_indices(cluster_groups)
     group = np.max(get_array(cluster_groups))
     # color_old = get_array(cluster_colors)[0]
     color_new = random_color()
     self.loader.add_cluster(cluster_merged, group, color_new)
     # Set the new cluster to the corresponding spikes.
     self.loader.set_cluster(spikes, cluster_merged)
     # Remove old clusters.
     for cluster in clusters_to_merge:
         self.loader.remove_cluster(cluster)
     self.loader.unselect()
     return dict(clusters_to_merge=clusters_to_merge,
                 cluster_merged=cluster_merged,
                 cluster_merged_colors=(color_new, color_new),)
示例#13
0
    def set_data(self, cluster_groups=None, similarity_matrix=None):
        """Update the data."""

        if cluster_groups is not None:
            self.clusters_unique = get_array(get_indices(cluster_groups))
            self.cluster_groups = get_array(cluster_groups)

        if (similarity_matrix is not None and similarity_matrix.size > 0):
            self.matrix = similarity_matrix
            self.quality = np.diag(self.matrix)

            assert len(self.cluster_groups) == self.matrix.shape[0]
示例#14
0
 def set_data(self, cluster_groups=None, similarity_matrix=None):
     """Update the data."""
     
     if cluster_groups is not None:
         self.clusters_unique = get_array(get_indices(cluster_groups))
         self.cluster_groups = get_array(cluster_groups)
     
     if (similarity_matrix is not None and similarity_matrix.size > 0):
         self.matrix = similarity_matrix
         self.quality = np.diag(self.matrix)
         
         assert len(self.cluster_groups) == self.matrix.shape[0]
示例#15
0
    def set_data(self, cluster_groups=None, similarity_matrix=None):
        """Update the data."""
        
        if cluster_groups is not None:
            self.clusters_unique = get_array(get_indices(cluster_groups))
            self.cluster_groups = get_array(cluster_groups)
            
        if (similarity_matrix is not None and similarity_matrix.size > 0):

            if len(get_array(cluster_groups)) != similarity_matrix.shape[0]:
                log.warn(("Cannot update the wizard: cluster_groups "
                    "has {0:d} elements whereas the similarity matrix has {1:d}.").format(
                        len(get_array(cluster_groups)), similarity_matrix.shape[0]))
                return

            self.matrix = similarity_matrix
            self.quality = np.diag(self.matrix)
    def set_data(
            self,
            similarity_matrix=None,
            cluster_colors_full=None,
            clusters_hidden=[],  # WARNING: relative indexing
    ):
        if similarity_matrix is None:
            similarity_matrix = np.zeros(0)
            cluster_colors_full = np.zeros(0)

        if similarity_matrix.size == 0:
            similarity_matrix = -np.ones((2, 2))
        elif similarity_matrix.shape[0] == 1:
            similarity_matrix = -np.ones((2, 2))

        self.similarity_matrix = similarity_matrix
        n = similarity_matrix.shape[0]

        self.texture = colormap(self.similarity_matrix.copy())
        # similarity_matrix axes are originally (x, y) from the lower left corner
        # but when displayed, they are (i, j) from the upper left corner
        # so we need to transpose
        self.texture = np.swapaxes(self.texture, 0, 1)

        self.clusters_unique = get_indices(cluster_colors_full)

        self.cluster_colors = cluster_colors_full
        self.nclusters = len(self.clusters_unique)

        # Remove hidden clusters.
        indices = np.array(
            sorted(set(range(self.nclusters)) - set(clusters_hidden)),
            dtype=np.int32)
        self.indices = indices

        if len(indices) >= 2:
            tex0 = self.texture.copy()
            self.texture = tex0[[[_] for _ in (indices)], indices, :]
        else:
            indices = range(self.nclusters)

        self.clusters_displayed = self.clusters_unique[indices]
        self.nclusters_displayed = len(indices)

        self.texture = self.texture[::-1, :, :]
示例#17
0
    def set_data(self, cluster_groups=None, similarity_matrix=None):
        """Update the data."""

        if cluster_groups is not None:
            self.clusters_unique = get_array(get_indices(cluster_groups))
            self.cluster_groups = get_array(cluster_groups)

        if (similarity_matrix is not None and similarity_matrix.size > 0):

            if len(get_array(cluster_groups)) != similarity_matrix.shape[0]:
                log.warn((
                    "Cannot update the wizard: cluster_groups "
                    "has {0:d} elements whereas the similarity matrix has {1:d}."
                ).format(len(get_array(cluster_groups)),
                         similarity_matrix.shape[0]))
                return

            self.matrix = similarity_matrix
            self.quality = np.diag(self.matrix)
示例#18
0
 def set_data(self, similarity_matrix=None,
     cluster_colors_full=None,
     clusters_hidden=[],  # WARNING: relative indexing
     ):
     if similarity_matrix is None:
         similarity_matrix = np.zeros(0)
         cluster_colors_full = np.zeros(0)
     
     if similarity_matrix.size == 0:
         similarity_matrix = -np.ones((2, 2))
     elif similarity_matrix.shape[0] == 1:
         similarity_matrix = -np.ones((2, 2))
        
     self.similarity_matrix = similarity_matrix
     n = similarity_matrix.shape[0]
     
     self.texture = colormap(self.similarity_matrix.copy())
     # similarity_matrix axes are originally (x, y) from the lower left corner
     # but when displayed, they are (i, j) from the upper left corner
     # so we need to transpose
     self.texture = np.swapaxes(self.texture, 0, 1)
     
     self.clusters_unique = get_indices(cluster_colors_full)
     
     self.cluster_colors = cluster_colors_full
     self.nclusters = len(self.clusters_unique)
 
     # Remove hidden clusters.
     indices = np.array(sorted(set(range(self.nclusters)) - set(clusters_hidden)),
                             dtype=np.int32)
     self.indices = indices
     
     if len(indices) >= 2:
         tex0 = self.texture.copy()
         self.texture = tex0[[[_] for _ in (indices)],indices,:]
     else:
         indices = range(self.nclusters)
     
     self.clusters_displayed = self.clusters_unique[indices]
     self.nclusters_displayed = len(indices)
     
     self.texture = self.texture[::-1,:,:]
示例#19
0
 def merge_clusters_undo(self, clusters_old, cluster_groups, 
     cluster_colors, cluster_merged):
     # Get spikes in clusters to merge.
     spikes = self.loader.get_spikes(clusters=cluster_merged)
     clusters_to_merge = get_indices(cluster_groups)
     # Add old clusters.
     for cluster, group, color in zip(
             clusters_to_merge, cluster_groups, cluster_colors):
         self.loader.add_cluster(cluster, group, color)
     # Set the new clusters to the corresponding spikes.
     self.loader.set_cluster(spikes, clusters_old)
     # Remove merged cluster.
     self.loader.remove_cluster(cluster_merged)
     self.loader.unselect()
     color_old = self.loader.get_cluster_color(clusters_to_merge[0])
     color_old2 = self.loader.get_cluster_color(clusters_to_merge[1])
     return dict(clusters_to_merge=clusters_to_merge,
                 cluster_merged=cluster_merged,
                 cluster_to_merge_colors=(color_old, color_old2),
                 )
示例#20
0
 def merge_clusters_undo(self, clusters_old, cluster_groups, 
     cluster_colors, cluster_merged):
     # Get spikes in clusters to merge.
     spikes = self.loader.get_spikes(clusters=cluster_merged)
     clusters_to_merge = get_indices(cluster_groups)
     # Add old clusters.
     for cluster, group, color in zip(
             clusters_to_merge, cluster_groups, cluster_colors):
         self.loader.add_cluster(cluster, group, color)
     # Set the new clusters to the corresponding spikes.
     self.loader.set_cluster(spikes, clusters_old)
     # Remove merged cluster.
     self.loader.remove_cluster(cluster_merged)
     self.loader.unselect()
     color_old = self.loader.get_cluster_color(clusters_to_merge[0])
     color_old2 = self.loader.get_cluster_color(clusters_to_merge[1])
     return dict(clusters_to_merge=clusters_to_merge,
                 cluster_merged=cluster_merged,
                 cluster_to_merge_colors=(color_old, color_old2),
                 )
示例#21
0
    def set_data(self,
                 features=None,
                 features_background=None,
                 spiketimes=None,  # a subset of all spikes, disregarding cluster
                 masks=None,  # masks for all spikes in selected clusters
                 clusters=None,  # clusters for all spikes in selected clusters
                 clusters_selected=None,
                 cluster_colors=None,
                 fetdim=None,
                 nchannels=None,
                 channels=None,
                 nextrafet=None,
                 autozoom=None,  # None, or the target cluster
                 duration=None,
                 freq=None,
                 alpha_selected=.75,
                 alpha_background=.25,
                 time_unit=None,
                 ):

        if features is None:
            features = np.zeros((0, 2))
            features_background = np.zeros((0, 2))
            masks = np.zeros((0, 1))
            clusters = np.zeros(0, dtype=np.int32)
            clusters_selected = []
            cluster_colors = np.zeros(0, dtype=np.int32)
            fetdim = 2
            nchannels = 1
            nextrafet = 0

        if features.shape[1] == 1:
            features = np.tile(features, (1, 4))
        if features_background.shape[1] == 1:
            features_background = np.tile(features_background, (1, 4))

        assert fetdim is not None

        self.duration = duration
        self.spiketimes = spiketimes
        self.freq = freq
        self.interaction_manager.get_processor('grid').update_viewbox()

        # Feature background alpha value.
        self.alpha_selected = alpha_selected
        self.alpha_background = alpha_background

        # can be 'second' or 'samples'
        self.time_unit = time_unit

        # Extract the relevant spikes, but keep the other ones in features_full
        self.clusters = clusters

        # Contains all spikes, needed for splitting.
        self.features_full = features
        self.features_full_array = get_array(features)

        # Keep a subset of all spikes in the view.
        self.nspikes_full = len(features)
        # > features_nspikes_per_cluster_max spikes ==> take a selection
        nspikes_max = USERPREF.get('features_nspikes_per_cluster_max', 1000)
        k = self.nspikes_full // nspikes_max + 1
        # self.features = features[::k]
        subsel = slice(None, None, k)
        self.features = select(features, subsel)
        self.features_array = get_array(self.features)

        # self.features_background contains all non-selected spikes
        self.features_background = features_background
        self.features_background_array = get_array(self.features_background)

        # Background spikes are those which do not belong to the selected clusters
        self.npoints_background = self.features_background_array.shape[0]
        self.nspikes_background = self.npoints_background

        if channels is None:
            channels = range(nchannels)

        self.nspikes, self.ndim = self.features.shape
        self.fetdim = fetdim
        self.nchannels = nchannels
        self.channels = channels
        self.nextrafet = nextrafet
        self.npoints = self.features.shape[0]

        if masks is None:
            masks = np.ones_like(self.features, dtype=np.float32)
        self.masks = masks


        # Subselection
        self.masks = select(self.masks, subsel)
        self.masks_array = get_array(self.masks)
        if self.spiketimes is not None:
            self.spiketimes = select(self.spiketimes, subsel)
        self.clusters = select(self.clusters, subsel)
        self.clusters_array = get_array(self.clusters)


        self.feature_indices = get_indices(self.features)
        self.feature_full_indices = get_indices(self.features_full)
        self.feature_indices_array = get_array(self.feature_indices)

        self.cluster_colors = get_array(cluster_colors, dosort=True)

        # Relative indexing.
        if self.npoints > 0:
            self.clusters_rel = np.digitize(self.clusters_array, sorted(clusters_selected)) - 1
            self.clusters_rel_ordered = np.argsort(clusters_selected)[self.clusters_rel]
        else:
            self.clusters_rel = np.zeros(0, dtype=np.int32)
            self.clusters_rel_ordered = np.zeros(0, dtype=np.int32)

        self.clusters_unique = sorted(clusters_selected)
        self.nclusters = len(clusters_selected)
        self.masks_full = self.masks_array.T.ravel()
        self.clusters_full_depth = self.clusters_rel_ordered
        self.clusters_full = self.clusters_rel

        # prepare GPU data
        self.data = np.empty((self.nspikes, 2), dtype=np.float32)
        self.data_full = np.empty((self.nspikes_full, 2), dtype=np.float32)
        self.data_background = np.empty((self.nspikes_background, 2),
            dtype=np.float32)

        # set initial projection
        self.projection_manager.set_data()
        self.autozoom = autozoom
        if autozoom is None:
            self.projection_manager.reset_projection()
        else:
            self.projection_manager.auto_projection(autozoom)

        # update the highlight manager
        self.highlight_manager.initialize()
        self.selection_manager.initialize()
        self.selection_manager.cancel_selection()
示例#22
0
 def set_data(self,
              waveforms=None,
              channels=None,
              masks=None,
              clusters=None,
              # list of clusters that are selected, the order matters
              clusters_selected=None,
              cluster_colors=None,
              geometrical_positions=None,
              keep_order=None,
              autozoom=None,
              ):
              
     self.autozoom = autozoom
     if clusters_selected is None:
         clusters_selected = []
     if waveforms is None:
         waveforms = np.zeros((0, 1, 1))
         masks = np.zeros((0, 1))
         clusters = np.zeros(0, dtype=np.int32)
         cluster_colors = np.zeros(0, dtype=np.int32)
         clusters_selected = []
         
     self.keep_order = keep_order
     
     # Not all waveforms have been selected, so select the appropriate 
     # samples in clusters and masks.
     self.waveform_indices = get_indices(waveforms)
     self.waveform_indices_array = get_array(self.waveform_indices)
     masks = select(masks, self.waveform_indices)
     clusters = select(clusters, self.waveform_indices)
     
     # Convert from Pandas into raw NumPy arrays.
     self.waveforms_array = get_array(waveforms)
     self.masks_array = get_array(masks)
     self.clusters_array = get_array(clusters)
     # Relative indexing.
     if len(clusters_selected) > 0 and len(self.waveform_indices) > 0:
         self.clusters_rel = np.array(np.digitize(self.clusters_array, 
             sorted(clusters_selected)) - 1, dtype=np.int32)
         self.clusters_rel_ordered = (np.argsort(clusters_selected)
             [self.clusters_rel]).astype(np.int32)
     else:
         self.clusters_rel = np.zeros(0, dtype=np.int32)
         self.clusters_rel_ordered = np.zeros(0, dtype=np.int32)
         
     if self.keep_order:
         self.clusters_rel_ordered2 = self.clusters_rel_ordered
         self.cluster_colors_array = get_array(cluster_colors, dosort=True)[np.argsort(clusters_selected)]
         self.clusters_selected2 = clusters_selected
     else:
         self.clusters_rel_ordered2 = self.clusters_rel
         self.cluster_colors_array = get_array(cluster_colors, dosort=True)
         self.clusters_selected2 = sorted(clusters_selected)
         
     self.nspikes, self.nsamples, self.nchannels = self.waveforms_array.shape
     if channels is None:
         channels = range(self.nchannels)
     self.channels = channels
     self.npoints = self.waveforms_array.size
     self.geometrical_positions = geometrical_positions
     self.clusters_selected = clusters_selected
     self.clusters_unique = sorted(clusters_selected)
     self.nclusters = len(clusters_selected)
     self.waveforms = waveforms
     self.clusters = clusters
     # self.cluster_colors = cluster_colors
     self.masks = masks
     
     # Prepare GPU data.
     self.data = self.prepare_waveform_data()
     self.masks_full = np.repeat(self.masks_array.T.ravel(), self.nsamples)
     self.clusters_full = np.tile(np.repeat(self.clusters_rel_ordered2, self.nsamples), self.nchannels)
     self.clusters_full_depth = np.tile(np.repeat(self.clusters_rel_ordered, self.nsamples), self.nchannels)
     self.channels_full = np.repeat(np.arange(self.nchannels, dtype=np.int32), self.nspikes * self.nsamples)
     
     # Compute average waveforms.
     self.data_avg = self.prepare_average_waveform_data()
     self.masks_full_avg = np.repeat(self.masks_avg.T.ravel(), self.nsamples_avg)
     self.clusters_full_avg = np.tile(np.repeat(self.clusters_rel_ordered_avg2, self.nsamples_avg), self.nchannels_avg)
     self.clusters_full_depth_avg = np.tile(np.repeat(self.clusters_rel_ordered_avg, self.nsamples_avg), self.nchannels_avg)
     self.channels_full_avg = np.repeat(np.arange(self.nchannels_avg, dtype=np.int32), self.nspikes_avg * self.nsamples_avg)
     
     # position waveforms
     self.position_manager.set_info(self.nchannels, self.nclusters, 
        geometrical_positions=self.geometrical_positions,)
     
     # update the highlight manager
     self.highlight_manager.initialize()
示例#23
0
 def set_data(self,
              waveforms=None,
              masks=None,
              clusters=None,
              # list of clusters that are selected, the order matters
              clusters_selected=None,
              cluster_colors=None,
              geometrical_positions=None,
              keep_order=None,
              autozoom=None,
              ):
              
     self.autozoom = autozoom
     if clusters_selected is None:
         clusters_selected = []
     if waveforms is None:
         waveforms = np.zeros((0, 1, 1))
         masks = np.zeros((0, 1))
         clusters = np.zeros(0, dtype=np.int32)
         cluster_colors = np.zeros(0, dtype=np.int32)
         clusters_selected = []
         
     self.keep_order = keep_order
     
     # Not all waveforms have been selected, so select the appropriate 
     # samples in clusters and masks.
     self.waveform_indices = get_indices(waveforms)
     self.waveform_indices_array = get_array(self.waveform_indices)
     masks = select(masks, self.waveform_indices)
     clusters = select(clusters, self.waveform_indices)
     
     # Convert from Pandas into raw NumPy arrays.
     self.waveforms_array = get_array(waveforms)
     self.masks_array = get_array(masks)
     self.clusters_array = get_array(clusters)
     # Relative indexing.
     if len(clusters_selected) > 0:
         self.clusters_rel = np.array(np.digitize(self.clusters_array, 
             sorted(clusters_selected)) - 1, dtype=np.int32)
         self.clusters_rel_ordered = (np.argsort(clusters_selected)
             [self.clusters_rel]).astype(np.int32)
     else:
         self.clusters_rel = np.zeros(0, dtype=np.int32)
         self.clusters_rel_ordered = np.zeros(0, dtype=np.int32)
         
     if self.keep_order:
         self.clusters_rel_ordered2 = self.clusters_rel_ordered
         self.cluster_colors_array = get_array(cluster_colors, dosort=True)[np.argsort(clusters_selected)]
         self.clusters_selected2 = clusters_selected
     else:
         self.clusters_rel_ordered2 = self.clusters_rel
         self.cluster_colors_array = get_array(cluster_colors, dosort=True)
         self.clusters_selected2 = sorted(clusters_selected)
         
     self.nspikes, self.nsamples, self.nchannels = self.waveforms_array.shape
     self.npoints = self.waveforms_array.size
     self.geometrical_positions = geometrical_positions
     self.clusters_selected = clusters_selected
     self.clusters_unique = sorted(clusters_selected)
     self.nclusters = len(clusters_selected)
     self.waveforms = waveforms
     self.clusters = clusters
     # self.cluster_colors = cluster_colors
     self.masks = masks
     
     # Prepare GPU data.
     self.data = self.prepare_waveform_data()
     self.masks_full = np.repeat(self.masks_array.T.ravel(), self.nsamples)
     self.clusters_full = np.tile(np.repeat(self.clusters_rel_ordered2, self.nsamples), self.nchannels)
     self.clusters_full_depth = np.tile(np.repeat(self.clusters_rel_ordered, self.nsamples), self.nchannels)
     self.channels_full = np.repeat(np.arange(self.nchannels, dtype=np.int32), self.nspikes * self.nsamples)
     
     # Compute average waveforms.
     self.data_avg = self.prepare_average_waveform_data()
     self.masks_full_avg = np.repeat(self.masks_avg.T.ravel(), self.nsamples_avg)
     self.clusters_full_avg = np.tile(np.repeat(self.clusters_rel_ordered_avg2, self.nsamples_avg), self.nchannels_avg)
     self.clusters_full_depth_avg = np.tile(np.repeat(self.clusters_rel_ordered_avg, self.nsamples_avg), self.nchannels_avg)
     self.channels_full_avg = np.repeat(np.arange(self.nchannels_avg, dtype=np.int32), self.nspikes_avg * self.nsamples_avg)
     
     # position waveforms
     self.position_manager.set_info(self.nchannels, self.nclusters, 
        geometrical_positions=self.geometrical_positions,)
     
     # update the highlight manager
     self.highlight_manager.initialize()
示例#24
0
    def set_data(self,
                 features=None,
                 features_background=None,
                 spiketimes=None,  # a subset of all spikes, disregarding cluster
                 masks=None,  # masks for all spikes in selected clusters
                 clusters=None,  # clusters for all spikes in selected clusters
                 clusters_selected=None,
                 cluster_colors=None,
                 fetdim=None,
                 nchannels=None,
                 nextrafet=None,
                 autozoom=None,  # None, or the target cluster
                 duration=None,
                 freq=None,
                 alpha_selected=.75,
                 alpha_background=.25,
                 time_unit=None,
                 ):

        if features is None:
            features = np.zeros((0, 2))
            features_background = np.zeros((0, 2))
            masks = np.zeros((0, 1))
            clusters = np.zeros(0, dtype=np.int32)
            clusters_selected = []
            cluster_colors = np.zeros(0, dtype=np.int32)
            fetdim = 2
            nchannels = 1
            nextrafet = 0
        
        assert fetdim is not None
        
        self.duration = duration
        self.spiketimes = spiketimes
        self.freq = freq
        self.interaction_manager.get_processor('grid').update_viewbox()
        
        # Feature background alpha value.
        self.alpha_selected = alpha_selected
        self.alpha_background = alpha_background
        
        # can be 'second' or 'samples'
        self.time_unit = time_unit
        
        # # Indices of all subset spikes.
        # indices_all = get_indices(features)
        
        # # Select only the clusters for subset of spikes.
        # clusters = select(clusters, indices_all)
        
        # # Indices of subset spikes in selected clusters.
        # indices_selection = get_indices(clusters)
        
        # # Indices of subset spikes that are not in selected clusters.
        # indices_background = np.setdiff1d(indices_all, indices_selection, True)
        
        # Extract the relevant spikes, but keep the other ones in features_full
        self.clusters = clusters
        self.clusters_array = get_array(self.clusters)
        
        
        # self.features contains selected spikes.
        # self.features = select(features, indices_selection)
        self.features = features
        self.features_array = get_array(self.features)
        
        # self.features_background contains all non-selected spikes
        # self.features_background = select(features, indices_background)
        self.features_background = features_background
        self.features_background_array = get_array(self.features_background)
        
        
        # Background spikes are those which do not belong to the selected clusters
        self.npoints_background = self.features_background_array.shape[0]
        self.nspikes_background = self.npoints_background
        
        self.nspikes, self.ndim = self.features.shape
        self.fetdim = fetdim
        self.nchannels = nchannels
        self.nextrafet = nextrafet
        self.npoints = self.features.shape[0]
        self.masks = masks
        self.feature_indices = get_indices(self.features)
        self.feature_indices_array = get_array(self.feature_indices)
        
        self.masks_array = get_array(self.masks)
        self.cluster_colors = get_array(cluster_colors, dosort=True)
        
        # Relative indexing.
        if self.npoints > 0:
            self.clusters_rel = np.digitize(self.clusters_array, sorted(clusters_selected)) - 1
            self.clusters_rel_ordered = np.argsort(clusters_selected)[self.clusters_rel]
        else:
            self.clusters_rel = np.zeros(0, dtype=np.int32)
            self.clusters_rel_ordered = np.zeros(0, dtype=np.int32)
        
        self.clusters_unique = sorted(clusters_selected)
        self.nclusters = len(clusters_selected)
        self.masks_full = self.masks_array.T.ravel()
        self.clusters_full_depth = self.clusters_rel_ordered
        self.clusters_full = self.clusters_rel
        
        # prepare GPU data
        self.data = np.empty((self.nspikes, 2), dtype=np.float32)
        self.data_background = np.empty((self.nspikes_background, 2), 
            dtype=np.float32)
        
        # set initial projection
        self.projection_manager.set_data()
        self.autozoom = autozoom
        if autozoom is None:
            self.projection_manager.reset_projection()
        else:
            self.projection_manager.auto_projection(autozoom)
        
        # update the highlight manager
        self.highlight_manager.initialize()
        self.selection_manager.initialize()
        self.selection_manager.cancel_selection()
示例#25
0
    def set_data(
        self,
        features=None,
        features_background=None,
        spiketimes=None,  # a subset of all spikes, disregarding cluster
        masks=None,  # masks for all spikes in selected clusters
        clusters=None,  # clusters for all spikes in selected clusters
        clusters_selected=None,
        cluster_colors=None,
        fetdim=None,
        nchannels=None,
        nextrafet=None,
        autozoom=None,  # None, or the target cluster
        duration=None,
        freq=None,
        alpha_selected=.75,
        alpha_background=.25,
        time_unit=None,
    ):

        if features is None:
            features = np.zeros((0, 2))
            features_background = np.zeros((0, 2))
            masks = np.zeros((0, 1))
            clusters = np.zeros(0, dtype=np.int32)
            clusters_selected = []
            cluster_colors = np.zeros(0, dtype=np.int32)
            fetdim = 2
            nchannels = 1
            nextrafet = 0

        assert fetdim is not None

        self.duration = duration
        self.spiketimes = spiketimes
        self.freq = freq
        self.interaction_manager.get_processor('grid').update_viewbox()

        # Feature background alpha value.
        self.alpha_selected = alpha_selected
        self.alpha_background = alpha_background

        # can be 'second' or 'samples'
        self.time_unit = time_unit

        # # Indices of all subset spikes.
        # indices_all = get_indices(features)

        # # Select only the clusters for subset of spikes.
        # clusters = select(clusters, indices_all)

        # # Indices of subset spikes in selected clusters.
        # indices_selection = get_indices(clusters)

        # # Indices of subset spikes that are not in selected clusters.
        # indices_background = np.setdiff1d(indices_all, indices_selection, True)

        # Extract the relevant spikes, but keep the other ones in features_full
        self.clusters = clusters
        self.clusters_array = get_array(self.clusters)

        # self.features contains selected spikes.
        # self.features = select(features, indices_selection)
        self.features = features
        self.features_array = get_array(self.features)

        # self.features_background contains all non-selected spikes
        # self.features_background = select(features, indices_background)
        self.features_background = features_background
        self.features_background_array = get_array(self.features_background)

        # Background spikes are those which do not belong to the selected clusters
        self.npoints_background = self.features_background_array.shape[0]
        self.nspikes_background = self.npoints_background

        self.nspikes, self.ndim = self.features.shape
        self.fetdim = fetdim
        self.nchannels = nchannels
        self.nextrafet = nextrafet
        self.npoints = self.features.shape[0]
        self.masks = masks
        self.feature_indices = get_indices(self.features)
        self.feature_indices_array = get_array(self.feature_indices)

        self.masks_array = get_array(self.masks)
        self.cluster_colors = get_array(cluster_colors, dosort=True)

        # Relative indexing.
        if self.npoints > 0:
            self.clusters_rel = np.digitize(self.clusters_array,
                                            sorted(clusters_selected)) - 1
            self.clusters_rel_ordered = np.argsort(clusters_selected)[
                self.clusters_rel]
        else:
            self.clusters_rel = np.zeros(0, dtype=np.int32)
            self.clusters_rel_ordered = np.zeros(0, dtype=np.int32)

        self.clusters_unique = sorted(clusters_selected)
        self.nclusters = len(clusters_selected)
        self.masks_full = self.masks_array.T.ravel()
        self.clusters_full_depth = self.clusters_rel_ordered
        self.clusters_full = self.clusters_rel

        # prepare GPU data
        self.data = np.empty((self.nspikes, 2), dtype=np.float32)
        self.data_background = np.empty((self.nspikes_background, 2),
                                        dtype=np.float32)

        # set initial projection
        self.projection_manager.set_data()
        self.autozoom = autozoom
        if autozoom is None:
            self.projection_manager.reset_projection()
        else:
            self.projection_manager.auto_projection(autozoom)

        # update the highlight manager
        self.highlight_manager.initialize()
        self.selection_manager.initialize()
        self.selection_manager.cancel_selection()