Python selection.select函数代码示例

 def get_waveforms(self, spikes=None, clusters=None):
     
     if self.waveforms_selected is None:
         return None
     # Special case: return the already-selected values from the cache.
     if spikes is None and clusters is None:
         values = self.process_waveforms(self.waveforms_selected)
         return pandaize(values, self.spikes_waveforms)
     
     # Normal case.
     if self.spikes_selected_table is None:
         return None
     if spikes is not None:
         return select(self.waveforms, spikes)
     else:
         if clusters is None:
             clusters = self.clusters_selected
         if clusters is not None:
             spikes = get_some_spikes_in_clusters(clusters, self.clusters,
                 counter=self.counter,
                 nspikes_max_expected=self.userpref['waveforms_nspikes_max_expected'],
                 nspikes_per_cluster_min=self.userpref['waveforms_nspikes_per_cluster_min'])
         else:
             spikes = self.spikes_selected
     return select(self.waveforms, spikes)

 def get_waveforms(self, spikes=None, clusters=None):
     if spikes is not None:
         return select(self.waveforms, spikes)
     else:
         if clusters is None:
             clusters = self.clusters_selected
         if clusters is not None:
             spikes = get_some_spikes_in_clusters(clusters, self.clusters,
                 counter=self.counter,
                 nspikes_max_expected=self.userpref['waveforms_nspikes_max_expected'],
                 nspikes_per_cluster_min=self.userpref['waveforms_nspikes_per_cluster_min'])
         else:
             spikes = self.spikes_selected
     return select(self.waveforms, spikes)

 def get_spiketimes(self, spikes=None, clusters=None):
     if clusters is not None:
         spikes = get_spikes_in_clusters(clusters, self.clusters)
     if spikes is None:
         spikes = self.spikes_selected
     spiketimes = getattr(self, 'spiketimes', getattr(self, 'spiketimes_res', None))
     return select(spiketimes, spikes)

 def get_cluster_colors(self, clusters=None, can_override=True):
     if clusters is None:
         clusters = self.clusters_selected
     if can_override and self.override_color:
         group_colors = get_array(self.get_group_colors("all"))
         groups = get_array(self.get_cluster_groups("all"))
         colors = pd.Series(group_colors[groups], index=self.get_clusters_unique())
     else:
         colors = pd.Series([self.get_cluster_color(c) for c in clusters], index=clusters)
     return select(colors, clusters)

 def get_channel_colors(self, channels=None, can_override=True):
     if channels is None:
         channels = self.channels_selected
     if can_override and self.override_color:
         channel_group_colors = get_array(self.get_channel_group_colors("all"))
         channel_groups = get_array(self.get_channel_groups("all"))
         colors = pd.Series(channel_group_colors[channel_groups], index=self.channels)
     else:
         colors = self.channel_colors
     return select(colors, channels)

 def get_masks(self, spikes=None, full=None, clusters=None):
     if clusters is not None:
         spikes = get_spikes_in_clusters(clusters, self.clusters)
     if spikes is None:
         spikes = self.spikes_selected
     if not full:
         masks = self.masks
     else:
         masks = self.masks_full
     return select(masks, spikes)

 def get_features(self, spikes=None, clusters=None):
     if self.spikes_selected_table is None:
         return None
     # Special case: return the already-selected values from the cache.
     if spikes is None and clusters is None:
         features = self.spikes_selected_table['features']
         values = self.process_features(features)
         return pandaize(values, self.spikes_selected)
     # Normal case.
     if clusters is not None:
         spikes = get_spikes_in_clusters(clusters, self.clusters)
     if spikes is None:
         spikes = self.spikes_selected
     return select(self.features, spikes)

 def get_some_features(self, clusters=None):
     """Return the features for a subset of all spikes: a large number
     of spikes from any cluster, and a controlled subset of the selected 
     clusters."""
     if clusters is None:
         clusters = self.clusters_selected
     if clusters is not None:
         spikes_background = get_some_spikes(self.clusters,
             nspikes_max=self.userpref['features_nspikes_background_max'],)
         spikes_clusters = get_some_spikes_in_clusters(
             clusters,
             self.clusters,
             counter=self.counter,
             nspikes_max_expected=self.userpref[
                 'features_nspikes_selection_max'],
             nspikes_per_cluster_min=self.userpref[
                 'features_nspikes_per_cluster_min'])
         spikes = np.union1d(spikes_background, spikes_clusters)
     else:
         spikes = self.spikes_selected
     return select(self.features, spikes)

 def get_masks(self, spikes=None, full=None, clusters=None):
     if self.spikes_selected_table is None:
         return None
     # Special case: return the already-selected values from the cache.
     if spikes is None and clusters is None:
         masks = self.spikes_selected_table['masks']
         if full:
             values = self.process_masks_full(masks)
         else:
             values = self.process_masks(masks)
         return pandaize(values, self.spikes_selected)
         
     # Normal case.
     if clusters is not None:
         spikes = get_spikes_in_clusters(clusters, self.clusters)
     if spikes is None:
         spikes = self.spikes_selected
     if not full:
         masks = self.masks
     else:
         masks = self.masks_full
     return select(masks, spikes)

 def get_group_names(self, groups=None):
     return select(self.group_names, groups)

 def get_group_colors(self, groups=None):
     return select(self.group_colors, groups)

 def get_cluster_groups(self, clusters=None):
     if clusters is None:
         clusters = self.clusters_selected
     return select(self.cluster_groups, clusters)

 def get_cluster_color(self, cluster):
     try:
         return select(self.cluster_colors, cluster)
     except IndexError:
         return 0

 def get_traces(self):
     return select(self.raw)

 def get_masks(self, spikes=None, full=None):
     if not full:
         masks = self.masks
     else:
         masks = self.masks_full
     return select(masks, spikes)