Ignore:
Timestamp:
02/02/12 10:08:33 (2 years ago)
Author:
Miha Stajdohar <miha.stajdohar@…>
Branch:
default
rebase_source:
588b9bc44afc52a1fdb8df192b6d569989145639
Message:

Refactored NxView class.

File:
1 edited

Legend:

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

    r9588 r9623  
    6161import orangeom 
    6262import readwrite 
    63 from networkx import algorithms  
     63from networkx import algorithms 
    6464from networkx.classes import function 
    6565 
     
    7575    tmp = doc.replace('nx.', 'Orange.network.') 
    7676    return tmp 
    77      
     77 
    7878class BaseGraph(): 
    7979    """A collection of methods inherited by all graph types (:obj:`Graph`,  
     
    8181     
    8282    """ 
    83      
     83 
    8484    def __init__(self): 
    8585        self._items = None 
    8686        self._links = None 
    87          
     87 
    8888    def items(self): 
    8989        """Return the :obj:`Orange.data.Table` items with data about network  
     
    9191         
    9292        """ 
    93           
     93 
    9494        if self._items is not None and \ 
    9595                        len(self._items) != self.number_of_nodes(): 
    9696            print "Warning: items length does not match the number of nodes." 
    97              
     97 
    9898        return self._items 
    99      
     99 
    100100    def set_items(self, items=None): 
    101101        """Set the :obj:`Orange.data.Table` items to the given data. Notice  
     
    103103         
    104104        """ 
    105          
     105 
    106106        if items is not None: 
    107107            if not isinstance(items, Orange.data.Table): 
     
    109109            if len(items) != self.number_of_nodes(): 
    110110                print "Warning: items length must match the number of nodes." 
    111                  
     111 
    112112        self._items = items 
    113          
     113 
    114114    def links(self): 
    115115        """Return the :obj:`Orange.data.Table` links with data about network  
     
    117117         
    118118        """ 
    119          
     119 
    120120        if self._links is not None \ 
    121121                    and len(self._links) != self.number_of_edges(): 
    122122            print "Warning: links length does not match the number of edges." 
    123              
     123 
    124124        return self._links 
    125      
     125 
    126126    def set_links(self, links=None): 
    127127        """Set the :obj:`Orange.data.Table` links to the given data. Notice  
     
    129129         
    130130        """ 
    131          
     131 
    132132        if links is not None: 
    133133            if not isinstance(links, Orange.data.Table): 
     
    135135            if len(links) != self.number_of_edges(): 
    136136                print "Warning: links length must match the number of edges." 
    137          
     137 
    138138        self._links = links 
    139          
     139 
    140140    def to_orange_network(self): 
    141141        """Convert the current network to >>Orange<< NetworkX standard. To use 
     
    143143        [0, no_of_nodes - 1]. 
    144144         
    145         """  
    146          
     145        """ 
     146 
    147147        G = self.__class__() 
    148148        node_list = sorted(self.nodes()) 
    149149        node_to_index = dict(zip(node_list, range(self.number_of_nodes()))) 
    150150        index_to_node = dict(zip(range(self.number_of_nodes()), node_list)) 
    151          
     151 
    152152        G.add_nodes_from(zip(range(self.number_of_nodes()), [copy.deepcopy(self.node[nid]) for nid in node_list])) 
    153         G.add_edges_from(((node_to_index[u], node_to_index[v], copy.deepcopy(self.edge[u][v])) for u,v in self.edges())) 
    154          
     153        G.add_edges_from(((node_to_index[u], node_to_index[v], copy.deepcopy(self.edge[u][v])) for u, v in self.edges())) 
     154 
    155155        for id in G.node.keys(): 
    156             G.node[id]['old_id'] = index_to_node[id]   
    157          
     156            G.node[id]['old_id'] = index_to_node[id] 
     157 
    158158        if self.items(): 
    159159            G.set_items(self.items()) 
     
    161161        if self.links(): 
    162162            G.set_links(self.links()) 
    163          
     163 
    164164        return G 
    165          
     165 
    166166    ### TODO: OVERRIDE METHODS THAT CHANGE GRAPH STRUCTURE, add warning prints 
    167      
     167 
    168168    def items_vars(self): 
    169169        """Return a list of features in the :obj:`Orange.data.Table` items.""" 
    170          
     170 
    171171        vars = [] 
    172172        if (self._items is not None): 
    173173            if isinstance(self._items, Orange.data.Table): 
    174174                vars = list(self._items.domain.variables) 
    175              
     175 
    176176                metas = self._items.domain.getmetas(0) 
    177177                vars.extend(var for i, var in metas.iteritems()) 
    178178        return vars 
    179      
     179 
    180180    def links_vars(self): 
    181181        """Return a list of features in the :obj:`Orange.data.Table` links.""" 
    182          
     182 
    183183        vars = [] 
    184184        if (self._links is not None): 
    185185            if isinstance(self._links, Orange.data.Table): 
    186186                vars = list(self._links.domain.variables) 
    187              
     187 
    188188                metas = self._links.domain.getmetas(0) 
    189189                vars.extend(var for i, var in metas.iteritems()) 
    190         return [x for x in vars if str(x.name) != 'u' and str(x.name) != 'v']     
    191      
     190        return [x for x in vars if str(x.name) != 'u' and str(x.name) != 'v'] 
     191 
    192192class Graph(BaseGraph, nx.Graph): 
    193193    """Bases: `NetworkX.Graph <http://networkx.lanl.gov/reference/classes.graph.html>`_,  
     
    195195     
    196196    """ 
    197      
    198     def __init__(self, data=None, name='', **attr):   
     197 
     198    def __init__(self, data=None, name='', **attr): 
    199199        nx.Graph.__init__(self, data, name=name, **attr) 
    200200        BaseGraph.__init__(self) 
    201      
     201 
    202202    def subgraph(self, nbunch): 
    203203        G = nx.Graph.subgraph(self, nbunch) 
     
    207207        return G 
    208208        # TODO: _links 
    209      
     209 
    210210    __doc__ += _get_doc(nx.Graph.__doc__) 
    211211    __init__.__doc__ = _get_doc(nx.Graph.__init__.__doc__) 
    212       
     212 
    213213class DiGraph(BaseGraph, nx.DiGraph): 
    214214    """Bases: `NetworkX.DiGraph <http://networkx.lanl.gov/reference/classes.digraph.html>`_,  
     
    216216     
    217217    """ 
    218      
    219      
     218 
     219 
    220220    def __init__(self, data=None, name='', **attr): 
    221221        nx.DiGraph.__init__(self, data, name=name, **attr) 
    222222        BaseGraph.__init__(self) 
    223      
     223 
    224224    __doc__ += _get_doc(nx.DiGraph.__doc__) 
    225225    __init__.__doc__ = _get_doc(nx.DiGraph.__init__.__doc__) 
    226       
     226 
    227227class MultiGraph(BaseGraph, nx.MultiGraph): 
    228228    """Bases: `NetworkX.MultiGraph <http://networkx.lanl.gov/reference/classes.multigraph.html>`_,  
     
    230230     
    231231    """ 
    232      
    233      
     232 
     233 
    234234    def __init__(self, data=None, name='', **attr): 
    235235        nx.MultiGraph.__init__(self, data, name=name, **attr) 
    236236        BaseGraph.__init__(self) 
    237      
     237 
    238238    __doc__ += _get_doc(nx.MultiGraph.__doc__) 
    239239    __init__.__doc__ = _get_doc(nx.MultiGraph.__init__.__doc__) 
    240       
     240 
    241241class MultiDiGraph(BaseGraph, nx.MultiDiGraph): 
    242242    """Bases: `NetworkX.MultiDiGraph <http://networkx.lanl.gov/reference/classes.multidigraph.html>`_,  
     
    244244     
    245245    """ 
    246      
    247      
     246 
     247 
    248248    def __init__(self, data=None, name='', **attr): 
    249249        nx.MultiDiGraph.__init__(self, data, name=name, **attr) 
    250250        BaseGraph.__init__(self) 
    251      
     251 
    252252    __doc__ += _get_doc(nx.MultiDiGraph.__doc__) 
    253253    __init__.__doc__ = _get_doc(nx.MultiDiGraph.__init__.__doc__) 
    254      
     254 
    255255class GraphLayout(orangeom.GraphLayout): 
    256256    """A class for graph layout optimization. Before using any of the layout 
     
    329329     
    330330    """ 
    331      
     331 
    332332    def __init__(self): 
    333333        self.graph = None 
    334334        self.items_matrix = None 
    335          
     335 
    336336    def set_graph(self, graph=None, positions=None): 
    337337        """Init graph structure. 
     
    345345        """ 
    346346        self.graph = graph 
    347          
     347 
    348348        if positions is not None and len(positions) == graph.number_of_nodes(): 
    349349            orangeom.GraphLayout.set_graph(self, graph, positions) 
    350350        else: 
    351351            orangeom.GraphLayout.set_graph(self, graph) 
    352              
     352 
    353353    def random(self): 
    354354        """Random graph layout.""" 
    355          
     355 
    356356        orangeom.GraphLayout.random(self) 
    357          
     357 
    358358    def fr(self, steps, temperature, coolFactor=0, weighted=False): 
    359359        """Fruchterman-Reingold spring layout optimization. Set number of  
     
    362362         
    363363        """ 
    364          
     364 
    365365        return orangeom.GraphLayout.fr(self, steps, temperature, coolFactor, weighted) 
    366          
     366 
    367367    def fr_radial(self, center, steps, temperature): 
    368368        """Radial Fruchterman-Reingold spring layout optimization. Set center  
     
    371371         
    372372        """ 
    373          
     373 
    374374        return orangeom.GraphLayout.fr_radial(self, center, steps, temperature) 
    375      
     375 
    376376    def circular_original(self): 
    377377        """Circular graph layout with original node order.""" 
    378          
     378 
    379379        orangeom.GraphLayout.circular_original(self) 
    380      
     380 
    381381    def circular_random(self): 
    382382        """Circular graph layout with random node order.""" 
    383          
     383 
    384384        orangeom.GraphLayout.circular_random(self) 
    385      
     385 
    386386    def circular_crossing_reduction(self): 
    387387        """Circular graph layout with edge crossing reduction (Michael Baur,  
     
    389389         
    390390        """ 
    391          
     391 
    392392        orangeom.GraphLayout.circular_crossing_reduction(self) 
    393      
     393 
    394394    def get_vertices_in_rect(self, x1, y1, x2, y2): 
    395395        """Return a list of nodes in the given rectangle.""" 
    396          
     396 
    397397        return orangeom.GraphLayout.get_vertices_in_rect(self, x1, y1, x2, y2) 
    398      
     398 
    399399    def closest_vertex(self, x, y): 
    400400        """Return the closest node to given point.""" 
    401          
     401 
    402402        return orangeom.GraphLayout.closest_vertex(self, x, y) 
    403      
     403 
    404404    def vertex_distances(self, x, y): 
    405405        """Return distances (a list of (distance, vertex) tuples) of all nodes  
     
    407407         
    408408        """ 
    409          
     409 
    410410        return orangeom.GraphLayout.vertex_distances(self, x, y) 
    411      
    412     def rotate_vertices(self, components, phi):  
     411 
     412    def rotate_vertices(self, components, phi): 
    413413        """Rotate network components for a given angle. 
    414414         
     
    419419        :type phi: float 
    420420         
    421         """   
     421        """ 
    422422        #print phi  
    423423        for i in range(len(components)): 
    424424            if phi[i] == 0: 
    425425                continue 
    426              
     426 
    427427            component = components[i] 
    428              
     428 
    429429            x = self.coors[0][component] 
    430430            y = self.coors[1][component] 
    431              
     431 
    432432            x_center = x.mean() 
    433433            y_center = y.mean() 
    434              
     434 
    435435            x = x - x_center 
    436436            y = y - y_center 
    437              
     437 
    438438            r = numpy.sqrt(x ** 2 + y ** 2) 
    439439            fi = numpy.arctan2(y, x) 
    440              
     440 
    441441            fi += phi[i] 
    442442            #fi += factor * M[i] * numpy.pi / 180 
    443                  
     443 
    444444            x = r * numpy.cos(fi) 
    445445            y = r * numpy.sin(fi) 
    446              
     446 
    447447            self.coors[0][component] = x + x_center 
    448448            self.coors[1][component] = y + y_center 
    449      
    450     def rotate_components(self, maxSteps=100, minMoment=0.000000001,  
     449 
     450    def rotate_components(self, maxSteps=100, minMoment=0.000000001, 
    451451                          callbackProgress=None, callbackUpdateCanvas=None): 
    452452        """Rotate the network components using a spring model.""" 
    453          
     453 
    454454        if self.items_matrix == None: 
    455455            return 1 
    456          
     456 
    457457        if self.graph == None: 
    458458            return 1 
    459          
     459 
    460460        if self.items_matrix.dim != self.graph.number_of_nodes(): 
    461461            return 1 
    462          
     462 
    463463        self.stopRotate = 0 
    464          
     464 
    465465        # rotate only components with more than one vertex 
    466466        components = [component for component \ 
     
    474474        while step < maxSteps and (max(M) > minMoment or \ 
    475475                                min(M) < -minMoment) and not self.stopRotate: 
    476             M = [0] * len(components)  
    477              
     476            M = [0] * len(components) 
     477 
    478478            for i in range(len(components)): 
    479479                component = components[i] 
    480                  
     480 
    481481                outer_vertices = vertices - set(component) 
    482                  
     482 
    483483                x = self.coors[0][component] 
    484484                y = self.coors[1][component] 
    485                  
     485 
    486486                x_center = x.mean() 
    487487                y_center = y.mean() 
    488                  
     488 
    489489                for j in range(len(component)): 
    490490                    u = component[j] 
     
    500500                        e = math.sqrt((v_x - x_center) ** 2 + \ 
    501501                                      (v_y - y_center) ** 2) 
    502                          
     502 
    503503                        M[i] += (1 - d) / (e ** 2) * numpy.cross(R, L) 
    504              
     504 
    505505            tmpM = numpy.array(M) 
    506506            #print numpy.min(tmpM), numpy.max(tmpM),numpy.average(tmpM),numpy.min(numpy.abs(tmpM)) 
    507              
     507 
    508508            phi = [0] * len(components) 
    509509            #print "rotating", temperature, M 
     
    514514                        temperature[i][1] = 1 
    515515                        dirChange[i] += 1 
    516                          
     516 
    517517                    phi[i] = temperature[i][0] * numpy.pi / 180 
    518                 elif M[i] < 0:   
     518                elif M[i] < 0: 
    519519                    if temperature[i][1] > 0: 
    520520                        temperature[i][0] = temperature[i][0] * 5 / 10 
    521521                        temperature[i][1] = -1 
    522522                        dirChange[i] += 1 
    523                      
     523 
    524524                    phi[i] = -temperature[i][0] * numpy.pi / 180 
    525              
     525 
    526526            # stop rotating when phi is to small to notice the rotation 
    527527            if max(phi) < numpy.pi / 1800: 
    528528                #print "breaking" 
    529529                break 
    530              
     530 
    531531            self.rotate_vertices(components, phi) 
    532532            if callbackUpdateCanvas: callbackUpdateCanvas() 
     
    534534                                    in range(len(dirChange)) if M[i] != 0]), 9) 
    535535            step += 1 
    536      
     536 
    537537    def mds_update_data(self, components, mds, callbackUpdateCanvas): 
    538538        """Translate and rotate the network components to computed positions.""" 
    539          
     539 
    540540        component_props = [] 
    541541        x_mds = [] 
    542542        y_mds = [] 
    543543        phi = [None] * len(components) 
    544         self.diag_coors = math.sqrt(( \ 
    545                     min(self.coors[0]) - max(self.coors[0]))**2 + \ 
    546                     (min(self.coors[1]) - max(self.coors[1]))**2) 
    547          
     544        self.diag_coors = math.sqrt((\ 
     545                    min(self.coors[0]) - max(self.coors[0])) ** 2 + \ 
     546                    (min(self.coors[1]) - max(self.coors[1])) ** 2) 
     547 
    548548        if self.mdsType == MdsType.MDS: 
    549549            x = [mds.points[u][0] for u in range(self.graph.number_of_nodes())] 
    550550            y = [mds.points[u][1] for u in range(self.graph.number_of_nodes())] 
    551             self.coors[0][range(self.graph.number_of_nodes())] =  x 
    552             self.coors[1][range(self.graph.number_of_nodes())] =  y 
     551            self.coors[0][range(self.graph.number_of_nodes())] = x 
     552            self.coors[1][range(self.graph.number_of_nodes())] = y 
    553553            if callbackUpdateCanvas: 
    554554                callbackUpdateCanvas() 
    555555            return 
    556          
    557         for i in range(len(components)):     
     556 
     557        for i in range(len(components)): 
    558558            component = components[i] 
    559              
     559 
    560560            if len(mds.points) == len(components):  # if average linkage before 
    561561                x_avg_mds = mds.points[i][0] 
     
    564564                x = [mds.points[u][0] for u in component] 
    565565                y = [mds.points[u][1] for u in component] 
    566          
    567                 x_avg_mds = sum(x) / len(x)  
     566 
     567                x_avg_mds = sum(x) / len(x) 
    568568                y_avg_mds = sum(y) / len(y) 
    569569                # compute rotation angle 
    570570                c = [numpy.linalg.norm(numpy.cross(mds.points[u], \ 
    571                             [self.coors[0][u],self.coors[1][u]])) \ 
     571                            [self.coors[0][u], self.coors[1][u]])) \ 
    572572                            for u in component] 
    573573                n = [numpy.vdot([self.coors[0][u], \ 
     
    577577                phi[i] = sum(c) / sum(n) 
    578578                #print phi 
    579              
     579 
    580580            x = self.coors[0][component] 
    581581            y = self.coors[1][component] 
    582              
     582 
    583583            x_avg_graph = sum(x) / len(x) 
    584584            y_avg_graph = sum(y) / len(y) 
    585              
    586             x_mds.append(x_avg_mds)  
     585 
     586            x_mds.append(x_avg_mds) 
    587587            y_mds.append(y_avg_mds) 
    588588 
    589589            component_props.append((x_avg_graph, y_avg_graph, \ 
    590590                                    x_avg_mds, y_avg_mds, phi)) 
    591          
     591 
    592592        w = max(self.coors[0]) - min(self.coors[0]) 
    593593        h = max(self.coors[1]) - min(self.coors[1]) 
    594         d = math.sqrt(w**2 + h**2) 
     594        d = math.sqrt(w ** 2 + h ** 2) 
    595595        #d = math.sqrt(w*h) 
    596         e = [math.sqrt((self.coors[0][u] - self.coors[0][v])**2 +  
    597                   (self.coors[1][u] - self.coors[1][v])**2) for  
     596        e = [math.sqrt((self.coors[0][u] - self.coors[0][v]) ** 2 + 
     597                  (self.coors[1][u] - self.coors[1][v]) ** 2) for 
    598598                  (u, v) in self.graph.edges()] 
    599          
     599 
    600600        if self.scalingRatio == 0: 
    601601            pass 
     
    621621                    x2 = self.coors[0][j] 
    622622                    y2 = self.coors[1][j] 
    623                     e_fr += math.sqrt((x1-x2)**2 + (y1-y2)**2) 
     623                    e_fr += math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2) 
    624624                    e_count += 1 
    625625            self.mdsScaleRatio = e_fr / e_count 
     
    633633                    x_avg_graph_j, y_avg_graph_j, x_avg_mds_j, \ 
    634634                    y_avg_mds_j, phi_j = component_props[j] 
    635                     e_fr += math.sqrt((x_avg_graph_i-x_avg_graph_j)**2 + \ 
    636                                       (y_avg_graph_i-y_avg_graph_j)**2) 
     635                    e_fr += math.sqrt((x_avg_graph_i - x_avg_graph_j) ** 2 + \ 
     636                                      (y_avg_graph_i - y_avg_graph_j) ** 2) 
    637637                    e_count += 1 
    638             self.mdsScaleRatio = e_fr / e_count        
     638            self.mdsScaleRatio = e_fr / e_count 
    639639        elif self.scalingRatio == 9: 
    640640            e_fr = 0 
    641641            e_count = 0 
    642             for i in range(len(components)):     
     642            for i in range(len(components)): 
    643643                component = components[i] 
    644644                x = self.coors[0][component] 
     
    650650                        x2 = x[j] 
    651651                        y2 = y[j] 
    652                         e_fr += math.sqrt((x1-x2)**2 + (y1-y2)**2) 
     652                        e_fr += math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2) 
    653653                        e_count += 1 
    654654            self.mdsScaleRatio = e_fr / e_count 
    655          
    656         diag_mds =  math.sqrt((max(x_mds) - min(x_mds))**2 + (max(y_mds) - \ 
    657                                                               min(y_mds))**2) 
    658         e = [math.sqrt((self.coors[0][u] - self.coors[0][v])**2 +  
    659                   (self.coors[1][u] - self.coors[1][v])**2) for  
     655 
     656        diag_mds = math.sqrt((max(x_mds) - min(x_mds)) ** 2 + (max(y_mds) - \ 
     657                                                              min(y_mds)) ** 2) 
     658        e = [math.sqrt((self.coors[0][u] - self.coors[0][v]) ** 2 + 
     659                  (self.coors[1][u] - self.coors[1][v]) ** 2) for 
    660660                  (u, v) in self.graph.edges()] 
    661661        e = sum(e) / float(len(e)) 
    662          
     662 
    663663        x = [mds.points[u][0] for u in range(len(mds.points))] 
    664664        y = [mds.points[u][1] for u in range(len(mds.points))] 
    665665        w = max(x) - min(x) 
    666666        h = max(y) - min(y) 
    667         d = math.sqrt(w**2 + h**2) 
    668          
     667        d = math.sqrt(w ** 2 + h ** 2) 
     668 
    669669        if len(x) == 1: 
    670670            r = 1 
     
    693693                        x2 = mds.points[j][0] 
    694694                        y2 = mds.points[j][1] 
    695                         e_mds += math.sqrt((x1-x2)**2 + (y1-y2)**2) 
     695                        e_mds += math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2) 
    696696                        e_count += 1 
    697697                r = self.mdsScaleRatio / e_mds * e_count 
     
    705705                        x_avg_graph_j, y_avg_graph_j, x_avg_mds_j, \ 
    706706                        y_avg_mds_j, phi_j = component_props[j] 
    707                         e_mds += math.sqrt((x_avg_mds_i-x_avg_mds_j)**2 + \ 
    708                                            (y_avg_mds_i-y_avg_mds_j)**2) 
     707                        e_mds += math.sqrt((x_avg_mds_i - x_avg_mds_j) ** 2 + \ 
     708                                           (y_avg_mds_i - y_avg_mds_j) ** 2) 
    709709                        e_count += 1 
    710710                r = self.mdsScaleRatio / e_mds * e_count 
     
    718718                        x2 = mds.points[j][0] 
    719719                        y2 = mds.points[j][1] 
    720                         e_mds += math.sqrt((x1-x2)**2 + (y1-y2)**2) 
     720                        e_mds += math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2) 
    721721                        e_count += 1 
    722722                r = self.mdsScaleRatio / e_mds * e_count 
    723                  
     723 
    724724            #r = self.mdsScaleRatio / d 
    725725            #print "d", d, "r", r 
    726726            #r = self.mdsScaleRatio / math.sqrt(self.graph.number_of_nodes()) 
    727              
     727 
    728728        for i in range(len(components)): 
    729729            component = components[i] 
    730730            x_avg_graph, y_avg_graph, x_avg_mds, \ 
    731731            y_avg_mds, phi = component_props[i] 
    732              
     732 
    733733#            if phi[i]:  # rotate vertices 
    734734#                #print "rotate", i, phi[i] 
     
    738738#                self.coors[0][component] = [u[0] for u in v] 
    739739#                self.coors[1][component] = [u[1] for u in v] 
    740                  
     740 
    741741            # translate vertices 
    742742            if not self.rotationOnly: 
     
    745745                self.coors[1][component] = \ 
    746746                (self.coors[1][component] - y_avg_graph) / r + y_avg_mds 
    747                 
     747 
    748748        if callbackUpdateCanvas: 
    749749            callbackUpdateCanvas() 
    750      
     750 
    751751    def mds_callback(self, a, b=None): 
    752752        """Refresh the UI when running  MDS on network components.""" 
    753          
     753 
    754754        if not self.mdsStep % self.mdsRefresh: 
    755             self.mds_update_data(self.mdsComponentList,  
    756                                self.mds,  
     755            self.mds_update_data(self.mdsComponentList, 
     756                               self.mds, 
    757757                               self.callbackUpdateCanvas) 
    758              
     758 
    759759            if self.mdsType == MdsType.exactSimulation: 
    760760                self.mds.points = [[self.coors[0][i], \ 
     
    762762                                    for i in range(len(self.coors))] 
    763763                self.mds.freshD = 0 
    764              
     764 
    765765            if self.callbackProgress != None: 
    766766                self.callbackProgress(self.mds.avg_stress, self.mdsStep) 
    767                  
     767 
    768768        self.mdsStep += 1 
    769769 
     
    772772        else: 
    773773            return 1 
    774              
     774 
    775775    def mds_components(self, mdsSteps, mdsRefresh, callbackProgress=None, \ 
    776776                       callbackUpdateCanvas=None, torgerson=0, \ 
    777                        minStressDelta=0, avgLinkage=False, rotationOnly=False,\ 
     777                       minStressDelta=0, avgLinkage=False, rotationOnly=False, \ 
    778778                       mdsType=MdsType.componentMDS, scalingRatio=0, \ 
    779779                       mdsFromCurrentPos=0): 
     
    786786            self.information('Set distance matrix to input signal') 
    787787            return 1 
    788          
     788 
    789789        if self.graph == None: 
    790790            return 1 
    791          
     791 
    792792        if self.items_matrix.dim != self.graph.number_of_nodes(): 
    793793            return 1 
    794          
     794 
    795795        self.mdsComponentList = Orange.network.nx.algorithms.components.connected_components(self.graph) 
    796796        self.mdsRefresh = mdsRefresh 
     
    798798        self.stopMDS = 0 
    799799        self.items_matrix.matrixType = Orange.core.SymMatrix.Symmetric 
    800         self.diag_coors = math.sqrt((min(self.coors[0]) -  \ 
    801                                      max(self.coors[0]))**2 + \ 
     800        self.diag_coors = math.sqrt((min(self.coors[0]) - \ 
     801                                     max(self.coors[0])) ** 2 + \ 
    802802                                     (min(self.coors[1]) - \ 
    803                                       max(self.coors[1]))**2) 
     803                                      max(self.coors[1])) ** 2) 
    804804        self.rotationOnly = rotationOnly 
    805805        self.mdsType = mdsType 
     
    808808        w = max(self.coors[0]) - min(self.coors[0]) 
    809809        h = max(self.coors[1]) - min(self.coors[1]) 
    810         d = math.sqrt(w**2 + h**2) 
     810        d = math.sqrt(w ** 2 + h ** 2) 
    811811        #d = math.sqrt(w*h) 
    812         e = [math.sqrt((self.coors[0][u] - self.coors[0][v])**2 +  
    813                   (self.coors[1][u] - self.coors[1][v])**2) for  
     812        e = [math.sqrt((self.coors[0][u] - self.coors[0][v]) ** 2 + 
     813                  (self.coors[1][u] - self.coors[1][v]) ** 2) for 
    814814                  (u, v) in self.graph.edges()] 
    815815        self.mdsScaleRatio = d / sum(e) * float(len(e)) 
    816816        #print d / sum(e) * float(len(e)) 
    817          
     817 
    818818        if avgLinkage: 
    819819            matrix = self.items_matrix.avgLinkage(self.mdsComponentList) 
    820820        else: 
    821821            matrix = self.items_matrix 
    822          
     822 
    823823        #if self.mds == None:  
    824824        self.mds = Orange.projection.mds.MDS(matrix) 
    825          
     825 
    826826        if mdsFromCurrentPos: 
    827827            if avgLinkage: 
     
    833833            else: 
    834834                for u in range(self.graph.number_of_nodes()): 
    835                     self.mds.points[u][0] = self.coors[0][u]  
     835                    self.mds.points[u][0] = self.coors[0][u] 
    836836                    self.mds.points[u][1] = self.coors[1][u] 
    837              
     837 
    838838        # set min stress difference between 0.01 and 0.00001 
    839839        self.minStressDelta = minStressDelta 
    840840        self.callbackUpdateCanvas = callbackUpdateCanvas 
    841841        self.callbackProgress = callbackProgress 
    842          
     842 
    843843        if torgerson: 
    844             self.mds.Torgerson()  
    845  
    846         self.mds.optimize(mdsSteps, Orange.projection.mds.SgnRelStress, self.minStressDelta,\ 
     844            self.mds.Torgerson() 
     845 
     846        self.mds.optimize(mdsSteps, Orange.projection.mds.SgnRelStress, self.minStressDelta, \ 
    847847                          progress_callback=self.mds_callback) 
    848848        self.mds_update_data(self.mdsComponentList, self.mds, callbackUpdateCanvas) 
    849          
     849 
    850850        if callbackProgress != None: 
    851851            callbackProgress(self.mds.avg_stress, self.mdsStep) 
    852          
     852 
    853853        del self.rotationOnly 
    854854        del self.diag_coors 
     
    868868                                   callbackProgress=None, \ 
    869869                                   callbackUpdateCanvas=None, torgerson=0, \ 
    870                                    minStressDelta = 0, scalingRatio=0,\ 
     870                                   minStressDelta=0, scalingRatio=0, \ 
    871871                                   mdsFromCurrentPos=0): 
    872872        return self.mds_components(mdsSteps, mdsRefresh, callbackProgress, \ 
     
    875875                                   scalingRatio=scalingRatio, \ 
    876876                                   mdsFromCurrentPos=mdsFromCurrentPos) 
    877      
     877 
    878878    ########################################################################## 
    879879    ### BEGIN: DEPRECATED METHODS (TO DELETE IN ORANGE 3.0)                ### 
    880880    ########################################################################## 
    881      
     881 
    882882    def map_to_graph(self, graph): 
    883883        nodes = sorted(graph.nodes()) 
    884         return dict((v, (self.coors[0][i], self.coors[1][i])) for i,v in \ 
     884        return dict((v, (self.coors[0][i], self.coors[1][i])) for i, v in \ 
    885885                    enumerate(nodes)) 
    886      
     886 
     887 
    887888class NxView(object): 
    888     """Network View 
    889      
    890     """ 
    891      
     889    """Network View""" 
     890 
    892891    def __init__(self, **attr): 
    893892        self._network = None 
    894893        self._nx_explorer = None 
    895          
     894 
    896895    def set_nx_explorer(self, _nx_explorer): 
    897896        self._nx_explorer = _nx_explorer 
    898          
     897 
    899898    def init_network(self, graph): 
    900899        return graph 
    901          
    902     def nodes_selected(self): 
     900 
     901    def node_selection_changed(self): 
    903902        pass 
    904903 
    905     #def node_selection_changed(self): 
    906     #    pass 
     904    def update_network(self): 
     905        if self._nx_explorer is not None and self._network is not None: 
     906            subnet = self._network 
     907            self._nx_explorer.change_graph(subnet) 
Note: See TracChangeset for help on using the changeset viewer.