def __init__(self, data=None, **attr): # the init could be # graph = Graph(g) where g is a Graph # graph = Graph((v,e)) where v is Graph.v like and e is Graph.e like # graph = Graph(({},e)) for an edgelist with no specified nodes # others with classmethods like # Graph.from_adjacency_matrix(m) # Graph.from_adjacency_list(l) # # should abstract the data here self._nodedata = {} # empty node attribute dict self._adjacency = {} # empty adjacency dict # the interface is n,e,a,data self.n = Nodes(self._nodedata, self._adjacency) # rename to self.nodes self.e = Edges(self._nodedata, self._adjacency) # rename to self.edges self.a = Adjacency(self._adjacency) # rename to self.adjacency self.data = {} # dictionary for graph attributes # load with data if hasattr(data,'n') and not hasattr(data,'name'): # it is a new graph self.n.update(data.n) self.e.update(data.e) self.data.update(data.data) data = None try: nodes,edges = data # containers of edges and nodes self.n.update(nodes) self.e.update(edges) except: # old style if data is not None: convert.to_networkx_graph(data, create_using=self) # load __init__ graph attribute keywords self.data.update(attr)
def setUp(self): self.Graph = nxGraph # build dict-of-dict-of-dict K3 ed1, ed2, ed3 = ({}, {}, {}) self.k3adj = { 0: { 1: ed1, 2: ed2 }, 1: { 0: ed1, 2: ed3 }, 2: { 0: ed2, 1: ed3 } } self.k3edges = [(0, 1), (0, 2), (1, 2)] self.k3nodes = [0, 1, 2] self.K3 = self.Graph() self.K3.adj = self.K3._adjacency = self.K3.edge = self.k3adj self.K3.node = self.K3._nodedata = {} self.K3.node[0] = {} self.K3.node[1] = {} self.K3.node[2] = {} self.K3.n = Nodes(self.K3._nodedata, self.K3._adjacency) self.K3.e = Edges(self.K3._nodedata, self.K3._adjacency) self.K3.a = Adjacency(self.K3._adjacency)
def addEdges(self, v1, v2, weight=None, orientation=None): """ Add a new edges in the Graph Required parameters : v1 : the first edge v2 : the second edge Optional parameters : weight : if weighted graph, must add a weight (default : None) orientation : if oriented graph, must add an orientation (default : None) """ existing_vertices = self.getVertices() if v1 in existing_vertices and v2 in existing_vertices: if not self.existingEdges(v1, v2): if not self.weighted: weight = None else: if weight == None: print("Error : Weighted graph, must add a weight.") return -1 if not self.oriented: orientation = None else: if orientation == None: print( "Error : Oriented Graph, must add an orientation.") return -1 new_edges = Edges(v1, v2, weight, orientation) self.edges.append(new_edges) else: print("Error : [" + v1 + "," + v2 + "]" + " already exists.") else: print("Error : " + v1 + " or " + v2 + " doesn't exist.")
def __init__(self, data=None, **attr): # the init could be # graph = Graph(g) where g is a Graph # graph = Graph((v,e)) where v is Graph.v like and e is Graph.e like # graph = Graph(({},e)) for an edgelist with no specified nodes # others with classmethods like # Graph.from_adjacency_matrix(m) # Graph.from_adjacency_list(l) # # should abstract the data here self._nodedata = {} # empty node attribute dict self._adjacency = {} # empty adjacency dict # the interface is n,e,a,data self.n = Nodes(self._nodedata, self._adjacency) # rename to self.nodes self.e = Edges(self._nodedata, self._adjacency) # rename to self.edges self.a = Adjacency(self._adjacency) # rename to self.adjacency self.data = {} # dictionary for graph attributes # load with data if hasattr(data, "n") and not hasattr(data, "name"): # it is a new graph self.n.update(data.n) self.e.update(data.e) self.data.update(data.data) data = None try: nodes, edges = data # containers of edges and nodes self.n.update(nodes) self.e.update(edges) except: # old style if data is not None: convert.to_networkx_graph(data, create_using=self) # load __init__ graph attribute keywords self.data.update(attr)
def __init__(self, graph, subnodes): # TODO Can we replace nbunch_iter with set(subnodes) & set(graph)? # We lose the Error messages... self._subnodes = set(self._nbunch_iter(graph, subnodes)) self._nodedata = SubNbrDict(self._subnodes, graph._nodedata) self._adjacency = SubAdjacency(self._subnodes, graph._adjacency) self.data = graph.data self.n = Nodes(self._nodedata, self._adjacency) self.e = Edges(self._nodedata, self._adjacency) self.a = self._adjacency
def do_POST(self): if re.search('/edge/status_report/*', self.path) is not None: edge_id = self.path.split('/')[-1] data = self.rfile.read() edge = json.loads(data) self.send_response(200) self.end_headers() edges = Edges.get_instance() edges.update_edge(edge_id, edge) log.info('edge {} report status {}'.format(edge_id, edge)) else: self.send_response(403) self.send_header('Content-Type', 'application/json') self.end_headers() return
def do_GET(self): if re.search('/content/*', self.path) is not None: content_id = self.path.split('/')[-1] self.send_response(200) self.send_header('Content-Type', 'application/json') self.end_headers() edges = Edges.get_instance() target = edges.get_edge(content_id) json_string = json.dumps(target) self.wfile.write(bytes(json_string, 'utf-8')) log.info('Access {} in {}'.format(content_id, json_string)) else: self.send_response(403) self.send_header('Content-Type', 'application/json') self.end_headers() return
def setUp(self): self.v1 = Vertex() self.v2 = Vertex() self.v3 = Vertex() self.v4 = Vertex() self.v5 = Vertex() self.e1 = Edge(self.v1, self.v2) self.e2 = Edge(self.v2, self.v3) self.e3 = Edge(self.v3, self.v4) self.e4 = Edge(self.v4, self.v5) self.e5 = Edge(self.v1, self.v3) self.e6 = Edge(self.v1, self.v4) self.e7 = Edge(self.v1, self.v5) self.edges = Edges({self.e1, self.e2, \ self.e3, self.e4, self.e5, \ self.e6, self.e7})
class Sketch: def __init__(self, image): self.img = cv.imread(image) def sketch(self): grey = cv.cvtColor(self.img, cv.COLOR_BGR2GRAY) inv = 255 - grey blur = cv.GaussianBlur(inv, (13,13), 0) return cv.divide(grey, 255-blur, scale=256) img = Image.open(filename) sketch = Sketch(filename).sketch() cv.imwrite("sketch.png", sketch) bg = Background(img.size, octaves=6).background() edges = Edges(filename).edges() #sketchTrans = cv.cvtColor(sketch, cv.COLOR_GRAY2RGBA) mask = edges[3] sketch = cv.bitwise_and(sketch, edges, edges) (thresh, sketch) = cv.threshold(sketch, 240, 255, cv.THRESH_BINARY) #sketch = cv.multiply(sketch, np.array(bg), scale=(1./128)) h, w = sketch.shape[:2] mask = np.zeros((h+2, w+2), np.uint8) #mask[1:h+1, 1:w+1] = sketch sketchColor = cv.cvtColor(sketch, cv.COLOR_GRAY2RGBA) white = np.all(sketchColor == [255,255,255,255], axis=-1) sketchColor[white, -1] = 0 cv.imwrite("final.png", sketchColor)
class Graph(object): def __init__(self, data=None, **attr): # the init could be # graph = Graph(g) where g is a Graph # graph = Graph((v,e)) where v is Graph.v like and e is Graph.e like # graph = Graph(({},e)) for an edgelist with no specified nodes # others with classmethods like # Graph.from_adjacency_matrix(m) # Graph.from_adjacency_list(l) # # should abstract the data here self._nodedata = {} # empty node attribute dict self._adjacency = {} # empty adjacency dict # the interface is n,e,a,data self.n = Nodes(self._nodedata, self._adjacency) # rename to self.nodes self.e = Edges(self._nodedata, self._adjacency) # rename to self.edges self.a = Adjacency(self._adjacency) # rename to self.adjacency self.data = {} # dictionary for graph attributes # load with data if hasattr(data,'n') and not hasattr(data,'name'): # it is a new graph self.n.update(data.n) self.e.update(data.e) self.data.update(data.data) data = None try: nodes,edges = data # containers of edges and nodes self.n.update(nodes) self.e.update(edges) except: # old style if data is not None: convert.to_networkx_graph(data, create_using=self) # load __init__ graph attribute keywords self.data.update(attr) def s(self, nbunch): H = Subgraph(self, nbunch) return H # crazy use of call - get subgraph? def __call__(self, nbunch): return self.s(nbunch) # rewrite these in terms of new interface def __iter__(self): return iter(self.n) def __len__(self): return len(self.n) def clear(self): self.name = '' self.n.clear() self.e.clear() self.data.clear() def copy(self, with_data=True): if with_data: return deepcopy(self) G = self.__class__() G.n.update(self.n) G.e.update(self.e) return G def is_multigraph(self): """Return True if graph is a multigraph, False otherwise.""" return False def is_directed(self): """Return True if graph is directed, False otherwise.""" return False def order(self): return len(self.n) def size(self, weight=None): s = sum(d for v, d in self.n.degree(weight=weight)) # If `weight` is None, the sum of the degrees is guaranteed to be # even, so we can perform integer division and hence return an # integer. Otherwise, the sum of the weighted degrees is not # guaranteed to be an integer, so we perform "real" division. return s // 2 if weight is None else s / 2 @classmethod def from_adjacency_matrix(self, matrix): import numpy as np kind_to_python_type={'f':float, 'i':int, 'u':int, 'b':bool, 'c':complex, 'S':str, 'V':'void'} try: # Python 3.x blurb = chr(1245) # just to trigger the exception kind_to_python_type['U']=str except ValueError: # Python 2.6+ kind_to_python_type['U']=unicode n,m=matrix.shape if n!=m: raise nx.NetworkXError("Adjacency matrix is not square.", "nx,ny=%s"%(matrix.shape,)) dt=matrix.dtype try: python_type=kind_to_python_type[dt.kind] except: raise TypeError("Unknown numpy data type: %s"%dt) # Make sure we get even the isolated nodes of the graph. nodes = range(n) # Get a list of all the entries in the matrix with nonzero entries. These # coordinates will become the edges in the graph. edges = zip(*(np.asarray(matrix).nonzero())) # handle numpy constructed data type if python_type is 'void': # Sort the fields by their offset, then by dtype, then by name. fields = sorted((offset, dtype, name) for name, (dtype, offset) in matrix.dtype.fields.items()) triples = ((u, v, {name: kind_to_python_type[dtype.kind](val) for (_, dtype, name), val in zip(fields, matrix[u, v])}) for u, v in edges) else: # basic data type triples = ((u, v, dict(weight=python_type(matrix[u, v]))) for u, v in edges) graph = self((nodes, triples)) return graph @classmethod def from_adjacency_list(self, adjlist): nodes = range(len(adjlist)) edges = [(node,n) for node,nbrlist in enumerate(adjlist) for n in nbrlist] return self((nodes,edges))
from edges import Edges if __name__ == '__main__': rng = 5 edges = Edges(edges_filename='edges_dump').get_edges() print(edges[1]) for index, edge in edges.items(): print(index) print(edge.speed_indicators) break
def create(cls, vertices = Vertices()): edges = Edges.create(vertices) return Graph(vertices, edges)
def complement(self): all_edges = Edges.create(self.vertices) return Graph(self.vertices, all_edges - self.edges)
def test_size(self): """O tamanho de um conjunto de arestas é o número de arestas""" self.assertEqual(self.edges.size(), 7) e = Edges() self.assertEqual(e.size(), 0)
class TestEdges(unittest.TestCase): def setUp(self): self.v1 = Vertex() self.v2 = Vertex() self.v3 = Vertex() self.v4 = Vertex() self.v5 = Vertex() self.e1 = Edge(self.v1, self.v2) self.e2 = Edge(self.v2, self.v3) self.e3 = Edge(self.v3, self.v4) self.e4 = Edge(self.v4, self.v5) self.e5 = Edge(self.v1, self.v3) self.e6 = Edge(self.v1, self.v4) self.e7 = Edge(self.v1, self.v5) self.edges = Edges({self.e1, self.e2, \ self.e3, self.e4, self.e5, \ self.e6, self.e7}) def test_size(self): """O tamanho de um conjunto de arestas é o número de arestas""" self.assertEqual(self.edges.size(), 7) e = Edges() self.assertEqual(e.size(), 0) def test_valid_vertice(self): """Um vértice é válido se pertence à alguma aresta de E""" v = Vertex('v') self.assertTrue(self.edges.valid_vertice(self.v1)) self.assertFalse(self.edges.valid_vertice(v)) def test_eq(self): """Dois conjuntos de arestas são iguais, não importa a ordem""" es2 = Edges({self.e7, \ self.e6, self.e5, self.e4, \ self.e3, self.e2, self.e1}) self.assertTrue(self.edges == es2) def test_eq_false(self): """Dois conjuntos de arestas não são iguais, se não possuem mesmos componentes""" es2 = Edges({self.e7, \ self.e6, self.e5, self.e4, \ self.e3, self.e2, self.e1, Edge(Vertex(), Vertex())}) self.assertFalse(self.edges == es2) def test_contains(self): """É possível utilizar o operador in e not in para verificar pertencimento""" self.assertTrue(self.e1 in self.edges) self.assertTrue(self.e2 in self.edges) self.assertTrue(Edge(Vertex(), Vertex()) not in self.edges) def test_subset(self): """É possível utilizar o operador <= para verificar se é subconjunto""" es1 = Edges({self.e1}) es2 = Edges({self.e2}) es3 = Edges({self.e1, self.e2, Vertex()}) eigual = Edges({self.e7, \ self.e6, self.e5, self.e4, \ self.e3, self.e2, self.e1}) self.assertTrue(es1 <= self.edges) self.assertTrue(es2 <= self.edges) self.assertTrue(eigual <= self.edges) self.assertFalse(es3 <= self.edges) def test_iterator(self): """É possível iterar sobre o conjunto de arestas""" i = 0 es = set() for e in self.edges: es.add(e) self.assertEqual(Edges(es), self.edges) def test_isdisjoint(self): """Dois conjuntos distintos de arestas são disjuntos""" self.assertTrue(self.edges.isdisjoint(Edges({Edge(Vertex(), Vertex())})))
class Graph(object): def __init__(self, data=None, **attr): # the init could be # graph = Graph(g) where g is a Graph # graph = Graph((v,e)) where v is Graph.v like and e is Graph.e like # graph = Graph(({},e)) for an edgelist with no specified nodes # others with classmethods like # Graph.from_adjacency_matrix(m) # Graph.from_adjacency_list(l) # # should abstract the data here self._nodedata = {} # empty node attribute dict self._adjacency = {} # empty adjacency dict # the interface is n,e,a,data self.n = Nodes(self._nodedata, self._adjacency) # rename to self.nodes self.e = Edges(self._nodedata, self._adjacency) # rename to self.edges self.a = Adjacency(self._adjacency) # rename to self.adjacency self.data = {} # dictionary for graph attributes # load with data if hasattr(data, "n") and not hasattr(data, "name"): # it is a new graph self.n.update(data.n) self.e.update(data.e) self.data.update(data.data) data = None try: nodes, edges = data # containers of edges and nodes self.n.update(nodes) self.e.update(edges) except: # old style if data is not None: convert.to_networkx_graph(data, create_using=self) # load __init__ graph attribute keywords self.data.update(attr) def s(self, nbunch): H = Subgraph(self, nbunch) return H # crazy use of call - get subgraph? def __call__(self, nbunch): return self.s(nbunch) # rewrite these in terms of new interface def __iter__(self): return iter(self.n) def __len__(self): return len(self.n) def clear(self): self.name = "" self.n.clear() self.e.clear() self.data.clear() def copy(self, with_data=True): if with_data: return deepcopy(self) G = self.__class__() G.n.update(self.n) G.e.update(self.e) return G def is_multigraph(self): """Return True if graph is a multigraph, False otherwise.""" return False def is_directed(self): """Return True if graph is directed, False otherwise.""" return False def order(self): return len(self.n) def size(self, weight=None): s = sum(d for v, d in self.n.degree(weight=weight)) # If `weight` is None, the sum of the degrees is guaranteed to be # even, so we can perform integer division and hence return an # integer. Otherwise, the sum of the weighted degrees is not # guaranteed to be an integer, so we perform "real" division. return s // 2 if weight is None else s / 2 @classmethod def from_adjacency_matrix(self, matrix): import numpy as np kind_to_python_type = {"f": float, "i": int, "u": int, "b": bool, "c": complex, "S": str, "V": "void"} try: # Python 3.x blurb = chr(1245) # just to trigger the exception kind_to_python_type["U"] = str except ValueError: # Python 2.6+ kind_to_python_type["U"] = unicode n, m = matrix.shape if n != m: raise nx.NetworkXError("Adjacency matrix is not square.", "nx,ny=%s" % (matrix.shape,)) dt = matrix.dtype try: python_type = kind_to_python_type[dt.kind] except: raise TypeError("Unknown numpy data type: %s" % dt) # Make sure we get even the isolated nodes of the graph. nodes = range(n) # Get a list of all the entries in the matrix with nonzero entries. These # coordinates will become the edges in the graph. edges = zip(*(np.asarray(matrix).nonzero())) # handle numpy constructed data type if python_type is "void": # Sort the fields by their offset, then by dtype, then by name. fields = sorted((offset, dtype, name) for name, (dtype, offset) in matrix.dtype.fields.items()) triples = ( ( u, v, {name: kind_to_python_type[dtype.kind](val) for (_, dtype, name), val in zip(fields, matrix[u, v])}, ) for u, v in edges ) else: # basic data type triples = ((u, v, dict(weight=python_type(matrix[u, v]))) for u, v in edges) graph = self((nodes, triples)) return graph @classmethod def from_adjacency_list(self, adjlist): nodes = range(len(adjlist)) edges = [(node, n) for node, nbrlist in enumerate(adjlist) for n in nbrlist] return self((nodes, edges))