Changeset 8450:b14dd96a5138 in orange


Ignore:
Timestamp:
07/25/11 18:01:55 (3 years ago)
Author:
miha <miha.stajdohar@…>
Branch:
default
Convert:
24ac682d7dc1b79a8ab5dfe47a62cb0793857834
Message:
 
Location:
orange/OrangeWidgets/Prototypes
Files:
2 edited

Legend:

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

    r8449 r8450  
    1919 
    2020class NodeItem(orangeplot.NodeItem): 
    21     def __init__(self, index, x, y, parent=None): 
     21    def __init__(self, index, x=None, y=None, parent=None): 
    2222        orangeplot.NodeItem.__init__(self, index, OWPoint.Ellipse, Qt.blue, 5, parent) 
    23         self.set_x(x) 
    24         self.set_y(y) 
     23        if x is not None: 
     24            self.set_x(x) 
     25        if y is not None: 
     26            self.set_y(y) 
    2527         
    2628class EdgeItem(orangeplot.EdgeItem): 
     
    11431145        #add nodes 
    11441146        #self.vertices_old = [(None, []) for v in self.graph] 
    1145         vertices = dict((v, NodeItem(v, random.random(), random.random(), parent=self.networkCurve)) for v in self.graph) 
     1147        vertices = dict((v, NodeItem(v, parent=self.networkCurve)) for v in self.graph) 
    11461148        self.networkCurve.set_nodes(vertices) 
    11471149                 
  • orange/OrangeWidgets/Prototypes/OWNxExplorerQt.py

    r8449 r8450  
    120120         
    121121        self._network_view = None 
    122         self.layout = Orange.network.GraphLayout() 
     122#        self.layout = Orange.network.GraphLayout() 
    123123        self.graph = None 
    124124        self.graph_base = None 
     
    424424         
    425425    def drawForce(self): 
    426         if self.btnForce.isChecked() and self.graph is not None: 
    427             self.networkCanvas.forceVectors = self.layout._computeForces()  
    428         else: 
    429             self.networkCanvas.forceVectors = None 
    430              
    431         self.networkCanvas.updateCanvas() 
     426#        if self.btnForce.isChecked() and self.graph is not None: 
     427#            self.networkCanvas.forceVectors = self.layout._computeForces()  
     428#        else: 
     429#            self.networkCanvas.forceVectors = None 
     430#             
     431#        self.networkCanvas.updateCanvas() 
     432        pass 
    432433         
    433434    def rotateProgress(self, curr, max): 
     
    436437         
    437438    def rotateComponentsMDS(self): 
    438         print "rotate" 
    439         if self.items_matrix is None: 
    440             self.information('Set distance matrix to input signal') 
    441             self.btnRotateMDS.setChecked(False) 
    442             return 
    443          
    444         if self.graph is None: 
    445             self.information('No network found') 
    446             self.btnRotateMDS.setChecked(False) 
    447             return 
    448         if self.items_matrix.dim != self.graph.number_of_nodes(): 
    449             self.error('Distance matrix dimensionality must equal number of vertices') 
    450             self.btnRotateMDS.setChecked(False) 
    451             return 
    452          
    453         if not self.btnRotateMDS.isChecked(): 
    454           self.layout.stopMDS = 1 
    455           #self.btnMDS.setChecked(False) 
    456           #self.btnMDS.setText("MDS on graph components") 
    457           return 
    458          
    459         self.btnRotateMDS.setText("Stop") 
    460         qApp.processEvents() 
    461          
    462         self.layout.items_matrix = self.items_matrix 
    463         self.progressBarInit() 
    464          
    465         self.layout.mds_components(self.mdsSteps, self.mdsRefresh, self.mdsProgress, self.updateCanvas, self.mdsTorgerson, self.mdsStressDelta, rotationOnly=True, mdsFromCurrentPos=self.mdsFromCurrentPos)             
    466              
    467         self.btnRotateMDS.setChecked(False) 
    468         self.btnRotateMDS.setText("Rotate graph components (MDS)") 
    469         self.progressBarFinished() 
     439#        print "rotate" 
     440#        if self.items_matrix is None: 
     441#            self.information('Set distance matrix to input signal') 
     442#            self.btnRotateMDS.setChecked(False) 
     443#            return 
     444#         
     445#        if self.graph is None: 
     446#            self.information('No network found') 
     447#            self.btnRotateMDS.setChecked(False) 
     448#            return 
     449#        if self.items_matrix.dim != self.graph.number_of_nodes(): 
     450#            self.error('Distance matrix dimensionality must equal number of vertices') 
     451#            self.btnRotateMDS.setChecked(False) 
     452#            return 
     453#         
     454#        if not self.btnRotateMDS.isChecked(): 
     455#          self.layout.stopMDS = 1 
     456#          #self.btnMDS.setChecked(False) 
     457#          #self.btnMDS.setText("MDS on graph components") 
     458#          return 
     459#         
     460#        self.btnRotateMDS.setText("Stop") 
     461#        qApp.processEvents() 
     462#         
     463#        self.layout.items_matrix = self.items_matrix 
     464#        self.progressBarInit() 
     465#         
     466#        self.layout.mds_components(self.mdsSteps, self.mdsRefresh, self.mdsProgress, self.updateCanvas, self.mdsTorgerson, self.mdsStressDelta, rotationOnly=True, mdsFromCurrentPos=self.mdsFromCurrentPos)             
     467#             
     468#        self.btnRotateMDS.setChecked(False) 
     469#        self.btnRotateMDS.setText("Rotate graph components (MDS)") 
     470#        self.progressBarFinished() 
     471        pass 
    470472     
    471473    def rotateComponents(self): 
    472         if self.items_matrix is None: 
    473             self.information('Set distance matrix to input signal') 
    474             self.btnRotate.setChecked(False) 
    475             return 
    476          
    477         if self.graph is None: 
    478             self.information('No network found') 
    479             self.btnRotate.setChecked(False) 
    480             return 
    481          
    482         if self.items_matrix.dim != self.graph.number_of_nodes(): 
    483             self.error('Distance matrix dimensionality must equal number of vertices') 
    484             self.btnRotate.setChecked(False) 
    485             return 
    486          
    487         if not self.btnRotate.isChecked(): 
    488           self.layout.stopRotate = 1 
    489           return 
    490        
    491         self.btnRotate.setText("Stop") 
    492         qApp.processEvents() 
    493          
    494         self.layout.items_matrix = self.items_matrix 
    495         self.progressBarInit() 
    496         self.layout.rotateComponents(self.rotateSteps, 0.0001, self.rotateProgress, self.updateCanvas) 
    497         self.btnRotate.setChecked(False) 
    498         self.btnRotate.setText("Rotate graph components") 
    499         self.progressBarFinished() 
     474#        if self.items_matrix is None: 
     475#            self.information('Set distance matrix to input signal') 
     476#            self.btnRotate.setChecked(False) 
     477#            return 
     478#         
     479#        if self.graph is None: 
     480#            self.information('No network found') 
     481#            self.btnRotate.setChecked(False) 
     482#            return 
     483#         
     484#        if self.items_matrix.dim != self.graph.number_of_nodes(): 
     485#            self.error('Distance matrix dimensionality must equal number of vertices') 
     486#            self.btnRotate.setChecked(False) 
     487#            return 
     488#         
     489#        if not self.btnRotate.isChecked(): 
     490#          self.layout.stopRotate = 1 
     491#          return 
     492#       
     493#        self.btnRotate.setText("Stop") 
     494#        qApp.processEvents() 
     495#         
     496#        self.layout.items_matrix = self.items_matrix 
     497#        self.progressBarInit() 
     498#        self.layout.rotateComponents(self.rotateSteps, 0.0001, self.rotateProgress, self.updateCanvas) 
     499#        self.btnRotate.setChecked(False) 
     500#        self.btnRotate.setText("Rotate graph components") 
     501#        self.progressBarFinished() 
     502        pass 
    500503         
    501504    def mdsProgress(self, avgStress, stepCount):     
     
    508511         
    509512    def mds_components(self, mdsType=Orange.network.MdsType.componentMDS): 
    510         if mdsType == Orange.network.MdsType.componentMDS: 
    511             btn = self.btnMDS 
    512         elif mdsType == Orange.network.MdsType.exactSimulation: 
    513             btn = self.btnESIM 
    514         elif mdsType == Orange.network.MdsType.MDS: 
    515             btn = self.btnMDSv 
    516          
    517         btnCaption = btn.text() 
    518          
    519         if self.items_matrix is None: 
    520             self.information('Set distance matrix to input signal') 
    521             btn.setChecked(False) 
    522             return 
    523          
    524         if self.layout is None: 
    525             self.information('No network found') 
    526             btn.setChecked(False) 
    527             return 
    528          
    529         if self.items_matrix.dim != self.graph.number_of_nodes(): 
    530             self.error('Distance matrix dimensionality must equal number of vertices') 
    531             btn.setChecked(False) 
    532             return 
    533          
    534         if not btn.isChecked(): 
    535             self.layout.stopMDS = 1 
    536             btn.setChecked(False) 
    537             btn.setText(btnCaption) 
    538             return 
    539          
    540         btn.setText("Stop") 
    541         qApp.processEvents() 
    542          
    543         self.layout.items_matrix = self.items_matrix 
    544         self.progressBarInit() 
    545          
    546         if self.mdsAvgLinkage: 
    547             self.layout.mds_components_avg_linkage(self.mdsSteps, self.mdsRefresh, self.mdsProgress, self.networkCanvas.updateCanvas, self.mdsTorgerson, self.mdsStressDelta, scalingRatio = self.scalingRatio, mdsFromCurrentPos=self.mdsFromCurrentPos) 
    548         else: 
    549             self.layout.mds_components(self.mdsSteps, self.mdsRefresh, self.mdsProgress, self.networkCanvas.updateCanvas, self.mdsTorgerson, self.mdsStressDelta, mdsType=mdsType, scalingRatio=self.scalingRatio, mdsFromCurrentPos=self.mdsFromCurrentPos)             
    550          
    551         btn.setChecked(False) 
    552         btn.setText(btnCaption) 
    553         self.progressBarFinished() 
    554          
     513#        if mdsType == Orange.network.MdsType.componentMDS: 
     514#            btn = self.btnMDS 
     515#        elif mdsType == Orange.network.MdsType.exactSimulation: 
     516#            btn = self.btnESIM 
     517#        elif mdsType == Orange.network.MdsType.MDS: 
     518#            btn = self.btnMDSv 
     519#         
     520#        btnCaption = btn.text() 
     521#         
     522#        if self.items_matrix is None: 
     523#            self.information('Set distance matrix to input signal') 
     524#            btn.setChecked(False) 
     525#            return 
     526#         
     527#        if self.layout is None: 
     528#            self.information('No network found') 
     529#            btn.setChecked(False) 
     530#            return 
     531#         
     532#        if self.items_matrix.dim != self.graph.number_of_nodes(): 
     533#            self.error('Distance matrix dimensionality must equal number of vertices') 
     534#            btn.setChecked(False) 
     535#            return 
     536#         
     537#        if not btn.isChecked(): 
     538#            self.layout.stopMDS = 1 
     539#            btn.setChecked(False) 
     540#            btn.setText(btnCaption) 
     541#            return 
     542#         
     543#        btn.setText("Stop") 
     544#        qApp.processEvents() 
     545#         
     546#        self.layout.items_matrix = self.items_matrix 
     547#        self.progressBarInit() 
     548#         
     549#        if self.mdsAvgLinkage: 
     550#            self.layout.mds_components_avg_linkage(self.mdsSteps, self.mdsRefresh, self.mdsProgress, self.networkCanvas.updateCanvas, self.mdsTorgerson, self.mdsStressDelta, scalingRatio = self.scalingRatio, mdsFromCurrentPos=self.mdsFromCurrentPos) 
     551#        else: 
     552#            self.layout.mds_components(self.mdsSteps, self.mdsRefresh, self.mdsProgress, self.networkCanvas.updateCanvas, self.mdsTorgerson, self.mdsStressDelta, mdsType=mdsType, scalingRatio=self.scalingRatio, mdsFromCurrentPos=self.mdsFromCurrentPos)             
     553#         
     554#        btn.setChecked(False) 
     555#        btn.setText(btnCaption) 
     556#        self.progressBarFinished() 
     557        pass 
     558     
    555559    def set_items_distance_matrix(self, matrix): 
    556         self.error('') 
    557         self.information('') 
    558         self.showDistancesCheckBox.setEnabled(0) 
    559          
    560         if matrix is None or self.graph is None: 
    561             self.items_matrix = None 
    562             self.layout.items_matrix = None 
    563             if self.networkCanvas: self.networkCanvas.items_matrix = None 
    564             return 
    565  
    566         if matrix.dim != self.graph.number_of_nodes(): 
    567             self.error('Distance matrix dimensionality must equal number of vertices') 
    568             self.items_matrix = None 
    569             self.layout.items_matrix = None 
    570             if self.networkCanvas: self.networkCanvas.items_matrix = None 
    571             return 
    572          
    573         self.items_matrix = matrix 
    574         self.layout.items_matrix = matrix 
    575         if self.networkCanvas: self.networkCanvas.items_matrix = matrix 
    576         self.showDistancesCheckBox.setEnabled(1) 
    577          
    578         self.networkCanvas.updateCanvas() 
    579              
     560#        self.error('') 
     561#        self.information('') 
     562#        self.showDistancesCheckBox.setEnabled(0) 
     563#         
     564#        if matrix is None or self.graph is None: 
     565#            self.items_matrix = None 
     566#            self.layout.items_matrix = None 
     567#            if self.networkCanvas: self.networkCanvas.items_matrix = None 
     568#            return 
     569# 
     570#        if matrix.dim != self.graph.number_of_nodes(): 
     571#            self.error('Distance matrix dimensionality must equal number of vertices') 
     572#            self.items_matrix = None 
     573#            self.layout.items_matrix = None 
     574#            if self.networkCanvas: self.networkCanvas.items_matrix = None 
     575#            return 
     576#         
     577#        self.items_matrix = matrix 
     578#        self.layout.items_matrix = matrix 
     579#        if self.networkCanvas: self.networkCanvas.items_matrix = matrix 
     580#        self.showDistancesCheckBox.setEnabled(1) 
     581#         
     582#        self.networkCanvas.updateCanvas() 
     583        pass 
     584     
    580585    def setSendMarkedNodes(self): 
    581586        if self.checkSendMarkedNodes: 
     
    10801085         
    10811086    def save_network(self): 
    1082         if self.networkCanvas is None or self.graph is None: 
    1083             return 
    1084          
    1085         filename = QFileDialog.getSaveFileName(self, 'Save Network File', '', 'NetworkX graph as Python pickle (*.gpickle)\nPajek network (*.net)\nGML network (*.gml)') 
    1086         if filename: 
    1087             fn = "" 
    1088             head, tail = os.path.splitext(str(filename)) 
    1089             if not tail: 
    1090                 fn = head + ".net" 
    1091             else: 
    1092                 fn = str(filename) 
    1093              
    1094             for i in range(self.graph.number_of_nodes()): 
    1095                 node = self.graph.node[i] 
    1096                 node['x'] = self.layout.coors[0][i] 
    1097                 node['y'] = self.layout.coors[1][i] 
    1098  
    1099             Orange.network.readwrite.write(self.graph, fn) 
     1087#        if self.networkCanvas is None or self.graph is None: 
     1088#            return 
     1089#         
     1090#        filename = QFileDialog.getSaveFileName(self, 'Save Network File', '', 'NetworkX graph as Python pickle (*.gpickle)\nPajek network (*.net)\nGML network (*.gml)') 
     1091#        if filename: 
     1092#            fn = "" 
     1093#            head, tail = os.path.splitext(str(filename)) 
     1094#            if not tail: 
     1095#                fn = head + ".net" 
     1096#            else: 
     1097#                fn = str(filename) 
     1098#             
     1099#            for i in range(self.graph.number_of_nodes()): 
     1100#                node = self.graph.node[i] 
     1101#                node['x'] = self.layout.coors[0][i] 
     1102#                node['y'] = self.layout.coors[1][i] 
     1103# 
     1104#            Orange.network.readwrite.write(self.graph, fn) 
     1105        pass 
     1106     
    11001107             
    11011108    def sendData(self): 
     
    12331240        self.networkCanvas.networkCurve.coors.update((node, (0,0)) for node in add_nodes) 
    12341241        positions = [self.networkCanvas.networkCurve.coors[key] for key in sorted(self.networkCanvas.networkCurve.coors.iterkeys())] 
    1235         self.layout.set_graph(newgraph, positions) 
     1242#        self.layout.set_graph(newgraph, positions) 
    12361243         
    12371244        self.graph = newgraph 
     
    12641271        nodes = self.graph.number_of_nodes() 
    12651272        t = k * nodes * nodes 
    1266         self.frSteps = 10 #int(5.0 / t) 
     1273        self.frSteps = int(5.0 / t) 
    12671274        if self.frSteps <   1: self.frSteps = 1; 
    1268         if self.frSteps > 3000: self.frSteps = 3000; 
     1275        if self.frSteps > 10000: self.frSteps = 10000; 
    12691276         
    12701277        if self.frSteps < 10: 
     
    12941301            self.graph = None 
    12951302            self.graph_base = None 
    1296             self.layout.set_graph(None) 
     1303#            self.layout.set_graph(None) 
    12971304            self.networkCanvas.set_graph_layout(None, None) 
    12981305            self.clearCombos() 
     
    13121319        self.graph = graph 
    13131320         
    1314         if self._items is not None and 'x' in self._items.domain and 'y' in self._items.domain: 
    1315             positions = [(self._items[node]['x'].value, self._items[node]['y'].value) \ 
    1316                          for node in sorted(self.graph) if self._items[node]['x'].value != '?' \ 
    1317                          and self._items[node]['y'].value != '?'] 
    1318             self.layout.set_graph(self.graph, positions) 
    1319         else: 
    1320             self.layout.set_graph(self.graph) 
     1321#        if self._items is not None and 'x' in self._items.domain and 'y' in self._items.domain: 
     1322#            positions = [(self._items[node]['x'].value, self._items[node]['y'].value) \ 
     1323#                         for node in sorted(self.graph) if self._items[node]['x'].value != '?' \ 
     1324#                         and self._items[node]['y'].value != '?'] 
     1325#            self.layout.set_graph(self.graph, positions) 
     1326#        else: 
     1327#            self.layout.set_graph(self.graph) 
    13211328         
    13221329        self.number_of_nodes_label = self.graph.number_of_nodes() 
     
    13751382        nodes = self.graph.number_of_nodes() 
    13761383        t = k * nodes * nodes 
    1377         self.frSteps = 10 #int(5.0 / t) 
     1384        self.frSteps = int(5.0 / t) 
    13781385        if self.frSteps <   1: self.frSteps = 1; 
    1379         if self.frSteps > 3000: self.frSteps = 3000; 
     1386        if self.frSteps > 10000: self.frSteps = 10000; 
    13801387         
    13811388        self.networkCanvas.labelsOnMarkedOnly = self.labelsOnMarkedOnly 
     
    15691576            self.graph_layout_fr_radial() 
    15701577        elif self.optMethod == 5: 
    1571             self.layout.circular_crossing_reduction() 
     1578#            self.layout.circular_crossing_reduction() 
     1579            pass 
    15721580        elif self.optMethod == 6: 
    1573             self.layout.circular_original() 
     1581#            self.layout.circular_original() 
     1582            pass 
    15741583        elif self.optMethod == 7: 
    1575             self.layout.circular_random() 
     1584#            self.layout.circular_random() 
     1585            pass 
    15761586        elif self.optMethod == 8: 
    1577             self.graph_layout_pivot_mds() 
     1587#            self.graph_layout_pivot_mds() 
     1588            pass 
    15781589             
    15791590        self.optButton.setChecked(False) 
    1580         self.networkCanvas.networkCurve.coors = self.layout.map_to_graph(self.graph)  
     1591#        self.networkCanvas.networkCurve.coors = self.layout.map_to_graph(self.graph)  
    15811592        self.networkCanvas.updateCanvas() 
    15821593        qApp.processEvents() 
     
    16761687            return 
    16771688         
    1678         steps = 100 
    1679         initTemp = 1000 
    1680         coolFactor = math.exp(math.log(10.0/10000.0) / steps) 
    1681         oldXY = [(self.layout.coors[0][i], self.layout.coors[1][i]) for i in range(self.graph.number_of_nodes())] 
    1682         #print oldXY 
    1683         initTemp = self.layout.fr(steps, initTemp, coolFactor) 
    1684         #print oldXY 
    1685         self.networkCanvas.updateDataSpecial(oldXY) 
    1686         self.networkCanvas.replot() 
     1689#        steps = 100 
     1690#        initTemp = 1000 
     1691#        coolFactor = math.exp(math.log(10.0/10000.0) / steps) 
     1692#        oldXY = [(self.layout.coors[0][i], self.layout.coors[1][i]) for i in range(self.graph.number_of_nodes())] 
     1693#        #print oldXY 
     1694#        initTemp = self.layout.fr(steps, initTemp, coolFactor) 
     1695#        #print oldXY 
     1696#        self.networkCanvas.updateDataSpecial(oldXY) 
     1697#        self.networkCanvas.replot() 
    16871698                 
    16881699    def graph_layout_fr_radial(self): 
     
    16901701            return 
    16911702         
    1692         #print "F-R Radial" 
    1693         k = 1.13850193174e-008 
    1694         nodes = self.graph.number_of_nodes() 
    1695         t = k * nodes * nodes 
    1696         refreshRate = int(5.0 / t) 
    1697         if refreshRate <    1: refreshRate = 1; 
    1698         if refreshRate > 1500: refreshRate = 1500; 
    1699         #print "refreshRate: " + str(refreshRate) 
    1700          
    1701         tolerance = 5 
    1702         initTemp = 100 
    1703         centerNdx = 0 
    1704          
    1705         selection = self.networkCanvas.getSelection() 
    1706         if len(selection) > 0: 
    1707             centerNdx = selection[0] 
    1708              
    1709         #print "center ndx: " + str(centerNdx) 
    1710         initTemp = self.layout.fr_radial(centerNdx, refreshRate, initTemp) 
    1711         self.networkCanvas.circles = [10000 / 12, 10000/12*2, 10000/12*3]#, 10000/12*4, 10000/12*5] 
    1712         #self.networkCanvas.circles = [100, 200, 300] 
    1713         self.networkCanvas.updateCanvas() 
    1714         self.networkCanvas.circles = [] 
     1703#        #print "F-R Radial" 
     1704#        k = 1.13850193174e-008 
     1705#        nodes = self.graph.number_of_nodes() 
     1706#        t = k * nodes * nodes 
     1707#        refreshRate = int(5.0 / t) 
     1708#        if refreshRate <    1: refreshRate = 1; 
     1709#        if refreshRate > 1500: refreshRate = 1500; 
     1710#        #print "refreshRate: " + str(refreshRate) 
     1711#         
     1712#        tolerance = 5 
     1713#        initTemp = 100 
     1714#        centerNdx = 0 
     1715#         
     1716#        selection = self.networkCanvas.getSelection() 
     1717#        if len(selection) > 0: 
     1718#            centerNdx = selection[0] 
     1719#             
     1720#        #print "center ndx: " + str(centerNdx) 
     1721#        initTemp = self.layout.fr_radial(centerNdx, refreshRate, initTemp) 
     1722#        self.networkCanvas.circles = [10000 / 12, 10000/12*2, 10000/12*3]#, 10000/12*4, 10000/12*5] 
     1723#        #self.networkCanvas.circles = [100, 200, 300] 
     1724#        self.networkCanvas.updateCanvas() 
     1725#        self.networkCanvas.circles = [] 
    17151726             
    17161727    def graph_layout_pivot_mds(self): 
    17171728        self.information() 
    17181729         
    1719         if self.items_matrix is None: 
    1720             self.information('Set distance matrix to input signal') 
    1721             return 
    1722          
    1723         if self.graph is None: 
    1724             self.information('No network found') 
    1725             return 
    1726          
    1727         if self.items_matrix.dim != self.graph.number_of_nodes(): 
    1728             self.error('Distance matrix dimensionality must equal number of vertices') 
    1729             return 
    1730          
    1731         self.frSteps = min(self.frSteps, self.items_matrix.dim) 
    1732         qApp.processEvents() 
    1733         mds = orngMDS.PivotMDS(self.items_matrix, self.frSteps) 
    1734         x,y = mds.optimize() 
    1735         self.layout.coors[0] = x 
    1736         self.layout.coors[1] = y 
    1737         self.networkCanvas.updateCanvas() 
     1730#        if self.items_matrix is None: 
     1731#            self.information('Set distance matrix to input signal') 
     1732#            return 
     1733#         
     1734#        if self.graph is None: 
     1735#            self.information('No network found') 
     1736#            return 
     1737#         
     1738#        if self.items_matrix.dim != self.graph.number_of_nodes(): 
     1739#            self.error('Distance matrix dimensionality must equal number of vertices') 
     1740#            return 
     1741#         
     1742#        self.frSteps = min(self.frSteps, self.items_matrix.dim) 
     1743#        qApp.processEvents() 
     1744#        mds = orngMDS.PivotMDS(self.items_matrix, self.frSteps) 
     1745#        x,y = mds.optimize() 
     1746#        self.layout.coors[0] = x 
     1747#        self.layout.coors[1] = y 
     1748#        self.networkCanvas.updateCanvas() 
    17381749     
    17391750       
Note: See TracChangeset for help on using the changeset viewer.