Changeset 8840:794c2150500e in orange


Ignore:
Timestamp:
08/30/11 09:36:46 (3 years ago)
Author:
miha <miha.stajdohar@…>
Branch:
default
Convert:
98d597ddb5a29bdbd716be1378398ad84030336f
Message:

Added FragViz.

Location:
orange/OrangeWidgets/Visualize Qt
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • orange/OrangeWidgets/Visualize Qt/OWNxCanvasQt.py

    r8173 r8840  
    3737        self.name = "Network Curve" 
    3838         
    39     def fr(self, steps, weighted=False, smooth_cooling=False): 
     39    def layout_fr(self, steps, weighted=False, smooth_cooling=False): 
    4040        orangeqt.NetworkCurve.fr(self, steps, weighted, smooth_cooling) 
    4141       
    4242    def set_node_sizes(self, values={}, min_size=0, max_size=0): 
    4343        orangeqt.NetworkCurve.set_node_sizes(self, values, min_size, max_size) 
     44     
     45    def mds_callback(self, a, b, mds, mdsRefresh, components, progress_callback): 
     46        """Refresh the UI when running  MDS on network components.""" 
     47         
     48        if not self.mdsStep % mdsRefresh: 
     49            rotationOnly = False 
     50            component_props = [] 
     51            x_mds = [] 
     52            y_mds = [] 
     53            phi = [None] * len(components) 
     54            nodes = self.nodes() 
     55             
     56            for i, component in enumerate(components):     
     57                 
     58                if len(mds.points) == len(components):  # if average linkage before 
     59                    x_avg_mds = mds.points[i][0] 
     60                    y_avg_mds = mds.points[i][1] 
     61                else:                                   # if not average linkage before 
     62                    x = [mds.points[u][0] for u in component] 
     63                    y = [mds.points[u][1] for u in component] 
     64             
     65                    x_avg_mds = sum(x) / len(x)  
     66                    y_avg_mds = sum(y) / len(y) 
     67                    # compute rotation angle 
     68#                    c = [numpy.linalg.norm(numpy.cross(mds.points[u], \ 
     69#                                [nodes[u].x(), nodes[u].y()])) for u in component] 
     70#                     
     71#                    n = [numpy.vdot([nodes[u].x(), nodes[u].y()], \ 
     72#                                    [nodes[u].x(), nodes[u].y()]) for u in component] 
     73#                    phi[i] = sum(c) / sum(n) 
     74                     
     75                 
     76                x = [nodes[i].x() for i in component] 
     77                y = [nodes[i].y() for i in component] 
     78                 
     79                x_avg_graph = sum(x) / len(x) 
     80                y_avg_graph = sum(y) / len(y) 
     81                 
     82                x_mds.append(x_avg_mds)  
     83                y_mds.append(y_avg_mds) 
     84     
     85                component_props.append((x_avg_graph, y_avg_graph, \ 
     86                                        x_avg_mds, y_avg_mds, phi)) 
     87 
     88            for i, component in enumerate(components): 
     89                x_avg_graph, y_avg_graph, x_avg_mds, \ 
     90                y_avg_mds, phi = component_props[i] 
     91                 
     92    #            if phi[i]:  # rotate vertices 
     93    #                #print "rotate", i, phi[i] 
     94    #                r = numpy.array([[numpy.cos(phi[i]), -numpy.sin(phi[i])], [numpy.sin(phi[i]), numpy.cos(phi[i])]])  #rotation matrix 
     95    #                c = [x_avg_graph, y_avg_graph]  # center of mass in FR coordinate system 
     96    #                v = [numpy.dot(numpy.array([self.graph.coors[0][u], self.graph.coors[1][u]]) - c, r) + c for u in component] 
     97    #                self.graph.coors[0][component] = [u[0] for u in v] 
     98    #                self.graph.coors[1][component] = [u[1] for u in v] 
     99                     
     100                # translate vertices 
     101                if not rotationOnly: 
     102                    self.set_node_coordinates(dict( 
     103                       (i, ((nodes[i].x() - x_avg_graph) + x_avg_mds,   
     104                            (nodes[i].y() - y_avg_graph) + y_avg_mds)) \ 
     105                                  for i in component)) 
     106                     
     107            #if self.mdsType == MdsType.exactSimulation: 
     108            #    self.mds.points = [[self.graph.coors[0][i], \ 
     109            #                        self.graph.coors[1][i]] \ 
     110            #                        for i in range(len(self.graph.coors))] 
     111            #    self.mds.freshD = 0 
     112             
     113            #self.update_properties() 
     114            self.plot().replot() 
     115            qApp.processEvents() 
     116             
     117            if progress_callback is not None: 
     118                progress_callback(a, self.mdsStep)  
     119             
     120        self.mdsStep += 1 
     121        return 0 if self.stopMDS else 1 
     122             
     123    def layout_fragviz(self, steps, distances, graph, progress_callback=None, opt_from_curr=False): 
     124        """Position the network components according to similarities among  
     125        them. 
     126         
     127        """ 
     128 
     129        if distances == None or graph == None or distances.dim != graph.number_of_nodes(): 
     130            self.information('invalid or no distance matrix') 
     131            return 1 
     132         
     133        p = self.plot() 
     134        edges = self.edges() 
     135        nodes = self.nodes() 
     136         
     137        avgLinkage = True 
     138        rotationOnly = False 
     139        minStressDelta = 0 
     140        mdsRefresh = int(steps / 20) 
     141         
     142        self.mdsStep = 1 
     143        self.stopMDS = False 
     144         
     145        components = Orange.network.nx.algorithms.components.connected.connected_components(graph) 
     146        distances.matrixType = Orange.core.SymMatrix.Symmetric 
     147         
     148        # scale net coordinates 
     149        if avgLinkage: 
     150            distances = distances.avgLinkage(components) 
     151             
     152        mds = Orange.projection.mds.MDS(distances) 
     153        mds.optimize(10, Orange.projection.mds.SgnRelStress, 0) 
     154        rect = self.data_rect() 
     155        w_fr = rect.width() 
     156        h_fr = rect.height() 
     157        d_fr = math.sqrt(w_fr**2 + h_fr**2) 
    44158       
     159        x_mds = [mds.points[u][0] for u in range(len(mds.points))] 
     160        y_mds = [mds.points[u][1] for u in range(len(mds.points))] 
     161        w_mds = max(x_mds) - min(x_mds) 
     162        h_mds = max(y_mds) - min(y_mds) 
     163        d_mds = math.sqrt(w_mds**2 + h_mds**2) 
     164         
     165        animate_points = p.animate_points 
     166        p.animate_points = False 
     167         
     168        self.set_node_coordinates(dict( 
     169           (n, (nodes[n].x()*d_mds/d_fr, nodes[n].y()*d_mds/d_fr)) for n in nodes)) 
     170         
     171        #self.update_properties() 
     172        p.replot() 
     173        qApp.processEvents() 
     174                      
     175        if opt_from_curr: 
     176            if avgLinkage: 
     177                for u, c in enumerate(components): 
     178                    x = sum([nodes[n].x() for n in c]) / len(c) 
     179                    y = sum([nodes[n].y() for n in c]) / len(c) 
     180                    mds.points[u][0] = x 
     181                    mds.points[u][1] = y 
     182            else: 
     183                for i,u in enumerate(nodes): 
     184                    mds.points[i][0] = u.x() 
     185                    mds.points[i][1] = u.y() 
     186        else: 
     187            mds.Torgerson()  
     188 
     189        mds.optimize(steps, Orange.projection.mds.SgnRelStress, minStressDelta,  
     190                     progressCallback= 
     191                         lambda a,  
     192                                b=None,  
     193                                mds=mds, 
     194                                mdsRefresh=mdsRefresh, 
     195                                components=components, 
     196                                progress_callback=progress_callback:  
     197                                    self.mds_callback(a, b, mds, mdsRefresh, components, progress_callback)) 
     198         
     199        self.mds_callback(mds.avgStress, 0, mds, mdsRefresh, components, progress_callback) 
     200         
     201        if progress_callback != None: 
     202            progress_callback(mds.avgStress, self.mdsStep) 
     203         
     204        p.animate_points = animate_points 
     205        return 0 
     206     
    45207#    def move_selected_nodes(self, dx, dy): 
    46208#        selected = self.get_selected_nodes() 
     
    86248        self.show_indices = False 
    87249        self.show_weights = False 
     250        self.trim_label_words = 0 
    88251         
    89252        self.showComponentAttribute = None 
     
    271434            indices = [[str(u)] for u in nodes] 
    272435             
    273         self.networkCurve.set_node_labels(dict((node, ', '.join(indices[i] + \ 
     436        if self.trim_label_words > 0: 
     437            self.networkCurve.set_node_labels(dict((node,  
     438                ', '.join(indices[i] +  
     439                          [' '.join(str(self.items[node][att]).split(' ')[:min(self.trim_label_words,len(str(self.items[node][att]).split(' ')))]) 
     440                for att in label_attributes])) for i, node in enumerate(nodes))) 
     441        else: 
     442            self.networkCurve.set_node_labels(dict((node, ', '.join(indices[i]+\ 
    274443                           [str(self.items[node][att]) for att in \ 
    275444                           label_attributes])) for i, node in enumerate(nodes))) 
  • orange/OrangeWidgets/Visualize Qt/OWNxExplorerQt.py

    r8173 r8840  
    11""" 
    2 <name>Nx Explorer (Qt)</name> 
     2<name>Net Explorer (Qt)</name> 
    33<description>Orange widget for network exploration.</description> 
    44<icon>icons/Network.png</icon> 
     
    4242    "mdsSteps", "mdsRefresh", "mdsStressDelta", "organism","showTextMiningInfo",  
    4343    "toolbarSelection", "minComponentEdgeWidth", "maxComponentEdgeWidth", 
    44     "mdsFromCurrentPos", "labelsOnMarkedOnly", "tabIndex"]  
     44    "mdsFromCurrentPos", "labelsOnMarkedOnly", "tabIndex",  
     45    "networkCanvas.trim_label_words", "opt_from_curr"]  
    4546     
    46     def __init__(self, parent=None, signalManager=None, name = 'Nx Explorer (qt)',  
     47    def __init__(self, parent=None, signalManager=None, name = 'Net Explorer (qt)',  
    4748                 NetworkCanvas=OWNxCanvas): 
    4849        OWWidget.__init__(self, parent, signalManager, name) 
     
    119120        self.number_of_nodes_label = -1 
    120121        self.number_of_edges_label = -1 
     122        self.opt_from_curr = False 
    121123         
    122124        self.loadSettings() 
    123125         
    124126        self._network_view = None 
    125 #        self.layout = Orange.network.GraphLayout() 
    126127        self.graph = None 
    127128        self.graph_base = None 
    128129        self.markInputItems = None 
     130         
     131        # if optimization method is set to FragViz, set it to FR 
     132        if self.optMethod == 9: 
     133            self.optMethod = 3 
    129134         
    130135        self.mainArea.layout().setContentsMargins(0,4,4,4) 
     
    145150        self.infoTab = OWGUI.createTabPage(self.tabs, "Info") 
    146151        self.performanceTab = OWGUI.createTabPage(self.tabs, "Performance") 
    147         #self.editTab = OWGUI.createTabPage(self.tabs, "Edit") 
    148152         
    149153        self.tabs.setCurrentIndex(self.tabIndex) 
     
    162166        self.optCombo.addItem("Circular Random") 
    163167        self.optCombo.addItem("Pivot MDS") 
     168        self.optCombo.addItem("FragViz") 
     169        self.optCombo.addItem("MDS") 
    164170        self.optCombo.setCurrentIndex(self.optMethod) 
    165171        self.stepsSpin = OWGUI.spin(self.optimizeBox, self, "frSteps", 1, 100000, 1, label="Iterations: ") 
     172        self.cb_opt_from_curr = OWGUI.checkBox(self.optimizeBox, self, "opt_from_curr", label="Optimize from current positions") 
     173        self.cb_opt_from_curr.setEnabled(False) 
    166174        self.stepsSpin.setEnabled(False) 
    167175         
     
    185193        hb = OWGUI.widgetBox(ib, orientation="horizontal", addSpace = False) 
    186194        self.attListBox = OWGUI.listBox(hb, self, "markerAttributes", "attributes", selectionMode=QListWidget.MultiSelection, callback=self.clickedAttLstBox) 
    187         self.tooltipListBox = OWGUI.listBox(hb, self, "tooltipAttributes", "attributes", selectionMode=QListWidget.MultiSelection, callback=self.clickedTooltipLstBox) 
     195        self.tooltipListBox = OWGUI.listBox(hb, self, "tooltipAttributes", "attributes", selectionMode=QListWidget.MultiSelection, callback=self.clickedTooltipLstBox)         
     196        OWGUI.spin(ib, self, "networkCanvas.trim_label_words", 0, 5, 1, label='Trim label words to', callback=self.clickedAttLstBox) 
    188197         
    189198        ib = OWGUI.widgetBox(self.edgesTab, "General", orientation="vertical") 
     
    275284         
    276285        #OWGUI.button(self.edgesTab, self, "Clustering", callback=self.clustering) 
     286        ib = OWGUI.widgetBox(self.infoTab, "Edit") 
     287        self.editAttribute = 0 
     288        self.editCombo = OWGUI.comboBox(ib, self, "editAttribute", label="Edit attribute:", orientation="horizontal") 
     289        self.editCombo.addItem("Select attribute") 
     290        self.editValue = '' 
     291        hb = OWGUI.widgetBox(ib, orientation="horizontal") 
     292        OWGUI.lineEdit(hb, self, "editValue", "Value:", orientation='horizontal') 
     293        OWGUI.button(hb, self, "Set", callback=self.edit) 
    277294         
    278295        ib = OWGUI.widgetBox(self.infoTab, "Prototype") 
    279         ib.setVisible(False) 
     296        ib.setVisible(True) 
    280297        #ib = OWGUI.widgetBox(ibProto, "Name components") 
    281298        OWGUI.lineEdit(ib, self, "organism", "Organism:", orientation='horizontal') 
     
    291308         
    292309        #ib = OWGUI.widgetBox(ibProto, "Distance Matrix") 
    293         ibs = OWGUI.widgetBox(ib, orientation="horizontal") 
    294         self.btnMDS = OWGUI.button(ibs, self, "Fragviz", callback=self.mds_components, toggleButton=1) 
    295         self.btnESIM = OWGUI.button(ibs, self, "eSim", callback=(lambda: self.mds_components(Orange.network.MdsType.exactSimulation)), toggleButton=1) 
    296         self.btnMDSv = OWGUI.button(ibs, self, "MDS", callback=(lambda: self.mds_components(Orange.network.MdsType.MDS)), toggleButton=1) 
    297         ibs = OWGUI.widgetBox(ib, orientation="horizontal") 
    298         self.btnRotate = OWGUI.button(ibs, self, "Rotate", callback=self.rotateComponents, toggleButton=1) 
    299         self.btnRotateMDS = OWGUI.button(ibs, self, "Rotate (MDS)", callback=self.rotateComponentsMDS, toggleButton=1) 
    300         self.btnForce = OWGUI.button(ibs, self, "Draw Force", callback=self.drawForce, toggleButton=1) 
    301         self.scalingRatio = 0 
    302         OWGUI.spin(ib, self, "scalingRatio", 0, 9, 1, label="Set scalingRatio: ") 
    303         OWGUI.doubleSpin(ib, self, "mdsStressDelta", 0, 10, 0.0000000000000001, label="Min stress change: ") 
    304         OWGUI.spin(ib, self, "mdsSteps", 1, 100000, 1, label="MDS steps: ") 
    305         OWGUI.spin(ib, self, "mdsRefresh", 1, 100000, 1, label="MDS refresh steps: ") 
    306         ibs = OWGUI.widgetBox(ib, orientation="horizontal") 
    307         OWGUI.checkBox(ibs, self, 'mdsTorgerson', "Torgerson's approximation") 
    308         OWGUI.checkBox(ibs, self, 'mdsAvgLinkage', "Use average linkage") 
    309         OWGUI.checkBox(ib, self, 'mdsFromCurrentPos', "MDS from current positions") 
    310         self.mdsInfoA=OWGUI.widgetLabel(ib, "Avg. stress:") 
    311         self.mdsInfoB=OWGUI.widgetLabel(ib, "Num. steps:") 
    312         self.rotateSteps = 100 
    313          
    314         OWGUI.spin(ib, self, "rotateSteps", 1, 10000, 1, label="Rotate max steps: ") 
     310        #ibs = OWGUI.widgetBox(ib, orientation="horizontal") 
     311        #self.btnMDS = OWGUI.button(ibs, self, "Fragviz", callback=self.mds_components, toggleButton=1) 
     312        #self.btnESIM = OWGUI.button(ibs, self, "eSim", callback=(lambda: self.mds_components(Orange.network.MdsType.exactSimulation)), toggleButton=1) 
     313        #self.btnMDSv = OWGUI.button(ibs, self, "MDS", callback=(lambda: self.mds_components(Orange.network.MdsType.MDS)), toggleButton=1) 
     314        #ibs = OWGUI.widgetBox(ib, orientation="horizontal") 
     315        #self.btnRotate = OWGUI.button(ibs, self, "Rotate", callback=self.rotateComponents, toggleButton=1) 
     316        #self.btnRotateMDS = OWGUI.button(ibs, self, "Rotate (MDS)", callback=self.rotateComponentsMDS, toggleButton=1) 
     317        #self.btnForce = OWGUI.button(ibs, self, "Draw Force", callback=self.drawForce, toggleButton=1) 
     318        #self.scalingRatio = 0 
     319        #OWGUI.spin(ib, self, "scalingRatio", 0, 9, 1, label="Set scalingRatio: ") 
     320        #OWGUI.doubleSpin(ib, self, "mdsStressDelta", 0, 10, 0.0000000000000001, label="Min stress change: ") 
     321        #OWGUI.spin(ib, self, "mdsSteps", 1, 100000, 1, label="MDS steps: ") 
     322        #OWGUI.spin(ib, self, "mdsRefresh", 1, 100000, 1, label="MDS refresh steps: ") 
     323        #ibs = OWGUI.widgetBox(ib, orientation="horizontal") 
     324        #OWGUI.checkBox(ibs, self, 'mdsTorgerson', "Torgerson's approximation") 
     325        #OWGUI.checkBox(ibs, self, 'mdsAvgLinkage', "Use average linkage") 
     326        #OWGUI.checkBox(ib, self, 'mdsFromCurrentPos', "MDS from current positions") 
     327        #self.mdsInfoA=OWGUI.widgetLabel(ib, "Avg. stress:") 
     328        #self.mdsInfoB=OWGUI.widgetLabel(ib, "Num. steps:") 
     329        #self.rotateSteps = 100 
     330         
     331        #OWGUI.spin(ib, self, "rotateSteps", 1, 10000, 1, label="Rotate max steps: ") 
    315332        OWGUI.spin(ib, self, "minComponentEdgeWidth", 0, 100, 1, label="Min component edge width: ", callback=(lambda changedMin=1: self.setComponentEdgeWidth(changedMin))) 
    316333        OWGUI.spin(ib, self, "maxComponentEdgeWidth", 0, 200, 1, label="Max component edge width: ", callback=(lambda changedMin=0: self.setComponentEdgeWidth(changedMin))) 
     
    325342        self.set_mark_mode() 
    326343         
    327         self.editAttribute = 0 
    328         self.editCombo = OWGUI.comboBox(self.infoTab, self, "editAttribute", label="Edit attribute:", orientation="horizontal") 
    329         self.editCombo.addItem("Select attribute") 
    330         self.editValue = '' 
    331         OWGUI.lineEdit(self.infoTab, self, "editValue", "Value:", orientation='horizontal') 
    332         OWGUI.button(self.infoTab, self, "Edit", callback=self.edit) 
    333          
    334344        self.networkCanvas.gui.effects_box(self.performanceTab) 
    335345         
     
    352362        self.set_graph(None) 
    353363        self.setMinimumWidth(900) 
    354          
    355         #self.resize(1000, 600) 
    356         #self.controlArea.setEnabled(False) 
    357364         
    358365    def setComponentEdgeWidth(self, changedMin=True): 
     
    494501#        self.progressBarFinished() 
    495502        pass 
    496          
    497     def mdsProgress(self, avgStress, stepCount):     
    498         self.drawForce() 
    499  
    500         self.mdsInfoA.setText("Avg. Stress: %.20f" % avgStress) 
    501         self.mdsInfoB.setText("Num. steps: %i" % stepCount) 
    502         self.progressBarSet(int(stepCount * 100 / self.mdsSteps)) 
    503         qApp.processEvents() 
    504          
    505     def mds_components(self, mdsType=Orange.network.MdsType.componentMDS): 
    506 #        if mdsType == Orange.network.MdsType.componentMDS: 
    507 #            btn = self.btnMDS 
    508 #        elif mdsType == Orange.network.MdsType.exactSimulation: 
    509 #            btn = self.btnESIM 
    510 #        elif mdsType == Orange.network.MdsType.MDS: 
    511 #            btn = self.btnMDSv 
    512 #         
    513 #        btnCaption = btn.text() 
    514 #         
    515 #        if self.items_matrix is None: 
    516 #            self.information('Set distance matrix to input signal') 
    517 #            btn.setChecked(False) 
    518 #            return 
    519 #         
    520 #        if self.layout is None: 
    521 #            self.information('No network found') 
    522 #            btn.setChecked(False) 
    523 #            return 
    524 #         
    525 #        if self.items_matrix.dim != self.graph.number_of_nodes(): 
    526 #            self.error('Distance matrix dimensionality must equal number of vertices') 
    527 #            btn.setChecked(False) 
    528 #            return 
    529 #         
    530 #        if not btn.isChecked(): 
    531 #            self.layout.stopMDS = 1 
    532 #            btn.setChecked(False) 
    533 #            btn.setText(btnCaption) 
    534 #            return 
    535 #         
    536 #        btn.setText("Stop") 
    537 #        qApp.processEvents() 
    538 #         
    539 #        self.layout.items_matrix = self.items_matrix 
    540 #        self.progressBarInit() 
    541 #         
    542 #        if self.mdsAvgLinkage: 
    543 #            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) 
    544 #        else: 
    545 #            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)             
    546 #         
    547 #        btn.setChecked(False) 
    548 #        btn.setText(btnCaption) 
    549 #        self.progressBarFinished() 
    550         pass 
    551503     
    552504    def set_items_distance_matrix(self, matrix): 
     
    570522        self.showDistancesCheckBox.setEnabled(1) 
    571523         
    572         if self.optMethod == 8: 
    573             self.optButton.setChecked(True) 
    574             self.graph_layout() 
     524        if str(self.optMethod) in ['8', '9', '10']: 
     525            if self.items_matrix is not None and self.graph is not None and \ 
     526            self.items_matrix.dim == self.graph.number_of_nodes(): 
     527                self.optButton.setEnabled(True) 
     528                self.optButton.setChecked(True) 
     529                self.graph_layout() 
    575530     
    576531    def send_marked_nodes(self): 
     
    12631218        self.networkCanvas.animate_points = animation_enabled 
    12641219        qApp.processEvents() 
    1265         self.networkCanvas.networkCurve.fr(100, weighted=False, smooth_cooling=True) 
     1220        self.networkCanvas.networkCurve.layout_fr(100, weighted=False, smooth_cooling=True) 
    12661221        self.networkCanvas.networkCurve.update_properties() 
    12671222        self.networkCanvas.replot() 
     
    15101465            return 
    15111466         
    1512         if not self.optButton.isChecked() and not self.optMethod == 2: 
     1467        if not self.optButton.isChecked() and not self.optMethod in [2, 9]: 
    15131468            self.optButton.setChecked(False) 
    15141469            return 
     
    15321487        elif self.optMethod == 8: 
    15331488            self.graph_layout_pivot_mds() 
     1489        elif self.optMethod == 9: 
     1490            self.graph_layout_fragviz() 
     1491        elif self.optMethod == 10:  
     1492            print "TODO: MDS" 
     1493            #self.mds_components(Orange.network.MdsType.MDS) 
    15341494             
    15351495        self.optButton.setChecked(False) 
     
    15431503        self.information() 
    15441504        self.stepsSpin.label.setText('Iterations: ') 
     1505        self.optButton.setEnabled(True) 
     1506        self.cb_opt_from_curr.setEnabled(False) 
    15451507         
    15461508        if method is not None: 
     
    15541516        if str(self.optMethod) in ['2', '3', '4']: 
    15551517            self.stepsSpin.setEnabled(True) 
    1556         elif str(self.optMethod) == '8': 
    1557             self.stepsSpin.label.setText('Pivots: ') 
     1518             
     1519        elif str(self.optMethod) in ['8', '9', '10']: 
     1520            if str(self.optMethod) == '8':  
     1521                self.stepsSpin.label.setText('Pivots: ') 
     1522             
     1523            if str(self.optMethod) == '9':  
     1524                self.cb_opt_from_curr.setEnabled(True) 
     1525                 
    15581526            self.stepsSpin.setEnabled(True) 
    15591527             
    15601528            if self.items_matrix is None: 
    15611529                self.information('Set distance matrix to input signal') 
     1530                self.optButton.setEnabled(False) 
    15621531                return 
    15631532            if self.graph is None: 
    15641533                self.information('No network found') 
     1534                self.optButton.setEnabled(False) 
    15651535                return 
    15661536            if self.items_matrix.dim != self.graph.number_of_nodes(): 
    15671537                self.error('Distance matrix dimensionality must equal number of vertices') 
     1538                self.optButton.setEnabled(False) 
    15681539                return 
    15691540        else: 
     
    15721543            self.graph_layout() 
    15731544         
     1545     
     1546    def mdsProgress(self, avgStress, stepCount):     
     1547        #self.drawForce() 
     1548 
     1549        #self.mdsInfoA.setText("Avg. Stress: %.20f" % avgStress) 
     1550        #self.mdsInfoB.setText("Num. steps: %i" % stepCount) 
     1551        self.progressBarSet(int(stepCount * 100 / self.frSteps)) 
     1552        qApp.processEvents() 
     1553         
     1554    def graph_layout_fragviz(self): 
     1555        if self.items_matrix is None: 
     1556            self.information('Set distance matrix to input signal') 
     1557            self.optButton.setChecked(False) 
     1558            return 
     1559         
     1560        if self.layout is None: 
     1561            self.information('No network found') 
     1562            self.optButton.setChecked(False) 
     1563            return 
     1564         
     1565        if self.items_matrix.dim != self.graph.number_of_nodes(): 
     1566            self.error('Distance matrix dimensionality must equal number of vertices') 
     1567            self.optButton.setChecked(False) 
     1568            return 
     1569         
     1570        if not self.optButton.isChecked(): 
     1571            self.networkCanvas.networkCurve.stopMDS = True 
     1572            self.optButton.setChecked(False) 
     1573            self.optButton.setText("Optimize layout") 
     1574            return 
     1575         
     1576        self.optButton.setText("Stop") 
     1577         
     1578        qApp.processEvents() 
     1579 
     1580        self.progressBarInit() 
     1581 
     1582        if self.graph.number_of_nodes() == self.graph_base.number_of_nodes(): 
     1583            matrix = self.items_matrix 
     1584        else: 
     1585            matrix = self.items_matrix.get_items(sorted(self.graph.nodes())) 
     1586         
     1587        self.networkCanvas.networkCurve.layout_fragviz(self.frSteps, matrix, self.graph, self.mdsProgress, self.opt_from_curr) 
     1588 
     1589        self.optButton.setChecked(False) 
     1590        self.optButton.setText("Optimize layout") 
     1591        self.progressBarFinished() 
     1592         
    15741593    def graph_layout_fr(self, weighted): 
    15751594        if self.graph is None: 
     
    15771596               
    15781597        if not self.optButton.isChecked(): 
    1579             print 'stop opt' 
    15801598            self.networkCanvas.networkCurve.stop_optimization() 
    15811599            self.optButton.setChecked(False) 
     
    15851603        self.optButton.setText("Stop") 
    15861604        qApp.processEvents() 
    1587         self.networkCanvas.networkCurve.fr(self.frSteps, False) 
     1605        self.networkCanvas.networkCurve.layout_fr(self.frSteps, False) 
    15881606        self.networkCanvas.update_canvas() 
    15891607        self.optButton.setChecked(False) 
     
    16511669    Network Visualization 
    16521670    """ 
    1653         
    16541671    def clickedAttLstBox(self): 
    16551672        if self.graph is None: 
Note: See TracChangeset for help on using the changeset viewer.