class Scene: def __init__(self): self.reset(gen_uuid()) def update(self, nodes): current_time = rospy.Time.now() for node in nodes: node.last_update.data = current_time if node.parent not in self.__nodes: node.parent = self.root_id() self.__nodes.update(nodes) return [n.id for n in nodes if n.name != "root"] def remove(self, ids): self.__nodes.remove(ids) return ids def root_id(self): return self.__root_id def nodes(self): return self.__nodes def reset(self, root_id): self.__root_id = root_id if not hasattr(self, '__nodes'): node_ids = [] self.__nodes = Nodes() else: node_ids = self.__nodes.ids() self.__nodes.reset() root = Node(id=self.__root_id, name="root") root.position.pose.orientation.w = 1.0 self.__nodes.update([root]) return node_ids
} """ client = Nodes() # client.create(**input) # node = client.retrieveById('0cd16aed4e20f18b') # for ent in node: # print ent, ': ', node[ent] ''' list = client.retrieveAll() for node in list: for ent in node: print ent, ': ', node[ent] print ''' ''' update_input = { '_id': '0cd16aed4e20f18b', 'nodeDisplay': 'TestNode3_modified', 'nodeDescription': 'Test for Nodes Class', 'nodeTags': ndtags, 'nodeParents': ndparents, 'nodeChildren': ndchildren, 'nodeVotes': ndvotes, 'nodeStatus': count, 'nodeCreateAt': node['nodeCreateAt'] } client.update(**update_input) ''' # nodeDisply is another attribute which can uniquely identify a node # children = client.retrieveChild('0cd39ce2bd2095cb')
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))
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))