Changeset 10878:9fc2d9665475 in orange


Ignore:
Timestamp:
05/18/12 10:31:57 (2 years ago)
Author:
mstajdohar
Branch:
default
Message:

Added FragViz optimization on network view.

Location:
Orange/OrangeWidgets/Unsupervised
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • Orange/OrangeWidgets/Unsupervised/OWNxCanvasQt.py

    r10877 r10878  
    99MOVE_SELECTION = 100 
    1010 
    11 import Orange 
    12 import random 
    1311import numpy 
    1412 
     
    1715from plot.owtools import * 
    1816 
     17from Orange import core, data, misc, network, orangeqt, projection 
    1918from orngScaleScatterPlotData import * 
    20 from Orange import orangeqt 
    2119 
    2220class NodeItem(orangeqt.NodeItem): 
     
    4745        orangeqt.NetworkCurve.set_node_sizes(self, values, min_size, max_size) 
    4846 
    49     def fragviz_callback(self, a, b, mds, mdsRefresh, components, progress_callback): 
     47    def fragviz_callback(self, a, b, mds, mdsRefresh, graph_components, matrix_components, progress_callback): 
    5048        """Refresh the UI when running  MDS on network components.""" 
    5149 
     
    5553            x_mds = [] 
    5654            y_mds = [] 
    57             phi = [None] * len(components) 
     55            phi = [None] * len(graph_components) 
    5856            nodes = self.nodes() 
    59  
    60             for i, component in enumerate(components): 
    61  
    62                 if len(mds.points) == len(components):  # if average linkage before 
     57            ncomponents = len(graph_components) 
     58 
     59            for i in range(ncomponents): 
     60 
     61                if len(mds.points) == ncomponents:  # if average linkage before 
    6362                    x_avg_mds = mds.points[i][0] 
    6463                    y_avg_mds = mds.points[i][1] 
    6564                else:                                   # if not average linkage before 
    66                     x = [mds.points[u][0] for u in component] 
    67                     y = [mds.points[u][1] for u in component] 
     65                    x = [mds.points[u][0] for u in matrix_components[i]] 
     66                    y = [mds.points[u][1] for u in matrix_components[i]] 
    6867 
    6968                    x_avg_mds = sum(x) / len(x) 
     
    7877 
    7978 
    80                 x = [nodes[i].x() for i in component] 
    81                 y = [nodes[i].y() for i in component] 
     79                x = [nodes[j].x() for j in graph_components[i]] 
     80                y = [nodes[j].y() for j in graph_components[i]] 
    8281 
    8382                x_avg_graph = sum(x) / len(x) 
     
    9089                                        x_avg_mds, y_avg_mds, phi)) 
    9190 
    92             for i, component in enumerate(components): 
     91            for i, component in enumerate(graph_components): 
    9392                x_avg_graph, y_avg_graph, x_avg_mds, \ 
    9493                y_avg_mds, phi = component_props[i] 
     
    105104                if not rotationOnly: 
    106105                    self.set_node_coordinates(dict( 
    107                        (i, ((nodes[i].x() - x_avg_graph) + x_avg_mds, 
    108                             (nodes[i].y() - y_avg_graph) + y_avg_mds)) \ 
    109                                   for i in component)) 
     106                       (j, ((nodes[j].x() - x_avg_graph) + x_avg_mds, 
     107                            (nodes[j].y() - y_avg_graph) + y_avg_mds)) \ 
     108                                  for j in component)) 
    110109 
    111110            #if self.mdsType == MdsType.exactSimulation: 
     
    147146        self.stopMDS = False 
    148147 
    149         components = Orange.network.nx.algorithms.components.connected.connected_components(graph) 
    150         distances.matrixType = Orange.core.SymMatrix.Symmetric 
    151         # TODO!!!!!!! 
    152         sorted(graph.nodes_iter()) 
     148        nodes_inds = {n: i for i, n in enumerate(sorted(graph.nodes_iter()))} 
     149        inds_nodes = {i: n for i, n in enumerate(sorted(graph.nodes_iter()))} 
     150 
     151        graph_components = network.nx.algorithms.connected_components(graph) 
     152        matrix_components = [[nodes_inds[n] for n in c] for c in graph_components] 
     153 
     154        distances.matrixType = misc.SymMatrix.Symmetric 
    153155 
    154156        # scale net coordinates 
    155157        if avgLinkage: 
    156             distances = distances.avgLinkage(components) 
     158            distances = distances.avgLinkage(matrix_components) 
    157159 
    158160        # if only one component 
     
    160162            return 0 
    161163 
    162         mds = Orange.projection.mds.MDS(distances) 
    163         mds.optimize(10, Orange.projection.mds.SgnRelStress, 0) 
     164        mds = projection.mds.MDS(distances) 
     165        mds.optimize(10, projection.mds.SgnRelStress, 0) 
    164166        rect = self.data_rect() 
    165167        w_fr = rect.width() 
     
    167169        d_fr = math.sqrt(w_fr ** 2 + h_fr ** 2) 
    168170 
    169         x_mds = [mds.points[u][0] for u in range(len(mds.points))] 
    170         y_mds = [mds.points[u][1] for u in range(len(mds.points))] 
     171        x_mds, y_mds = zip(*mds.points) 
    171172        w_mds = max(x_mds) - min(x_mds) 
    172173        h_mds = max(y_mds) - min(y_mds) 
     
    181182            d_fr = 1 
    182183 
    183         self.set_node_coordinates(dict( 
    184            (n, (nodes[n].x() * d_mds / d_fr, nodes[n].y() * d_mds / d_fr)) for n in nodes)) 
     184        self.set_node_coordinates({key: (node.x() * d_mds / d_fr, node.y() * d_mds / d_fr) \ 
     185                                   for key, node in nodes.iteritems()}) 
    185186 
    186187        #self.update_properties() 
     
    190191        if opt_from_curr: 
    191192            if avgLinkage: 
    192                 for u, c in enumerate(components): 
     193                for u, c in enumerate(graph_components): 
    193194                    x = sum([nodes[n].x() for n in c]) / len(c) 
    194195                    y = sum([nodes[n].y() for n in c]) / len(c) 
     
    202203            mds.Torgerson() 
    203204 
    204         mds.optimize(steps, Orange.projection.mds.SgnRelStress, minStressDelta, 
     205        mds.optimize(steps, projection.mds.SgnRelStress, minStressDelta, 
    205206                     progressCallback= 
    206                          lambda a, 
    207                                 b=None, 
    208                                 mds=mds, 
    209                                 mdsRefresh=mdsRefresh, 
    210                                 components=components, 
    211                                 progress_callback=progress_callback: 
    212                                     self.fragviz_callback(a, b, mds, mdsRefresh, components, progress_callback)) 
    213  
    214         self.fragviz_callback(mds.avgStress, 0, mds, mdsRefresh, components, progress_callback) 
    215  
    216         if progress_callback != None: 
     207                         lambda a, b=None, mds=mds, mdsRefresh=mdsRefresh, graph_comp=graph_components, 
     208                                matrix_comp=matrix_components, progress_callback=progress_callback: 
     209                         self.fragviz_callback(a, b, mds, mdsRefresh, graph_comp, matrix_comp, progress_callback)) 
     210 
     211        self.fragviz_callback(mds.avgStress, 0, mds, mdsRefresh, graph_components, matrix_components, progress_callback) 
     212 
     213        if progress_callback is not None: 
    217214            progress_callback(mds.avgStress, self.mdsStep) 
    218215 
     
    225222        if not self.mdsStep % mdsRefresh: 
    226223 
    227             self.set_node_coordinates(dict((u, (mds.points[u][0], \ 
    228                                                 mds.points[u][1])) for u in \ 
    229                                            range(len(mds.points)))) 
     224            self.set_node_coordinates({n: (mds.points[i][0], \ 
     225                                           mds.points[i][1]) for i, n in enumerate(sorted(self.nodes()))}) 
    230226            self.plot().replot() 
    231227            qApp.processEvents() 
     
    256252        self.stopMDS = False 
    257253 
    258         distances.matrixType = Orange.core.SymMatrix.Symmetric 
    259         mds = Orange.projection.mds.MDS(distances) 
    260         mds.optimize(10, Orange.projection.mds.SgnRelStress, 0) 
     254        distances.matrixType = core.SymMatrix.Symmetric 
     255        mds = projection.mds.MDS(distances) 
     256        mds.optimize(10, projection.mds.SgnRelStress, 0) 
    261257        rect = self.data_rect() 
    262258        w_fr = rect.width() 
     
    264260        d_fr = math.sqrt(w_fr ** 2 + h_fr ** 2) 
    265261 
    266         x_mds = [mds.points[u][0] for u in range(len(mds.points))] 
    267         y_mds = [mds.points[u][1] for u in range(len(mds.points))] 
     262        x_mds, y_mds = zip(*mds.points) 
    268263        w_mds = max(x_mds) - min(x_mds) 
    269264        h_mds = max(y_mds) - min(y_mds) 
     
    286281            mds.Torgerson() 
    287282 
    288         mds.optimize(steps, Orange.projection.mds.SgnRelStress, minStressDelta, 
     283        mds.optimize(steps, projection.mds.SgnRelStress, minStressDelta, 
    289284                     progressCallback= 
    290285                         lambda a, 
     
    297292        self.mds_callback(mds.avgStress, 0, mds, mdsRefresh, progress_callback) 
    298293 
    299         if progress_callback != None: 
     294        if progress_callback is not None: 
    300295            progress_callback(mds.avgStress, self.mdsStep) 
    301296 
     
    444439            return 
    445440 
    446         components = Orange.network.nx.algorithms.components.connected_components(self.graph) 
     441        components = network.nx.algorithms.components.connected_components(self.graph) 
    447442        nodes = self.networkCurve.nodes() 
    448443 
     
    468463                if var.name == attribute: 
    469464                    colorIndex = i 
    470                     if var.varType == orange.VarTypes.Discrete: 
     465                    if var.varType == core.VarTypes.Discrete: 
    471466                        colorIndices = getVariableValueIndices(var, colorIndex) 
    472467 
     
    476471                if var.name == attribute: 
    477472                    colorIndex = i 
    478                     if var.varType == orange.VarTypes.Discrete: 
     473                    if var.varType == core.VarTypes.Discrete: 
    479474                        colorIndices = getVariableValueIndices(var, colorIndex) 
    480475 
     
    482477        palette.setNumberOfColors(len(colorIndices)) 
    483478 
    484         if colorIndex != None and table.domain[colorIndex].varType == orange.VarTypes.Continuous: 
     479        if colorIndex != None and table.domain[colorIndex].varType == core.VarTypes.Continuous: 
    485480            minValue = float(min([x[colorIndex].value for x in table if x[colorIndex].value != "?"] or [0.0])) 
    486481            maxValue = float(max([x[colorIndex].value for x in table if x[colorIndex].value != "?"] or [0.0])) 
     
    498493            nodes = self.graph.nodes() 
    499494 
    500         if colorIndex is not None and self.items.domain[colorIndex].varType == orange.VarTypes.Continuous and minValue == maxValue: 
     495        if colorIndex is not None and self.items.domain[colorIndex].varType == core.VarTypes.Continuous and minValue == maxValue: 
    501496            colors.update((node, self.discPalette[0]) for node in nodes) 
    502497 
    503         elif colorIndex is not None and self.items.domain[colorIndex].varType == orange.VarTypes.Continuous: 
     498        elif colorIndex is not None and self.items.domain[colorIndex].varType == core.VarTypes.Continuous: 
    504499            colors.update((v, self.contPalette[(float(self.items[v][colorIndex].value) - minValue) / (maxValue - minValue)]) 
    505500                          if str(self.items[v][colorIndex].value) != '?' else 
    506501                          (v, self.discPalette[0]) for v in nodes) 
    507502 
    508         elif colorIndex is not None and self.items.domain[colorIndex].varType == orange.VarTypes.Discrete: 
     503        elif colorIndex is not None and self.items.domain[colorIndex].varType == core.VarTypes.Discrete: 
    509504            colors.update((v, self.discPalette[colorIndices[self.items[v][colorIndex].value]]) for v in nodes) 
    510505 
     
    525520 
    526521        label_attributes = [] 
    527         if self.items is not None and isinstance(self.items, orange.ExampleTable): 
     522        if self.items is not None and isinstance(self.items, data.Table): 
    528523            label_attributes = [self.items.domain[att] for att in \ 
    529524                self.node_label_attributes if att in self.items.domain] 
     
    565560        colors = [] 
    566561 
    567         if colorIndex is not None and self.links.domain[colorIndex].varType == orange.VarTypes.Continuous and minValue == maxValue: 
     562        if colorIndex is not None and self.links.domain[colorIndex].varType == core.VarTypes.Continuous and minValue == maxValue: 
    568563            colors = [self.discEdgePalette[0] for edge in self.networkCurve.edge_indices()] 
    569564 
    570         elif colorIndex is not None and self.links.domain[colorIndex].varType == orange.VarTypes.Continuous: 
     565        elif colorIndex is not None and self.links.domain[colorIndex].varType == core.VarTypes.Continuous: 
    571566            colors = [self.contPalette[(float(self.links[edge.links_index()][colorIndex].value) - minValue) / (maxValue - minValue)] 
    572567                          if str(self.links[edge.links_index()][colorIndex].value) != '?' else 
    573568                          self.discPalette[0] for edge in self.networkCurve.edges()] 
    574569 
    575         elif colorIndex is not None and self.links.domain[colorIndex].varType == orange.VarTypes.Discrete: 
     570        elif colorIndex is not None and self.links.domain[colorIndex].varType == core.VarTypes.Discrete: 
    576571            colors = [self.discEdgePalette[colorIndices[self.links[edge.links_index()][colorIndex].value]] for edge in self.networkCurve.edges()] 
    577572 
     
    592587 
    593588        label_attributes = [] 
    594         if self.links is not None and isinstance(self.links, orange.ExampleTable): 
     589        if self.links is not None and isinstance(self.links, data.Table): 
    595590            label_attributes = [self.links.domain[att] for att in \ 
    596591                self.edge_label_attributes if att in self.links.domain] 
     
    608603    def set_tooltip_attributes(self, attributes): 
    609604        if self.graph is None or self.items is None or \ 
    610            not isinstance(self.items, orange.ExampleTable): 
     605           not isinstance(self.items, data.Table): 
    611606            return 
    612607 
    613608        tooltip_attributes = [self.items.domain[att] for att in \ 
    614609                                 attributes if att in self.items.domain] 
    615         self.networkCurve.set_node_tooltips(dict((node, ', '.join(str(\ 
     610        self.networkCurve.set_node_tooltips(dict((node, ', '.join(str( \ 
    616611                   self.items[node][att]) for att in tooltip_attributes)) \ 
    617612                                                        for node in self.graph)) 
  • Orange/OrangeWidgets/Unsupervised/OWNxExplorer.py

    r10877 r10878  
    1111import time 
    1212 
    13 import Orange 
    1413import OWGUI 
    1514import OWColorPalette 
    1615import orngMDS 
    1716 
     17from Orange import core, data, feature, network 
    1818from OWWidget import * 
    1919from operator import itemgetter 
     
    4646            OWWidget.__init__(self, parent, signalManager, name, noReport=True) 
    4747            #self.contextHandlers = {"": DomainContextHandler("", [ContextField("attributes", selected="markerAttributes"), ContextField("attributes", selected="tooltipAttributes"), "color"])} 
    48             self.inputs = [("Network", Orange.network.Graph, self.set_graph, Default), 
    49                            ("Items", Orange.data.Table, self.set_items), 
    50                            ("Item Subset", Orange.data.Table, self.mark_items), 
    51                            ("Distances", Orange.core.SymMatrix, self.set_items_distance_matrix), 
    52                            ("Net View", Orange.network.NxView, self.set_network_view)] 
    53  
    54             self.outputs = [("Selected Network", Orange.network.Graph), 
    55                             ("Distance Matrix", Orange.core.SymMatrix), 
    56                             ("Marked Items", Orange.data.Table), 
    57                             ("Selected Items", Orange.data.Table), 
    58                             ("Other Items", Orange.data.Table)] 
     48            self.inputs = [("Network", network.Graph, self.set_graph, Default), 
     49                           ("Items", data.Table, self.set_items), 
     50                           ("Item Subset", data.Table, self.mark_items), 
     51                           ("Distances", core.SymMatrix, self.set_items_distance_matrix), 
     52                           ("Net View", network.NxView, self.set_network_view)] 
     53 
     54            self.outputs = [("Selected Network", network.Graph), 
     55                            ("Distance Matrix", core.SymMatrix), 
     56                            ("Marked Items", data.Table), 
     57                            ("Selected Items", data.Table), 
     58                            ("Other Items", data.Table)] 
    5959                            #("Attribute Selection List", AttributeList)] 
    6060 
     
    353353        def hide_selection(self): 
    354354            nodes = set(self.graph.nodes()).difference(self.networkCanvas.selected_nodes()) 
    355             self.change_graph(Orange.network.nx.Graph.subgraph(self.graph, nodes)) 
     355            self.change_graph(network.nx.Graph.subgraph(self.graph, nodes)) 
    356356 
    357357        def show_selection(self): 
     
    372372 
    373373            items = self.graph_base.items() 
    374             if items.domain[att].var_type == Orange.feature.Type.Continuous: 
     374            if items.domain[att].var_type == feature.Type.Continuous: 
    375375                for v in vertices: 
    376376                    items[v][att] = float(self.editValue) 
     
    407407            self.cb_show_component_distances.setEnabled(1) 
    408408 
    409             if str(self.optMethod) in ['8', '9', '10']: 
    410                 if self.items_matrix is not None and self.graph is not None and \ 
    411                 self.items_matrix.dim == self.graph.number_of_nodes(): 
     409            if self.optMethod in [8, 9, 10]: 
     410                if self.items_matrix is not None and self.graph_base is not None and \ 
     411                                    self.items_matrix.dim == self.graph_base.number_of_nodes(): 
    412412                    self.optButton.setEnabled(True) 
    413                     self.optButton.setChecked(True) 
    414                     self.graph_layout() 
     413 
     414                    if self.optMethod in [8, 9]: 
     415                        self.cb_opt_from_curr.setEnabled(True) 
     416 
     417                    if self.optMethod == 8: # if FragViz, run FR first 
     418                        self.optMethod = 2 
     419                        self.optButton.setChecked(True) 
     420                        self.graph_layout() 
     421                        self.optMethod = 8 
     422 
     423                self.optButton.setChecked(True) 
     424                self.graph_layout() 
    415425 
    416426        def _set_canvas_attr(self, attr, value): 
     
    556566                    graph_node['y'] = plot_node.y() 
    557567 
    558                 Orange.network.readwrite.write(self.graph, fn) 
     568                network.readwrite.write(self.graph, fn) 
    559569 
    560570        def send_data(self): 
     
    622632 
    623633            for var in vars: 
    624                 if var.varType in [Orange.feature.Type.Discrete, \ 
    625                                    Orange.feature.Type.Continuous]: 
     634                if var.varType in [feature.Type.Discrete, \ 
     635                                   feature.Type.Continuous]: 
    626636                    self.colorCombo.addItem(self.icons.get(var.varType, \ 
    627637                                            self.icons[-1]), unicode(var.name)) 
    628638 
    629                 if var.varType in [Orange.feature.Type.String] and hasattr(self.graph, 'items') and self.graph_base.items() is not None and len(self.graph_base.items()) > 0: 
     639                if var.varType in [feature.Type.String] and hasattr(self.graph, 'items') and self.graph_base.items() is not None and len(self.graph_base.items()) > 0: 
    630640 
    631641                    value = self.graph_base.items()[0][var].value 
     
    642652                        self.vertexSizeCombo.addItem(self.icons.get(var.varType, self.icons[-1]), "num of " + unicode(var.name)) 
    643653 
    644                 elif var.varType in [Orange.feature.Type.Continuous]: 
     654                elif var.varType in [feature.Type.Continuous]: 
    645655                    self.vertexSizeCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
    646656 
     
    651661 
    652662            for var in edgeVars: 
    653                 if var.varType in [Orange.feature.Type.Discrete, Orange.feature.Type.Continuous]: 
     663                if var.varType in [feature.Type.Discrete, feature.Type.Continuous]: 
    654664                    self.edgeColorCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
    655665 
     
    956966                commonVars = set(lstNewDomain) & set(lstOrgDomain) 
    957967 
    958                 self.markInputCombo.addItem(self.icons[Orange.feature.Type.Discrete], unicode("ID")) 
     968                self.markInputCombo.addItem(self.icons[feature.Type.Discrete], unicode("ID")) 
    959969 
    960970                if len(commonVars) > 0: 
     
    963973                        mrkVar = items.domain[var] 
    964974 
    965                         if orgVar.varType == mrkVar.varType and orgVar.varType == Orange.feature.Type.String: 
     975                        if orgVar.varType == mrkVar.varType and orgVar.varType == feature.Type.String: 
    966976                            self.markInputCombo.addItem(self.icons[orgVar.varType], unicode(orgVar.name)) 
    967977 
     
    10491059                self.optMethod = method 
    10501060 
    1051             if str(self.optMethod) == '0': 
     1061            if self.optMethod == 0: 
    10521062                self.optButton.setEnabled(False) 
    10531063            else: 
    10541064                self.optButton.setEnabled(True) 
    10551065 
    1056             if str(self.optMethod) in ['2', '3', '4']: 
     1066            if self.optMethod in [2, 3, 4]: 
    10571067                self.stepsSpin.setEnabled(True) 
    10581068 
    1059             elif str(self.optMethod) in ['8', '9', '10']: 
    1060                 if str(self.optMethod) == '8': 
     1069            elif self.optMethod in [8, 9, 10]: 
     1070                if self.optMethod == 10: 
    10611071                    self.stepsSpin.label.setText('Pivots: ') 
    10621072 
    1063                 if str(self.optMethod) in ['9', '10']: 
     1073                if self.optMethod in [8, 9]: 
    10641074                    self.cb_opt_from_curr.setEnabled(True) 
    10651075 
     
    14301440 
    14311441            self.progressBarInit() 
    1432             components = [c for c in Orange.network.nx.algorithms.components.connected_components(self.graph) if len(c) > 1] 
     1442            components = [c for c in network.nx.algorithms.components.connected_components(self.graph) if len(c) > 1] 
    14331443            if 'component name' in self.graph_base.items().domain: 
    14341444                keyword_table = self.graph_base.items() 
    14351445            else: 
    1436                 keyword_table = Orange.data.Table(Orange.data.Domain(Orange.feature.String('component name')), [[''] for i in range(len(self.graph_base.items()))]) 
     1446                keyword_table = data.Table(data.Domain(feature.String('component name')), [[''] for i in range(len(self.graph_base.items()))]) 
    14371447 
    14381448            import obiGO 
     
    15501560 
    15511561            self.lastNameComponentAttribute = self.nameComponentCombo.currentText() 
    1552             self.set_items(Orange.data.Table([self.graph_base.items(), keyword_table])) 
     1562            self.set_items(data.Table([self.graph_base.items(), keyword_table])) 
    15531563            self.progressBarFinished() 
    15541564 
Note: See TracChangeset for help on using the changeset viewer.