def test_rdflib_to_graphtool():
try:
from graph_tool import util as gt_util
except ImportError:
raise SkipTest("couldn't find graph_tool")
from rdflib.extras.external_graph_libs import rdflib_to_graphtool
g = Graph()
a, b, l = URIRef('a'), URIRef('b'), Literal('l')
p, q = URIRef('p'), URIRef('q')
edges = [(a, p, b), (a, q, b), (b, p, a), (b, p, l)]
for t in edges:
g.add(t)
mdg = rdflib_to_graphtool(g)
assert len(list(mdg.edges())) == 4
vpterm = mdg.vertex_properties['term']
va = gt_util.find_vertex(mdg, vpterm, a)[0]
vb = gt_util.find_vertex(mdg, vpterm, b)[0]
vl = gt_util.find_vertex(mdg, vpterm, l)[0]
assert (va, vb) in [(e.source(), e.target()) for e in list(mdg.edges())]
epterm = mdg.edge_properties['term']
assert len(list(gt_util.find_edge(mdg, epterm, p))) == 3
assert len(list(gt_util.find_edge(mdg, epterm, q))) == 1
mdg = rdflib_to_graphtool(
g,
e_prop_names=[text_type('name')],
transform_p=lambda s, p, o: {text_type('name'): text_type(p)})
epterm = mdg.edge_properties['name']
assert len(list(gt_util.find_edge(mdg, epterm, text_type(p)))) == 3
assert len(list(gt_util.find_edge(mdg, epterm, text_type(q)))) == 1
def get_shortest_path(self, start_key, end_key, key_field):
"""Returns the length of and the vertices involved in the shortest path in the network
:param start_geoid: The string value of the starting GeoID for the shortest path analysis
:param end_geoid: The string value of the ending GeoID for the shortest path analysis
:return shortest_distance, vertex_list, edge_list: The length of the shortest path from the field
weight_distance and the list of vertices and edges in the shortest path network
"""
start_vertex, end_vertex = None, None
vertex_geoid = self._graph.vertex_properties[key_field]
vertices = gutil.find_vertex(self._graph, vertex_geoid, start_key)
if (len(vertices) > 0):
start_vertex = vertices[0]
vertices = gutil.find_vertex(self._graph, vertex_geoid, end_key)
if (len(vertices) > 0):
end_vertex = vertices[0]
if (start_vertex is not None) and (end_vertex is not None):
vertex_list, edge_list = gtopo.shortest_path(self._graph, start_vertex,
end_vertex, self._graph.edge_properties["weight_dist"])
shortest_distance = gtopo.shortest_distance(self._graph, start_vertex,
end_vertex, self._graph.edge_properties["weight_dist"])
return shortest_distance, vertex_list, edge_list
else:
return -1, "Could not find start or end vertex"
def test_rdflib_to_graphtool():
try:
from graph_tool import util as gt_util
except ImportError:
raise SkipTest("couldn't find graph_tool")
from rdflib.extras.external_graph_libs import rdflib_to_graphtool
g = Graph()
a, b, l = URIRef("a"), URIRef("b"), Literal("l")
p, q = URIRef("p"), URIRef("q")
edges = [(a, p, b), (a, q, b), (b, p, a), (b, p, l)]
for t in edges:
g.add(t)
mdg = rdflib_to_graphtool(g)
assert len(list(mdg.edges())) == 4
vpterm = mdg.vertex_properties["term"]
va = gt_util.find_vertex(mdg, vpterm, a)[0]
vb = gt_util.find_vertex(mdg, vpterm, b)[0]
vl = gt_util.find_vertex(mdg, vpterm, l)[0]
assert (va, vb) in [(e.source(), e.target()) for e in list(mdg.edges())]
epterm = mdg.edge_properties["term"]
assert len(list(gt_util.find_edge(mdg, epterm, p))) == 3
assert len(list(gt_util.find_edge(mdg, epterm, q))) == 1
mdg = rdflib_to_graphtool(
g,
e_prop_names=[str("name")],
transform_p=lambda s, p, o: {str("name"): str(p)})
epterm = mdg.edge_properties["name"]
assert len(list(gt_util.find_edge(mdg, epterm, str(p)))) == 3
assert len(list(gt_util.find_edge(mdg, epterm, str(q)))) == 1
def _add_graph_vertices(self, feature, key_field):
"""Add the graph verices as the end points of the street geometry.
This method first checks whether each vertex has already been
added to the network and if not adds it. The method
uses the vertex's XY coordiantes as unique identifiers. It's
technically possible that a Shapefile street network might have multiple
nodes at a single location, there's no reason to duplicate those
in a transportation analysis network.
The key to a vertex is its latlon value which is a colon-separated
lat/lon value from the street graph's start and end nodes.
e.g.,
"11914024.0:3024277.1", "11915337.4:3023873.7"
"11914067.9:3024195.7", "11914264.2:3024196.6"
:param feature: The ogr feature from which the start and end vertices will be extracted
:return v1, v2: The start and end verticies
"""
v1, v2 = None, None
line_geometry = self._convert_multilinestring_to_linestring(feature.GetGeometryRef())
line_geometry.Transform(self._transform)
start_vertex_lon, start_vertex_lat, start_vertex_z = line_geometry.GetPoint(0)
end_vertex_lon, end_vertex_lat, end_vertex_z = line_geometry.GetPoint(line_geometry.GetPointCount() - 1)
start_lat_lon = str(start_vertex_lat) + ":" + str(start_vertex_lon)
end_lat_lon = str(end_vertex_lat) + ":" + str(end_vertex_lon)
key_value = ""
if feature.GetFieldIndex(key_field) > -1:
key_value = feature.GetField(key_field)
vertex_index = self._graph.vertex_properties["latlon"]
vertex_key = self._graph.vertex_properties[key_field]
"""Possibly add the start node of the street segment and set the
geoid if it's available"""
vertices = gutil.find_vertex(self._graph, vertex_index, start_lat_lon)
if (len(vertices) == 0):
v1 = self._graph.add_vertex()
vertex_index[self._graph.vertex(v1)] = start_lat_lon
vertex_key[self._graph.vertex(v1)] = key_value
else:
v1 = vertices[0]
"""Possibly add the end node of the street segment. Here we don't
care about the GeoID because it only belongs on the starting node."""
vertices = gutil.find_vertex(self._graph, vertex_index, end_lat_lon)
if (len(vertices) == 0):
v2 = self._graph.add_vertex()
vertex_index[self._graph.vertex(v2)] = end_lat_lon
else:
v2 = vertices[0]
return v1, v2
def generate_graph_by_gt(after=None, before=None):
submissions = [
s for s in Submission.objects.filter(
id__in=[comment.submission_id for comment in Comment.objects.all()]).prefetch_related('author')]
graph = gt.Graph()
graph.vp['author'] = graph.new_vp('string')
for submission in submissions:
authors = set()
if submission.created_at.replace(tzinfo=None) >= after and submission.created_at.replace(tzinfo=None) <= before:
authors.add(submission.author.name)
authors = authors | set(
comment.author.name for comment in Comment.objects.filter(
submission=submission, created_at__gte=after, created_at__lte=before).prefetch_related('author'))
s_graph = complete_graph(len(authors))
s_graph.vertex_properties['author'] = s_graph.new_vp('string')
s_graph.vertex_properties['author_idx'] = s_graph.new_vp('int')
authors = list(authors)
for author_idx, v in enumerate(s_graph.get_vertices()):
s_graph.vertex_properties['author'][v] = authors[author_idx]
rv = find_vertex(graph, graph.vp['author'], s_graph.vp['author'][v])
s_graph.vertex_properties['author_idx'][v] = graph.vertex_index[rv[0]] if rv else -1
graph, props = graph_union(graph, s_graph, s_graph.vp['author_idx'], [(graph.vp['author'], s_graph.vp['author'])])
graph.vp['author'] = props[0]
return graph
def draw_community(gml_fn,
output,
layout_name=None,
layout_kwargs=dict(),
**draw_kwargs):
g = load_graph(gml_fn)
# Sampel of graph g
# g = GraphView(g, vfilt=lambda v: g.vertex_index[v]%2==0)
g.vp['wdeg'] = g.degree_property_map('total', weight=g.ep['weight'])
# g = GraphView(g, vfilt=lambda v: g.vp['wdeg'][v]>0)
# label for hub account only in each community
g.vp['clabel'] = g.new_vertex_property("string", val="")
for c in np.nditer(np.unique(g.vp['community'].a)):
cg = GraphView(g, vfilt=(g.vp['community'].a == c))
v_hub = find_vertex(cg, cg.vp['wdeg'], cg.vp['wdeg'].fa.max())[0]
cg.vp['clabel'][v_hub] = cg.vp['screenname'][v_hub]
v_size = prop_to_size(
g.vp['wdeg'],
mi=MIN_V_SIZE,
ma=MAX_V_SIZE,
log=V_SIZE_LOG,
power=V_SIZE_POWER)
e_width = prop_to_size(
g.ep['weight'],
mi=MIN_E_WIDTH,
ma=MAX_E_WIDTH,
log=E_WIDTH_LOG,
power=E_WIDTH_POWER)
if layout_name is not None:
try:
pos = globals()[layout_name](g, **layout_kwargs)
except KeyError as e:
logger.critical('No such layout function found!')
raise
graph_draw(
g,
pos,
output=output,
vprops=dict(
fill_color=g.vp['community'],
# color='grey',
size=v_size,
pen_width=0.01,
text=g.vp['clabel'],
text_position='centered',
font_size=8,),
eprops=dict(
pen_width=e_width,
end_marker="arrow",),
**draw_kwargs)
def _get_vertex(self, id):
''' return vertex with given id, creates vertex with corresponding
actor information if id is not in graph yet'''
vertices = util.find_vertex(self.graph, self.graph.vp['id'], id)
if (len(vertices) > 0):
return vertices[0]
# add actor to graph
actor = Actor.objects.get(id=id)
vertex = self.graph.add_vertex()
# not existing in basegraph -> no flows in or out in status quo ->
# balance factor of 1
self.graph.vp.downstream_balance_factor[vertex] = 1
self.graph.vp.id[vertex] = id
self.graph.vp.bvdid[vertex] = actor.BvDid
self.graph.vp.name[vertex] = actor.name
return vertex
def values(self, value):
if value is None:
for v in self.variables:
self.vp_node[v].value = None
elif isinstance(value, self.Values):
for v in self.variables:
self.vp_node[v].value = getattr(value, self.vp_node[v].name)
elif isinstance(value, np.ndarray) or isinstance(value, list):
raise Exception('This should not happen anymore.')
for var, val in zip(self.variables, value):
self.vp_node[var].value = val
elif isinstance(value, dict):
raise Exception('This should not happen anymore.')
for k, v in value.iteritems():
vertices = find_vertex(self.graph, self.vp_name, k)
if len(vertices) is 1:
self.vp_node[vertices[0]].value = v
elif len(vertices) > 1:
raise Exception('This should not happen.')
# log.log_values(self)
else:
raise NotImplementedError('values.setter with object type {} not defined.'.format(type(value)))
def makeGraph(self,img,dia,xScale,yScale):
print 'Building Graph Data Structure'
start=time.time()
G = Graph(directed=False)
vprop=G.new_vertex_property('object')
eprop=G.new_edge_property('object')
epropW=G.new_edge_property("int32_t")
avgScale=(xScale+yScale)/2
test=np.where(img==True)
ss = np.shape(test)
cccc=0
percentOld=0.0
print str(np.round(percentOld,1))+'%'
for (i,j) in zip(test[1],test[0]):
cccc+=1
percent=(float(cccc)/float(ss[1]))*100
if percentOld+10< percent:
print str(np.round(percent,1))+'%'
percentOld=percent
nodeNumber1 = (float(i)*yScale,float(j)*xScale)
if gu.find_vertex(G, vprop, {'imgIdx':(j,i),'coord':nodeNumber1, 'nrOfPaths':0, 'diameter':float(dia[j][i])*avgScale}):
v1=gu.find_vertex(G, vprop, {'imgIdx':(j,i),'coord':nodeNumber1, 'nrOfPaths':0, 'diameter':float(dia[j][i])*avgScale})[0]
else:
v1=G.add_vertex()
vprop[G.vertex(v1)]={'imgIdx':(j,i),'coord':nodeNumber1, 'nrOfPaths':0, 'diameter':float(dia[j][i])*avgScale}
try:
if img[j,i+1] == True:
nodeNumber2 = (float(i+1)*yScale,float(j)*xScale)
if gu.find_vertex(G, vprop, {'imgIdx':(j,i+1),'coord':nodeNumber2, 'nrOfPaths':0, 'diameter':float(dia[j][i+1])*avgScale}):
v2=gu.find_vertex(G, vprop, {'imgIdx':(j,i+1),'coord':nodeNumber2, 'nrOfPaths':0, 'diameter':float(dia[j][i+1])*avgScale})[0]
if gu.find_edge(G, eprop, {'coord1':vprop[v2]['coord'], 'coord2':vprop[v1]['coord'],'weight':((vprop[v1]['diameter']+vprop[v2]['diameter'])/2)**4,'RTP':False}):
pass
else:
e = G.add_edge(v1, v2)
epropW[e]=(((vprop[v1]['diameter']+vprop[v2]['diameter'])/2)/avgScale)**4
eprop[e]={'coord1':vprop[v1]['coord'], 'coord2':vprop[v2]['coord'],'weight':((vprop[v1]['diameter']+vprop[v2]['diameter'])/2)**4,'RTP':False}
else:
v2=G.add_vertex()
vprop[G.vertex(v2)]={'imgIdx':(j,i+1),'coord':nodeNumber2, 'nrOfPaths':0, 'diameter':float(dia[j][i+1])*avgScale}
e = G.add_edge(v1, v2)
epropW[e]=(((vprop[v1]['diameter']+vprop[v2]['diameter'])/2)/avgScale)**4
eprop[e]={'coord1':vprop[v1]['coord'], 'coord2':vprop[v2]['coord'],'weight':((vprop[v1]['diameter']+vprop[v2]['diameter'])/2)**4,'RTP':False}
except:
pass
try:
if img[j,i-1] == True:
nodeNumber2 = (float(i-1)*yScale,float(j)*xScale)
if gu.find_vertex(G, vprop, {'imgIdx':(j,i-1),'coord':nodeNumber2, 'nrOfPaths':0, 'diameter':float(dia[j][i-1])*avgScale}):
v2=gu.find_vertex(G, vprop, {'imgIdx':(j,i-1),'coord':nodeNumber2, 'nrOfPaths':0, 'diameter':float(dia[j][i-1])*avgScale})[0]
if gu.find_edge(G, eprop, {'coord1':vprop[v2]['coord'], 'coord2':vprop[v1]['coord'],'weight':((vprop[v1]['diameter']+vprop[v2]['diameter'])/2)**4,'RTP':False}):
pass
else:
e = G.add_edge(v1, v2)
epropW[e]=(((vprop[v1]['diameter']+vprop[v2]['diameter'])/2)/avgScale)**4
eprop[e]={'coord1':vprop[v1]['coord'], 'coord2':vprop[v2]['coord'],'weight':((vprop[v1]['diameter']+vprop[v2]['diameter'])/2)**4,'RTP':False}
else:
v2=G.add_vertex()
vprop[G.vertex(v2)]={'imgIdx':(j,i-1),'coord':nodeNumber2, 'nrOfPaths':0, 'diameter':float(dia[j][i-1])*avgScale}
e = G.add_edge(v1, v2)
epropW[e]=(((vprop[v1]['diameter']+vprop[v2]['diameter'])/2)/avgScale)**4
eprop[e]={'coord1':vprop[v1]['coord'], 'coord2':vprop[v2]['coord'],'weight':((vprop[v1]['diameter']+vprop[v2]['diameter'])/2)**4,'RTP':False}
except:pass
try:
if img[j + 1,i] == True:
nodeNumber2 = (float(i)*yScale,float(j+1)*xScale)
if gu.find_vertex(G, vprop, {'imgIdx':(j+1,i),'coord':nodeNumber2, 'nrOfPaths':0, 'diameter':float(dia[j+1][i])*avgScale}):
v2=gu.find_vertex(G, vprop, {'imgIdx':(j+1,i),'coord':nodeNumber2, 'nrOfPaths':0, 'diameter':float(dia[j+1][i])*avgScale})[0]
if gu.find_edge(G, eprop, {'coord1':vprop[v2]['coord'], 'coord2':vprop[v1]['coord'],'weight':((vprop[v1]['diameter']+vprop[v2]['diameter'])/2)**4,'RTP':False}):
pass
else:
e = G.add_edge(v1, v2)
epropW[e]=(((vprop[v1]['diameter']+vprop[v2]['diameter'])/2)/avgScale)**4
eprop[e]={'coord1':vprop[v1]['coord'], 'coord2':vprop[v2]['coord'],'weight':((vprop[v1]['diameter']+vprop[v2]['diameter'])/2)**4,'RTP':False}
else:
v2=G.add_vertex()
vprop[G.vertex(v2)]={'imgIdx':(j+1,i),'coord':nodeNumber2, 'nrOfPaths':0, 'diameter':float(dia[j+1][i])*avgScale}
e = G.add_edge(v1, v2)
epropW[e]=(((vprop[v1]['diameter']+vprop[v2]['diameter'])/2)/avgScale)**4
eprop[e]={'coord1':vprop[v1]['coord'], 'coord2':vprop[v2]['coord'],'weight':((vprop[v1]['diameter']+vprop[v2]['diameter'])/2)**4,'RTP':False}
except:pass
try:
if img[j - 1,i] == True:
nodeNumber2 = (float(i)*yScale,float(j-1)*xScale)
if gu.find_vertex(G, vprop, {'imgIdx':(j-1,i),'coord':nodeNumber2, 'nrOfPaths':0, 'diameter':float(dia[j-1][i])*avgScale}):
v2=gu.find_vertex(G, vprop, {'imgIdx':(j-1,i),'coord':nodeNumber2, 'nrOfPaths':0, 'diameter':float(dia[j-1][i])*avgScale})[0]
if gu.find_edge(G, eprop, {'coord1':vprop[v2]['coord'], 'coord2':vprop[v1]['coord'],'weight':((vprop[v1]['diameter']+vprop[v2]['diameter'])/2)**4,'RTP':False}):
pass
else:
e = G.add_edge(v1, v2)
epropW[e]=(((vprop[v1]['diameter']+vprop[v2]['diameter'])/2)/avgScale)**4
eprop[e]={'coord1':vprop[v1]['coord'], 'coord2':vprop[v2]['coord'],'weight':((vprop[v1]['diameter']+vprop[v2]['diameter'])/2)**4,'RTP':False}
else:
v2=G.add_vertex()
vprop[G.vertex(v2)]={'imgIdx':(j-1,i),'coord':nodeNumber2, 'nrOfPaths':0, 'diameter':float(dia[j-1][i])*avgScale}
e = G.add_edge(v1, v2)
epropW[e]=(((vprop[v1]['diameter']+vprop[v2]['diameter'])/2)/avgScale)**4
eprop[e]={'coord1':vprop[v1]['coord'], 'coord2':vprop[v2]['coord'],'weight':((vprop[v1]['diameter']+vprop[v2]['diameter'])/2)**4,'RTP':False}
except: pass
#
print '100.0%'
print 'selecting largest connected component'
G.edge_properties["ep"] = eprop
G.edge_properties["w"] = epropW
G.vertex_properties["vp"] = vprop
l = gt.label_largest_component(G)
print(l.a)
u = gt.GraphView(G, vfilt=l)
print '# vertices'
print(u.num_vertices())
print(G.num_vertices())
print '# edges'
print(u.num_edges())
print 'building graph finished in: '+str(time.time()-start)+'s'
return u
def makeGraph(self, img, dia, xScale, yScale):
print 'Building Graph Data Structure'
start = time.time()
G = Graph(directed=False)
vprop = G.new_vertex_property('object')
eprop = G.new_edge_property('object')
epropW = G.new_edge_property("int32_t")
avgScale = (xScale + yScale) / 2
test = np.where(img == True)
ss = np.shape(test)
cccc = 0
percentOld = 0.0
print str(np.round(percentOld, 1)) + '%'
for (i, j) in zip(test[1], test[0]):
cccc += 1
percent = (float(cccc) / float(ss[1])) * 100
if percentOld + 10 < percent:
print str(np.round(percent, 1)) + '%'
percentOld = percent
nodeNumber1 = (float(i) * yScale, float(j) * xScale)
if gu.find_vertex(
G, vprop, {
'imgIdx': (j, i),
'coord': nodeNumber1,
'nrOfPaths': 0,
'diameter': float(dia[j][i]) * avgScale
}):
v1 = gu.find_vertex(
G, vprop, {
'imgIdx': (j, i),
'coord': nodeNumber1,
'nrOfPaths': 0,
'diameter': float(dia[j][i]) * avgScale
})[0]
else:
v1 = G.add_vertex()
vprop[G.vertex(v1)] = {
'imgIdx': (j, i),
'coord': nodeNumber1,
'nrOfPaths': 0,
'diameter': float(dia[j][i]) * avgScale
}
try:
if img[j, i + 1] == True:
nodeNumber2 = (float(i + 1) * yScale, float(j) * xScale)
if gu.find_vertex(
G, vprop, {
'imgIdx': (j, i + 1),
'coord': nodeNumber2,
'nrOfPaths': 0,
'diameter': float(dia[j][i + 1]) * avgScale
}):
v2 = gu.find_vertex(
G, vprop, {
'imgIdx': (j, i + 1),
'coord': nodeNumber2,
'nrOfPaths': 0,
'diameter': float(dia[j][i + 1]) * avgScale
})[0]
if gu.find_edge(
G, eprop, {
'coord1':
vprop[v2]['coord'],
'coord2':
vprop[v1]['coord'],
'weight': ((vprop[v1]['diameter'] +
vprop[v2]['diameter']) / 2)**4,
'RTP':
False
}):
pass
else:
e = G.add_edge(v1, v2)
epropW[e] = (((vprop[v1]['diameter'] +
vprop[v2]['diameter']) / 2) /
avgScale)**4
eprop[e] = {
'coord1':
vprop[v1]['coord'],
'coord2':
vprop[v2]['coord'],
'weight': ((vprop[v1]['diameter'] +
vprop[v2]['diameter']) / 2)**4,
'RTP':
False
}
else:
v2 = G.add_vertex()
vprop[G.vertex(v2)] = {
'imgIdx': (j, i + 1),
'coord': nodeNumber2,
'nrOfPaths': 0,
'diameter': float(dia[j][i + 1]) * avgScale
}
e = G.add_edge(v1, v2)
epropW[e] = (
((vprop[v1]['diameter'] + vprop[v2]['diameter']) /
2) / avgScale)**4
eprop[e] = {
'coord1':
vprop[v1]['coord'],
'coord2':
vprop[v2]['coord'],
'weight':
((vprop[v1]['diameter'] + vprop[v2]['diameter']) /
2)**4,
'RTP':
False
}
except:
pass
try:
if img[j, i - 1] == True:
nodeNumber2 = (float(i - 1) * yScale, float(j) * xScale)
if gu.find_vertex(
G, vprop, {
'imgIdx': (j, i - 1),
'coord': nodeNumber2,
'nrOfPaths': 0,
'diameter': float(dia[j][i - 1]) * avgScale
}):
v2 = gu.find_vertex(
G, vprop, {
'imgIdx': (j, i - 1),
'coord': nodeNumber2,
'nrOfPaths': 0,
'diameter': float(dia[j][i - 1]) * avgScale
})[0]
if gu.find_edge(
G, eprop, {
'coord1':
vprop[v2]['coord'],
'coord2':
vprop[v1]['coord'],
'weight': ((vprop[v1]['diameter'] +
vprop[v2]['diameter']) / 2)**4,
'RTP':
False
}):
pass
else:
e = G.add_edge(v1, v2)
epropW[e] = (((vprop[v1]['diameter'] +
vprop[v2]['diameter']) / 2) /
avgScale)**4
eprop[e] = {
'coord1':
vprop[v1]['coord'],
'coord2':
vprop[v2]['coord'],
'weight': ((vprop[v1]['diameter'] +
vprop[v2]['diameter']) / 2)**4,
'RTP':
False
}
else:
v2 = G.add_vertex()
vprop[G.vertex(v2)] = {
'imgIdx': (j, i - 1),
'coord': nodeNumber2,
'nrOfPaths': 0,
'diameter': float(dia[j][i - 1]) * avgScale
}
e = G.add_edge(v1, v2)
epropW[e] = (
((vprop[v1]['diameter'] + vprop[v2]['diameter']) /
2) / avgScale)**4
eprop[e] = {
'coord1':
vprop[v1]['coord'],
'coord2':
vprop[v2]['coord'],
'weight':
((vprop[v1]['diameter'] + vprop[v2]['diameter']) /
2)**4,
'RTP':
False
}
except:
pass
try:
if img[j + 1, i] == True:
nodeNumber2 = (float(i) * yScale, float(j + 1) * xScale)
if gu.find_vertex(
G, vprop, {
'imgIdx': (j + 1, i),
'coord': nodeNumber2,
'nrOfPaths': 0,
'diameter': float(dia[j + 1][i]) * avgScale
}):
v2 = gu.find_vertex(
G, vprop, {
'imgIdx': (j + 1, i),
'coord': nodeNumber2,
'nrOfPaths': 0,
'diameter': float(dia[j + 1][i]) * avgScale
})[0]
if gu.find_edge(
G, eprop, {
'coord1':
vprop[v2]['coord'],
'coord2':
vprop[v1]['coord'],
'weight': ((vprop[v1]['diameter'] +
vprop[v2]['diameter']) / 2)**4,
'RTP':
False
}):
pass
else:
e = G.add_edge(v1, v2)
epropW[e] = (((vprop[v1]['diameter'] +
vprop[v2]['diameter']) / 2) /
avgScale)**4
eprop[e] = {
'coord1':
vprop[v1]['coord'],
'coord2':
vprop[v2]['coord'],
'weight': ((vprop[v1]['diameter'] +
vprop[v2]['diameter']) / 2)**4,
'RTP':
False
}
else:
v2 = G.add_vertex()
vprop[G.vertex(v2)] = {
'imgIdx': (j + 1, i),
'coord': nodeNumber2,
'nrOfPaths': 0,
'diameter': float(dia[j + 1][i]) * avgScale
}
e = G.add_edge(v1, v2)
epropW[e] = (
((vprop[v1]['diameter'] + vprop[v2]['diameter']) /
2) / avgScale)**4
eprop[e] = {
'coord1':
vprop[v1]['coord'],
'coord2':
vprop[v2]['coord'],
'weight':
((vprop[v1]['diameter'] + vprop[v2]['diameter']) /
2)**4,
'RTP':
False
}
except:
pass
try:
if img[j - 1, i] == True:
nodeNumber2 = (float(i) * yScale, float(j - 1) * xScale)
if gu.find_vertex(
G, vprop, {
'imgIdx': (j - 1, i),
'coord': nodeNumber2,
'nrOfPaths': 0,
'diameter': float(dia[j - 1][i]) * avgScale
}):
v2 = gu.find_vertex(
G, vprop, {
'imgIdx': (j - 1, i),
'coord': nodeNumber2,
'nrOfPaths': 0,
'diameter': float(dia[j - 1][i]) * avgScale
})[0]
if gu.find_edge(
G, eprop, {
'coord1':
vprop[v2]['coord'],
'coord2':
vprop[v1]['coord'],
'weight': ((vprop[v1]['diameter'] +
vprop[v2]['diameter']) / 2)**4,
'RTP':
False
}):
pass
else:
e = G.add_edge(v1, v2)
epropW[e] = (((vprop[v1]['diameter'] +
vprop[v2]['diameter']) / 2) /
avgScale)**4
eprop[e] = {
'coord1':
vprop[v1]['coord'],
'coord2':
vprop[v2]['coord'],
'weight': ((vprop[v1]['diameter'] +
vprop[v2]['diameter']) / 2)**4,
'RTP':
False
}
else:
v2 = G.add_vertex()
vprop[G.vertex(v2)] = {
'imgIdx': (j - 1, i),
'coord': nodeNumber2,
'nrOfPaths': 0,
'diameter': float(dia[j - 1][i]) * avgScale
}
e = G.add_edge(v1, v2)
epropW[e] = (
((vprop[v1]['diameter'] + vprop[v2]['diameter']) /
2) / avgScale)**4
eprop[e] = {
'coord1':
vprop[v1]['coord'],
'coord2':
vprop[v2]['coord'],
'weight':
((vprop[v1]['diameter'] + vprop[v2]['diameter']) /
2)**4,
'RTP':
False
}
except:
pass
#
print '100.0%'
print 'selecting largest connected component'
G.edge_properties["ep"] = eprop
G.edge_properties["w"] = epropW
G.vertex_properties["vp"] = vprop
l = gt.label_largest_component(G)
print(l.a)
u = gt.GraphView(G, vfilt=l)
print '# vertices'
print(u.num_vertices())
print(G.num_vertices())
print '# edges'
print(u.num_edges())
print 'building graph finished in: ' + str(time.time() - start) + 's'
return u
def detectVerticesNeighbors(self, isOnVoronoi, isVertice):
# width = isVertice.shape[1]
# height = isVertice.shape[0]
verticesPoses = []
for i in xrange(0, isVertice.shape[0]):
for j in xrange(0, isVertice.shape[1]):
if isVertice[i][j] == 1:
verticesPoses.append((i, j))
self.graph.vertex_properties['pose'] = self.graph.new_vertex_property(
"vector<double>")
self.graph.edge_properties['distance'] = self.graph.new_edge_property(
"double")
# self.graph.edge_properties['label'] = self.graph.new_edge_property("string")
for v in verticesPoses:
vertice = self.graph.add_vertex()
self.graph.vertex_properties['pose'][vertice] = (v[0], v[1])
for v in self.graph.vertices():
# print "iteration ", v
brush = np.full(isVertice.shape, -1)
current = []
brush[isVertice > 0] = 0
# print brush
current.append(self.graph.vertex_properties['pose'][v].a)
# print self.graph.vertex_properties['pose'][v].a
# print current
# print type(current)
_next = []
expanded = True
counter = -1
while expanded:
expanded = False
counter += 1
for c in current:
# print "current", c
for kx in range(-1, 2):
for ky in range(-1, 2):
if ky == 0 and kx == 0:
continue
x = c[0] + kx
y = c[1] + ky
if x >= 0 and x < isVertice.shape[0] \
and y >= 0 and y < isVertice.shape[1]:
# print "x,y =",x,y
if brush[x][y] == -1 and isOnVoronoi[x][y] == 1:
brush[x][y] = counter + 1
_next.append([x, y])
expanded = True
# print brush
if brush[x][y] == 0 and isVertice[x][y] == 1:
v_pos = self.graph.vp['pose'][v].a
# print "current vertex pos=",v_pos[0], v_pos[1]
if not (v_pos[0] == x and v_pos[1] == y):
# add this node as neighbor
v1 = util.find_vertex(
self.graph, self.graph.
vertex_properties['pose'], (x, y))
# print v, " ", v1[0]
# add the edge (compute the distance)
if not self.graph.edge(v, v1[0]):
e = self.graph.add_edge(v, v1[0])
# add distance as edge property
self.graph.ep['distance'][
e] = counter + 1
# self.graph.ep.label[e] = self.graph.ep['distance'][e]
# print "distance=", self.graph.ep['distance'][e]
current = _next
_next = []
