def graph_filter(g, threshold=0.3, min_len=None):
road_segments, _ = graph.get_graph_road_segments(g)
bad_edges = set()
for rs in road_segments:
if min_len is not None and len(rs.edges) < min_len:
bad_edges.update(rs.edges)
continue
probs = []
if len(rs.edges) < 5 or True:
for edge in rs.edges:
if hasattr(edge, 'prob'):
probs.append(edge.prob)
else:
for edge in rs.edges[2:-2]:
if hasattr(edge, 'prob'):
probs.append(edge.prob)
if not probs:
continue
avg_prob = numpy.mean(probs)
if avg_prob < threshold:
bad_edges.update(rs.edges)
print('filtering {} edges'.format(len(bad_edges)))
ng = graph.Graph()
vertex_map = {}
for vertex in g.vertices:
vertex_map[vertex] = ng.add_vertex(vertex.point)
for edge in g.edges:
if edge not in bad_edges:
ng.add_edge(vertex_map[edge.src], vertex_map[edge.dst])
return ng
def graph_filter_edges(g, bad_edges):
print 'filtering {} edges'.format(len(bad_edges))
ng = graph.Graph()
vertex_map = {}
for vertex in g.vertices:
vertex_map[vertex] = ng.add_vertex(vertex.point)
for edge in g.edges:
if edge not in bad_edges:
nedge = ng.add_edge(vertex_map[edge.src], vertex_map[edge.dst])
if hasattr(edge, 'prob'):
nedge.prob = edge.prob
return ng
def __init__(self, gc, tile_data, start_loc=None, g=None):
self.gc = gc
self.tile_data = tile_data
if g is None:
self.graph = graph.Graph()
else:
self.graph = g
self.explored_pairs = {}
self.unmatched_vertices = 0
if start_loc:
#v1 = self.graph.add_vertex(start_loc[0]['point'])
v2 = self.graph.add_vertex(start_loc[1]['point'])
#self.graph.add_bidirectional_edge(v1, v2)
#v1.edge_pos = start_loc[0]['edge_pos']
v2.edge_pos = start_loc[1]['edge_pos']
self.search_vertices = [v2]
else:
self.search_vertices = []
self._load_edge_rtree()
m6_mask = numpy.concatenate([m6_mask[:, 64:96], m6_mask[:, 32:64]],
axis=1).reshape(
(1024, 1024, 64)).astype('float32')
m6_mask = 1 - m6_mask
cache_m6 = m6_new * m6_mask
result = eval([path],
m,
session,
save=False,
compute_targets=False,
cache_m6=cache_m6,
cache_m6_old=m6_old,
cache_m6_new=m6_new)
ng = graph.Graph()
vertex_map = {}
for edge in path.graph.edges:
if not hasattr(edge, 'prob'):
continue
for vertex in [edge.src, edge.dst]:
if vertex not in vertex_map:
vertex_map[vertex] = ng.add_vertex(vertex.point)
new_edge = ng.add_edge(vertex_map[edge.src], vertex_map[edge.dst])
new_edge.prob = edge.prob
ng.save(cur_graph_out_fname)
edge_probs = []
for edge in ng.edges:
edge_probs.append(int(edge.prob * 100))
with open(os.path.join(out_path, '{}_{}.json'.format(x, y)), 'w') as f:
json.dump(edge_probs, f)
def func(in_fname, out_fname):
g = graph.read_graph(in_fname)
bad_edges = set()
merge_vertices = {}
merge_groups = []
road_segments, _ = graph.get_graph_road_segments(g)
edge_index = g.edgeIndex()
# prune short branches
for rs in road_segments:
if (len(rs.dst().out_edges) < 2 or len(rs.src().out_edges) < 2) and rs.length() < BRANCH_THRESHOLD:
for edge in rs.edges:
bad_edges.add(edge)
# merge short loops
for rs in road_segments:
if rs.length() < LOOP_THRESHOLD:
if rs.src() in merge_vertices and rs.dst() in merge_vertices:
group = merge_vertices[rs.src()]
dst_group = merge_vertices[rs.dst()]
if group != dst_group:
group.update(dst_group)
for vertex in dst_group:
merge_vertices[vertex] = group
elif rs.src() in merge_vertices:
group = merge_vertices[rs.src()]
group.add(rs.dst())
merge_vertices[rs.dst()] = group
elif rs.dst() in merge_vertices:
group = merge_vertices[rs.dst()]
group.add(rs.src())
merge_vertices[rs.src()] = group
else:
group = Group()
group.add(rs.src())
group.add(rs.dst())
merge_vertices[rs.src()] = group
merge_vertices[rs.dst()] = group
merge_groups.append(group)
for edge in rs.edges:
merge_vertices[edge.src] = group
merge_vertices[edge.dst] = group
group.add(edge.src)
group.add(edge.dst)
def get_avg(group):
point_sum = geom.Point(0, 0)
for vertex in group:
point_sum = point_sum.add(vertex.point)
return point_sum.scale(1.0 / len(group))
ng = graph.Graph()
vertex_map = {}
def get_vertex(vertex):
if vertex in merge_vertices:
group = merge_vertices[vertex]
group_head = group.head()
if group_head not in vertex_map:
vertex_map[group_head] = ng.add_vertex(get_avg(group))
return vertex_map[group_head]
else:
if vertex not in vertex_map:
vertex_map[vertex] = ng.add_vertex(vertex.point)
return vertex_map[vertex]
for edge in g.edges:
if edge in bad_edges:
continue
src = get_vertex(edge.src)
dst = get_vertex(edge.dst)
if src == dst:
continue
ng.add_edge(src, dst)
ng.save(out_fname)
print('reading inferred graph')
g = graph.read_graph(TEST_PATH)
print('creating edge index')
idx = g.edgeIndex()
# determine which tiles the graph spans
print('identifying spanned tiles')
tiles = set()
for vertex in g.vertices:
x, y = vertex.point.x / 4096, vertex.point.y / 4096
tiles.add(geom.Point(x, y))
counter = 0
out_graph = graph.Graph()
out_vertex_map = {}
def get_out_vertex(p):
if (p.x, p.y) not in out_vertex_map:
out_vertex_map[(p.x, p.y)] = out_graph.add_vertex(p)
return out_vertex_map[(p.x, p.y)]
for tile in tiles:
print('...', tile)
tile_rect = geom.Rectangle(tile.scale(4096),
tile.add(geom.Point(1, 1)).scale(4096))
tile_graph = idx.subgraph(tile_rect)
for vertex in tile_graph.vertices:
