def toilet_dist(floor, path_dists, paths):
ppt = defaultdict(int)
toilet_centers = set([
floor.room_centers[ID] for ID, name in floor.room_names.items()
if name == 'toilet'
])
ctr = {c: ID for ID, c in floor.room_centers.items()}
has_bathroom = set(['1', '2', 'PK', 'K'])
needs_bathroom = [
ID for ID, name in floor.room_names.items() if name not in has_bathroom
]
total_path_length = 0
n = 0
for ID in needs_bathroom:
c = floor.room_centers[ID]
path = pathing.min_path(path_dists[c], paths[c], toilet_centers)
load = floor.population * (floor.room_sizes[ID] / floor.area)
# load = floor.population * floor.room_sizes[ID] / len(floor.rooms)
n += load
total_path_length += path_length(floor, path)
ppt[path[-1]] += load
# for load, path in pathing.closest_paths(floor, path_dists, paths, vert_options=toilet_centers):
# total_path_length += load * path_length(floor, path)
# n += load
foo = mean(list(v / floor.room_sizes[ctr[c]] for c, v in ppt.items()))
return (total_path_length / n), foo
def get_average_fitness(self):
"""Get the per-generation average fitness."""
avg_fitness = []
for stats in self.generation_statistics:
scores = []
for fitness in stats.values():
scores.extend(fitness)
avg_fitness.append(mean(scores))
return avg_fitness
def post_evaluate(self, population, species, best):
fit_mean = mean([c.fitness for c in population])
fit_std = stdev([c.fitness for c in population])
print('Population\'s average fitness: {0:3.5f} stdev: {1:3.5f}'.format(
fit_mean, fit_std))
print('Best fitness: {0:3.5f} - size: {1!r} - species {2} - id {3}'.
format(best.fitness, best.size(), best.species_id, best.ID))
print('Species length: {0:d} totaling {1:d} individuals'.format(
len(species), sum([len(s.members) for s in species])))
print('Species ID : {0!s}'.format([s.ID for s in species]))
print('Species size : {0!s}'.format(
[len(s.members) for s in species]))
print('Species age : {0}'.format([s.age for s in species]))
def get_species_fitness(population, null_value=''):
all_species = set()
for gen_data in population.generation_statistics:
all_species = all_species.union(gen_data.keys())
max_species = max(all_species)
species_fitness = []
for gen_data in population.generation_statistics:
member_fitness = [gen_data.get(sid, []) for sid in range(1, max_species + 1)]
fitness = []
for mf in member_fitness:
if mf:
fitness.append(mean(mf))
else:
fitness.append(null_value)
species_fitness.append(fitness)
return species_fitness
def window_area(floor):
class_rooms = set(['computer lab', 'tutoring', 'title 1', 'work', \
'team', 'library', 'tutoring', 'conference', 'resource', \
'2', '1', 'pk', 'k', 'art', 'music', 'life skills',
'faculty', 'library', 'administration', 'cafeteria'])
foo = []
for rid, verts in floor.rooms.items():
if floor.room_names[rid].lower() not in class_rooms:
continue
total = 0
outside = 0
for i, j in pairwise(verts):
d = floor.edge[i][j]
total += d['length']
outside += d['length'] * d['outside']
foo.append(outside / total)
return mean(foo)
def species_mean_fitness(species):
return mean([m.fitness for m in species.members])
def create_hallways(floor,
iters=10,
alpha=12,
k=10,
pheromone_decay=.1,
fe_weight=.5,
start_pheromone=0,
verbose=False,
firescapes=False):
max_width = 12
min_width = 5
intitialize(floor, start_pheromone)
# print(fe_weight)
# fe_weight = 1
# Main loop.
for step in range(iters):
calculate_loads(floor, fe_weight, True)
normalize_loads(floor)
pheromone_values = [] # for logging
for i, j, data in floor.edges(data=True):
if not (data['between_fixed'] or data['outside']
): #if not (data['between_fixed'] or data['outside']):
data['pheromone'] = (1 - pheromone_decay) * data[
'pheromone'] + k * data['load_normalized']
pheromone_values.append(data['pheromone'])
if data['pheromone'] > 0: # and not data['inner']:
data['weight'] = data['length'] / (
(1 + data['pheromone'])**alpha)
if verbose:
print("step %i, mean phero=%f, min=%f, max=%f" % \
(step, mean(pheromone_values), min(pheromone_values), max(pheromone_values)))
print("step %i, mean phero=%f, min=%f, max=%f" % \
(step, mean(pheromone_values), min(pheromone_values), max(pheromone_values)))
entrances = create_entrances(
floor) # Create entrances based on those paths to exit
floor.entrances = entrances
calculate_loads(floor, fe_weight, firescapes)
# Now that entrances are created. Find path to main one.
path_dists, paths = pathing.all_paths(floor, weight='weight')
if not firescapes:
for i, j, d in floor.edges_iter(data=True):
d['entrance_laod'] = 0
# for load, path in pathing.closest_paths(floor, path_dists, paths, entrances):
# if len(path) > 1:
# add_load(floor, path, key='entrance_load', load=load)
for load, path in pathing.closest_paths(floor, path_dists, paths,
entrances[:1]):
add_load(floor, path, key='entrance_load', load=load)
for i, j, d in floor.edges_iter(data=True):
d['load'] = max(d['load'], d['entrance_load'])
# print(c)
derp(floor)
########
# # TODO explain.
# for ID, face in floor.rooms.items():
# vc = floor.room_centers[ID]
# # print(list(floor.inner_edges(ID)))
# edge_with_door = max(floor.inner_edges(ID), key=lambda et: et[2]['load'])
# vd = edge_with_door[0] if edge_with_door[1] == vc else edge_with_door[1] # vert for door
# for v1, v2, data in floor.inner_edges(ID):
# if v2 != vc and data['load'] < load_for_doorway:
# data['load'] = 0
# data['weigh'] = data['length']
# s = sum(floor.edge[vc][j_]['load'] for j_ in face if floor.has_edge(vc, j_))
# jmax = max((floor.edge[vc][j_]['load'], j_) for j_ in face if floor.has_edge(vc, j_))[1]
# for j in face:
# if j != jmax and floor.has_edge(vc, j):
# floor.edge[vc][j]['load'] =0 maps
# ########
# max_laod = max(d['load'] for i, j,d in floor.edges_iter(data=True))
load_to_width = 1 #, max_width / max_laod
# Convert loads into hallway dimensions.
for i, j, d in floor.edges(data=True):
if d['load'] > 0:
d['width'] = min(max_width,
max(min_width, d['load'] * load_to_width))
else:
d['width'] = 0
def from_genome(cls, genome, firescapes=False, view=None, cache=True):
if genome.phenotype is not None and cache:
return genome.phenotype
G = genome_to_graph(genome) # First create a graph representation.
pos = nx.spectral_layout(G) # Create with spectral layout of graph.
scale_offset(pos, dx=75, dy=75, scale=600)
fix_overlapping(pos) # Prevent overlapping points.
center(pos, dimensions=(750, 750))
pos = physics_layout(G, pos, view) # Apply physics simulation.
center(pos, dimensions=(750, 750))
if 'concave_alpha' in genome.attribute_genes:
a = genome.attribute_genes['concave_alpha'].value
else:
a = 40
cells, debug_data = voronoi_cells(
pos, genome.node_genes, a) # Room walls by voronoi tesselation.
vert_to_id = defaultdict(
lambda: len(vert_to_id)) # Map vertices to global indexes.
rooms = defaultdict(list)
vert_to_room = defaultdict(set)
room_names = dict()
room_centers = dict()
edges = []
no_outside = set()
for ID, verts in cells.items():
gene = genome.node_genes[ID]
# print(gene.name)
if gene.name == 'empty' or gene.name == 'playground':
no_outside.update(set([vert_to_id[vert] for vert in verts]))
if gene.name == 'empty':
continue
center_v = polygon.center(verts)
center_i = vert_to_id[center_v]
room_centers[ID] = center_i
vert_to_room[center_i].add(ID)
room_names[ID] = gene.name
# if gene.name == 'playground':
# continue
for i, vert in enumerate(verts):
vid = vert_to_id[
vert] # voronoi points are integers and thus hashable.
rooms[ID].append(vid)
vert_to_room[vid].add(ID)
if gene.name != 'playground':
edges.append((vid, vert_to_id[verts[i - 1]], {
'inner': False
}))
edges.append((vid, center_i, {
'inner': True,
'directed': None
}))
vertices = sorted(vert_to_id.keys(), key=lambda v: vert_to_id[v])
floor = cls(vertices,
dict(rooms),
room_names,
vert_to_room,
room_centers,
entrances=[])
floor.debug_data = debug_data # temporary
for i, j, data in edges: # add edges.
floor.add_edge(i, j, **data)
floor.calc_outisde_edges(no_outside)
# Remove edges that connect centers to outside
# for ri, vc in floor.room_centers.items():
# if room_names[ri] in ['cafeteria', 'library', 'gym']:
# continue
# verts = rooms[ri]
# out = [v for v in verts if v in floor.outside_verts]
# if len(out) == len(verts):
# continue
# for v in out:
# if floor.has_edge(vc, v):
# floor.remove_edge(vc, v)
# for v in floor.outside_verts:
# for ri in vert_to_room[v]:
# if room_names[ri] not in ['cafeteria', 'library', 'gym'] and \
# len(room_centers[ri]):
# vc = room_centers[ri]
# floor.remove_edge(v, vc)
# new_polygons = []
# for ID, face in floor.rooms:
# polygon = [floor.vertices[vi] for vi in face]
# clipped = poylgon.clip(polygon, floor.hallway_geometry)
# new_polygons.append(clipped)
# self.topologize(new_polygons)
""" Prevent adjacency requirements from having a hallway between them.
"""
for conn in genome.conn_genes.values():
if conn.fixed:
room1_id = conn.in_node_id
room2_id = conn.out_node_id
edge = floor.get_rooms_edge(room1_id, room2_id)
if edge:
i, j, data = edge
data['between_fixed'] = True
else:
raise InvalidContraintException()
alpha = genome.attribute_genes['hallway_alpha'].value
decay = genome.attribute_genes['hallway_decay'].value
if 'fe_weight' in genome.attribute_genes:
fe_weight = genome.attribute_genes['fe_weight'].value
else:
fe_weight = .2
create_hallways(floor, alpha=alpha, pheromone_decay=decay, iters=10, fe_weight=fe_weight,\
verbose=False, firescapes=firescapes)
for i, j, d in floor.edges(data=True):
if d['between_fixed'] and d['width']:
raise InvalidContraintException()
cx = mean([x for x, y in floor.vertices])
cy = mean([y for x, y in floor.vertices])
x1, y1 = floor.vertices[floor.entrances[0]]
angle = -math.atan2(y1 - cy, x1 - cx) + math.pi / 2
floor.vertices = [
geometry.rotate_point((cx, cy), p, angle) for p in floor.vertices
]
floor.add_adjacent_room_edges([(c.in_node_id, c.out_node_id)
for c in genome.conn_genes.values()
if c.fixed])
smooth(floor)
floor.hallway_geometry = create_geometry(floor)
floor.stats = fps.calculate_all(floor)
return floor