Changeset 1840:66a7f9e0a719 in orange-bioinformatics


Ignore:
Timestamp:
08/13/13 15:25:37 (8 months ago)
Author:
Flashpoint <vid.flashpoint@…>
Branch:
default
Message:

Separated the row and column clustering in OWHeatMap.py

File:
1 edited

Legend:

Unmodified
Added
Removed
  • _bioinformatics/widgets/OWHeatMap.py

    r1701 r1840  
    7676    return groups.items() 
    7777 
    78 def hierarchical_cluster_ordering(data, group_domains=None, opt_order=False, progress_callback=None): 
     78 
     79#Rows separately 
     80def hierarchical_cluster_ordering_data(data, group_domains=None, opt_order=False, progress_callback=None): 
    7981    classVar = data.domain.classVar 
    8082    if classVar and isinstance(classVar, orange.EnumVariable): 
     
    98100    else: 
    99101        stacked = data     
    100          
    101     attr_cluster = orngClustering.hierarchicalClustering_attributes(stacked, order=opt_order, progressCallback=pp_callback(0)) 
    102     attr_ordering = list(attr_cluster.mapping) 
    103          
     102                
    104103    def indices_map(indices): 
    105104        map = zip(range(len(indices)), indices) 
     
    116115        data_clusters.append(cluster) 
    117116         
    118     return attr_ordering, attr_cluster, data_ordering, data_clusters   
    119          
     117    return data_ordering, data_clusters   
     118 
     119#Columns separately 
     120def hierarchical_cluster_ordering_attr(data, group_domains=None, opt_order=False, progress_callback=None): 
     121    classVar = data.domain.classVar 
     122    if classVar and isinstance(classVar, orange.EnumVariable): 
     123        class_data = [select_by_class_indices(data, val) for val in data.domain.classVar.values] 
     124    else: 
     125        class_data = [[1] * len(data)] 
     126         
     127    parts = len(class_data) + 1  
     128     
     129    def pp_callback(part): 
     130        def callback(value): 
     131            return progress_callback(value / parts + 100.0 * part / parts) 
     132        if progress_callback: 
     133            callback(100.0 * part / parts) 
     134            return callback 
     135        else: 
     136            return progress_callback 
     137         
     138    if group_domains is not None and len(group_domains) > 1: 
     139        stacked = vstack_by_subdomain(data, group_domains) 
     140    else: 
     141        stacked = data     
     142         
     143    attr_cluster = orngClustering.hierarchicalClustering_attributes(stacked, order=opt_order, progressCallback=pp_callback(0)) 
     144    attr_ordering = list(attr_cluster.mapping) 
     145            
     146    return attr_ordering, attr_cluster 
     147 
    120148 
    121149############################################################################## 
     
    190218        self.BSpotVar = None; self.BAnnotationVar = None  # these are names of variables 
    191219        self.BSpotIndx = None; self.BAnnotationIndx = None # these are id's of the combo boxes 
    192         self.SortGenes = 1 
    193220        self.ShowClustering = 1 
    194221        self.SelectionType = 0         # selection on a single data set 
     
    208235        self.maxHSize = 30; self.maxVSize = 15 
    209236 
     237        self.SortExamples = 0 
     238        self.SortAttributes = 0 
     239         
    210240 
    211241        # GUI definition 
     
    264294         
    265295        OWGUI.separator(settingsTab) 
    266  
    267         OWGUI.comboBox(settingsTab, self, "SortGenes", "Sort genes", 
    268                        items=["No sorting", "Sort genes", "Clustering", 
    269                               "Clustering with leaf ordering"], 
    270                                callback=self.update_sorting) 
     296         
     297        # For examples 
     298        OWGUI.comboBox(settingsTab, self, "SortExamples", "Sort Examples", 
     299                        items=["No sorting", "Sort examples", "Clustering", 
     300                               "Clustering with leaf ordering"], 
     301                               callback=self.update_sorting_examples) 
     302         
     303        # For attributes 
     304        OWGUI.comboBox(settingsTab, self, "SortAttributes", "Sort Attributes", 
     305                        items=["No sorting", "Clustering", 
     306                               "Clustering with leaf ordering"], 
     307                               callback=self.update_sorting_attributes) 
     308         
    271309        OWGUI.rubber(settingsTab) 
    272310         
     
    378416         
    379417        self._ordering_cache = {} 
     418        self._ordering_cache_examples = {} 
     419        self._ordering_cache_attributes = {} 
    380420         
    381421        self.resize(800,400) 
     
    522562            for (key, value), attrs in groups.items(): 
    523563                by_keys[key].append(attrs) 
    524              
     564            
    525565            # Find the keys for which all values have the same number of attributes. 
    526566            candidates = [] 
     
    574614    def set_dataset(self, data=None, id=None): 
    575615        self.closeContext("Selection") 
     616         
    576617        self._ordering_cache.clear() 
     618        self._ordering_cache_examples.clear() 
     619        self._ordering_cache_attributes.clear() 
     620         
    577621        self.clear() 
    578622        self.data = data 
     
    602646             
    603647        group_domains = [dom for _, dom in groups] 
    604          
    605         if self.SortGenes > 1: 
     648 
     649        # Both rows and columns 
     650        if self.SortExamples > 1 and self.SortAttributes > 0: 
    606651            self.progressBarInit() 
    607              
    608             args_key = tuple(tuple(d) for d in group_domains), self.SortGenes == 3 
     652 
     653            args_key = tuple(tuple(d) for d in group_domains), self.SortExamples == 3, self.SortAttributes == 2 
    609654            cluster_ordering = self._ordering_cache.get(args_key, None) 
    610655            if cluster_ordering is None: 
    611                 attr_ordering, attr_cluster, data_ordering, data_clusters = \ 
    612                         hierarchical_cluster_ordering(data, group_domains, 
    613                                       opt_order=self.SortGenes == 3, 
     656 
     657                # Rows separately 
     658                data_ordering, data_clusters = \ 
     659                        hierarchical_cluster_ordering_data(data, group_domains, 
     660                                      opt_order=self.SortExamples == 3, 
    614661                                      progress_callback=self.progressBarSet) 
     662 
     663                # Columns separately 
     664                attr_ordering, attr_cluster = \ 
     665                        hierarchical_cluster_ordering_attr(data, group_domains, 
     666                                      opt_order=self.SortAttributes == 2, 
     667                                      progress_callback=self.progressBarSet) 
     668 
    615669                # Cache the clusters 
    616670                self._ordering_cache[args_key] = (attr_ordering, attr_cluster, 
     
    621675            sorted_data = [data[i] for i in itertools.chain(*data_ordering)] 
    622676            self.progressBarFinished() 
    623              
     677         
     678        # Only rows 
     679        elif self.SortExamples > 1: 
     680            self.progressBarInit() 
     681 
     682            args_key = tuple(tuple(d) for d in group_domains), self.SortExamples == 3 
     683            cluster_ordering_examples = self._ordering_cache_examples.get(args_key, None) 
     684            if cluster_ordering_examples is None: 
     685 
     686                # Rows separately 
     687                data_ordering, data_clusters = \ 
     688                        hierarchical_cluster_ordering_data(data, group_domains, 
     689                                      opt_order=self.SortExamples == 3, 
     690                                      progress_callback=self.progressBarSet) 
     691 
     692                # Cache the clusters 
     693                self._ordering_cache_examples[args_key] = (data_ordering, data_clusters) 
     694            else: 
     695                 data_ordering, data_clusters = cluster_ordering_examples 
     696             
     697            attr_ordering = range(len(group_domains[0][1].attributes)) 
     698            attr_cluster = None 
     699            sorted_data = [data[i] for i in itertools.chain(*data_ordering)] 
     700            self.progressBarFinished() 
     701         
     702        # Only columns 
     703        elif self.SortAttributes > 0: 
     704            self.progressBarInit() 
     705 
     706            args_key = tuple(tuple(d) for d in group_domains), self.SortAttributes == 2 
     707            cluster_ordering_attributes = self._ordering_cache_attributes.get(args_key, None) 
     708            if cluster_ordering_attributes is None: 
     709 
     710                # Columns separately 
     711                attr_ordering, attr_cluster = \ 
     712                        hierarchical_cluster_ordering_attr(data, group_domains, 
     713                                      opt_order=self.SortAttributes == 2, 
     714                                      progress_callback=self.progressBarSet) 
     715 
     716                # Cache the clusters 
     717                self._ordering_cache_attributes[args_key] = (attr_ordering, attr_cluster) 
     718            else: 
     719                 attr_ordering, attr_cluster = cluster_ordering_attributes 
     720             
     721            data_ordering = [] 
     722            data_clusters = [None] 
     723            sorted_data = data 
     724            self.progressBarFinished() 
     725 
    624726        else: 
    625727            attr_ordering = range(len(group_domains[0][1].attributes)) 
     
    640742            group_data = orange.ExampleTable(group_domain, sorted_data) 
    641743            self._group_data.append((group_data, group_domain)) # Crashes at accessing the heatmap.examples[0] without this  
    642             if self.SortGenes == 1: 
     744            if self.SortExamples == 1: 
    643745                hc = orangene.HeatmapConstructor(group_data) 
    644746            else: 
     
    651753        self.sorted_data = sorted_data 
    652754        self.group_domains = groups 
    653              
     755              
    654756    def create_heatmaps(self, constructors): 
    655757        self.lowerBound = 1000 
     
    10191121        if self.data: 
    10201122            self.update_heatmaps() 
    1021              
     1123         
     1124    def update_sorting_examples(self): 
     1125        if self.data: 
     1126            self.update_heatmaps() 
     1127 
     1128    def update_sorting_attributes(self): 
     1129        if self.data: 
     1130            self.update_heatmaps() 
     1131 
    10221132    def update_legend(self): 
    10231133        for item in self.heatmap_scene.items(): 
Note: See TracChangeset for help on using the changeset viewer.