def get_training_tile_data(self, tile_idx):
tile = self.train_tiles[tile_idx]
rect = geom.Rectangle(tile.scale(tile_size),
tile.add(geom.Point(1, 1)).scale(tile_size))
if tries < 3:
search_rect_x = random.randint(
window_size / 2,
tile_size - window_size / 2 - self.search_rect_size)
search_rect_y = random.randint(
window_size / 2,
tile_size - window_size / 2 - self.search_rect_size)
search_rect = geom.Rectangle(
rect.start.add(geom.Point(search_rect_x, search_rect_y)),
rect.start.add(geom.Point(search_rect_x, search_rect_y)).add(
geom.Point(self.search_rect_size, self.search_rect_size)),
)
return {
'region': tile.region,
'rect': rect,
'search_rect': search_rect,
'cache': self.cache,
'starting_locations': [],
'gc': self.gcs[tile.region],
}
def get_tile_example(tile, tries=10):
rect = get_tile_rect(tile)
# pick origin: must be multiple of the output scale
origin = geom.Point(
random.randint(0,
rect.lengths().x / 4 - WINDOW_SIZE / 4),
random.randint(0,
rect.lengths().y / 4 - WINDOW_SIZE / 4))
origin = origin.scale(4)
origin = origin.add(rect.start)
tile_origin = origin.sub(rect.start)
big_ims = tiles.cache.get_window(
tile.region, rect,
geom.Rectangle(tile_origin,
tile_origin.add(geom.Point(WINDOW_SIZE, WINDOW_SIZE))))
input = big_ims['input'].astype('float32') / 255.0
target = big_ims['angles'].astype('float32') / 255.0
if numpy.count_nonzero(target.max(axis=2)) < 64 and tries > 0:
return get_tile_example(tile, tries - 1)
example = {
'region': tile.region,
'origin': origin,
'input': input,
'target': target,
}
if MASK_NEAR_ROADS:
mask = target.max(axis=2) > 0
mask = scipy.ndimage.morphology.binary_dilation(mask, iterations=9)
example['mask'] = mask
return example
def load_rect(region, rect, load_func=load_tile, mode='all'):
# special case for fast load: rect is single tile
if rect.start.x % tile_size == 0 and rect.start.y % tile_size == 0 and rect.end.x % tile_size == 0 and rect.end.y % tile_size == 0 and rect.end.x - rect.start.x == tile_size and rect.end.y - rect.start.y == tile_size:
return load_func(region, rect.start.x / tile_size, rect.start.y / tile_size, mode=mode)
tile_rect = geom.Rectangle(
geom.Point(rect.start.x / tile_size, rect.start.y / tile_size),
geom.Point((rect.end.x - 1) / tile_size + 1, (rect.end.y - 1) / tile_size + 1)
)
full_rect = geom.Rectangle(
tile_rect.start.scale(tile_size),
tile_rect.end.scale(tile_size)
)
full_ims = {}
for i in xrange(tile_rect.start.x, tile_rect.end.x):
for j in xrange(tile_rect.start.y, tile_rect.end.y):
p = geom.Point(i - tile_rect.start.x, j - tile_rect.start.y).scale(tile_size)
tile_ims = load_func(region, i, j, mode=mode)
for k, im in tile_ims.iteritems():
scale = tile_size / im.shape[0]
if k not in full_ims:
full_ims[k] = numpy.zeros((full_rect.lengths().x / scale, full_rect.lengths().y / scale, im.shape[2]), dtype='uint8')
full_ims[k][p.x/scale:(p.x+tile_size)/scale, p.y/scale:(p.y+tile_size)/scale, :] = im
crop_rect = geom.Rectangle(
rect.start.sub(full_rect.start),
rect.end.sub(full_rect.start)
)
for k in full_ims:
scale = (full_rect.end.x - full_rect.start.x) / full_ims[k].shape[0]
full_ims[k] = full_ims[k][crop_rect.start.x/scale:crop_rect.end.x/scale, crop_rect.start.y/scale:crop_rect.end.y/scale, :]
return full_ims
def prepare_connection(sat, outim, inferred_idx, connection, size=320): path = [geom.Point(p[0], p[1]) for p in connection['path']] r = path[0].bounds() for p in path: r = r.extend(p) l = r.lengths() if l.x > 256 or l.y > 256: return s = geom.Point((size - l.x)/2, (size - l.y)/2) r = geom.Rectangle(r.start.sub(s), r.end.add(s)) r = geom.Rectangle(geom.Point(0, 0), geom.Point(sat.shape[0], sat.shape[1])).clip_rect(r) l = r.lengths() im = numpy.zeros((size, size, 6), dtype='uint8') im[0:l.x, 0:l.y, 0:3] = sat[r.start.x:r.end.x, r.start.y:r.end.y, :] im[0:l.x, 0:l.y, 5] = outim[r.start.x:r.end.x, r.start.y:r.end.y] # draw graph for edge in inferred_idx.search(r.add_tol(32)): segment = edge.segment() start = segment.start.sub(r.start) end = segment.end.sub(r.start) for p in geom.draw_line(start, end, r.lengths()): im[p.x, p.y, 3] = 255 # draw connection for i in xrange(len(path) - 1): start = path[i].sub(r.start) end = path[i + 1].sub(r.start) for p in geom.draw_line(start, end, r.lengths()): im[p.x, p.y, 4] = 255 return im
def vis_example(example, outputs=None): x = numpy.zeros((WINDOW_SIZE, WINDOW_SIZE, 3), dtype='uint8') x[:, :, :] = example['input'] * 255 x[WINDOW_SIZE/2-2:WINDOW_SIZE/2+2, WINDOW_SIZE/2-2:WINDOW_SIZE/2+2, :] = 255 gc = tiles.get_gc(example['region']) rect = geom.Rectangle(example['origin'], example['origin'].add(geom.Point(WINDOW_SIZE, WINDOW_SIZE))) for edge in gc.edge_index.search(rect): start = edge.src.point end = edge.dst.point for p in geom.draw_line(start.sub(example['origin']), end.sub(example['origin']), geom.Point(WINDOW_SIZE, WINDOW_SIZE)): x[p.x, p.y, 0:2] = 0 x[p.x, p.y, 2] = 255 for i in xrange(WINDOW_SIZE): for j in xrange(WINDOW_SIZE): di = i - WINDOW_SIZE/2 dj = j - WINDOW_SIZE/2 d = math.sqrt(di * di + dj * dj) a = int((math.atan2(dj, di) - math.atan2(0, 1) + math.pi) * NUM_BUCKETS / 2 / math.pi) if a >= NUM_BUCKETS: a = NUM_BUCKETS - 1 elif a < 0: a = 0 elif d > 100 and d <= 120 and example['target'] is not None: x[i, j, 0] = example['target'][WINDOW_SIZE/8, WINDOW_SIZE/8, a] * 255 x[i, j, 1] = example['target'][WINDOW_SIZE/8, WINDOW_SIZE/8, a] * 255 x[i, j, 2] = 0 elif d > 70 and d <= 90 and outputs is not None: x[i, j, 0] = outputs[WINDOW_SIZE/8, WINDOW_SIZE/8, a] * 255 x[i, j, 1] = outputs[WINDOW_SIZE/8, WINDOW_SIZE/8, a] * 255 x[i, j, 2] = 0 return x
def get_tile_rect(tile): if RECT_OVERRIDE: return RECT_OVERRIDE p = geom.Point(tile.x, tile.y) return geom.Rectangle( p.scale(TILE_SIZE), p.add(geom.Point(1, 1)).scale(TILE_SIZE) )
def best_angle_to_pos(pos): angle_points = [get_next_point(extension_vertex.point, angle_bucket, segment_length) for angle_bucket in range(64)] distances = [angle_point.distance(pos.point()) for angle_point in angle_points] point_angle = numpy.argmin(distances) * math.pi * 2 / 64.0 - math.pi edge_angle = geom.Point(1, 0).signed_angle(pos.edge.segment().vector()) avg_vector = vector_from_angle(point_angle).add(vector_from_angle(edge_angle)) avg_angle = geom.Point(1, 0).signed_angle(avg_vector) return int((avg_angle + math.pi) * 64.0 / math.pi / 2)
def get_shortest_path(im, src, opp, edge_im, g, vertex_distances):
r = src.bounds().add_tol(MAX_STRAIGHT_DISTANCE)
r = geom.Rectangle(geom.Point(0, 0), geom.Point(im.shape[0],
im.shape[1])).clip_rect(r)
seen_points = set()
distances = {}
prev = {}
dst_edge = None
dst_point = None
distances[src] = 0
while len(distances) > 0:
closest_point = None
closest_distance = None
for point, distance in distances.items():
if closest_point is None or distance < closest_distance:
closest_point = point
closest_distance = distance
del distances[closest_point]
seen_points.add(closest_point)
if edge_im[closest_point.x, closest_point.y] >= 0:
edge = g.edges[edge_im[closest_point.x, closest_point.y]]
src_distance = vertex_distances.get(edge.src, MIN_GRAPH_DISTANCE)
dst_distance = vertex_distances.get(edge.dst, MIN_GRAPH_DISTANCE)
if src_distance + closest_point.distance(
edge.src.point
) >= MIN_GRAPH_DISTANCE and dst_distance + closest_point.distance(
edge.dst.point) >= MIN_GRAPH_DISTANCE:
dst_edge = edge
dst_point = closest_point
break
for offset in [(-1, 0), (1, 0), (0, -1), (0, 1), (-1, -1), (-1, 1),
(1, -1), (1, 1)]:
adj_point = closest_point.add(geom.Point(offset[0], offset[1]))
if r.contains(adj_point
) and adj_point not in seen_points and src.distance(
adj_point) < opp.distance(adj_point):
distance = closest_distance + 1 + (
1 - im[adj_point.x, adj_point.y])
if adj_point not in distances or distance < distances[
adj_point]:
distances[adj_point] = distance
prev[adj_point] = closest_point
if dst_edge is None:
return None, None
path = []
point = dst_point
while point != src:
path.append(point)
point = prev[point]
path.append(src)
path.reverse()
return dst_edge, path
def count_adjacent(skeleton, point):
r = geom.Rectangle(geom.Point(0, 0),
geom.Point(skeleton.shape[0], skeleton.shape[1]))
count = 0
for offset in [(-1, 0), (1, 0), (0, -1), (0, 1), (-1, -1), (-1, 1),
(1, -1), (1, 1)]:
adj_point = point.add(geom.Point(offset[0], offset[1]))
if skeleton[adj_point.x, adj_point.y] > 0:
count += 1
return count
def best_angle_to_pos(pos):
angle_points = [
model_utils.get_next_point(point, angle_bucket, SEGMENT_LENGTH)
for angle_bucket in xrange(64)
]
distances = [
angle_point.distance(pos.point()) for angle_point in angle_points
]
point_angle = numpy.argmin(distances) * math.pi * 2 / 64.0 - math.pi
edge_angle = geom.Point(1, 0).signed_angle(pos.edge.segment().vector())
avg_vector = geom.vector_from_angle(point_angle, 50).add(
geom.vector_from_angle(edge_angle, 50))
avg_angle = geom.Point(1, 0).signed_angle(avg_vector)
return int((avg_angle + math.pi) * 64.0 / math.pi / 2)
def extract_features(im, connection): path = [geom.Point(p[0], p[1]) for p in connection['path']] samples = sample_points(path) softmax_scores = [] distance_nonroad = [] for point in samples: softmax_scores.append(im[point.x, point.y])
def points_from_poly_str(s):
parts = s.split(' ')
points = []
for part in parts:
x, y = part.split(',')
points.append(geom.Point(float(x), float(y)))
return points
def draw(rs, distance, remaining, is_explored=False): start_edge_idx = rs.distance_to_edge(distance, return_idx=True) for edge_idx in xrange(start_edge_idx, len(rs.edges)): edge = rs.edges[edge_idx] edge_distance = distance - rs.edge_distances[edge.id] start_edge_pos = graph.EdgePos(edge, edge_distance) start = start_edge_pos.point() if edge_distance + remaining < edge.segment().length(): end_edge_pos = graph.EdgePos(edge, edge_distance + remaining) end = end_edge_pos.point() else: end = edge.dst.point if not is_explored: for p in geom.draw_line(start.sub(origin), end.sub(origin), geom.Point(window_size, window_size)): p_small = p.scale(128.0 / window_size) tile[p_small.x, p_small.y] = 1.0 remaining -= edge.segment().length() - edge_distance distance = rs.edge_distances[edge.id] + edge.segment().length() + 0.001 if remaining <= 0: return for next_rs in rs.out_rs(path.gc.edge_to_rs): if rs == next_rs or next_rs.is_opposite(rs): continue draw(next_rs, 0, remaining, is_explored=path.is_explored(next_rs.edges[0]))
def process(region):
print region
city = region.split('_')[0]
offset_x, offset_y = int(region.split('_')[1]), int(region.split('_')[2])
sat = scipy.ndimage.imread('{}/{}_sat.png'.format(sat_path, region))
sat = sat.swapaxes(0, 1)
im = scipy.ndimage.imread('{}/{}.png'.format(
out_im_path, region)).astype('float32') / 255.0
im = im.swapaxes(0, 1)
g = graph.read_graph('{}/{}.graph'.format(out_graph_path, region))
g_idx = g.edgeIndex()
gt = graph.read_graph('{}/{}.graph'.format(graph_path, city))
offset = geom.Point(offset_x * 4096, offset_y * 4096)
for vertex in gt.vertices:
vertex.point = vertex.point.sub(offset)
gt_idx = gt.edgeIndex()
connections = get_connections.get_connections(g, im, limit=512)
good, bad = label_gt.label_connections(gt, g, connections)
for i, connection in enumerate(good):
label_gt.write_connection(sat, im, g_idx, connection,
'{}/good/{}_{}'.format(dst_path, region, i))
for i, connection in enumerate(bad):
label_gt.write_connection(sat, im, g_idx, connection,
'{}/bad/{}_{}'.format(dst_path, region, i))
def get_starting_locations(gcs, segment_length, region=None):
all_starting_locations = {}
with open(startlocs_path, 'r') as f:
# top-level is dict from tile to starting location lists
for tile, locs in json.load(f).items():
tile_region = tile.split('_')[0]
if region is not None and tile_region != region:
continue
elif tile_region not in gcs:
continue
starting_locations = []
# each loc is a dict with keys 'x', 'y', 'edge_id'
for loc in locs:
point = geom.Point(int(loc['x']), int(loc['y']))
edge_pos = gcs[tile_region].graph.edges[int(
loc['edge_id'])].closest_pos(point)
next_positions = graph.follow_graph(edge_pos, segment_length)
if not next_positions:
continue
starting_locations.append([{
'point': point,
'edge_pos': edge_pos,
}, {
'point': next_positions[0].point(),
'edge_pos': next_positions[0],
}])
all_starting_locations[tile] = starting_locations
return all_starting_locations
def sample_disjoint(origin):
while True:
i = random.randint(0, 4096 - SIZE)
j = random.randint(0, 4096 - SIZE)
if i >= origin.x and i < origin.x + SIZE and j >= origin.y and j < origin.y + SIZE:
continue
return geom.Point(i, j)
def load_rect(region, rect, load_func=load_tile, mode='all'):
# special case for fast load: rect is single tile
if rect.start.x % tile_size == 0 and rect.start.y % tile_size == 0 and rect.end.x % tile_size == 0 and rect.end.y % tile_size == 0 and rect.end.x - rect.start.x == tile_size and rect.end.y - rect.start.y == tile_size:
tile = load_rect(region,
int(rect.start.x / tile_size),
int(rect.start.y / tile_size),
mode=mode)
return tile
tile_rect = geom.Rectangle(
geom.Point(rect.start.x / tile_size, rect.start.y / tile_size),
geom.Point((rect.end.x - 1) / tile_size + 1,
(rect.end.y - 1) / tile_size + 1))
full_rect = geom.Rectangle(tile_rect.start.scale(tile_size),
tile_rect.end.scale(tile_size))
full_ims = {}
for i in range(tile_rect.start.x, tile_rect.end.x):
for j in range(tile_rect.start.y, tile_rect.end.y):
p = geom.Point(i - tile_rect.start.x,
j - tile_rect.start.y).scale(tile_size)
tile_ims = load_func(region, i, j, mode=mode)
for k, im in tile_ims.items():
print('tile_size, im shape', tile_size, im.shape[0])
scale = tile_size / im.shape[0]
if k not in full_ims:
full_ims[k] = numpy.zeros(
(int(full_rect.lengths().x / scale),
int(full_rect.lengths().y / scale), im.shape[2]),
dtype='uint8')
full_ims[k][int(p.x / scale):int((p.x + tile_size) / scale),
int(p.y / scale):int((p.y + tile_size) /
scale), :] = im
print('scale: {},fullims: {}'.format(scale,
numpy.shape(full_ims[k])))
crop_rect = geom.Rectangle(rect.start.sub(full_rect.start),
rect.end.sub(full_rect.start))
print('crop_rect', crop_rect.start, crop_rect.end)
for k in full_ims:
scale = (full_rect.end.x - full_rect.start.x) / full_ims[k].shape[0]
full_ims[k] = full_ims[k][int(crop_rect.start.x /
scale):int(crop_rect.end.x / scale),
int(crop_rect.start.y /
scale):int(crop_rect.end.y / scale), :]
return full_ims
def get_tile_list():
tiles = []
with open(pytiles_path, 'r') as f:
for json_tile in json.load(f):
tile = geom.Point(int(json_tile['x']), int(json_tile['y']))
tile.region = json_tile['region']
tiles.append(tile)
return tiles
def vis_example(example, outputs=None):
info, input, angle_targets, detect_targets = example
x = numpy.zeros((WINDOW_SIZE, WINDOW_SIZE, 3), dtype='uint8')
x[:, :, :] = input * 255
x[WINDOW_SIZE / 2 - 2:WINDOW_SIZE / 2 + 2,
WINDOW_SIZE / 2 - 2:WINDOW_SIZE / 2 + 2, :] = 255
gc = tiles.get_gc(info['region'])
rect = geom.Rectangle(
info['origin'], info['origin'].add(geom.Point(WINDOW_SIZE,
WINDOW_SIZE)))
for edge in gc.edge_index.search(rect):
start = edge.src.point
end = edge.dst.point
for p in geom.draw_line(start.sub(info['origin']),
end.sub(info['origin']),
geom.Point(WINDOW_SIZE, WINDOW_SIZE)):
x[p.x, p.y, 0:2] = 0
x[p.x, p.y, 2] = 255
if info['closest_pos'] is not None:
p = info['closest_pos'].point().sub(info['origin'])
x[p.x - 2:p.x + 2, p.y - 2:p.y + 2, 0] = 255
x[p.x - 2:p.x + 2, p.y - 2:p.y + 2, 1:3] = 0
for i in xrange(WINDOW_SIZE):
for j in xrange(WINDOW_SIZE):
di = i - WINDOW_SIZE / 2
dj = j - WINDOW_SIZE / 2
d = math.sqrt(di * di + dj * dj)
a = int((math.atan2(dj, di) - math.atan2(0, 1) + math.pi) * 64 /
2 / math.pi)
if a >= 64:
a = 63
elif a < 0:
a = 0
elif d > 100 and d <= 120 and angle_targets is not None:
x[i, j, 0] = angle_targets[a] * 255
x[i, j, 1] = angle_targets[a] * 255
x[i, j, 2] = 0
elif d > 70 and d <= 90 and outputs is not None:
x[i, j, 0] = outputs[a] * 255
x[i, j, 1] = outputs[a] * 255
x[i, j, 2] = 0
return x
def get_reachable_points(im, point, iterations):
points = set()
search = set()
r = geom.Rectangle(geom.Point(0, 0),
geom.Point(im.shape[0] - 1, im.shape[1] - 1))
search.add(point)
for _ in xrange(iterations):
next_search = set()
for point in search:
for offset in [(-1, 0), (1, 0), (0, -1), (0, 1), (-1, -1), (-1, 1),
(1, -1), (1, 1)]:
adj_point = point.add(geom.Point(offset[0], offset[1]))
if r.contains(adj_point) and adj_point not in points and im[
adj_point.x, adj_point.y] > 0:
points.add(adj_point)
next_search.add(adj_point)
search = next_search
return points
def get_test_tile_data(self):
if 'chicago' not in REGIONS:
return None
rect = geom.Rectangle(
geom.Point(1024, -8192),
geom.Point(4096, -5376),
)
starting_locations = self.all_starting_locations['chicago_0_-2']
starting_locations = [loc for loc in starting_locations if rect.add_tol(-window_size).contains(loc[0]['point'])]
return {
'region': 'chicago',
'rect': rect,
'search_rect': rect.add_tol(-window_size/2),
'cache': self.cache,
'starting_locations': starting_locations,
'gc': self.gcs['chicago'],
}
def tile_filter(tile):
if tile.region not in REGIONS:
return False
rect = geom.Rectangle(
tile.scale(tile_size),
tile.add(geom.Point(1, 1)).scale(tile_size)
)
starting_locations = self.all_starting_locations['{}_{}_{}'.format(tile.region, tile.x, tile.y)]
starting_locations = [loc for loc in starting_locations if rect.add_tol(-window_size).contains(loc[0]['point'])]
return len(starting_locations) > 0
def visualize_connection(sat, gt_idx, inferred_idx, connection, fname, good=True): path = [geom.Point(p[0], p[1]) for p in connection['path']] r = path[0].bounds() for p in path: r = r.extend(p) r = r.add_tol(128) r = geom.Rectangle(geom.Point(0, 0), geom.Point(sat.shape[0], sat.shape[1])).clip_rect(r) im = numpy.copy(sat[r.start.x:r.end.x, r.start.y:r.end.y]) im_rect = geom.Rectangle(geom.Point(0, 0), geom.Point(im.shape[0], im.shape[1])) def color_point(p, color, tol=1): s = im_rect.clip(p.sub(geom.Point(tol, tol))) e = im_rect.clip(p.add(geom.Point(tol, tol))) im[s.x:e.x+1, s.y:e.y+1, :] = color # draw graph yellow for edge in inferred_idx.search(r.add_tol(32)): segment = edge.segment() start = segment.start.sub(r.start) end = segment.end.sub(r.start) for p in geom.draw_line(start, end, r.lengths()): color_point(p, [255, 255, 0]) # draw connection red or green for i in xrange(len(path) - 1): start = path[i].sub(r.start) end = path[i + 1].sub(r.start) for p in geom.draw_line(start, end, r.lengths()): if good: color_point(p, [0, 255, 0]) else: color_point(p, [255, 0, 0]) # draw gt graph blue for edge in gt_idx.search(r.add_tol(32)): segment = edge.segment() start = segment.start.sub(r.start) end = segment.end.sub(r.start) for p in geom.draw_line(start, end, r.lengths()): color_point(p, [0, 0, 255], tol=0) Image.fromarray(im.swapaxes(0, 1)).save(fname)
def get_compact_path_input(path, extension_vertex, window_size=512):
origin = extension_vertex.point.sub(geom.Point(window_size/2, window_size/2))
rect = origin.bounds().extend(origin.add(geom.Point(window_size, window_size)))
path_segments = []
for edge_id in path.edge_rtree.intersection((rect.start.x, rect.start.y, rect.end.x, rect.end.y)):
path_segments.append(path.graph.edges[edge_id].segment())
gt_segments = []
for edge in path.gc.edge_index.search(rect):
gt_segments.append(edge.segment())
return {
'window_size': window_size,
'cache': path.tile_data['cache'],
'region': path.tile_data['region'],
'big_rect': path.tile_data['rect'],
'origin': origin,
'path_segments': path_segments,
'gt_segments': gt_segments,
}
def get_shortest_path(im, src, max_distance):
r = geom.Rectangle(geom.Point(0, 0), geom.Point(im.shape[0], im.shape[1]))
in_r = r.add_tol(-1)
seen_points = set()
distances = {}
prev = {}
dst = None
distances[src] = 0
while len(distances) > 0:
closest_point = None
closest_distance = None
for point, distance in distances.items():
if closest_point is None or distance < closest_distance:
closest_point = point
closest_distance = distance
del distances[closest_point]
seen_points.add(closest_point)
if closest_distance > max_distance:
break
elif not in_r.contains(closest_point):
dst = closest_point
break
for offset in [(-1, 0), (1, 0), (0, -1), (0, 1), (-1, -1), (-1, 1),
(1, -1), (1, 1)]:
adj_point = closest_point.add(geom.Point(offset[0], offset[1]))
if r.contains(adj_point) and adj_point not in seen_points:
distance = closest_distance + distance_from_value(
im[adj_point.x, adj_point.y])
if adj_point not in distances or distance < distances[
adj_point]:
distances[adj_point] = distance
prev[adj_point] = closest_point
if dst is None:
return
return dst
def set_by_positions(positions):
# get existing angle buckets, don't use any that are within 3 buckets
bad_buckets = set()
for edge in extension_vertex.out_edges:
edge_angle = geom.Point(1, 0).signed_angle(edge.segment().vector())
edge_bucket = int((edge_angle + math.pi) * 64.0 / math.pi / 2)
for offset in xrange(3):
clockwise_bucket = (edge_bucket + offset) % 64
counterclockwise_bucket = (edge_bucket + 64 - offset) % 64
bad_buckets.add(clockwise_bucket)
bad_buckets.add(counterclockwise_bucket)
for pos in positions:
best_angle_bucket = best_angle_to_pos(pos)
if best_angle_bucket in bad_buckets:
continue
set_angle_bucket_soft(best_angle_bucket)
def get_tile_list():
tiles = []
with open(pytiles_path, 'r') as f:
for json_tile in json.load(f):
tile = geom.Point(int(json_tile['x']), int(json_tile['y']))
tile.region = json_tile['region']
tiles.append(tile)
downloaded = set([
fname.split('_sat.png')[0] for fname in os.listdir(get_tile_dirs()[0])
if '_sat.png' in fname
])
dl_tiles = [
tile for tile in tiles
if '{}_{}_{}'.format(tile.region, tile.x, tile.y) in downloaded
]
print 'found {} total tiles, using {} downloaded tiles'.format(
len(tiles), len(dl_tiles))
return dl_tiles
def get_tile_list():
tiles = []
for fname in os.listdir(get_tile_dirs()[0]):
if not fname.endswith('_sat.jpg'):
continue
parts = fname.split('_sat.jpg')[0].split('_')
region = parts[0]
x, y = int(parts[1]), int(parts[2])
tile = geom.Point(x, y)
tile.region = region
tiles.append(tile)
if angles_dir:
# filter tiles for only those that are in angles_dir
angle_keys = set(os.listdir(angles_dir))
tiles = [
tile for tile in tiles
if '{}_{}_{}.bin'.format(tile.region, tile.x, tile.y) in angle_keys
]
return tiles
def insert_connections(g, connections):
split_edges = {
} # map from edge to (split pos, new edge before pos, new edge after pos)
for idx, connection in enumerate(connections):
# figure out which current edge the connection intersects
edge = g.edges[connection['edge']]
path = [geom.Point(p[0], p[1]) for p in connection['path']]
intersection_point = path[-1]
while edge in split_edges:
our_pos = edge.closest_pos(intersection_point).distance
if our_pos < split_edges[edge]['pos']:
edge = split_edges[edge]['before']
else:
edge = split_edges[edge]['after']
# add path vertices
prev_vertex = g.vertices[connection['src']]
for point in path[1:]:
vertex = g.add_vertex(point)
edge1, edge2 = g.add_bidirectional_edge(prev_vertex, vertex)
edge1.phantom = True
edge1.connection_idx = idx
edge2.phantom = True
edge2.connection_idx = idx
prev_vertex = vertex
# split the edge
new_vertex = prev_vertex
for edge in [edge, edge.get_opposite_edge()]:
split_pos = edge.closest_pos(intersection_point).distance
split_edges[edge] = {
'pos': split_pos,
'before': g.add_edge(edge.src, new_vertex),
'after': g.add_edge(new_vertex, edge.dst),
}
# remove extraneous edges
filter_edges = set([edge for edge in split_edges.keys()])
g = g.filter_edges(filter_edges)
return g
def get_training_tile_data_normal(self, tile, tries=0):
rect = geom.Rectangle(
tile.scale(tile_size),
tile.add(geom.Point(1, 1)).scale(tile_size)
)
if tries < 3:
search_rect_x = random.randint(window_size/2, tile_size - window_size/2 - self.search_rect_size)
search_rect_y = random.randint(window_size/2, tile_size - window_size/2 - self.search_rect_size)
search_rect = geom.Rectangle(
rect.start.add(geom.Point(search_rect_x, search_rect_y)),
rect.start.add(geom.Point(search_rect_x, search_rect_y)).add(geom.Point(self.search_rect_size, self.search_rect_size)),
)
starting_locations = self.all_starting_locations['{}_{}_{}'.format(tile.region, tile.x, tile.y)]
starting_locations = [loc for loc in starting_locations if search_rect.add_tol(-window_size/4).contains(loc[0]['point'])]
else:
starting_locations = self.all_starting_locations['{}_{}_{}'.format(tile.region, tile.x, tile.y)]
starting_locations = [loc for loc in starting_locations if rect.add_tol(-window_size).contains(loc[0]['point'])]
starting_location = random.choice(starting_locations)
search_rect_min = starting_location[0]['point'].sub(geom.Point(self.search_rect_size / 2, self.search_rect_size / 2)).sub(rect.start)
if search_rect_min.x < window_size/2:
search_rect_min.x = window_size/2
elif search_rect_min.x > tile_size - window_size/2 - self.search_rect_size:
search_rect_min.x = tile_size - window_size/2 - self.search_rect_size
if search_rect_min.y < window_size/2:
search_rect_min.y = window_size/2
elif search_rect_min.y > tile_size - window_size/2 - self.search_rect_size:
search_rect_min.y = tile_size - window_size/2 - self.search_rect_size
search_rect = geom.Rectangle(
rect.start.add(search_rect_min),
rect.start.add(search_rect_min).add(geom.Point(self.search_rect_size, self.search_rect_size)),
)
starting_locations = [starting_location]
if not starting_locations:
return self.get_training_tile_data_normal(tile, tries + 1)
return {
'region': tile.region,
'rect': rect,
'search_rect': search_rect,
'cache': self.cache,
'starting_locations': starting_locations,
'gc': self.gcs[tile.region],
}
