Changeset 9577:7c6860f77fa7 in orange


Ignore:
Timestamp:
01/26/12 16:13:31 (2 years ago)
Author:
mstajdohar
Branch:
default
Message:

Bug fixes.

Files:
7 edited

Legend:

Unmodified
Added
Removed
  • orange/Orange/network/network.py

    r9349 r9577  
    902902    def nodes_selected(self): 
    903903        pass 
     904 
     905    #def node_selection_changed(self): 
     906    #    pass 
  • orange/OrangeWidgets/OWNxHist.py

    r9421 r9577  
    1515 
    1616class OWNxHist(): 
    17      
     17 
    1818    def __init__(self, parent=None, type=0): 
    1919        self.parent = parent 
    20          
     20 
    2121    def addHistogramControls(self, parent=None): 
    2222        # set default settings 
     
    3232        self.excludeLimit = 1 
    3333        self.percentil = 0 
    34          
     34 
    3535        if parent is None: 
    3636            parent = self.controlArea 
    37              
    38         boxGeneral = OWGUI.widgetBox(parent, box = "Distance boundaries") 
    39          
    40         ribg = OWGUI.widgetBox(boxGeneral, None, orientation="horizontal", addSpace = False) 
     37 
     38        boxGeneral = OWGUI.widgetBox(parent, box="Distance boundaries") 
     39 
     40        ribg = OWGUI.widgetBox(boxGeneral, None, orientation="horizontal", addSpace=False) 
    4141        OWGUI.lineEdit(ribg, self, "spinLowerThreshold", "Lower", orientation='horizontal', callback=self.changeLowerSpin, valueType=float, enterPlaceholder=True, controlWidth=100) 
    42         OWGUI.lineEdit(ribg, self, "spinUpperThreshold", "Upper    ", orientation='horizontal', callback=self.changeUpperSpin, valueType=float, enterPlaceholder=True,controlWidth=100) 
     42        OWGUI.lineEdit(ribg, self, "spinUpperThreshold", "Upper    ", orientation='horizontal', callback=self.changeUpperSpin, valueType=float, enterPlaceholder=True, controlWidth=100) 
    4343        ribg.layout().addStretch(1) 
    4444        #ribg = OWGUI.radioButtonsInBox(boxGeneral, self, "andor", [], orientation='horizontal', callback = self.generateGraph) 
     
    4747        #b.setEnabled(False) 
    4848        #ribg.hide(False) 
    49          
    50         ribg = OWGUI.widgetBox(boxGeneral, None, orientation="horizontal", addSpace = False) 
     49 
     50        ribg = OWGUI.widgetBox(boxGeneral, None, orientation="horizontal", addSpace=False) 
    5151        OWGUI.spin(ribg, self, "kNN", 0, 1000, 1, label="kNN   ", orientation='horizontal', callback=self.generateGraph, callbackOnReturn=1, controlWidth=100) 
    5252        OWGUI.doubleSpin(ribg, self, "percentil", 0, 100, 0.1, label="Percentil", orientation='horizontal', callback=self.setPercentil, callbackOnReturn=1, controlWidth=100) 
     
    5454        # Options 
    5555        self.attrColor = "" 
    56         ribg = OWGUI.radioButtonsInBox(parent, self, "netOption", [], "Options", callback = self.generateGraph) 
    57         OWGUI.appendRadioButton(ribg, self, "netOption", "All vertices", callback = self.generateGraph) 
    58         hb = OWGUI.widgetBox(ribg, None, orientation="horizontal", addSpace = False) 
    59         OWGUI.appendRadioButton(ribg, self, "netOption", "Exclude components with less nodes than:", insertInto=hb, callback=self.generateGraph) 
    60         OWGUI.spin(hb, self, "excludeLimit", 1, 100, 1, callback = (lambda h=True: self.generateGraph(h))) 
    61         OWGUI.appendRadioButton(ribg, self, "netOption", "Largest connected component only", callback = self.generateGraph) 
     56        ribg = OWGUI.radioButtonsInBox(parent, self, "netOption", [], "Options", callback=self.generateGraph) 
     57        OWGUI.appendRadioButton(ribg, self, "netOption", "All vertices", callback=self.generateGraph) 
     58        hb = OWGUI.widgetBox(ribg, None, orientation="horizontal", addSpace=False) 
     59        OWGUI.appendRadioButton(ribg, self, "netOption", "Large components only. Min nodes:", insertInto=hb, callback=self.generateGraph) 
     60        OWGUI.spin(hb, self, "excludeLimit", 1, 100, 1, callback=(lambda h=True: self.generateGraph(h))) 
     61        OWGUI.appendRadioButton(ribg, self, "netOption", "Largest connected component only", callback=self.generateGraph) 
    6262        OWGUI.appendRadioButton(ribg, self, "netOption", "Connected component with vertex") 
    6363        self.attribute = None 
    6464        self.attributeCombo = OWGUI.comboBox(parent, self, "attribute", box="Filter attribute", orientation='horizontal')#, callback=self.setVertexColor) 
    65          
     65 
    6666        ribg = OWGUI.radioButtonsInBox(parent, self, "dstWeight", [], "Distance -> Weight", callback=self.generateGraph) 
    67         hb = OWGUI.widgetBox(ribg, None, orientation="horizontal", addSpace = False) 
     67        hb = OWGUI.widgetBox(ribg, None, orientation="horizontal", addSpace=False) 
    6868        OWGUI.appendRadioButton(ribg, self, "dstWeight", "Weight := distance", insertInto=hb, callback=self.generateGraph) 
    6969        OWGUI.appendRadioButton(ribg, self, "dstWeight", "Weight := 1 - distance", insertInto=hb, callback=self.generateGraph) 
    70          
     70 
    7171        self.label = '' 
    7272        self.searchString = OWGUI.lineEdit(self.attributeCombo.box, self, "label", callback=self.setSearchStringTimer, callbackOnType=True) 
    7373        self.searchStringTimer = QTimer(self) 
    7474        self.connect(self.searchStringTimer, SIGNAL("timeout()"), self.generateGraph) 
    75          
     75 
    7676        if str(self.netOption) != '3': 
    7777            self.attributeCombo.box.setEnabled(False) 
    78              
     78 
    7979    def setPercentil(self): 
    8080        self.spinLowerThreshold = self.histogram.minValue 
    81         net = orngNetwork.Network(self.matrix.dim, 0) 
    82         lower, upper = net.getDistanceMatrixThreshold(self.matrix, self.percentil/100) 
    83         self.spinUpperThreshold = upper 
    84         self.generateGraph() 
    85          
     81        # flatten matrix, sort values and remove identities (self.matrix[i][i]) 
     82        vals = sorted(sum(self.matrix, ()))[self.matrix.dim:] 
     83        ind = int(len(vals) * self.percentil / 100) 
     84        self.spinUpperThreshold = vals[ind] 
     85        self.generateGraph() 
     86 
    8687    def enableAttributeSelection(self): 
    8788        self.attributeCombo.box.setEnabled(True) 
    88          
     89 
    8990    def setSearchStringTimer(self): 
    9091        self.searchStringTimer.stop() 
     
    9394    def setMatrix(self, data): 
    9495        if data == None: return 
    95          
     96 
    9697        self.matrix = data 
    9798        # draw histogram 
     
    100101        #print "values:",values 
    101102        self.histogram.setValues(values) 
    102          
     103 
    103104        low = min(values) 
    104105        upp = max(values) 
     
    109110        if (self.matrix != None): 
    110111            if hasattr(self.matrix, "items"): 
    111                   
     112 
    112113                if isinstance(self.matrix.items, orange.ExampleTable): 
    113114                    vars = list(self.matrix.items.domain.variables) 
    114                  
     115 
    115116                    metas = self.matrix.items.domain.getmetas(0) 
    116117                    for i, var in metas.iteritems(): 
    117118                        vars.append(var) 
    118                          
     119 
    119120        self.icons = self.createAttributeIconDict() 
    120                       
     121 
    121122        for var in vars: 
    122123            try: 
     
    127128    def changeLowerSpin(self): 
    128129        self.percentil = 0 
    129          
     130 
    130131        if self.spinLowerThreshold < self.histogram.minValue: 
    131132            self.spinLowerThreshold = self.histogram.minValue 
    132133        elif self.spinLowerThreshold > self.histogram.maxValue: 
    133134            self.spinLowerThreshold = self.histogram.maxValue 
    134              
     135 
    135136        if self.spinLowerThreshold >= self.spinUpperThreshold: 
    136137            self.spinUpperThreshold = self.spinLowerThreshold 
    137              
    138         self.generateGraph() 
    139          
     138 
     139        self.generateGraph() 
     140 
    140141    def changeUpperSpin(self): 
    141142        self.percentil = 0 
    142          
     143 
    143144        if self.spinUpperThreshold < self.histogram.minValue: 
    144145            self.spinUpperThreshold = self.histogram.minValue 
    145146        elif self.spinUpperThreshold > self.histogram.maxValue: 
    146147            self.spinUpperThreshold = self.histogram.maxValue 
    147              
     148 
    148149        if self.spinUpperThreshold <= self.spinLowerThreshold: 
    149150            self.spinLowerThreshold = self.spinUpperThreshold 
    150          
    151         self.generateGraph() 
    152          
    153     def generateGraph(self, N_changed = False): 
     151 
     152        self.generateGraph() 
     153 
     154    def generateGraph(self, N_changed=False): 
    154155        self.searchStringTimer.stop() 
    155156        self.attributeCombo.box.setEnabled(False) 
     
    157158        matrix = None 
    158159        self.warning('') 
    159          
     160 
    160161        if N_changed: 
    161162            self.netOption = 1 
    162              
     163 
    163164        if self.matrix == None: 
    164165            self.infoa.setText("No data loaded.") 
    165166            self.infob.setText("") 
    166167            return 
    167          
     168 
    168169        #print len(self.histogram.yData), len(self.histogram.xData) 
    169         nEdgesEstimate = 2 * sum([self.histogram.yData[i] for i,e in enumerate(self.histogram.xData) if self.spinLowerThreshold <= e <= self.spinUpperThreshold]) 
    170          
     170        nEdgesEstimate = 2 * sum([self.histogram.yData[i] for i, e in enumerate(self.histogram.xData) if self.spinLowerThreshold <= e <= self.spinUpperThreshold]) 
     171 
    171172        if nEdgesEstimate > 200000: 
    172173            self.graph = None 
     
    178179            graph.add_nodes_from(range(self.matrix.dim)) 
    179180            matrix = self.matrix 
    180              
    181             if hasattr(self.matrix, "items"):                
     181 
     182            if hasattr(self.matrix, "items"): 
    182183                if type(self.matrix.items) == Orange.data.Table: 
    183184                    graph.set_items(self.matrix.items) 
     
    186187                    items = Orange.data.Table(Orange.data.Domain(Orange.data.variable.String('label'), 0), data) 
    187188                    graph.set_items(items) 
    188                  
     189 
    189190            # set the threshold 
    190191            # set edges where distance is lower than threshold 
     
    195196            edge_list = Orange.network.GraphLayout().edges_from_distance_matrix(self.matrix, self.spinLowerThreshold, self.spinUpperThreshold, min(self.kNN, self.matrix.dim - 1)) 
    196197            if self.dstWeight == 1: 
    197                 graph.add_edges_from(((u,v,{'weight':1-d}) for u,v,d in edge_list)) 
     198                graph.add_edges_from(((u, v, {'weight':1 - d}) for u, v, d in edge_list)) 
    198199            else: 
    199                 graph.add_edges_from(((u,v,{'weight':d}) for u,v,d in edge_list)) 
    200              
     200                graph.add_edges_from(((u, v, {'weight':d}) for u, v, d in edge_list)) 
     201 
    201202            # exclude unconnected 
    202203            if str(self.netOption) == '1': 
    203204                components = [x for x in Orange.network.nx.algorithms.components.connected_components(graph) if len(x) > self.excludeLimit] 
    204205                if len(components) > 0: 
    205                     include = reduce(lambda x,y: x+y, components) 
     206                    include = reduce(lambda x, y: x + y, components) 
    206207                    if len(include) > 1: 
    207208                        self.graph = graph.subgraph(include) 
     
    230231                if self.attributeCombo.currentText() != '' and self.label != '': 
    231232                    components = Orange.network.nx.algorithms.components.connected_components(graph) 
    232                          
     233 
    233234                    txt = self.label.lower() 
    234235                    #print 'txt:',txt 
     
    242243                                    if len(component) > 0: 
    243244                                        vertices.extend(component) 
    244                                          
     245 
    245246                        if len(vertices) > 0: 
    246247                            #print "n vertices:", len(vertices), "n set vertices:", len(set(vertices)) 
     
    250251            else: 
    251252                self.graph = graph 
    252          
     253 
    253254        if matrix != None: 
    254             matrix.items  = self.graph.items() 
     255            matrix.items = self.graph.items() 
    255256            self.graph_matrix = matrix 
    256              
     257 
    257258        self.pconnected = self.graph.number_of_nodes() 
    258259        self.nedges = self.graph.number_of_edges() 
     
    263264        if hasattr(self, "infoc"): 
    264265            self.infoc.setText("Graph edges: %d (%.2f edges/node)" % (self.nedges, self.nedges / float(self.pconnected))) 
    265          
     266 
    266267        #print 'self.graph:',self.graph+ 
    267268        if hasattr(self, "sendSignals"): 
    268269            self.sendSignals() 
    269          
     270 
    270271        self.histogram.setBoundary(self.spinLowerThreshold, self.spinUpperThreshold) 
    271          
     272 
  • orange/OrangeWidgets/Unsupervised/OWModelMapQt.py

    r9546 r9577  
    1919 
    2020from orngScaleLinProjData import * 
    21 from OWNxExplorerQt import * 
     21from OWNxExplorer import * 
    2222from OWkNNOptimization import OWVizRank 
    2323from OWNxHist import * 
     
    3333              ("RADVIZ",            "Visualize/icons/Radviz"), 
    3434              ("POLYVIZ",           "Visualize/icons/Polyviz"), 
     35              ("NaiveLearner",      "Classify/icons/NaiveBayes"), 
    3536              ("BAYES",             "Classify/icons/NaiveBayes"), 
     37              ("kNNLearner",        "Classify/icons/kNearestNeighbours"), 
    3638              ("KNN",               "Classify/icons/kNearestNeighbours"), 
    3739              ("SVM",               "Classify/icons/BasicSVM")] 
     
    4648    for model, path in ICON_PATHS: 
    4749        MODEL_IMAGES[model + size] = "%s%s_%s.png" % (dir, path, size) 
    48  
    49 dir = os.path.dirname(__file__) + "/../icons/" 
    50 dlg_mark2sel   = dir + "Dlg_Mark2Sel.png" 
    51 dlg_sel2mark   = dir + "Dlg_Sel2Mark.png" 
    52 dlg_selIsmark  = dir + "Dlg_SelisMark.png" 
    53 dlg_selected   = dir + "Dlg_SelectedNodes.png" 
    54 dlg_unselected = dir + "Dlg_UnselectedNodes.png" 
    55 dlg_showall    = dir + "Dlg_clear.png" 
    5650 
    5751class ModelItem(orangeqt.ModelItem): 
     
    252246            v.set_image(PIXMAP_CACHE[fn]) 
    253247 
    254 class OWModelMapQt(OWNxExplorerQt, OWNxHist): 
    255     settingsList = ["vertexSize", "lastSizeAttribute", "lastColorAttribute",  
    256                     "maxVertexSize", "minVertexSize", "tabIndex",  
    257                     "colorSettings", "selectedSchemaIndex", "iterations",  
    258                     "radius", "vizAccurancy", "vizAttributes",  
    259                     "autoSendSelection", "spinExplicit", "spinPercentage", 
    260                     "maxLinkSize", "renderAntialiased", "labelsOnMarkedOnly", 
    261                     "invertSize", "optMethod", "lastVertexSizeColumn",  
    262                     "lastColorColumn", "lastNameComponentAttribute",  
    263                     "lastLabelColumns", "lastTooltipColumns", "showWeights", 
    264                     "showIndexes",  "showEdgeLabels", "edgeColorSettings",  
    265                     "selectedEdgeSchemaIndex", "showMissingValues", "fontSize",  
    266                     "mdsTorgerson", "mdsAvgLinkage", "mdsSteps", "mdsRefresh",  
    267                     "mdsStressDelta", "organism","showTextMiningInfo",  
    268                     "toolbarSelection", "minComponentEdgeWidth",  
    269                     "maxComponentEdgeWidth", "mdsFromCurrentPos"] 
     248class OWModelMapQt(OWNxExplorer, OWNxHist): 
     249#    settingsList = ["vertexSize", "lastSizeAttribute", "lastColorAttribute",  
     250#                    "maxVertexSize", "minVertexSize", "tabIndex",  
     251#                    "colorSettings", "selectedSchemaIndex", "iterations",  
     252#                    "radius", "vizAccurancy", "vizAttributes",  
     253#                    "autoSendSelection", "spinExplicit", "spinPercentage", 
     254#                    "maxLinkSize", "renderAntialiased", "labelsOnMarkedOnly", 
     255#                    "invertSize", "optMethod", "lastVertexSizeColumn",  
     256#                    "lastColorColumn", "lastNameComponentAttribute",  
     257#                    "lastLabelColumns", "lastTooltipColumns", "showWeights", 
     258#                    "showIndexes",  "showEdgeLabels", "edgeColorSettings",  
     259#                    "selectedEdgeSchemaIndex", "showMissingValues", "fontSize",  
     260#                    "mdsTorgerson", "mdsAvgLinkage", "mdsSteps", "mdsRefresh",  
     261#                    "mdsStressDelta", "organism","showTextMiningInfo",  
     262#                    "toolbarSelection", "minComponentEdgeWidth",  
     263#                    "maxComponentEdgeWidth", "mdsFromCurrentPos"] 
     264#     
     265    settingsList = ["autoSendSelection", "spinExplicit", "spinPercentage", 
     266        "maxLinkSize", "minVertexSize", "maxVertexSize", "networkCanvas.animate_plot", 
     267        "networkCanvas.animate_points", "networkCanvas.antialias_plot",  
     268        "networkCanvas.antialias_points", "networkCanvas.antialias_lines",  
     269        "networkCanvas.auto_adjust_performance", "invertSize", "optMethod",  
     270        "lastVertexSizeColumn", "lastColorColumn", "networkCanvas.show_indices", "networkCanvas.show_weights", 
     271        "lastNameComponentAttribute", "lastLabelColumns", "lastTooltipColumns", 
     272        "showWeights", "showEdgeLabels", "colorSettings",  
     273        "selectedSchemaIndex", "edgeColorSettings", "selectedEdgeSchemaIndex", 
     274        "showMissingValues", "fontSize", "mdsTorgerson", "mdsAvgLinkage", 
     275        "mdsSteps", "mdsRefresh", "mdsStressDelta", "organism","showTextMiningInfo",  
     276        "toolbarSelection", "minComponentEdgeWidth", "maxComponentEdgeWidth", 
     277        "mdsFromCurrentPos", "labelsOnMarkedOnly", "tabIndex",  
     278        "networkCanvas.trim_label_words", "opt_from_curr", "networkCanvas.explore_distances", 
     279        "networkCanvas.show_component_distances", "fontWeight", "networkCanvas.state", 
     280        "networkCanvas.selection_behavior"]  
    270281     
    271282    def __init__(self, parent=None, signalManager=None, name="Model Map"): 
    272         OWNxExplorerQt.__init__(self, parent, signalManager, name,  
     283        OWNxExplorer.__init__(self, parent, signalManager, name,  
    273284                               NetworkCanvas=OWModelMapCanvas) 
    274285         
     
    299310        self.tabs.insertTab(0, self.matrixTab, "Matrix") 
    300311        self.tabs.insertTab(1, self.modelTab, "Model Info") 
    301  
     312        self.tabs.setCurrentIndex(self.tabIndex) 
     313         
    302314        self.networkCanvas.appendToSelection = 0 
    303315        self.networkCanvas.minVertexSize = self.minVertexSize 
     
    329341        self.attrDifferenceBox = OWGUI.listBox(vizPredAcc, self, "attrDifference", "attrDifferenceList", "Attribute difference", selectionMode=QListWidget.NoSelection) 
    330342         
    331         self.attBox.setVisible(0) 
     343        self.attBox.hide() 
    332344        self.visualizeInfo() 
    333345         
     
    336348        self.matrixTab.layout().addStretch(1) 
    337349        self.modelTab.layout().addStretch(1) 
    338         self.setMinimumWidth(900) 
    339         self.controlArea.setMinimumWidth(378) 
    340350         
    341351    def plotAccuracy(self, vertices=None): 
     
    435445         
    436446    def set_node_sizes(self): 
    437         OWNxExplorerQt.set_node_sizes(self) 
     447        OWNxExplorer.set_node_sizes(self) 
    438448        self.networkCanvas.loadIcons() 
    439449        self.networkCanvas.replot() 
  • orange/OrangeWidgets/Unsupervised/OWNxAnalysis.py

    r9518 r9577  
    110110            ("closeness_centrality", False, "Closeness centrality", NODELEVEL, nx.closeness_centrality), 
    111111            ("betweenness_centrality", False, "Betweenness centrality", NODELEVEL, nx.betweenness_centrality), 
    112             ("current_flow_closeness_centrality", False, "Current flow closeness centrality", NODELEVEL, nx.current_flow_closeness_centrality), 
    113             ("current_flow_betweenness_centrality", False, "Current flow betweenness centrality", NODELEVEL, nx.current_flow_betweenness_centrality), 
    114             ("approximate_current_flow_betweenness_centrality", False, "Approximate current flow betweenness centrality", NODELEVEL, nx.approximate_current_flow_betweenness_centrality), 
     112            ("current_flow_closeness_centrality", False, "Information centrality", NODELEVEL, nx.current_flow_closeness_centrality), 
     113            ("current_flow_betweenness_centrality", False, "Random-walk betweenness centrality", NODELEVEL, nx.current_flow_betweenness_centrality), 
     114            ("approximate_current_flow_betweenness_centrality", False, "Approx. random-walk betweenness centrality", NODELEVEL, nx.approximate_current_flow_betweenness_centrality), 
    115115            ("eigenvector_centrality", False, "Eigenvector centrality", NODELEVEL, nx.eigenvector_centrality), 
    116116            ("eigenvector_centrality_numpy", False, "Eigenvector centrality (NumPy)", NODELEVEL, nx.eigenvector_centrality_numpy), 
     
    305305                    self.analdata[job.name] = job.result 
    306306                    setattr(self, "lbl_" + job.name, ("%.4f" % job.result).rstrip('0').rstrip('.')) 
    307                  
    308         self.job_working.remove(job) 
     307         
     308        if job in self.job_working: 
     309            self.job_working.remove(job) 
     310 
    309311        self.send_data() 
    310312        self.mutex.unlock() 
  • orange/OrangeWidgets/Unsupervised/OWNxCanvasQt.py

    r9424 r9577  
    1010 
    1111import Orange 
    12 import random  
     12import random 
    1313import numpy 
    1414 
    1515from plot.owplot import * 
    1616from plot.owpoint import * 
    17 from plot.owtools import *   
     17from plot.owtools import * 
    1818 
    1919from orngScaleScatterPlotData import * 
     
    2727        if y is not None: 
    2828            self.set_y(y) 
    29          
     29 
    3030class EdgeItem(orangeqt.EdgeItem): 
    3131    def __init__(self, u=None, v=None, weight=1, links_index=0, arrows=None, label='', parent=None): 
     
    4040        orangeqt.NetworkCurve.__init__(self, parent) 
    4141        self.name = "Network Curve" 
    42          
     42 
    4343    def layout_fr(self, steps, weighted=False, smooth_cooling=False): 
    4444        orangeqt.NetworkCurve.fr(self, steps, weighted, smooth_cooling) 
    45        
     45 
    4646    def set_node_sizes(self, values={}, min_size=0, max_size=0): 
    4747        orangeqt.NetworkCurve.set_node_sizes(self, values, min_size, max_size) 
    48      
     48 
    4949    def fragviz_callback(self, a, b, mds, mdsRefresh, components, progress_callback): 
    5050        """Refresh the UI when running  MDS on network components.""" 
    51          
     51 
    5252        if not self.mdsStep % mdsRefresh: 
    5353            rotationOnly = False 
     
    5757            phi = [None] * len(components) 
    5858            nodes = self.nodes() 
    59              
    60             for i, component in enumerate(components):     
    61                  
     59 
     60            for i, component in enumerate(components): 
     61 
    6262                if len(mds.points) == len(components):  # if average linkage before 
    6363                    x_avg_mds = mds.points[i][0] 
     
    6666                    x = [mds.points[u][0] for u in component] 
    6767                    y = [mds.points[u][1] for u in component] 
    68              
    69                     x_avg_mds = sum(x) / len(x)  
     68 
     69                    x_avg_mds = sum(x) / len(x) 
    7070                    y_avg_mds = sum(y) / len(y) 
    7171                    # compute rotation angle 
     
    7676#                                    [nodes[u].x(), nodes[u].y()]) for u in component] 
    7777#                    phi[i] = sum(c) / sum(n) 
    78                      
    79                  
     78 
     79 
    8080                x = [nodes[i].x() for i in component] 
    8181                y = [nodes[i].y() for i in component] 
    82                  
     82 
    8383                x_avg_graph = sum(x) / len(x) 
    8484                y_avg_graph = sum(y) / len(y) 
    85                  
    86                 x_mds.append(x_avg_mds)  
     85 
     86                x_mds.append(x_avg_mds) 
    8787                y_mds.append(y_avg_mds) 
    88      
     88 
    8989                component_props.append((x_avg_graph, y_avg_graph, \ 
    9090                                        x_avg_mds, y_avg_mds, phi)) 
     
    9393                x_avg_graph, y_avg_graph, x_avg_mds, \ 
    9494                y_avg_mds, phi = component_props[i] 
    95                  
     95 
    9696    #            if phi[i]:  # rotate vertices 
    9797    #                #print "rotate", i, phi[i] 
     
    101101    #                self.graph.coors[0][component] = [u[0] for u in v] 
    102102    #                self.graph.coors[1][component] = [u[1] for u in v] 
    103                      
     103 
    104104                # translate vertices 
    105105                if not rotationOnly: 
    106106                    self.set_node_coordinates(dict( 
    107                        (i, ((nodes[i].x() - x_avg_graph) + x_avg_mds,   
     107                       (i, ((nodes[i].x() - x_avg_graph) + x_avg_mds, 
    108108                            (nodes[i].y() - y_avg_graph) + y_avg_mds)) \ 
    109109                                  for i in component)) 
    110                      
     110 
    111111            #if self.mdsType == MdsType.exactSimulation: 
    112112            #    self.mds.points = [[self.graph.coors[0][i], \ 
     
    114114            #                        for i in range(len(self.graph.coors))] 
    115115            #    self.mds.freshD = 0 
    116              
     116 
    117117            #self.update_properties() 
    118118            self.plot().replot() 
    119119            qApp.processEvents() 
    120              
     120 
    121121            if progress_callback is not None: 
    122                 progress_callback(a, self.mdsStep)  
    123              
     122                progress_callback(a, self.mdsStep) 
     123 
    124124        self.mdsStep += 1 
    125125        return 0 if self.stopMDS else 1 
    126              
     126 
    127127    def layout_fragviz(self, steps, distances, graph, progress_callback=None, opt_from_curr=False): 
    128128        """Position the network components according to similarities among  
     
    134134            self.information('invalid or no distance matrix') 
    135135            return 1 
    136          
     136 
    137137        p = self.plot() 
    138138        edges = self.edges() 
    139139        nodes = self.nodes() 
    140          
     140 
    141141        avgLinkage = True 
    142142        rotationOnly = False 
    143143        minStressDelta = 0 
    144144        mdsRefresh = int(steps / 20) 
    145          
     145 
    146146        self.mdsStep = 1 
    147147        self.stopMDS = False 
    148          
     148 
    149149        components = Orange.network.nx.algorithms.components.connected.connected_components(graph) 
    150150        distances.matrixType = Orange.core.SymMatrix.Symmetric 
    151          
     151 
    152152        # scale net coordinates 
    153153        if avgLinkage: 
    154154            distances = distances.avgLinkage(components) 
    155              
     155 
    156156        mds = Orange.projection.mds.MDS(distances) 
    157157        mds.optimize(10, Orange.projection.mds.SgnRelStress, 0) 
     
    159159        w_fr = rect.width() 
    160160        h_fr = rect.height() 
    161         d_fr = math.sqrt(w_fr**2 + h_fr**2) 
    162        
     161        d_fr = math.sqrt(w_fr ** 2 + h_fr ** 2) 
     162 
    163163        x_mds = [mds.points[u][0] for u in range(len(mds.points))] 
    164164        y_mds = [mds.points[u][1] for u in range(len(mds.points))] 
    165165        w_mds = max(x_mds) - min(x_mds) 
    166166        h_mds = max(y_mds) - min(y_mds) 
    167         d_mds = math.sqrt(w_mds**2 + h_mds**2) 
    168          
     167        d_mds = math.sqrt(w_mds ** 2 + h_mds ** 2) 
     168 
    169169        animate_points = p.animate_points 
    170170        p.animate_points = False 
    171          
     171 
    172172        self.set_node_coordinates(dict( 
    173            (n, (nodes[n].x()*d_mds/d_fr, nodes[n].y()*d_mds/d_fr)) for n in nodes)) 
    174          
     173           (n, (nodes[n].x() * d_mds / d_fr, nodes[n].y() * d_mds / d_fr)) for n in nodes)) 
     174 
    175175        #self.update_properties() 
    176176        p.replot() 
    177177        qApp.processEvents() 
    178                       
     178 
    179179        if opt_from_curr: 
    180180            if avgLinkage: 
     
    185185                    mds.points[u][1] = y 
    186186            else: 
    187                 for i,u in enumerate(sorted(nodes.iterkeys())): 
     187                for i, u in enumerate(sorted(nodes.iterkeys())): 
    188188                    mds.points[i][0] = nodes[u].x() 
    189189                    mds.points[i][1] = nodes[u].y() 
    190190        else: 
    191             mds.Torgerson()  
    192  
    193         mds.optimize(steps, Orange.projection.mds.SgnRelStress, minStressDelta,  
     191            mds.Torgerson() 
     192 
     193        mds.optimize(steps, Orange.projection.mds.SgnRelStress, minStressDelta, 
    194194                     progressCallback= 
    195                          lambda a,  
    196                                 b=None,  
     195                         lambda a, 
     196                                b=None, 
    197197                                mds=mds, 
    198198                                mdsRefresh=mdsRefresh, 
    199199                                components=components, 
    200                                 progress_callback=progress_callback:  
     200                                progress_callback=progress_callback: 
    201201                                    self.fragviz_callback(a, b, mds, mdsRefresh, components, progress_callback)) 
    202          
     202 
    203203        self.fragviz_callback(mds.avgStress, 0, mds, mdsRefresh, components, progress_callback) 
    204          
     204 
    205205        if progress_callback != None: 
    206206            progress_callback(mds.avgStress, self.mdsStep) 
    207          
     207 
    208208        p.animate_points = animate_points 
    209209        return 0 
    210      
     210 
    211211    def mds_callback(self, a, b, mds, mdsRefresh, progress_callback): 
    212212        """Refresh the UI when running  MDS.""" 
    213          
     213 
    214214        if not self.mdsStep % mdsRefresh: 
    215              
     215 
    216216            self.set_node_coordinates(dict((u, (mds.points[u][0], \ 
    217217                                                mds.points[u][1])) for u in \ 
     
    219219            self.plot().replot() 
    220220            qApp.processEvents() 
    221              
     221 
    222222            if progress_callback is not None: 
    223                 progress_callback(a, self.mdsStep)  
    224              
     223                progress_callback(a, self.mdsStep) 
     224 
    225225        self.mdsStep += 1 
    226226        return 0 if self.stopMDS else 1 
    227      
     227 
    228228    def layout_mds(self, steps, distances, progress_callback=None, opt_from_curr=False): 
    229229        """Position the network components according to similarities among  
     
    232232        """ 
    233233        nodes = self.nodes() 
    234          
     234 
    235235        if distances == None or distances.dim != len(nodes): 
    236236            self.information('invalid or no distance matrix') 
    237237            return 1 
    238          
     238 
    239239        p = self.plot() 
    240          
     240 
    241241        minStressDelta = 0 
    242242        mdsRefresh = int(steps / 20) 
    243          
     243 
    244244        self.mdsStep = 1 
    245245        self.stopMDS = False 
    246          
     246 
    247247        distances.matrixType = Orange.core.SymMatrix.Symmetric 
    248248        mds = Orange.projection.mds.MDS(distances) 
     
    251251        w_fr = rect.width() 
    252252        h_fr = rect.height() 
    253         d_fr = math.sqrt(w_fr**2 + h_fr**2) 
    254        
     253        d_fr = math.sqrt(w_fr ** 2 + h_fr ** 2) 
     254 
    255255        x_mds = [mds.points[u][0] for u in range(len(mds.points))] 
    256256        y_mds = [mds.points[u][1] for u in range(len(mds.points))] 
    257257        w_mds = max(x_mds) - min(x_mds) 
    258258        h_mds = max(y_mds) - min(y_mds) 
    259         d_mds = math.sqrt(w_mds**2 + h_mds**2) 
    260          
     259        d_mds = math.sqrt(w_mds ** 2 + h_mds ** 2) 
     260 
    261261        animate_points = p.animate_points 
    262262        p.animate_points = False 
    263          
     263 
    264264        self.set_node_coordinates(dict( 
    265            (n, (nodes[n].x()*d_mds/d_fr, nodes[n].y()*d_mds/d_fr)) for n in nodes)) 
    266          
     265           (n, (nodes[n].x() * d_mds / d_fr, nodes[n].y() * d_mds / d_fr)) for n in nodes)) 
     266 
    267267        p.replot() 
    268268        qApp.processEvents() 
    269                       
     269 
    270270        if opt_from_curr: 
    271             for i,u in enumerate(sorted(nodes.iterkeys())): 
     271            for i, u in enumerate(sorted(nodes.iterkeys())): 
    272272                mds.points[i][0] = nodes[u].x() 
    273273                mds.points[i][1] = nodes[u].y() 
    274274        else: 
    275             mds.Torgerson()  
    276  
    277         mds.optimize(steps, Orange.projection.mds.SgnRelStress, minStressDelta,  
     275            mds.Torgerson() 
     276 
     277        mds.optimize(steps, Orange.projection.mds.SgnRelStress, minStressDelta, 
    278278                     progressCallback= 
    279                          lambda a,  
    280                                 b=None,  
     279                         lambda a, 
     280                                b=None, 
    281281                                mds=mds, 
    282282                                mdsRefresh=mdsRefresh, 
    283                                 progress_callback=progress_callback:  
     283                                progress_callback=progress_callback: 
    284284                                    self.mds_callback(a, b, mds, mdsRefresh, progress_callback)) 
    285          
     285 
    286286        self.mds_callback(mds.avgStress, 0, mds, mdsRefresh, progress_callback) 
    287          
     287 
    288288        if progress_callback != None: 
    289289            progress_callback(mds.avgStress, self.mdsStep) 
    290          
     290 
    291291        p.animate_points = animate_points 
    292292        return 0 
    293      
     293 
    294294#    def move_selected_nodes(self, dx, dy): 
    295295#        selected = self.get_selected_nodes() 
     
    318318#        for vertex in self.nodes().itervalues(): 
    319319#          vertex.show() 
    320      
    321      
    322          
     320 
     321 
     322 
    323323class OWNxCanvas(OWPlot): 
    324324    def __init__(self, master, parent=None, name="None"): 
     
    328328        self.NodeItem = NodeItem 
    329329        self.graph = None 
    330          
     330 
    331331        self.circles = [] 
    332332        self.freezeNeighbours = False 
     
    336336        self.show_weights = False 
    337337        self.trim_label_words = 0 
    338         self.explore_distances = False 
    339338        self.show_component_distances = False 
    340          
     339 
    341340        self.showComponentAttribute = None 
    342341        self.forceVectors = None 
    343342        #self.appendToSelection = 1 
    344343        self.fontSize = 12 
    345               
     344 
    346345        self.networkCurve = NetworkCurve() 
    347346        self.add_custom_curve(self.networkCurve) 
    348          
     347 
    349348        self.minComponentEdgeWidth = 0 
    350349        self.maxComponentEdgeWidth = 0 
    351350        self.items_matrix = None 
    352           
     351 
    353352        self.items = None 
    354353        self.links = None 
    355354        self.edge_to_row = None 
    356          
     355        self.label_distances = None 
     356 
    357357        self.node_label_attributes = [] 
    358358        self.edge_label_attributes = [] 
    359          
     359 
    360360        self.axis_margin = 0 
    361361        self.title_margin = 0 
    362362        self.graph_margin = 1 
    363363        self._legend_margin = QRectF(0, 0, 0, 0) 
    364          
     364 
    365365        #self.setFocusPolicy(Qt.StrongFocus) 
    366          
     366 
    367367    def update_canvas(self): 
    368368        self.networkCurve.update_properties() 
    369369        self.drawComponentKeywords() 
    370370        self.replot() 
    371          
     371 
    372372    def set_hidden_nodes(self, nodes): 
    373373        self.networkCurve.set_hidden_nodes(nodes) 
    374      
     374 
    375375    def hide_selected_nodes(self): 
    376376      self.networkCurve.hide_selected_nodes() 
    377377      self.drawPlotItems() 
    378        
     378 
    379379    def hide_unselected_nodes(self): 
    380380      self.networkCurve.hide_unselected_nodes() 
    381381      self.drawPlotItems() 
    382        
     382 
    383383    def show_all_vertices(self): 
    384384      self.networkCurve.show_all_vertices() 
    385385      self.drawPlotItems() 
    386      
     386 
    387387    def selected_nodes(self): 
    388388        return [vertex.index() for vertex in self.networkCurve.nodes().itervalues() if vertex.is_selected()] 
    389389        #return [p.index() for p in self.selected_points()] 
    390          
     390 
    391391    def not_selected_nodes(self): 
    392392        return [vertex.index() for vertex in self.networkCurve.nodes().itervalues() if not vertex.is_selected()] 
    393          
     393 
    394394    def marked_nodes(self): 
    395395        return [vertex.index() for vertex in self.networkCurve.nodes().itervalues() if vertex.is_marked()] 
    396396        #return [p.index() for p in self.marked_points()] 
    397          
     397 
    398398    def not_marked_nodes(self): 
    399         return [vertex.index() for vertex in self.networkCurve.nodes().itervalues() if not vertex.is_marked()]     
    400      
     399        return [vertex.index() for vertex in self.networkCurve.nodes().itervalues() if not vertex.is_marked()] 
     400 
    401401    def get_neighbors_upto(self, ndx, dist): 
    402402        newNeighbours = neighbours = set([ndx]) 
     
    408408            neighbours |= newNeighbours 
    409409        return neighbours 
    410      
     410             
    411411    def mark_on_selection_changed(self): 
    412412        toMark = set() 
    413413        for ndx in self.selected_nodes(): 
    414414            toMark |= self.get_neighbors_upto(ndx, self.mark_neighbors) 
    415          
     415 
    416416        self.networkCurve.clear_node_marks() 
    417417        self.networkCurve.set_node_marks(dict((i, True) for i in toMark)) 
    418      
     418 
    419419    def mark_on_focus_changed(self, node): 
    420420        self.networkCurve.clear_node_marks() 
    421          
     421 
    422422        if node is not None: 
    423423            toMark = set(self.get_neighbors_upto(node.index(), self.mark_neighbors)) 
    424424            self.networkCurve.set_node_marks(dict((i, True) for i in toMark)) 
    425          
     425 
    426426    def drawComponentKeywords(self): 
    427427        self.clear_markers() 
    428428        if self.showComponentAttribute == None or self.graph is None or self.items is None: 
    429429            return 
    430          
     430 
    431431        if str(self.showComponentAttribute) not in self.items.domain: 
    432432            self.showComponentAttribute = None 
    433433            return 
    434          
     434 
    435435        components = Orange.network.nx.algorithms.components.connected_components(self.graph) 
    436436        nodes = self.networkCurve.nodes() 
    437          
     437 
    438438        for c in components: 
    439439            if len(c) == 0: 
    440440                continue 
    441              
     441 
    442442            x1 = sum(nodes[n].x() for n in c) / len(c) 
    443443            y1 = sum(nodes[n].y() for n in c) / len(c) 
    444444            lbl = str(self.items[c[0]][str(self.showComponentAttribute)]) 
    445              
     445 
    446446            self.add_marker(lbl, x1, y1, alignment=Qt.AlignCenter, size=self.fontSize) 
    447              
    448             #mkey = self.addMarker(lbl, float(x1), float(y1), alignment=Qt.AlignCenter, size=self.fontSize) 
    449                              
     447 
    450448    def getColorIndeces(self, table, attribute, palette): 
    451449        colorIndices = {} 
     
    453451        minValue = None 
    454452        maxValue = None 
    455          
     453 
    456454        if attribute[0] != "(" or attribute[ -1] != ")": 
    457455            i = 0 
     
    459457                if var.name == attribute: 
    460458                    colorIndex = i 
    461                     if var.varType == orange.VarTypes.Discrete:  
     459                    if var.varType == orange.VarTypes.Discrete: 
    462460                        colorIndices = getVariableValueIndices(var, colorIndex) 
    463                          
     461 
    464462                i += 1 
    465463            metas = table.domain.getmetas() 
     
    467465                if var.name == attribute: 
    468466                    colorIndex = i 
    469                     if var.varType == orange.VarTypes.Discrete:  
     467                    if var.varType == orange.VarTypes.Discrete: 
    470468                        colorIndices = getVariableValueIndices(var, colorIndex) 
    471      
     469 
    472470        colorIndices['?'] = len(colorIndices) 
    473471        palette.setNumberOfColors(len(colorIndices)) 
    474          
     472 
    475473        if colorIndex != None and table.domain[colorIndex].varType == orange.VarTypes.Continuous: 
    476474            minValue = float(min([x[colorIndex].value for x in table if x[colorIndex].value != "?"] or [0.0])) 
    477475            maxValue = float(max([x[colorIndex].value for x in table if x[colorIndex].value != "?"] or [0.0])) 
    478              
     476 
    479477        return colorIndices, colorIndex, minValue, maxValue 
    480      
     478 
    481479    def set_node_colors(self, attribute, nodes=None): 
    482480        if self.graph is None: 
     
    485483        colorIndices, colorIndex, minValue, maxValue = self.getColorIndeces(self.items, attribute, self.discPalette) 
    486484        colors = {} 
    487          
     485 
    488486        if nodes is None: 
    489487            nodes = self.graph.nodes() 
    490          
     488 
    491489        if colorIndex is not None and self.items.domain[colorIndex].varType == orange.VarTypes.Continuous and minValue == maxValue: 
    492490            colors.update((node, self.discPalette[0]) for node in nodes) 
    493          
     491 
    494492        elif colorIndex is not None and self.items.domain[colorIndex].varType == orange.VarTypes.Continuous: 
    495             colors.update((v, self.contPalette[(float(self.items[v][colorIndex].value) - minValue) / (maxValue - minValue)])  
    496                           if str(self.items[v][colorIndex].value) != '?' else  
     493            colors.update((v, self.contPalette[(float(self.items[v][colorIndex].value) - minValue) / (maxValue - minValue)]) 
     494                          if str(self.items[v][colorIndex].value) != '?' else 
    497495                          (v, self.discPalette[0]) for v in nodes) 
    498496 
    499497        elif colorIndex is not None and self.items.domain[colorIndex].varType == orange.VarTypes.Discrete: 
    500498            colors.update((v, self.discPalette[colorIndices[self.items[v][colorIndex].value]]) for v in nodes) 
    501              
     499 
    502500        else: 
    503501            colors.update((node, self.discPalette[0]) for node in nodes) 
    504          
     502 
    505503        self.networkCurve.set_node_colors(colors) 
    506504        self.replot() 
    507          
     505 
    508506    def set_node_labels(self, attributes=None): 
    509507        if self.graph is None: 
    510             return  
    511          
     508            return 
     509 
    512510        nodes = self.graph.nodes() 
    513          
     511 
    514512        if attributes is not None: 
    515513            self.node_label_attributes = attributes 
    516          
     514 
    517515        label_attributes = [] 
    518516        if self.items is not None and isinstance(self.items, orange.ExampleTable): 
    519517            label_attributes = [self.items.domain[att] for att in \ 
    520518                self.node_label_attributes if att in self.items.domain] 
    521              
     519 
    522520        indices = [[] for u in nodes] 
    523521        if self.show_indices: 
    524522            indices = [[str(u)] for u in nodes] 
    525523         
    526         if len(label_attributes) == 0 and not self.show_indices: 
     524        distances = [[] for u in nodes] 
     525        show_distances = False 
     526        if self.label_distances is not None and type(self.label_distances) == \ 
     527                           type([]) and len(self.label_distances) == len(nodes): 
     528            distances = self.label_distances 
     529            show_distances = True 
     530             
     531        if len(label_attributes) == 0 and \ 
     532                        not self.show_indices and not show_distances: 
    527533            self.networkCurve.set_node_labels({}) 
    528          
     534 
    529535        elif self.trim_label_words > 0: 
    530             self.networkCurve.set_node_labels(dict((node,  
    531                 ', '.join(indices[i] +  
    532                           [' '.join(str(self.items[node][att]).split(' ')[:min(self.trim_label_words,len(str(self.items[node][att]).split(' ')))]) 
     536            self.networkCurve.set_node_labels(dict((node, 
     537                ', '.join(distances[i] + indices[i] + 
     538                          [' '.join(str(self.items[node][att]).split(' ')[:min(self.trim_label_words, len(str(self.items[node][att]).split(' ')))]) 
    533539                for att in label_attributes])) for i, node in enumerate(nodes))) 
    534540        else: 
    535             self.networkCurve.set_node_labels(dict((node, ', '.join(indices[i]+\ 
     541            self.networkCurve.set_node_labels(dict((node, ', '.join( \ 
     542                        distances[i] + indices[i] + \ 
    536543                           [str(self.items[node][att]) for att in \ 
    537544                           label_attributes])) for i, node in enumerate(nodes))) 
    538          
     545 
    539546        self.replot() 
    540          
    541      
     547 
     548 
    542549    def set_edge_colors(self, attribute): 
    543550        if self.graph is None: 
    544551            return 
    545          
     552 
    546553        colorIndices, colorIndex, minValue, maxValue = self.getColorIndeces(self.links, attribute, self.discPalette) 
    547554        colors = [] 
    548          
     555 
    549556        if colorIndex is not None and self.links.domain[colorIndex].varType == orange.VarTypes.Continuous and minValue == maxValue: 
    550557            colors = [self.discEdgePalette[0] for edge in self.networkCurve.edge_indices()] 
    551          
     558 
    552559        elif colorIndex is not None and self.links.domain[colorIndex].varType == orange.VarTypes.Continuous: 
    553560            colors = [self.contPalette[(float(self.links[edge.links_index()][colorIndex].value) - minValue) / (maxValue - minValue)] 
    554                           if str(self.links[edge.links_index()][colorIndex].value) != '?' else  
     561                          if str(self.links[edge.links_index()][colorIndex].value) != '?' else 
    555562                          self.discPalette[0] for edge in self.networkCurve.edges()] 
    556              
     563 
    557564        elif colorIndex is not None and self.links.domain[colorIndex].varType == orange.VarTypes.Discrete: 
    558565            colors = [self.discEdgePalette[colorIndices[self.links[edge.links_index()][colorIndex].value]] for edge in self.networkCurve.edges()] 
    559              
     566 
    560567        else: 
    561568            colors = [self.discEdgePalette[0] for edge in self.networkCurve.edge_indices()] 
    562              
     569 
    563570        self.networkCurve.set_edge_colors(colors) 
    564571        self.replot() 
    565          
     572 
    566573    def set_edge_labels(self, attributes=None): 
    567574        if self.graph is None: 
    568             return  
    569          
     575            return 
     576 
    570577        edges = self.networkCurve.edge_indices() 
    571          
     578 
    572579        if attributes is not None: 
    573580            self.edge_label_attributes = attributes 
    574          
     581 
    575582        label_attributes = [] 
    576583        if self.links is not None and isinstance(self.links, orange.ExampleTable): 
    577584            label_attributes = [self.links.domain[att] for att in \ 
    578585                self.edge_label_attributes if att in self.links.domain] 
    579              
     586 
    580587        weights = [[] for ex in edges] 
    581588        if self.show_weights: 
    582             weights = [["%.2f" % self.graph[u][v].get('weight', 1)] for u,v in edges] 
    583              
     589            weights = [["%.2f" % self.graph[u][v].get('weight', 1)] for u, v in edges] 
     590 
    584591        self.networkCurve.set_edge_labels([', '.join(weights[i] + \ 
    585592                           [str(self.links[i][att]) for att in \ 
    586                            label_attributes]) for i,edge in enumerate(edges)]) 
    587          
     593                           label_attributes]) for i, edge in enumerate(edges)]) 
     594 
    588595        self.replot() 
    589          
     596 
    590597    def set_tooltip_attributes(self, attributes): 
    591598        if self.graph is None or self.items is None or \ 
    592599           not isinstance(self.items, orange.ExampleTable): 
    593600            return 
    594          
     601 
    595602        tooltip_attributes = [self.items.domain[att] for att in \ 
    596603                                 attributes if att in self.items.domain] 
    597         self.networkCurve.set_node_tooltips(dict((node, ', '.join(str( \ 
     604        self.networkCurve.set_node_tooltips(dict((node, ', '.join(str(\ 
    598605                   self.items[node][att]) for att in tooltip_attributes)) \ 
    599606                                                        for node in self.graph)) 
    600                  
     607 
    601608    def change_graph(self, newgraph): 
    602609        old_nodes = set(self.graph.nodes_iter()) 
     
    605612        remove_nodes = list(old_nodes.difference(inter_nodes)) 
    606613        add_nodes = list(new_nodes.difference(inter_nodes)) 
    607          
     614 
    608615        self.graph = newgraph 
    609          
     616 
    610617        if len(remove_nodes) == 0 and len(add_nodes) == 0: 
    611618            return False 
    612          
     619 
    613620        current_nodes = self.networkCurve.nodes() 
    614          
     621 
    615622        center_x = numpy.average([node.x() for node in current_nodes.values()]) if len(current_nodes) > 0 else 0 
    616623        center_y = numpy.average([node.y() for node in current_nodes.values()]) if len(current_nodes) > 0 else 0 
    617          
     624 
    618625        def closest_nodes_with_pos(nodes): 
    619              
     626 
    620627            neighbors = set() 
    621628            for n in nodes: 
     
    625632            if len(neighbors - nodes) == 0: 
    626633                return [] 
    627              
     634 
    628635            inter = old_nodes.intersection(neighbors) 
    629636            if len(inter) > 0: 
     
    631638            else: 
    632639                return closest_nodes_with_pos(neighbors | nodes) 
    633          
     640 
    634641        pos = dict((n, [numpy.average(c) for c in zip(*[(current_nodes[u].x(), current_nodes[u].y()) for u in closest_nodes_with_pos(set([n]))])]) for n in add_nodes) 
    635          
     642 
    636643        self.networkCurve.remove_nodes(list(remove_nodes)) 
    637          
     644 
    638645        nodes = dict((v, self.NodeItem(v, x=pos[v][0] if len(pos[v]) == 2 else center_x, y=pos[v][1] if len(pos[v]) == 2 else center_y, parent=self.networkCurve)) for v in add_nodes) 
    639646        self.networkCurve.add_nodes(nodes) 
    640647        nodes = self.networkCurve.nodes() 
    641          
     648 
    642649        #add edges 
    643650        new_edges = self.graph.edges(add_nodes) 
    644          
     651 
    645652        if self.links is not None and len(self.links) > 0: 
    646653            links = self.links 
    647654            links_indices = (self.edge_to_row[i + 1][j + 1] for (i, j) in new_edges) 
    648              
     655 
    649656            if self.graph.is_directed(): 
    650657                edges = [EdgeItem(nodes[i], nodes[j], 
     
    663670            edges = [EdgeItem(nodes[i], nodes[j], self.graph[i][j].get('weight', 1), \ 
    664671                    parent=self.networkCurve) for (i, j) in new_edges] 
    665              
     672 
    666673        self.networkCurve.add_edges(edges) 
    667          
     674 
    668675        if len(current_nodes) < 3: 
    669676            self.networkCurve.random() 
    670          
     677 
    671678        return True 
    672          
     679 
    673680    def set_graph(self, graph, curve=None, items=None, links=None): 
    674681        self.clear() 
    675          
     682 
    676683        if graph is None: 
    677684            self.graph = None 
     
    686693            self.replot() 
    687694            return 
    688          
     695 
    689696        self.graph = graph 
    690697        self.networkCurve = NetworkCurve() if curve is None else curve() 
    691698        self.add_custom_curve(self.networkCurve) 
    692          
     699 
    693700        self.items = items if items is not None else self.graph.items() 
    694701        self.links = links if links is not None else self.graph.links() 
    695          
     702 
    696703        #add nodes 
    697704        #self.vertices_old = [(None, []) for v in self.graph] 
    698705        vertices = dict((v, self.NodeItem(v, parent=self.networkCurve)) for v in self.graph) 
    699706        self.networkCurve.set_nodes(vertices) 
    700                  
     707 
    701708        #build edge to row index 
    702709        self.edge_to_row = {} 
     
    714721                else: 
    715722                    print 'could not find edge', u, v 
    716                
     723 
    717724        #add edges 
    718725        if self.links is not None and len(self.links) > 0: 
    719726            links = self.links 
    720727            links_indices = (self.edge_to_row[i + 1][j + 1] for (i, j) in self.graph.edges()) 
    721              
     728 
    722729            if self.graph.is_directed(): 
    723730                edges = [EdgeItem(vertices[i], vertices[j], 
     
    730737                    parent=self.networkCurve) for ((i, j), links_index) in \ 
    731738                         zip(self.graph.edges(), links_indices)] 
    732                  
     739 
    733740        elif self.graph.is_directed(): 
    734741            edges = [EdgeItem(vertices[i], vertices[j], 
     
    737744            edges = [EdgeItem(vertices[i], vertices[j], 
    738745                                      graph[i][j].get('weight', 1), parent=self.networkCurve) for (i, j) in self.graph.edges()] 
    739              
     746 
    740747        self.networkCurve.set_edges(edges) 
    741748        self.networkCurve.update_properties() 
    742         self.replot()   
    743      
     749        self.replot() 
     750 
    744751    def update_animations(self, use_animations=None): 
    745752        OWPlot.update_animations(self, use_animations) 
     
    750757        self.set_node_labels() 
    751758        self.replot() 
    752      
     759 
    753760    def set_show_component_distances(self): 
    754761        self.networkCurve.set_show_component_distances(self.show_component_distances) 
    755762        self.replot() 
    756          
     763 
    757764    def replot(self): 
    758          
    759                 #, alignment = -1, bold = 0, color = None, brushColor = None, size=None, antiAlias = None, x_axis_key = xBottom, y_axis_key = yLeft): 
    760765        self.set_dirty() 
    761766        OWPlot.replot(self) 
    762767        if hasattr(self, 'networkCurve') and self.networkCurve is not None: 
    763768            self.networkCurve.update() 
    764              
     769 
  • orange/OrangeWidgets/Unsupervised/OWNxExplorer.py

    r9549 r9577  
    44<icon>icons/Network.png</icon> 
    55<contact>Miha Stajdohar (miha.stajdohar(@at@)gmail.com)</contact>  
    6 <priority>6420</priority> 
     6<priority>6420</priorbity> 
    77""" 
    88import math 
     
    120120            self.checkSendMarkedNodes = True 
    121121            self.checkSendSelectedNodes = True 
     122            self.explore_distances = False 
    122123             
    123124            self.loadSettings() 
     
    193194            #OWGUI.checkBox(ib, self, 'showEdgeLabels', 'Show labels on edges', callback=(lambda: self._set_canvas_attr('showEdgeLabels', self.showEdgeLabels))) 
    194195            OWGUI.spin(ib, self, "maxLinkSize", 1, 50, 1, label="Max edge width:", callback = self.set_edge_sizes) 
    195             self.cb_show_distances = OWGUI.checkBox(ib, self, 'networkCanvas.explore_distances', 'Explore node distances', callback=None, disabled=1) 
     196            self.cb_show_distances = OWGUI.checkBox(ib, self, 'explore_distances', 'Explore node distances', callback=self.set_explore_distances, disabled=1) 
    196197            self.cb_show_component_distances = OWGUI.checkBox(ib, self, 'networkCanvas.show_component_distances', 'Show component distances', callback=self.networkCanvas.set_show_component_distances, disabled=1) 
    197198             
     
    925926                self.markInputRadioButton.setEnabled(True) 
    926927                self.set_mark_mode(9) 
    927                    
     928         
     929        def set_explore_distances(self): 
     930            QObject.disconnect(self.networkCanvas, SIGNAL('selection_changed()'), self.explore_focused) 
     931 
     932            if self.explore_distances: 
     933                QObject.connect(self.networkCanvas, SIGNAL('selection_changed()'), self.explore_focused) 
     934                 
     935        def explore_focused(self): 
     936            sel = self.networkCanvas.selected_nodes() 
     937            if len(sel) == 1: 
     938                ndx_1 = sel[0] 
     939                self.networkCanvas.label_distances = [['%.2f' % \ 
     940                                self.items_matrix[ndx_1][ndx_2]] \ 
     941                                for ndx_2 in self.networkCanvas.graph.nodes()] 
     942            else: 
     943                self.networkCanvas.label_distances = None 
     944                 
     945            self.networkCanvas.set_node_labels(self.lastLabelColumns) 
     946            self.networkCanvas.replot()   
     947       
    928948        ####################################################################### 
    929949        ### Layout Optimization                                             ### 
     
    964984            self.optButton.setChecked(False) 
    965985            self.networkCanvas.update_canvas() 
    966             qApp.processEvents() 
    967986             
    968987        def graph_layout_method(self, method=None): 
  • source/orangeqt/curve.cpp

    r9361 r9577  
    498498        { 
    499499            m_pointItems[i]->setPos(m_pos_watcher.resultAt(i)); 
     500            // move point label 
     501            if (m_pointItems[i]->label) 
     502            { 
     503                m_pointItems[i]->label->setPos(m_pos_watcher.resultAt(i)); 
     504            } 
    500505        } 
    501506        else 
     
    504509            a->setEndValue(m_pos_watcher.resultAt(i)); 
    505510            group->addAnimation(a); 
     511 
     512            // move point label 
     513            if (m_pointItems[i]->label) 
     514            { 
     515                QPropertyAnimation* b = new QPropertyAnimation(m_pointItems[i]->label, "pos", m_pointItems[i]->label); 
     516                b->setEndValue(m_pos_watcher.resultAt(i)); 
     517                group->addAnimation(b); 
     518            } 
    506519        } 
    507520    } 
Note: See TracChangeset for help on using the changeset viewer.