def graph_property(self, property_name): """todo""" try: return self._graph_property[property_name] except KeyError: raise PropertyError("property %s is undefined on graph" % property_name)
def remove_vertex_property(self, property_name): """todo""" try: del self._vertex_property[property_name] except KeyError: raise PropertyError("property %s is undefined on vertices" % property_name)
def add_graph_property(self, property_name, values=None): """todo""" if property_name in self._graph_property: raise PropertyError("property %s is already defined on graph" % property_name) if values is None: values = {} self._graph_property[property_name] = values
def edge_property(self, property_name): """todo""" try: return self._edge_property[property_name] except KeyError: raise PropertyError("property %s is undefined on edges" % property_name)
def update_interface_property(self, property_name, degree, values, keys=None): """todo""" if not (isinstance(values, np.ndarray) or isinstance(values, dict) or isinstance(values, array_dict)): raise TypeError( "Values are not in an acceptable type (array, dict, array_dict)" ) if property_name not in self._interface_properties[degree]: print PropertyError("property " + property_name + " is undefined on elements of degree " + str(degree)) print "Creating property ", property_name, " for degree ", degree self._interface_properties[degree][property_name] = array_dict() if isinstance(values, np.ndarray): if keys is None: keys = np.array(self._interface.keys()) self._interface_properties[degree][property_name].update( values, keys=keys, ignore_missing_keys=False) elif isinstance(values, dict): if keys is None: keys = np.array(values.keys()) self._interface_properties[degree][property_name].update( np.array(values.values()), keys=keys, ignore_missing_keys=False) elif isinstance(values, array_dict): if keys is None: keys = values.keys() self._interface_properties[degree][property_name].update( values.values(), keys=keys, ignore_missing_keys=False)
def add_domains_from_dict(self, dict_domains, domain_names): """ If one already posses a dict indicating for a list of vertex which domain they belong to, it can be given to the graph directly. :Parameters: - `dict_domains` (dict) - *keys = ids (SpatialImage); *values = intergers indicating the domain(s) - `domain_name` (list) - a list containing the name of the domain(s) """ list_domains = np.unique(dict_domains.values()) if len(domain_names) != len(list_domains): warnings.warn( "You didn't provided the same number of domains and domain names." ) pass if not "domains" in self._vertex_property.keys(): self.add_vertex_property("domains") for domain, domain_name in enumerate(domain_names): if domain_name in self._graph_property: raise PropertyError( "property {} is already defined on graph".format( domain_name)) self._graph_property[domain_name] = [] for vid in dict_domains: if dict_domains[vid] == list_domains[domain]: self._add_vertex_to_domain(set([vid]), domain_name)
def interface_property(self, property_name, degree, wids=None): """todo""" try: return self._interface_properties[degree][property_name] except KeyError: raise PropertyError("property " + property_name + " is undefined on interfaces of degree " + str(degree))
def is_connected_domain(self, domain_name, edge_type=None): """Return True if a domain is connected.""" if not domain_name in self._graph_property: raise PropertyError("property %s is not defined on graph" % domain_name) domain_sub_graph = Graph.sub_graph(self, self._graph_property[domain_name]) distances = domain_sub_graph.topological_distance( domain_sub_graph._vertices.keys()[0], edge_type=edge_type) return not float('inf') in distances.values()
def remove_graph_property(self, property_name): """todo""" try: del self._graph_property[property_name] except KeyError: raise PropertyError("property %s is undefined on graph" % property_name) try: del self._graph_property['units'][property_name] except KeyError: pass
def vertex_property(self, property_name, vids=None): """todo""" try: if vids is not None: return dict([(k, v) for k, v in self._vertex_property[property_name].iteritems() if k in vids]) else: return self._vertex_property[property_name] except KeyError: raise PropertyError("property %s is undefined on vertices" % property_name)
def remove_domain(self, domain_name): """Remove a domain `domain_name`.""" if not domain_name in self._graph_property: raise PropertyError( "property {} is not defined on graph".format(domain_name)) for vid in self.iter_domain(domain_name): self._vertex_property["domains"][vid].remove(domain_name) if self._vertex_property["domains"][vid] == []: self._vertex_property["domains"].pop(vid) return self._graph_property.pop(domain_name)
def wisp_property(self, property_name, degree, wids=None): """todo""" try: if wids is not None: return array_dict( self._wisp_properties[degree][property_name].values(wids), wids) else: return self._wisp_properties[degree][property_name] except KeyError: raise PropertyError("property " + property_name + " is undefined on wisps of degree " + str(degree))
def add_domain_from_func(self, func, domain_name): """ Create a domain `domain_name` of vertices according to a function `func`. :Parameters: - `func` : the function to make the domain (might return True or False) - `domain_name` : the name of the domain """ if domain_name in self._graph_property: raise PropertyError( "property {} is already defined on graph".format(domain_name)) self._graph_property[domain_name] = [] if not "domains" in self._vertex_property.keys(): self.add_vertex_property("domains") for vid in self._vertices.keys(): if func(self, vid): self._add_vertex_to_domain(set([vid]), domain_name)
def add_interface_property(self, property_name, degree, values=None): """todo""" if property_name in self._interface_properties[degree]: raise PropertyError( "property " + property_name + " is already defined on interfaces of degree " + str(degree)) if values is None: values = array_dict() elif isinstance(values, np.ndarray): keys = np.array(self._interface.keys()) values = array_dict(values, keys) elif isinstance(values, dict): values = array_dict(values) if not isinstance(values, array_dict): raise TypeError( "Values are not in an acceptable type (array, dict, array_dict)" ) self._interface_properties[degree][property_name] = values
def extend_graph_property(self, property_name, values): """todo""" assert values is not None if property_name not in self._graph_property: raise PropertyError("property %s is not defined on graph" % property_name) #~ if self.graph_property(property_name) is not None or self.graph_property(property_name) != []: #~ assert isinstance(values, type(self.graph_property(property_name))) if isinstance(self.graph_property(property_name), list): self._graph_property[property_name].extend(values) elif isinstance(self.graph_property(property_name), dict): self._graph_property[property_name].update( dict([(k, v) for k, v in values.iteritems() if k not in self.graph_property(property_name).keys()])) else: print "Unable to extend 'graph_property' with this type of data: {}".format( type(values))
def extend_vertex_property(self, property_name, values): """todo AND TO CHECK AND TEST !!""" if not isinstance(values, dict): raise TypeError("Values %s is not a type 'dict'" % values) if property_name not in self._vertex_property: print PropertyError("Property %s is not defined on vertices" % property_name) print "Creating vertex property %s" % property_name self._vertex_property[property_name] = {} for k, v in values.iteritems(): if k in self.vertices(): if not self._vertex_property[property_name].has_key(k): self._vertex_property[property_name][k] = v else: print "Vertex id {} already has a value for vertex property {}".format( k, property_name) else: print "Vertex id {} doesn't exist in the graph !!".format(k)
def iter_domain(self, domain_name): if not domain_name in self._graph_property: raise PropertyError( "property {} is not defined on graph".format(domain_name)) return iter(self._graph_property[domain_name])
def remove_vertex_from_domain(self, vids, domain_name): """Remove a set of vertices `vids` from a domain `domain_name`.""" if not domain_name in self._graph_property: raise PropertyError( "property {} is not defined on graph".format(domain_name)) self._remove_vertex_from_domain(self.__to_set(vids), domain_name)
def add_edge_property(self, property_name): """todo""" if property_name in self._edge_property: raise PropertyError("property %s is already defined on edges" % property_name) self._edge_property[property_name] = {}