Python Network.metadata方法代码示例

# 需要导入模块: from network import Network [as 别名]
# 或者: from network.Network import metadata [as 别名]
    def add_network_from_matrix(self, name, matrix, like_network = None, metadata = None, \
                                directed = False, hierarchical = False, hypergraph = False):
        """ Add a network to the cfile based on the given connectivity matrix and
        an already existing other network with node and surface container information.
        
        Parameters
        ----------
        name : String
            Name of the newly added network
        matrix : NxN array
            A NxN Numpy array with the values for the edges. N must be the same
            as len(like_network.graph.nodes()). The first row of the matrix
            corresponds to the `NetworkX` node with id 'n1'
        like_network : `INetwork` object, optional
            Used to copy graph node information and surface containers
        metadata : Dict, optional
            A dictionary of metadata
        directed : bool, optional
            Is the network directed?
        hierarchical : bool, optional
            Is the network hierarchical? (default: '0') Not implemented yet.
        hypergraph : bool, optional
            Is the network a hypergraph? (default: '0') Not implemented yet.
            
        Returns
        -------
        networkid : int
            The index in the list of networks in the cfile
            
        Note
        ----
        If you use this function only with name and matrix, a spring-force layout
        algorithm is applied to define the node positions. This may take some time.
        You can also use the `add_network_from_matrix_pos` and define the
        node positions by yourself.
        
        """
        from cviewer.plugins.cff.network import Network
        
        create_graph_info = False
        
        if like_network is None:
            create_graph_info = True
        else:
            # matrix has N rows and columns which is equal to the number of nodes
            assert matrix.shape[0] == matrix.shape[1] == len(like_network.graph.nodes())

        # add graph 
        import networkx as nx
        test_G = nx.from_numpy_matrix(matrix)
        
        # relabeling function
        addn = lambda nmod:'n'+str(nmod+1)
        
        # relabel graph
        test_G_corrected = nx.relabel_nodes(test_G, addn)
        
        nodes_ids = test_G_corrected.nodes()
        
        # create node positions with springlayout if create_graph_info
        if create_graph_info:
            npos = nx.spring_layout(test_G_corrected, dim = 3, weighted = True, scale = 100)
        
        # add node properties
        if not create_graph_info:
            for k, v in like_network.graph.nodes(data=True):
                if not k in nodes_ids:
                    logger.error('Node id %s is not like_network.graph' % str(k))
                # add node properties
                test_G_corrected.node[k] = v
        else:
            for k in test_G_corrected.nodes():
                li = str(npos[k].tolist())
                li = li.replace('[','')
                li = li.replace(']','')
                test_G_corrected.node[k]['dn_position'] = li
                
                
        # create a new network object
        my_network = Network(name = name, directed = directed, hierarchical = hierarchical, \
                             hypergraph = hypergraph, graph = test_G_corrected)
        
        if not metadata is None:
            my_network.metadata = metadata
            
        # setting the correct parent cfile
        my_network._parentcfile = self
                
        if not create_graph_info:
            # add surface container from like_network
            action = ThreadedParsing(self)
            for surf in like_network.surfaces:
                if surf.is_atlas:
                    tmp_surfcont = action.process_atlas(surface_node=surf._lxml_node, \
                                                        nsprefix=surf._lxml_node_prefix)
                else:
                    tmp_surfcont = action.process_surface(surface_node=surf._lxml_node, \
                                                        nsprefix=surf._lxml_node_prefix)
                my_network.add_surface_container(tmp_surfcont)

#.........这里部分代码省略.........

# 需要导入模块: from network import Network [as 别名]
# 或者: from network.Network import metadata [as 别名]
    def run(self):
        logger.debug("Start Threaded Parsing of Connectome File ...")
        import time
        tic = time.time()
        
        # given the full path to meta.xml, create lxml tree and
        # under the precondition of having a certain file version and generator
        # one can assume some content of the .cff file
        # loop over the networks, for each network, the surfaces etc.
        # in the form of all the attributes (name, srce filename, description etc.)
        # are given to the created Network instance methods to complete
        from lxml import etree
        tree = etree.fromstring(self.metaxmlcontent)   
        nsprefix = "{%s}" % tree.nsmap[None]
        
        t = 0
        for child in tree.iterchildren():
            if child.tag == (nsprefix+'viewer-network'):
                t = t + 1

        if t != self.data.metadata.nr_of_networks:
            logger.error('The number of networks of networks in meta.xml is not correct!')
            logger.error('Loading ' + str(t) + ' network(s).')


        # find all the networks
        for child in tree.iterchildren():
            if child.tag == (nsprefix+'viewer-network'):

                # load network as string from zip
                # create temporary StringIO
                logger.info('-----------------------------------------')
                logger.info('Now loading ' + child.attrib['src'])
                logger.info('-----------------------------------------')
                
                if child.attrib.has_key('src'):
                    (tmpstring, pickled_graph, local_fname) = self.process_pickle(childnode = child)
                
                tmp_network = Network(name = child.attrib['name'],
                                    src = tmpstring,
                                    pickled_graph = pickled_graph,
                                    directed = child.attrib['directed'],
                                    hierarchical = child.attrib['hierarchical'],
                                    hypergraph = child.attrib['hypergraph'])

                # store pickled version in connectome file
                if not tmpstring is None and pickled_graph is None:
                    self.save_pickle_in_cfile(local_fname, networkref = tmp_network)

                
                # iterate over children
                for mchildren in child.iterchildren():
                    
                    # handling of the metadata
                    # -------------------------
                    if mchildren.tag == (nsprefix+'network-metadata'):
                        tmp_network.metadata = self.process_metadata(metadata_node = mchildren, nsprefix = nsprefix)
                        
                        
                    # handling of the surfaces
                    # ------------------------
                    if mchildren.tag == (nsprefix+'network-surface'):
                    
                        # load into surface
                        attr = mchildren.attrib
    
                        if attr.has_key('src'):
                            # create surface container
                            tmpsurfacecontainer = self.process_surface(surface_node = mchildren, nsprefix = nsprefix)
                            # and add it to the network
                            tmp_network.add_surface_container(tmpsurfacecontainer)

                        # adding a template atlas if stated in the meta.xml
                        if attr.has_key('addatlas'):
                            # create surface container for atlas
                            tmpsurfacecontainer = self.process_atlas(surface_node = mchildren, nsprefix = nsprefix)
                            # and add it to the network
                            tmp_network.add_surface_container(tmpsurfacecontainer)
                            
                        
                    # handling of the volumes
                    # -----------------------
                    elif mchildren.tag == (nsprefix+'network-volume'):
                        
                        # get the description, is there an easier way with lxml?
                        for desc in mchildren.iterchildren():
                            if desc.tag == (nsprefix+'description'):
                                mydescr = desc.text
                      
                        attr = mchildren.attrib
                        
                        if attr.has_key('src') and attr.has_key('name'):
                          
                            if not attr.has_key('segmentation'):
                                segm = False
                            else:
                                segm = bool(attr['segmentation'])
                          
                            # create an instance of the Volume class with it
                            tmpvolume = Volume(volumename = attr['name'], \
#.........这里部分代码省略.........

# 需要导入模块: from network import Network [as 别名]
# 或者: from network.Network import metadata [as 别名]
    def add_network_from_matrix_with_pos(self, name, matrix, pos, nodeinfo_like_graph = None, \
                                         metadata = None, directed = False, hierarchical = False, hypergraph = False):
        """ Add a network to the cfil based on the given connectivity matrix and
        position information.
        
        Parameters
        ----------
        name : String
            Name of the newly added network
        matrix : NxN array
            A NxN Numpy array with the values for the edges. N must be the same
            as len(like_network.graph.nodes()). The first row of the matrix
            corresponds to the `NetworkX` node with id 'n1'
        pos : Nx3 array
            A Nx3 array with the X,Y,Z coordinates for every row (=node) of the matrix
        nodeinfo_like_graph : `NetworkX` graph
            Use the node information for the new network
        metadata : Dict
            A dictionary of metadata
        directed : bool
            Is the network directed?
        hierarchical : bool
            Is the network hierarchical? (default: '0') Not implemented yet.
        hypergraph : bool
            Is the network a hypergraph? (default: '0') Not implemented yet.
            
        Returns
        -------
        networkid : int
            The index in the list of networks in the cfile
        """
        from cviewer.plugins.cff.network import Network
        
        # create a new network object
        my_network = Network(name = name, directed = directed, hierarchical = hierarchical, \
                             hypergraph = hypergraph)
        
        if not metadata is None:
            my_network.metadata = metadata

        # add graph 
        import networkx as nx
        test_G = nx.from_numpy_matrix(matrix)
        
        # relabeling function
        addn = lambda nmod:'n'+str(nmod+1)
        
        # relabel graph
        test_G_corrected = nx.relabel_nodes(test_G, addn)

        # update the node position
        for i in range(matrix.shape[0]):
            nodeid = addn(i)
            if not nodeinfo_like_graph is None and nodeinfo_like_graph.has_node(nodeid):
                test_G_corrected.node[nodeid] = nodeinfo_like_graph.node[nodeid]
            test_G_corrected.node[nodeid]['dn_position'] = ','.join(list(map(str,pos[i, :])))

        my_network.graph = test_G_corrected
        
        # setting the correct parent cfile
        my_network._parentcfile = self


        # add the created network object to this cfile
        self.networks.append(my_network)
        
        # returns the id of the added network
        return len(self.networks)-1