Changeset 8591:16b2bc812d54 in orange


Ignore:
Timestamp:
08/03/11 16:20:49 (3 years ago)
Author:
miha <miha.stajdohar@…>
Branch:
default
Convert:
21b610d4718680aa71ca8d31e2fd023b5963480e
Message:

First time working InsideView.

Location:
orange/OrangeWidgets/Prototypes
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • orange/OrangeWidgets/Prototypes/OWNxCanvasQt.py

    r8588 r8591  
    3535 
    3636class NetworkCurve(orangeplot.NetworkCurve): 
    37   def __init__(self, parent=None, pen=QPen(Qt.black), xData=None, yData=None): 
    38       orangeplot.NetworkCurve.__init__(self, parent) 
    39       self.name = "Network Curve" 
    40       self.showEdgeLabels = 0 
    41        
    42   def set_node_sizes(self, values={}, min_size=0, max_size=0): 
    43       orangeplot.NetworkCurve.set_node_sizes(self, values, min_size, max_size) 
    44        
    45   def move_selected_nodes(self, dx, dy): 
    46     selected = self.get_selected_nodes() 
    47      
    48     self.coors[selected][0] = self.coors[0][selected] + dx 
    49     self.coors[1][selected][1] = self.coors[1][selected] + dy 
    50        
    51     self.update_properties() 
    52     return selected 
     37    def __init__(self, parent=None, pen=QPen(Qt.black), xData=None, yData=None): 
     38        orangeplot.NetworkCurve.__init__(self, parent) 
     39        self.name = "Network Curve" 
     40        self.showEdgeLabels = 0 
     41       
     42    def set_node_sizes(self, values={}, min_size=0, max_size=0): 
     43        orangeplot.NetworkCurve.set_node_sizes(self, values, min_size, max_size) 
     44       
     45    def move_selected_nodes(self, dx, dy): 
     46        selected = self.get_selected_nodes() 
     47         
     48        self.coors[selected][0] = self.coors[0][selected] + dx 
     49        self.coors[1][selected][1] = self.coors[1][selected] + dy 
     50           
     51        self.update_properties() 
     52        return selected 
    5353   
    54   def get_selected_nodes(self): 
    55     return [vertex.index() for vertex in self.nodes().itervalues() if vertex.is_selected()] 
    56  
    57   def get_unselected_nodes(self): 
    58     return [vertex.index() for vertex in self.nodes().itervalues() if not vertex.is_selected()] 
    59  
    60   def get_marked_nodes(self): 
    61     return [vertex.index() for vertex in self.nodes().itervalues() if vertex.is_marked()] 
     54    def get_selected_nodes(self): 
     55        return [vertex.index() for vertex in self.nodes().itervalues() if vertex.is_selected()] 
     56 
     57    def get_unselected_nodes(self): 
     58        return [vertex.index() for vertex in self.nodes().itervalues() if not vertex.is_selected()] 
     59 
     60    def get_marked_nodes(self): 
     61        return [vertex.index() for vertex in self.nodes().itervalues() if vertex.is_marked()] 
    6262   
    63   def set_marked_nodes(self, vertices): 
    64     n = self.nodes() 
    65     for vertex in n.itervalues(): 
    66       vertex.set_marked(False) 
    67     for index in vertices: 
    68       if index in n: 
    69         n[index].set_marked(True) 
    70          
    71   def mark_to_sel(self): 
    72     for vertex in self.nodes().itervalues(): 
    73       if vertex.is_marked(): 
    74           vertex.set_selected(True) 
     63    def set_marked_nodes(self, vertices): 
     64        n = self.nodes() 
     65        for vertex in n.itervalues(): 
     66          vertex.set_marked(False) 
     67        for index in vertices: 
     68          if index in n: 
     69            n[index].set_marked(True) 
     70         
     71    def mark_to_sel(self): 
     72        for vertex in self.nodes().itervalues(): 
     73          if vertex.is_marked(): 
     74              vertex.set_selected(True) 
    7575           
    76   def sel_to_mark(self): 
    77     for vertex in self.nodes().itervalues(): 
    78       if vertex.is_selected(): 
    79           vertex.set_selected(False) 
    80           vertex.set_marked(True) 
     76    def sel_to_mark(self): 
     77        for vertex in self.nodes().itervalues(): 
     78          if vertex.is_selected(): 
     79              vertex.set_selected(False) 
     80              vertex.set_marked(True) 
    8181   
    82   def unmark(self): 
    83     for vertex in self.nodes().itervalues(): 
    84       vertex.set_marked(False) 
    85        
    86   def unselect(self): 
    87     for vertex in self.nodes().itervalues(): 
    88         vertex.set_selected(False) 
    89          
    90   def set_hidden_nodes(self, nodes): 
    91     for vertex in self.nodes().itervalues(): 
    92         vertex.setVisible(vertex.index() in nodes) 
    93        
    94   def hide_selected_nodes(self): 
    95     for vertex in self.nodes().itervalues(): 
    96       if vertex.selected: 
    97         vertex.hide() 
     82    def unmark(self): 
     83        for vertex in self.nodes().itervalues(): 
     84          vertex.set_marked(False) 
     85       
     86    def unselect(self): 
     87        for vertex in self.nodes().itervalues(): 
     88            vertex.set_selected(False) 
     89         
     90    def set_hidden_nodes(self, nodes): 
     91        for vertex in self.nodes().itervalues(): 
     92            vertex.setVisible(vertex.index() in nodes) 
     93       
     94    def hide_selected_nodes(self): 
     95        for vertex in self.nodes().itervalues(): 
     96          if vertex.selected: 
     97            vertex.hide() 
    9898   
    99   def hide_unselected_nodes(self): 
    100     for vertex in self.nodes().itervalues(): 
    101       if not vertex.selected: 
    102         vertex.hide() 
    103      
    104   def show_all_vertices(self): 
    105     for vertex in self.nodes().itervalues(): 
    106       vertex.show() 
    107      
    108   def changed(self): 
    109       self.itemChanged() 
    110 # 
    111 #  def draw(self, painter, xMap, yMap, rect): 
    112 #    for edge in self.edges: 
    113 #      if edge.u.show and edge.v.show: 
    114 #        painter.setPen(edge.pen) 
    115 # 
    116 #        px1 = xMap.transform(self.coors[edge.u.index][0])   #ali pa tudi self.x1, itd 
    117 #        py1 = yMap.transform(self.coors[edge.u.index][1]) 
    118 #        px2 = xMap.transform(self.coors[edge.v.index][0]) 
    119 #        py2 = yMap.transform(self.coors[edge.v.index][1]) 
    120 #         
    121 #        painter.drawLine(px1, py1, px2, py2) 
    122 #         
    123 #        d = 12 
    124 #        #painter.setPen(QPen(Qt.lightGray, 1)) 
    125 #        painter.setBrush(Qt.lightGray) 
    126 #        if edge.arrowu: 
    127 #            x = px2 - px1 
    128 #            y = py2 - py1 
    129 #             
    130 #            fi = math.atan2(y, x) * 180 * 16 / math.pi  
    131 # 
    132 #            if not fi is None: 
    133 #                # (180*16) - fi - (20*16), (40*16) 
    134 #                rect = QRectF(px2 - d, py2 - d, 2 * d, 2 * d) 
    135 #                painter.drawPie(rect, 2560 - fi, 640) 
    136 #                 
    137 #        if edge.arrowv: 
    138 #            x = px2 - px1 
    139 #            y = py2 - py1 
    140 #             
    141 #            fi = math.atan2(y, x) * 180 * 16 / math.pi  
    142 #            if not fi is None: 
    143 #                # (180*16) - fi - (20*16), (40*16) 
    144 #                rect = QRectF(px2 - d, py2 - d, 2 * d, 2 * d) 
    145 #                painter.drawPie(rect, 2560 - fi, 640) 
    146 #                 
    147 #        if self.showEdgeLabels and len(edge.label) > 0: 
    148 #            lbl = ', '.join(edge.label) 
    149 #            x = (px1 + px2) / 2 
    150 #            y = (py1 + py2) / 2 
    151 #             
    152 #            th = painter.fontMetrics().height() 
    153 #            tw = painter.fontMetrics().width(lbl) 
    154 #            r = QRect(x - tw / 2, y - th / 2, tw, th) 
    155 #            painter.fillRect(r, QBrush(Qt.white)) 
    156 #            painter.drawText(r, Qt.AlignHCenter + Qt.AlignVCenter, lbl) 
    157 #     
    158 #    for key, vertex in self.vertices.iteritems(): 
    159 #      if vertex.show: 
    160 #        pX = xMap.transform(self.coors[vertex.index][0])   #dobimo koordinati v pikslih (tipa integer) 
    161 #        pY = yMap.transform(self.coors[vertex.index][1])   #ki se stejeta od zgornjega levega kota canvasa 
    162 #        if vertex.selected:     
    163 #          painter.setPen(QPen(Qt.yellow, 3)) 
    164 #          painter.setBrush(vertex.color) 
    165 #          rect = QRectF(pX - (vertex.size + 4) / 2, pY - (vertex.size + 4) / 2, vertex.size + 4, vertex.size + 4) 
    166 #          painter.drawEllipse(rect) 
    167 #        elif vertex.marked: 
    168 #          painter.setPen(vertex.pen) 
    169 #          painter.setBrush(vertex.color) 
    170 #          rect = QRectF(pX - vertex.size / 2, pY - vertex.size / 2, vertex.size, vertex.size) 
    171 #          painter.drawEllipse(rect) 
    172 #        else: 
    173 #          painter.setPen(vertex.pen) 
    174 #          painter.setBrush(vertex.nocolor) 
    175 #          rect = QRectF(pX - vertex.size / 2, pY - vertex.size / 2, vertex.size, vertex.size) 
    176 #          painter.drawEllipse(rect) 
    177          
    178   def closest_node(self, px, py): 
    179     ndx = min(self.coors, key=lambda x: abs(self.coors[x][0]-px) + abs(self.coors[x][1]-py)) 
    180     return ndx, math.sqrt((self.coors[ndx][0]-px)**2 + (self.coors[ndx][0]-px)**2) 
    181  
    182   def get_nodes_in_rect(self, x1, y1, x2, y2): 
    183       if x1 > x2: 
    184           x1, x2 = x2, x1 
    185       if y1 > y2: 
    186           y1, y2 = y2, y1 
    187       return [key for key in self.coors if x1 < self.coors[key][0] < x2 and y1 < self.coors[key][1] < y2] 
     99    def hide_unselected_nodes(self): 
     100        for vertex in self.nodes().itervalues(): 
     101          if not vertex.selected: 
     102            vertex.hide() 
     103     
     104    def show_all_vertices(self): 
     105        for vertex in self.nodes().itervalues(): 
     106          vertex.show() 
     107     
     108    def changed(self): 
     109        self.itemChanged() 
     110         
     111    def closest_node(self, px, py): 
     112        ndx = min(self.coors, key=lambda x: abs(self.coors[x][0]-px) + abs(self.coors[x][1]-py)) 
     113        return ndx, math.sqrt((self.coors[ndx][0]-px)**2 + (self.coors[ndx][0]-px)**2) 
     114 
     115    def get_nodes_in_rect(self, x1, y1, x2, y2): 
     116        if x1 > x2: 
     117            x1, x2 = x2, x1 
     118        if y1 > y2: 
     119            y1, y2 = y2, y1 
     120        return [key for key in self.coors if x1 < self.coors[key][0] < x2 and y1 < self.coors[key][1] < y2] 
     121         
     122    def fr(self, steps, weighted=False, smooth_cooling=False): 
     123        orangeplot.NetworkCurve.fr(self, steps, weighted, smooth_cooling) 
    188124         
    189125class OWNxCanvas(OWPlot): 
     
    226162        self.showDistances = 0 
    227163        self.showMissingValues = 0 
    228          
     164        self.show_indices = True 
    229165        self.showWeights = 0 
    230         self.showIndexes = 0 
    231166        self.minEdgeWeight = sys.maxint 
    232167        self.maxEdgeWeight = 0 
     
    250185        self.items = None 
    251186        self.links = None 
     187         
     188        self.node_label_attributes = [] 
     189        self.edge_color_attribute = None 
    252190         
    253191        self.axis_margin = 0 
     
    635573        self.replot() 
    636574         
    637     def set_label_attributes(self, attributes): 
    638         if self.graph is None or self.items is None or \ 
    639            not isinstance(self.items, orange.ExampleTable): 
    640             return 
    641          
    642         label_attributes = [self.items.domain[att] for att in \ 
    643                                  attributes if att in self.items.domain] 
    644         self.networkCurve.set_node_labels(dict((node, ', '.join(str( \ 
    645                     self.items[node][att]) for att in label_attributes)) \ 
    646                                                         for node in self.graph)) 
     575    def set_label_attributes(self, attributes=None): 
     576        if self.graph is None: 
     577            return  
     578         
     579        nodes = self.graph.nodes() 
     580         
     581        if attributes is not None: 
     582            self.node_label_attributes = attributes 
     583         
     584        label_attributes = [] 
     585        if self.items is not None and isinstance(self.items, orange.ExampleTable): 
     586            label_attributes = [self.items.domain[att] for att in \ 
     587                self.node_label_attributes if att in self.items.domain] 
     588             
     589        indices = [[] for u in nodes] 
     590        if self.show_indices: 
     591            indices = [[str(u)] for u in nodes] 
     592             
     593        self.networkCurve.set_node_labels(dict((node, ', '.join(indices[i] + \ 
     594                           [str(self.items[node][att]) for att in \ 
     595                           label_attributes])) for i, node in enumerate(nodes))) 
     596         
     597        self.replot() 
    647598         
    648599    def set_tooltip_attributes(self, attributes): 
     
    718669             
    719670        self.networkCurve.add_edges(edges) 
    720         self.set_dirty() 
    721         self.replot() 
    722671         
    723672    def set_graph(self, graph, curve=None, items=None, links=None): 
     
    792741        self.networkCurve.set_edges(edges) 
    793742        self.networkCurve.update_properties() 
    794         self.set_dirty() 
    795743        self.replot() 
    796744         
     
    824772                     
    825773    def replot(self): 
     774        self.set_dirty() 
    826775        OWPlot.replot(self) 
    827776        if hasattr(self, 'networkCurve') and self.networkCurve is not None: 
  • orange/OrangeWidgets/Prototypes/OWNxExplorerQt.py

    r8581 r8591  
    3232    settingsList = ["autoSendSelection", "spinExplicit", "spinPercentage", 
    3333    "maxLinkSize", "minVertexSize", "maxVertexSize", "networkCanvas.use_antialiasing", "networkCanvas.use_animations", 
    34     "invertSize", "optMethod", "lastVertexSizeColumn", "lastColorColumn", 
     34    "invertSize", "optMethod", "lastVertexSizeColumn", "lastColorColumn", "networkCanvas.show_indices" 
    3535    "lastNameComponentAttribute", "lastLabelColumns", "lastTooltipColumns", 
    36     "showWeights", "showIndexes",  "showEdgeLabels", "colorSettings",  
     36    "showWeights", "showEdgeLabels", "colorSettings",  
    3737    "selectedSchemaIndex", "edgeColorSettings", "selectedEdgeSchemaIndex", 
    3838    "showMissingValues", "fontSize", "mdsTorgerson", "mdsAvgLinkage", 
     
    9393        self.lastTooltipColumns = set() 
    9494        self.showWeights = 0 
    95         self.showIndexes = 0 
    9695        self.showEdgeLabels = 0 
    9796        self.colorSettings = None 
     
    117116        self.number_of_nodes_label = -1 
    118117        self.number_of_edges_label = -1 
     118         
    119119        self.loadSettings() 
    120120         
     
    199199         
    200200        ib = OWGUI.widgetBox(self.verticesTab, "General", orientation="vertical") 
    201         OWGUI.checkBox(ib, self, 'showIndexes', 'Show indexes', callback=(lambda: self._set_canvas_attr('showIndexes', self.showIndexes))) 
     201        OWGUI.checkBox(ib, self, 'networkCanvas.show_indices', 'Show indices', callback=self.networkCanvas.set_label_attributes) 
    202202        OWGUI.checkBox(ib, self, 'labelsOnMarkedOnly', 'Show labels on marked vertices only', callback=(lambda: self._set_canvas_attr('labelsOnMarkedOnly', self.labelsOnMarkedOnly))) 
    203203        self.networkCanvas.gui.antialiasing_check_box(ib) 
     
    11981198        self.comboAttSelection.addItem("Select attribute") 
    11991199       
     1200    def compute_network_info(self): 
     1201        self.nShown = self.graph.number_of_nodes() 
     1202         
     1203        if self.graph.number_of_edges() > 0: 
     1204            self.verticesPerEdge = float(self.graph.number_of_nodes()) / float(self.graph.number_of_edges()) 
     1205        else: 
     1206            self.verticesPerEdge = 0 
     1207             
     1208        if self.graph.number_of_nodes() > 0: 
     1209            self.edgesPerVertex = float(self.graph.number_of_edges()) / float(self.graph.number_of_nodes()) 
     1210        else: 
     1211            self.edgesPerVertex = 0 
     1212         
     1213        undirected_graph = self.graph.to_undirected() if self.graph.is_directed() else self.graph 
     1214        components = Orange.network.nx.algorithms.components.connected_components(undirected_graph) 
     1215        if len(components) > 1: 
     1216            self.diameter = -1 
     1217        else: 
     1218            self.diameter = Orange.network.nx.algorithms.distance_measures.diameter(self.graph) 
     1219        self.clustering_coefficient = Orange.network.nx.algorithms.cluster.average_clustering(undirected_graph) * 100 
     1220       
    12001221    def change_graph(self, newgraph): 
    12011222        self.graph = newgraph 
     
    12051226        self.networkCanvas.change_graph(self.graph) 
    12061227         
    1207 #        self.nShown = self.graph.number_of_nodes() 
    1208 #         
    1209 #        if self.graph.number_of_edges() > 0: 
    1210 #            self.verticesPerEdge = float(self.graph.number_of_nodes()) / float(self.graph.number_of_edges()) 
    1211 #        else: 
    1212 #            self.verticesPerEdge = 0 
    1213 #             
    1214 #        if self.graph.number_of_nodes() > 0: 
    1215 #            self.edgesPerVertex = float(self.graph.number_of_edges()) / float(self.graph.number_of_nodes()) 
    1216 #        else: 
    1217 #            self.edgesPerVertex = 0 
    1218 #         
    1219 #        undirected_graph = self.graph.to_undirected() if self.graph.is_directed() else self.graph 
    1220 #        components = Orange.network.nx.algorithms.components.connected_components(undirected_graph) 
    1221 #        if len(components) > 1: 
    1222 #            self.diameter = -1 
    1223 #        else: 
    1224 #            self.diameter = Orange.network.nx.algorithms.distance_measures.diameter(self.graph) 
    1225 #        self.clustering_coefficient = Orange.network.nx.algorithms.cluster.average_clustering(undirected_graph) * 100 
     1228        self.compute_network_info() 
    12261229         
    12271230        t = 1.13850193174e-008 * (self.graph.number_of_nodes()**2 + self.graph.number_of_edges()) 
     
    12291232        if self.frSteps <   1: self.frSteps = 1; 
    12301233        if self.frSteps > 100: self.frSteps = 100; 
    1231          
    1232         if self.frSteps < 10: 
    1233             self.networkCanvas.use_antialiasing = 0 
    1234             self.networkCanvas.use_animations = 0 
    1235             self.minVertexSize = 5 
    1236             self.maxVertexSize = 5 
    1237             self.maxLinkSize = 1 
    1238             self.optMethod = 0 
    1239             self.graph_layout_method()             
    1240              
     1234#         
     1235#        if self.frSteps < 10: 
     1236#            self.networkCanvas.use_antialiasing = 0 
     1237#            self.networkCanvas.use_animations = 0 
     1238#            self.minVertexSize = 5 
     1239#            self.maxVertexSize = 5 
     1240#            self.maxLinkSize = 1 
     1241#            self.optMethod = 0 
     1242#            self.graph_layout_method() 
     1243         
    12411244        self.set_vertex_size() 
    12421245        self.setVertexColor() 
    12431246        self.setEdgeColor() 
    1244         #self.networkCanvas.setEdgesSize() 
    1245          
    1246         #self.clickedAttLstBox() 
    1247         #self.clickedTooltipLstBox() 
    1248         #self.clickedEdgeLabelListBox() 
    1249          
    1250         #self.optButton.setChecked(1) 
    1251         #self.graph_layout()         
     1247             
     1248        self.networkCanvas.setEdgesSize() 
     1249        self.clickedAttLstBox() 
     1250        self.clickedTooltipLstBox() 
     1251        self.clickedEdgeLabelListBox() 
     1252         
     1253        self.networkCanvas.replot() 
     1254        qApp.processEvents() 
     1255        self.networkCanvas.networkCurve.fr(100, weighted=False, smooth_cooling=True) 
     1256        self.networkCanvas.replot() 
     1257           
    12521258        self.information(0) 
    12531259         
     
    12931299        self.networkCanvas.maxComponentEdgeWidth = self.maxComponentEdgeWidth 
    12941300         
    1295         self.nShown = self.graph.number_of_nodes() 
    1296          
    1297         if self.graph.number_of_edges() > 0: 
    1298             self.verticesPerEdge = float(self.graph.number_of_nodes()) / float(self.graph.number_of_edges()) 
    1299         else: 
    1300             self.verticesPerEdge = 0 
    1301              
    1302         if self.graph.number_of_nodes() > 0: 
    1303             self.edgesPerVertex = float(self.graph.number_of_edges()) / float(self.graph.number_of_nodes()) 
    1304         else: 
    1305             self.edgesPerVertex = 0 
    1306          
    1307         undirected_graph = self.graph.to_undirected() if self.graph.is_directed() else self.graph 
    1308         components = Orange.network.nx.algorithms.components.connected_components(undirected_graph) 
    1309         if len(components) > 1: 
    1310             self.diameter = -1 
    1311         else: 
    1312             self.diameter = Orange.network.nx.algorithms.distance_measures.diameter(self.graph) 
    1313         self.clustering_coefficient = Orange.network.nx.algorithms.cluster.average_clustering(undirected_graph) * 100 
    1314          
     1301        self.compute_network_info() 
    13151302        self.setCombos() 
    13161303             
     
    13471334        self.networkCanvas.labelsOnMarkedOnly = self.labelsOnMarkedOnly 
    13481335        self.networkCanvas.showWeights = self.showWeights 
    1349         self.networkCanvas.showIndexes = self.showIndexes 
    13501336             
    13511337        self.set_vertex_size() 
     
    13641350    def set_network_view(self, nxView): 
    13651351        self._network_view = nxView 
    1366         self._network_view.set_nx_explorer(self) 
     1352         
     1353        if self._network_view is not None: 
     1354            self._network_view.set_nx_explorer(self) 
     1355         
    13671356        self.set_graph(self.graph_base) 
    13681357         
    1369         QObject.connect(self.networkCanvas, SIGNAL('selection_changed()'), self._network_view.node_selection_changed) 
     1358        if self._network_view is not None: 
     1359            QObject.connect(self.networkCanvas, SIGNAL('selection_changed()'), self._network_view.node_selection_changed) 
    13701360         
    13711361    def setItems(self, items=None): 
     
    13831373        self.set_vertex_size() 
    13841374        self.networkCanvas.items = items 
    1385         self.networkCanvas.showIndexes = self.showIndexes 
    13861375        self.networkCanvas.showWeights = self.showWeights 
    13871376        self.networkCanvas.showEdgeLabels = self.showEdgeLabels 
  • orange/OrangeWidgets/Prototypes/OWNxInsideView.py

    r8578 r8591  
    3131        self._center_node = graph.nodes_iter().next() 
    3232        nodes = self._get_neighbors() 
    33         return self._network.subgraph(nodes) 
     33        return Orange.network.nx.Graph.subgraph(self._network, nodes) 
    3434     
    3535    def update_network(self): 
    3636        nodes = self._get_neighbors() 
    37         subnet = self._network.subgraph(nodes) 
    38          
     37        subnet = Orange.network.nx.Graph.subgraph(self._network, nodes) 
     38 
    3939        if self._nx_explorer is not None: 
    4040            self._nx_explorer.change_graph(subnet) 
Note: See TracChangeset for help on using the changeset viewer.