def __init__(self,
population_size,
sim_population,
sensor_radius=1,
n_threads=1):
"""Initializes a simulation
:population_size: The allowable population size per generation
:sim_population: The allowable population size per grid simulation
:n_threads: The number of threads to utilize
"""
# Type checking
if type(n_threads) is not int:
raise TypeError('Thread count must be a positive integer')
elif n_threads < 1:
raise ValueError('Thread count must be above 0')
self.n_threads = n_threads
self.sensor_radius = sensor_radius
# Create genetic pool for simulation
dims = (sensor_radius + 1, sensor_radius + 1)
self.pool = NEAT_Pool(dims, 3)
self.population = Population(population_size, sim_population,
self.pool)
self.renderer = Renderer()
def draw_avatars_timeline(dates):
pygame.init()
renderer = Renderer()
width = max(len(date[1]) for date in dates)
height = len(dates)
gap = 0
page1 = pygame.Surface(
(width * (8 * 2 + gap) + gap, height * (8 * 2 + gap) + gap))
page2 = pygame.Surface(
(width * (8 * 2 + gap) + gap, height * (8 * 2 + gap) + gap))
values1 = []
values2 = []
maps = []
for y, row in enumerate(dates):
for x, entry in enumerate(row[1]):
i = y * width + x
pos = (x * (8 * 2 + gap) + gap, y * (8 * 2 + gap) + gap)
try:
world = get_world(entry["boid"])
frame1, frame2 = get_avatar_frames(renderer, world)
page1.blit(frame1, pos)
page2.blit(frame2, pos)
except Exception as e:
print("Couldn't parse '%s' (%s)" %
(entry["title"], entry["boid"]))
pygame.image.save(page1, "timeline1.png")
pygame.image.save(page2, "timeline2.png")
def __init__(self):
self.screen = pygame.Surface((256, 256))
self.dialog = pygame.Surface((208, 38))
self.room_frame_0 = pygame.Surface((256, 256))
self.room_frame_1 = pygame.Surface((256, 256))
self.avatar_frame_0 = pygame.Surface((16, 16))
self.avatar_frame_1 = pygame.Surface((16, 16))
self.renderer = Renderer()
self.avatar_x = 0
self.avatar_y = 0
self.avatar_room = None
self.palette = None
self.dialogue_lines = []
self.dialogue_char = 0
self.dialogue_style = {
"shk": False,
"wvy": False,
"rbw": False,
"clr": 0
}
self.starting = False
self.ending = False
self.ended = True
self.prev_frame = -1
def draw_average(index):
pygame.init()
renderer = Renderer()
graphic = [pygame.Surface((16, 16)), pygame.Surface((16, 16))]
sums = [[[0 for x in xrange(8)] for y in xrange(8)],
[[0 for x in xrange(8)] for y in xrange(8)]]
avgs = [[[0 for x in xrange(8)] for y in xrange(8)],
[[0 for x in xrange(8)] for y in xrange(8)]]
count = 0.0
for entry in index.itervalues():
try:
world = get_world(entry["boid"])
if len(world["tiles"]) > 0:
graphic_ = world["sprites"]["A"]["graphic"]
if len(graphic_) > 1:
frame1, frame2 = graphic_[0], graphic_[-1]
for y in xrange(8):
for x in xrange(8):
sums[0][y][x] += 1 if frame1[y][x] else 0
sums[1][y][x] += 1 if frame2[y][x] else 0
count += 1
except Exception as e:
pass
for y in xrange(8):
for x in xrange(8):
avgs[0][y][x] = sums[0][y][x] / count > 0.5
avgs[1][y][x] = sums[1][y][x] / count > 0.5
"""
for y in xrange(0, 8):
for x in xrange(0, 8):
avg = avgs[0][y][x] * 255
color = (avg, avg, avg)
graphic[0].fill(color, (x * 2, y * 2, 2, 2))
avg = avgs[1][y][x] * 255
color = (avg, avg, avg)
graphic[1].fill(color, (x * 2, y * 2, 2, 2))"""
renderer.render_frame_to_surface(graphic[0], avgs[0], (255, 255, 255),
(0, 0, 0))
renderer.render_frame_to_surface(graphic[1], avgs[1], (255, 255, 255),
(0, 0, 0))
pygame.image.save(graphic[0], "average1.png")
pygame.image.save(graphic[1], "average2.png")
def draw_avatars(index):
pygame.init()
renderer = Renderer()
width = 35
height = int(math.ceil(len(index) / float(width)))
print(width, height)
gap = 0
page1 = pygame.Surface(
(width * (8 * 2 + gap) + gap, height * (8 * 2 + gap) + gap))
page2 = pygame.Surface(
(width * (8 * 2 + gap) + gap, height * (8 * 2 + gap) + gap))
values1 = []
values2 = []
urls = []
titles = []
for entry in index.itervalues():
try:
world = get_world(entry["boid"])
if len(world["tiles"]) > 0:
frame1, frame2 = get_avatar_frames(renderer, world)
values1.append(frame1)
values2.append(frame2)
urls.append(entry["url"])
titles.append(entry["title"])
except Exception as e:
print("Couldn't parse '%s' (%s)" % (entry["title"], entry["boid"]))
#traceback.print_exc()
maps = []
for y in xrange(height):
for x in xrange(width):
if y * width + x >= len(values1):
break
i = y * width + x
pos = (x * (8 * 2 + gap) + gap, y * (8 * 2 + gap) + gap)
page1.blit(values1[i], pos)
page2.blit(values2[i], pos)
maps.append((pos, urls[i], titles[i]))
pygame.image.save(page1, "avatars1.png")
pygame.image.save(page2, "avatars2.png")
print(len(index), len(values1))
with open("avatars.html", "w") as html:
html.write('<html><body><img src="avatars.gif" usemap="#avatars">\n')
html.write('<map name="avatars">\n')
for map in maps:
pos, url, title = map
x, y = pos
html.write(
'<area shape="rect" coords="%s,%s,%s,%s" href="%s" title="%s">\n'
% (x, y, x + 16, y + 16, url, title))
html.write("</map>\n")
html.write("</body></html>\n")
def __init__(self, map, agents_info, dynamic_obs_num=0):
self.window = None #Window("Test")
#self.window.show(block=False)
#load map info
self.map = map
self.obstacles = map["map"]["obstacles"]
#load agents info. Pose, goal and name are all python list format with length agents_num.
self.agents_num, self.agents_pose, self.agents_goal, self.agents_name = self.get_agents_info(
agents_info)
print("Agents number: ", self.agents_num)
#Env constant
self.tilesize = 16
self.font = cv2.FONT_HERSHEY_SIMPLEX
self.visibility = 5
self.traj_color = np.random.randint(256, size=(self.agents_num, 3))
#Map the grid index to object type.
self.idx_to_object = {
0: "free",
1: "obstacle",
2: "agent",
3: "dynamic obstacle",
4: "unseen",
5: "goal",
}
self.object_to_idx = dict(
zip(self.idx_to_object.values(), self.idx_to_object.keys()))
#initialize canvas 0
self.row = map["map"]["dimensions"][1]
self.col = map["map"]["dimensions"][0]
print("row: ", self.row, " col: ", self.col)
self.background_img = np.ones(
shape=(self.row * self.tilesize, self.col * self.tilesize, 3),
dtype=np.uint8) * 255
self.renderer = Renderer(self.row, self.col, self.tilesize,
self.traj_color)
#simulation variable
self.time = 0
self.descrip = str(self.time)
self.traj = []
self.background_grid = np.zeros(shape=(self.row, self.col), dtype=int)
self.current_grid = None
for i in range(self.agents_num):
self.traj.append([self.agents_pose[i]])
# Draw the goal and static obstacles on the background image
self.background_img = self.renderer.draw_background(
self.background_img, self.agents_goal, self.obstacles)
self.background_grid = self.update_background_grid(
self.background_grid)
#initialize dynamic obstacles
self.dynamic_obs_num = dynamic_obs_num
self.dynamic_obs_pose = []
self.dynamic_obs_future_traj = []
self.dynamic_obs_manager = RobotManager(self.background_grid,
self.idx_to_object,
self.dynamic_obs_num)
from rendering import Renderer
def load_graph(graph_filename):
with tf.gfile.GFile(graph_filename, 'rb') as f:
graph_def = tf.GraphDef()
graph_def.ParseFromString(f.read())
return graph_def
import dlib
det = dlib.get_frontal_face_detector()
pred = dlib.shape_predictor('shape_predictor_68_face_landmarks.dat')
renderer = Renderer()
def get_landmarks(image):
detection = det(image, 1)[0]
face_shape = pred(image, detection)
l_eye_x = np.mean([face_shape.part(i).x for i in range(42, 48)])
l_eye_y = np.mean([face_shape.part(i).y for i in range(42, 48)])
r_eye_x = np.mean([face_shape.part(i).x for i in range(36, 42)])
r_eye_y = np.mean([face_shape.part(i).y for i in range(36, 42)])
l_eye = (l_eye_x, l_eye_y)
r_eye = (r_eye_x, r_eye_y)
ROOT = os.path.dirname(__file__)
pygame.init()
pygame.mouse.set_visible(False)
gameDisplay = pygame.display.set_mode(SCREEN)
buffer = pygame.Surface((256, 256))
pygame.display.set_caption('bitspy')
clock = pygame.time.Clock()
pygame.time.set_timer(pygame.USEREVENT, 1000)
TIMER = 0
RENDERER = Renderer()
background = pygame.Surface((256, 256))
background.fill(RENDERER.BGR)
bg_inc = 255
bg_src = [(x, y) for x in xrange(16) for y in xrange(16)]
bg_dst = [(x, y) for x in xrange(16) for y in xrange(16)]
BLACKLIST = set()
WHITELIST = set()
def refresh_lists():
global WHITELIST, BLACKLIST
f_count = 1000 # fault count per mesa
f_height = 1.0 # max fault height
mat_list = [(0.2, 50.0), (0.3, 100.0), (0.0, 1.0), (0.2, 10.0),
(0.7, 1000.0)] # material list
road_maxdist = 20 # max dist for next road segment - meters
road_iterations = 50 # max road placement attemps
road_width = 10 # road width - meters
ValidateInput(hm_width, hm_height, hm_cellsize, m_origins, m_scale,
mp_segments, mp_angularvar, mp_extangularvar, mp_lengthvar,
mp_extensionprob, f_radiusvar, f_distance, f_count, f_height,
mat_list, road_maxdist, road_iterations, road_width)
# init
random.seed(_seed)
app = Renderer()
heightmap = hmp.HeightMap(hm_width, hm_height)
matlist = material.MaterialList(mat_list)
CFFkernels = CFF.InitKernels(f_radiusvar, f_height)
masI = []
for i in range(0, m_origins):
magent = maI.MesaAgentI(i, hm_width, hm_height, m_scale, mp_segments,
mp_angularvar, mp_extangularvar, mp_lengthvar,
mp_extensionprob, f_radiusvar, f_distance,
f_count, f_height)
magent.Run(heightmap, CFFkernels)
masI.append(magent)
printer.DrawMesaAgentI(masI,
heightmap,
