Changeset 8086:d01c816dd1ca in orange


Ignore:
Timestamp:
07/06/11 16:33:56 (3 years ago)
Author:
miha <miha.stajdohar@…>
Branch:
default
Convert:
e0e654e952d381989ccea8ae1348e4ea9b658ec0
Message:

Added a new network view functionality.

Location:
orange/OrangeWidgets/Unsupervised
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • orange/OrangeWidgets/Unsupervised/OWNxCanvas.py

    r8083 r8086  
    7171      self.vertices[v].color = color 
    7272      self.vertices[v].pen = QPen(color, pen.width()) 
     73 
     74  def set_nodes_color(self, vertices, color): 
     75      for v in vertices: 
     76          v.color = color 
     77          v.pen = QPen(color, v.pen.width()) 
    7378       
    7479  def set_edge_color(self, index, color, nocolor=0): 
     
    10001005        self.replot() 
    10011006     
    1002     def set_node_color(self, attribute): 
     1007    def set_node_color(self, attribute, nodes=None): 
    10031008        if self.graph is None: 
    10041009            return 
    10051010         
     1011        if nodes is None: 
     1012            nodes = self.networkCurve.vertices.itervalues() 
     1013        else: 
     1014            nodes = (self.networkCurve.vertices[nodes] for node in nodes)  
     1015             
    10061016        colorIndices, colorIndex, minValue, maxValue = self.getColorIndeces(self.items, attribute, self.discPalette) 
    10071017     
    1008         for key, vertex in self.networkCurve.vertices.iteritems(): 
    1009             v = vertex.index 
    1010             if colorIndex != None:     
    1011                 if self.items.domain[colorIndex].varType == orange.VarTypes.Continuous: 
    1012                     newColor = self.discPalette[0] 
     1018        if colorIndex is not None and self.items.domain[colorIndex].varType == orange.VarTypes.Continuous: 
     1019            for vertex in nodes: 
     1020                v = vertex.index 
     1021                newColor = self.discPalette[0] 
     1022                 
     1023                if str(self.items[v][colorIndex]) != "?": 
     1024                    if maxValue == minValue: 
     1025                        newColor = self.discPalette[0] 
     1026                    else: 
     1027                        value = (float(self.items[v][colorIndex].value) - minValue) / (maxValue - minValue) 
     1028                        newColor = self.contPalette[value] 
    10131029                     
    1014                     if str(self.items[v][colorIndex]) != "?": 
    1015                         if maxValue == minValue: 
    1016                             newColor = self.discPalette[0] 
    1017                         else: 
    1018                             value = (float(self.items[v][colorIndex].value) - minValue) / (maxValue - minValue) 
    1019                             newColor = self.contPalette[value] 
    1020                          
    1021                     self.networkCurve.set_node_color(v, newColor) 
    1022                      
    1023                 elif self.items.domain[colorIndex].varType == orange.VarTypes.Discrete: 
    1024                     newColor = self.discPalette[colorIndices[self.items[v][colorIndex].value]] 
    1025                     #print newColor 
    1026                     self.networkCurve.set_node_color(v, newColor) 
    1027                      
    1028             else: 
    1029                 newColor = self.discPalette[0] 
    10301030                self.networkCurve.set_node_color(v, newColor) 
    1031          
     1031                 
     1032        elif colorIndex is not None and self.items.domain[colorIndex].varType == orange.VarTypes.Discrete: 
     1033            for vertex in nodes: 
     1034                v = vertex.index 
     1035                newColor = self.discPalette[colorIndices[self.items[v][colorIndex].value]] 
     1036                self.networkCurve.set_node_color(v, newColor) 
     1037        else: 
     1038            self.networkCurve.set_nodes_color(nodes, self.discPalette[0]) 
     1039             
    10321040        self.replot() 
    10331041         
     
    10661074        if self.layout is None or self.graph is None or self.items is None: 
    10671075            return 
     1076         
     1077    def change_graph(self, newgraph, inter_nodes, add_nodes, remove_nodes): 
     1078        self.graph = newgraph 
     1079         
     1080        [self.networkCurve.vertices.pop(key) for key in remove_nodes] 
     1081        self.networkCurve.vertices.update(dict((v, NodeItem(v)) for v in add_nodes)) 
     1082        vertices = self.networkCurve.vertices 
     1083         
     1084        #build edge index 
     1085        row_ind = {} 
     1086        if self.links is not None and len(self.links) > 0: 
     1087          for i, r in enumerate(self.links): 
     1088              u = int(r['u'].value) 
     1089              v = int(r['v'].value) 
     1090              if u in self.graph and v in self.graph: 
     1091                  u_dict = row_ind.get(u, {}) 
     1092                  v_dict = row_ind.get(v, {}) 
     1093                  u_dict[v] = i 
     1094                  v_dict[u] = i 
     1095                  row_ind[u] = u_dict 
     1096                  row_ind[v] = v_dict 
     1097                   
     1098        #add edges 
     1099        if self.links is not None and len(self.links) > 0: 
     1100            links = self.links 
     1101            links_indices = (row_ind[i + 1][j + 1] for (i, j) in self.graph.edges()) 
     1102            labels = ([str(row[r].value) for r in range(2, len(row))] for row in (links[links_index] for links_index in links_indices)) 
     1103             
     1104            if self.graph.is_directed(): 
     1105                edges = [EdgeItem(vertices[i], vertices[j], 
     1106                    self.graph[i][j].get('weight', 1), 0, 1, links_index, label) for \ 
     1107                    ((i, j), links_index, label) in zip(self.graph.edges(), \ 
     1108                                                        links_indices, labels)] 
     1109            else: 
     1110                edges = [EdgeItem(vertices[i], vertices[j], 
     1111                    self.graph[i][j].get('weight', 1), links_index, label) for \ 
     1112                    ((i, j), links_index, label) in zip(self.graph.edges(), \ 
     1113                                                        links_indices, labels)] 
     1114        elif self.graph.is_directed(): 
     1115            edges = [EdgeItem(vertices[i], vertices[j], 
     1116                                      self.graph[i][j].get('weight', 1), 0, 1) for (i, j) in self.graph.edges()] 
     1117        else: 
     1118            edges = [EdgeItem(vertices[i], vertices[j], 
     1119                                      self.graph[i][j].get('weight', 1)) for (i, j) in self.graph.edges()] 
     1120                   
     1121        #self.minEdgeWeight = min(edge.weight for edge in edges) if len(edges) > 0 else 0 
     1122        #self.maxEdgeWeight = max(edge.weight for edge in edges) if len(edges) > 0 else 0 
     1123         
     1124        #if self.minEdgeWeight is None:  
     1125        #    self.minEdgeWeight = 0  
     1126         
     1127        #if self.maxEdgeWeight is None:  
     1128        #    self.maxEdgeWeight = 0  
     1129                           
     1130        #self.maxEdgeSize = 10 
     1131             
     1132        #self.setEdgesSize() 
     1133        #self.setVerticesSize() 
     1134         
     1135        self.networkCurve.coors = self.layout.map_to_graph(self.graph) 
     1136        self.networkCurve.edges = edges 
     1137        self.networkCurve.changed() 
    10681138         
    10691139    def set_graph_layout(self, graph, layout, curve=None, items=None, links=None): 
  • orange/OrangeWidgets/Unsupervised/OWNxExplorer.py

    r8083 r8086  
    175175        self.vertexSizeCombo.addItem("(none)") 
    176176         
    177         OWGUI.spin(self.vertexSizeCombo.box, self, "minVertexSize", 5, 200, 1, label="Min vertex size:", callback = self.setVertexSize) 
    178         OWGUI.spin(self.vertexSizeCombo.box, self, "maxVertexSize", 5, 200, 1, label="Max vertex size:", callback = self.setVertexSize) 
     177        OWGUI.spin(self.vertexSizeCombo.box, self, "minVertexSize", 5, 200, 1, label="Min vertex size:", callback=self.setVertexSize) 
     178        OWGUI.spin(self.vertexSizeCombo.box, self, "maxVertexSize", 5, 200, 1, label="Max vertex size:", callback=self.setVertexSize) 
    179179        OWGUI.checkBox(self.vertexSizeCombo.box, self, "invertSize", "Invert vertex size", callback = self.setVertexSize) 
    180180         
     
    379379     
    380380    def setAutoSendAttributes(self): 
    381         if self.autoSendAttributes: 
    382             self.networkCanvas.callbackSelectVertex = self.sendAttSelectionList 
    383         else: 
    384             self.networkCanvas.callbackSelectVertex = None 
     381        print 'TODO setAutoSendAttributes' 
     382        #if self.autoSendAttributes: 
     383        #    self.networkCanvas.callbackSelectVertex = self.sendAttSelectionList 
     384        #else: 
     385        #    self.networkCanvas.callbackSelectVertex = None 
    385386 
    386387    def sendAttSelectionList(self): 
     
    12221223        self.comboAttSelection.addItem("Select attribute") 
    12231224       
     1225    def change_graph(self, newgraph): 
     1226        old_nodes = set(self.graph.nodes_iter()) 
     1227        new_nodes = set(newgraph.nodes_iter()) 
     1228        inter_nodes = old_nodes.intersection(new_nodes) 
     1229        remove_nodes = old_nodes.difference(inter_nodes) 
     1230        add_nodes = new_nodes.difference(inter_nodes) 
     1231         
     1232        [self.networkCanvas.networkCurve.coors.pop(c) for c in remove_nodes] 
     1233        self.networkCanvas.networkCurve.coors.update((node, (0,0)) for node in add_nodes) 
     1234        positions = [self.networkCanvas.networkCurve.coors[key] for key in sorted(self.networkCanvas.networkCurve.coors.iterkeys())] 
     1235        self.layout.set_graph(newgraph, positions) 
     1236         
     1237        self.graph = newgraph 
     1238        self.number_of_nodes_label = self.graph.number_of_nodes() 
     1239        self.number_of_edges_label = self.graph.number_of_edges() 
     1240         
     1241        self.networkCanvas.change_graph(self.graph, inter_nodes, add_nodes, remove_nodes) 
     1242         
     1243#        self.nShown = self.graph.number_of_nodes() 
     1244#         
     1245#        if self.graph.number_of_edges() > 0: 
     1246#            self.verticesPerEdge = float(self.graph.number_of_nodes()) / float(self.graph.number_of_edges()) 
     1247#        else: 
     1248#            self.verticesPerEdge = 0 
     1249#             
     1250#        if self.graph.number_of_nodes() > 0: 
     1251#            self.edgesPerVertex = float(self.graph.number_of_edges()) / float(self.graph.number_of_nodes()) 
     1252#        else: 
     1253#            self.edgesPerVertex = 0 
     1254#         
     1255#        undirected_graph = self.graph.to_undirected() if self.graph.is_directed() else self.graph 
     1256#        components = Orange.network.nx.algorithms.components.connected_components(undirected_graph) 
     1257#        if len(components) > 1: 
     1258#            self.diameter = -1 
     1259#        else: 
     1260#            self.diameter = Orange.network.nx.algorithms.distance_measures.diameter(self.graph) 
     1261#        self.clustering_coefficient = Orange.network.nx.algorithms.cluster.average_clustering(undirected_graph) * 100 
     1262         
     1263        k = 1.13850193174e-008 
     1264        nodes = self.graph.number_of_nodes() 
     1265        t = k * nodes * nodes 
     1266        self.frSteps = int(5.0 / t) 
     1267        if self.frSteps <   1: self.frSteps = 1; 
     1268        if self.frSteps > 3000: self.frSteps = 3000; 
     1269         
     1270        if self.frSteps < 10: 
     1271            self.renderAntialiased = 0 
     1272            self.minVertexSize = 5 
     1273            self.maxVertexSize = 5 
     1274            self.maxLinkSize = 1 
     1275            self.optMethod = 0 
     1276            self.graph_layout_method()             
     1277             
     1278        #self.setVertexColor() 
     1279        #self.setEdgeColor() 
     1280        #self.networkCanvas.setEdgesSize() 
     1281         
     1282        #self.clickedAttLstBox() 
     1283        #self.clickedTooltipLstBox() 
     1284        #self.clickedEdgeLabelListBox() 
     1285         
     1286        self.optButton.setChecked(1) 
     1287        self.graph_layout()         
     1288        self.information(0) 
     1289         
    12241290    def set_graph(self, graph): 
    12251291        self.set_items_distance_matrix(None) 
     
    12481314        if self._items is not None and 'x' in self._items.domain and 'y' in self._items.domain: 
    12491315            positions = [(self._items[node]['x'].value, self._items[node]['y'].value) \ 
    1250                          for node in sorted(graph) if self._items[node]['x'].value != '?' \ 
     1316                         for node in sorted(self.graph) if self._items[node]['x'].value != '?' \ 
    12511317                         and self._items[node]['y'].value != '?'] 
    1252             self.layout.set_graph(graph, positions) 
    1253         else: 
    1254             self.layout.set_graph(graph) 
     1318            self.layout.set_graph(self.graph, positions) 
     1319        else: 
     1320            self.layout.set_graph(self.graph) 
    12551321         
    12561322        self.number_of_nodes_label = self.graph.number_of_nodes() 
     
    12631329        self.networkCanvas.maxVertexSize = self.maxVertexSize 
    12641330        self.networkCanvas.maxEdgeSize = self.maxLinkSize 
     1331        self.networkCanvas.minComponentEdgeWidth = self.minComponentEdgeWidth 
     1332        self.networkCanvas.maxComponentEdgeWidth = self.maxComponentEdgeWidth 
    12651333        self.lastVertexSizeColumn = self.vertexSizeCombo.currentText() 
    12661334        self.lastColorColumn = self.colorCombo.currentText() 
    1267         self.networkCanvas.minComponentEdgeWidth = self.minComponentEdgeWidth 
    1268         self.networkCanvas.maxComponentEdgeWidth = self.maxComponentEdgeWidth 
    1269          
    1270          
    1271  
    1272         #for i in range(graph.nVertices): 
    1273         #    print "x:", graph.coors[0][i], " y:", graph.coors[1][i] 
    1274  
    1275         self.nShown = graph.number_of_nodes() 
     1335         
     1336        self.nShown = self.graph.number_of_nodes() 
    12761337         
    12771338        if self.graph.number_of_edges() > 0: 
     
    12851346            self.edgesPerVertex = 0 
    12861347         
    1287         undirected_graph = graph.to_undirected() if graph.is_directed() else graph 
     1348        undirected_graph = self.graph.to_undirected() if self.graph.is_directed() else self.graph 
    12881349        components = Orange.network.nx.algorithms.components.connected_components(undirected_graph) 
    12891350        if len(components) > 1: 
    12901351            self.diameter = -1 
    12911352        else: 
    1292             self.diameter = Orange.network.nx.algorithms.distance_measures.diameter(graph) 
     1353            self.diameter = Orange.network.nx.algorithms.distance_measures.diameter(self.graph) 
    12931354        self.clustering_coefficient = Orange.network.nx.algorithms.cluster.average_clustering(undirected_graph) * 100 
    12941355         
     
    13491410    def set_network_view(self, nxView): 
    13501411        self._network_view = nxView 
     1412        self._network_view.set_nx_explorer(self) 
     1413        self.networkCanvas.callbackSelectVertex = self._network_view.nodes_selected 
    13511414        self.set_graph(self.graph_base) 
    13521415         
Note: See TracChangeset for help on using the changeset viewer.