class PyAgar(object):
title = "PyAgar"
def __init__(self, args):
self.args = args
pyglet.resource.path.append(os.path.join(dname,'resources'))
pyglet.resource.reindex()
pyglet.font.add_file('resources/DejaVuSans.ttf')
pyglet.font.add_file('resources/unifont.ttf')
director.set_show_FPS(False)
w = director.init(fullscreen=True, caption=self.title, visible=True, resizable=True)
# width = director.window.width
# height = director.window.height
# wnew, hnew = int(width * .75), int(height * .75)
# director.window.set_fullscreen(False)
# director.window.set_size(wnew, hnew)
# w.set_location((width-wnew)/2, (height-hnew)/2)
director.window.pop_handlers()
director.window.push_handlers(Handler())
self.gameScene = Scene()
self.gameLayer = AgarLayer()
self.gameScene.add(self.gameLayer)
director.replace(self.gameScene)
director.window.set_visible(True)
def interesting_problems():
sc = Scene()
locales = [(6, 2, 0), (6, -2, 0), (-5, -2, 0)]
fermat = Mobject(*TexMobjects(["x^n","+","y^n","=","z^n"]))
fermat.scale(0.5).shift((-2.5, 0.7, 0))
face = SimpleFace()
tb = ThoughtBubble().shift((-1.5, 1, 0))
sb = SpeechBubble().shift((-2.4, 1.3, 0))
fermat_copies, face_copies, tb_copies, sb_copies = (
Mobject(*[
deepcopy(mob).scale(0.5).shift(locale)
for locale in locales
])
for mob in [fermat, face, tb, sb]
)
sc.add(face, tb)
sc.animate(ShowCreation(fermat, run_time = 1))
sc.add(fermat)
sc.dither()
sc.animate(
Transform(
deepcopy(fermat).repeat(len(locales)),
fermat_copies
),
FadeIn(face_copies, run_time = 1.0)
)
sc.animate(FadeIn(tb_copies))
sc.dither()
sc.animate(
Transform(tb, sb),
Transform(tb_copies, sb_copies)
)
return sc
def different_points(radians1, radians2):
sc = Scene()
circle = Circle(density = CIRCLE_DENSITY).scale(RADIUS)
sc.add(circle)
points1, points2 = (
[
(RADIUS * np.cos(angle), RADIUS * np.sin(angle), 0)
for angle in radians
]
for radians in (radians1, radians2)
)
dots1, dots2 = (
Mobject(*[Dot(point) for point in points])
for points in (points1, points2)
)
lines1, lines2 = (
[
Line(point1, point2)
for point1, point2 in it.combinations(points, 2)
]
for points in (points1, points2)
)
sc.add(dots1, *lines1)
sc.animate(
Transform(dots1, dots2, run_time = 3),
*[
Transform(line1, line2, run_time = 3)
for line1, line2 in zip(lines1, lines2)
]
)
sc.dither()
return sc
def summarize_pattern(*radians):
sc = Scene()
circle = Circle(density = CIRCLE_DENSITY).scale(RADIUS)
sc.add(circle)
points = [
(RADIUS * np.cos(angle), RADIUS * np.sin(angle), 0)
for angle in radians
]
dots = [Dot(point) for point in points]
last_num = None
for x in xrange(len(points)):
new_lines = Mobject(*[
Line(points[x], points[y]) for y in xrange(x)
])
num = TexMobject(str(moser_function(x + 1))).center()
sc.animate(
Transform(last_num, num) if last_num else ShowCreation(num),
FadeIn(new_lines),
FadeIn(dots[x]),
run_time = 0.5,
)
sc.remove(last_num)
last_num = num
sc.add(num, dots[x], new_lines)
sc.dither()
return sc
def main():
# Defines global elements to use
global window
global shape
global scene
global camera
global camera_pos
global camera_front
global camera_up
global camera_speed
# Initiate scene
scene = Scene()
# Change coordinates of camera_pos and camera_up to change camera properties
camera_pos = Vec3d(0, 0, 2, 1)
camera_front = Vec3d(0, 0, -1, 1)
camera_up = Vec3d(0, 1, 0, 1)
camera_speed = 0.05
# The second argument is for target. Change for target object. Add camera to the scene
camera = Camera(camera_pos, Vec3d(0, 0, 0, 1), camera_up, camera_front)
scene.add(camera)
# Create a generic shape
shape = Shape()
# Read shape from the file and add to the scene
input_ops = InputOperations()
input_ops.read_file()
shape.vertices_list, shape.faces = input_ops.parse_contents()
scene.add(shape)
glutInit(sys.argv)
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH)
glutInitWindowSize(640, 480)
glutInitWindowPosition(0, 0)
window = glutCreateWindow("Bugrahan Donmez - Computer Graphics")
glutDisplayFunc(scene.draw_scene)
# Uncomment this line to get full screen.
# glutFullScreen()
glutIdleFunc(scene.draw_scene)
glutReshapeFunc(ReSizeGLScene)
glutSpecialFunc(keyPressed)
glutKeyboardFunc(keyPressed)
InitGL(640, 480)
glutMainLoop()
def logo_to_circle():
from generate_logo import DARK_BROWN, LOGO_RADIUS
sc = Scene()
small_circle = Circle(density=CIRCLE_DENSITY,
color='skyblue').scale(LOGO_RADIUS).highlight(
DARK_BROWN, lambda (x, y, z): x < 0 and y > 0)
big_circle = Circle(density=CIRCLE_DENSITY).scale(RADIUS)
sc.add(small_circle)
sc.dither()
sc.animate(Transform(small_circle, big_circle))
return sc
def addPathRow(self, path, row, start_date=None, end_date=None):
# start_date (str), YYYY-MM-DD
# end_date (str): YYYY-MM-DD
if not self.index_db_defined:
return 0
sql_query_str = """
SELECT
{0:s},
{1:s} """.format(self._colnames["target_id"],
self._colnames["url"])
sql_query_str = sql_query_str + """
FROM
"{0:s}" """.format(self.index_tb_name)
sql_query_str = sql_query_str + """
WHERE
{0:s} == {1:d}
AND {2:s} == {3:d} """.format(self._colnames["wrs_path"], path,
self._colnames["wrs_row"], row)
if start_date is not None:
sql_query_str = sql_query_str + """
AND {0:s} >= datetime("{1:s}")"""
sql_query_str = sql_query_str.format(self._colnames["acq_date"],
start_date)
if end_date is not None:
sql_query_str = sql_query_str + """
AND {0:s} <= datetime("{1:s}")"""
sql_query_str = sql_query_str.format(self._colnames["acq_date"],
"{0:s} 23:59:59".format(end_date))
if (self.bucket_id == "GOOGLE"):
sql_query_str = sql_query_str + """
AND {0:s} != "PRE"
AND {1:s} == "{2:s}" """.format(self._colnames["c_number"],
self._colnames["sc_id"],
self.spacecraft_id)
sql_query_str = sql_query_str + ";"
search_result = pd.read_sql_query(sql_query_str, self.index_db_engine)
if len(search_result) > 0:
for idx, row in search_result.iterrows():
one_scn = Scene(row[self._colnames["target_id"]])
file_urls = self._indexUrlToFileUrls(row[self._colnames["url"]])
for f in file_urls:
one_scn.add(f)
self.add(one_scn)
self._saved_scenes[one_scn.name] = False
return len(search_result)
def logo_to_circle():
from generate_logo import DARK_BROWN, LOGO_RADIUS
sc = Scene()
small_circle = Circle(
density = CIRCLE_DENSITY,
color = 'skyblue'
).scale(LOGO_RADIUS).highlight(
DARK_BROWN, lambda (x, y, z) : x < 0 and y > 0
)
big_circle = Circle(density = CIRCLE_DENSITY).scale(RADIUS)
sc.add(small_circle)
sc.dither()`
sc.animate(Transform(small_circle, big_circle))
return sc
def response_invitation():
sc = Scene()
video_icon = VideoIcon()
mini_videos = Mobject(
*
[deepcopy(video_icon).scale(0.5).shift((3, y, 0)) for y in [-2, 0, 2]])
comments = Mobject(*[
Line((-1.2, y, 0), (1.2, y, 0), color='white')
for y in [-1.5, -1.75, -2]
])
sc.add(video_icon)
sc.dither()
sc.animate(Transform(deepcopy(video_icon).repeat(3), mini_videos))
sc.add(mini_videos)
sc.dither()
sc.animate(ShowCreation(comments, run_time=1.0))
return sc
def addScene(self, scn_name, scn_index_url):
if scn_name not in self.scenes:
_sc_id = self._scnIdToSpacecraftId(scn_name)
_bkt_id = self._indexUrlToBucketId(scn_index_url)
if _sc_id is None or _bkt_id is None:
return None
if _sc_id != self.spacecraft_id:
return None
if _bkt_id != self.bucket_id:
return None
one_scn = Scene(scn_name)
file_urls = self._indexUrlToFileUrls(scn_index_url)
for f in file_urls:
one_scn.add(f)
self.add(one_scn)
self._saved_scenes[one_scn.name] = False
return scn_name
def count_sections(*radians):
sc = Scene()
circle = Circle(density = CIRCLE_DENSITY).scale(RADIUS)
sc.add(circle)
points = [
(RADIUS * np.cos(angle), RADIUS * np.sin(angle), 0)
for angle in radians
]
dots = [Dot(point) for point in points]
interior = Region(lambda x, y : x**2 + y**2 < RADIUS**2)
for x in xrange(1, len(points)):
if x == 1:
sc.animate(ShowCreation(dots[0]), ShowCreation(dots[1]))
sc.add(dots[0], dots[1])
else:
sc.animate(ShowCreation(dots[x]))
sc.add(dots[x])
new_lines = Mobject(*[
Line(points[x], points[y]) for y in xrange(x)
])
sc.animate(Transform(deepcopy(dots[x]), new_lines, run_time = 2.0))
sc.add(new_lines)
sc.dither()
regions = plane_partition_from_points(*points[:x+1])
for reg in regions:
reg.intersect(interior)
regions = filter(lambda reg : reg.bool_grid.any(), regions)
last_num = None
for reg, count in zip(regions, it.count(1)):
number = TexMobject(str(count)).shift((RADIUS, 3, 0))
sc.highlight_region(reg)
rt = 1.0 / (x**0.8)
sc.add(number)
sc.remove(last_num)
last_num = number
sc.dither(rt)
sc.reset_background()
sc.remove(last_num)
sc.animate(Transform(last_num, deepcopy(last_num).center()))
sc.dither()
sc.remove(last_num)
return sc
def response_invitation():
sc = Scene()
video_icon = VideoIcon()
mini_videos = Mobject(*[
deepcopy(video_icon).scale(0.5).shift((3, y, 0))
for y in [-2, 0, 2]
])
comments = Mobject(*[
Line((-1.2, y, 0), (1.2, y, 0), color = 'white')
for y in [-1.5, -1.75, -2]
])
sc.add(video_icon)
sc.dither()
sc.animate(Transform(deepcopy(video_icon).repeat(3), mini_videos))
sc.add(mini_videos)
sc.dither()
sc.animate(ShowCreation(comments, run_time = 1.0))
return sc
def next_few_videos(*radians):
sc = Scene()
circle = Circle(density=CIRCLE_DENSITY).scale(RADIUS)
points = [(RADIUS * np.cos(angle), RADIUS * np.sin(angle), 0)
for angle in radians]
dots = Mobject(*[Dot(point) for point in points])
lines = Mobject(*[
Line(point1, point2) for point1, point2 in it.combinations(points, 2)
])
thumbnail = Mobject(circle, dots, lines)
frame = VideoIcon().highlight("black",
lambda point: np.linalg.norm(point) < 0.5)
big_frame = deepcopy(frame).scale(SPACE_WIDTH)
frame.shift((-5, 0, 0))
sc.add(thumbnail)
sc.dither()
sc.animate(
Transform(big_frame, frame),
Transform(thumbnail,
deepcopy(thumbnail).scale(0.15).shift((-5, 0, 0))))
sc.add(frame, thumbnail)
sc.dither()
last = frame
for x in [-2, 1, 4]:
vi = VideoIcon().shift((x, 0, 0))
sc.animate(
Transform(deepcopy(last), vi),
Animation(thumbnail) #Keeps it from getting burried
)
sc.add(vi)
last = vi
return sc
def connect_points(*radians):
sc = Scene()
circle = Circle(density=CIRCLE_DENSITY).scale(RADIUS)
sc.add(circle)
points = [(RADIUS * np.cos(angle), RADIUS * np.sin(angle), 0)
for angle in radians]
dots = [Dot(point) for point in points]
sc.add(*dots)
anims = []
all_lines = []
for x in xrange(len(points)):
lines = [Line(points[x], points[y]) for y in range(len(points))]
lines = Mobject(*lines)
anims.append(Transform(deepcopy(dots[x]), lines, run_time=3.0))
all_lines.append(lines)
sc.animate(*anims)
sc.add(*all_lines)
sc.dither()
return sc
def next_few_videos(*radians):
sc = Scene()
circle = Circle(density = CIRCLE_DENSITY).scale(RADIUS)
points = [
(RADIUS * np.cos(angle), RADIUS * np.sin(angle), 0)
for angle in radians
]
dots = Mobject(*[
Dot(point) for point in points
])
lines = Mobject(*[
Line(point1, point2)
for point1, point2 in it.combinations(points, 2)
])
thumbnail = Mobject(circle, dots, lines)
frame = VideoIcon().highlight(
"black",
lambda point : np.linalg.norm(point) < 0.5
)
big_frame = deepcopy(frame).scale(SPACE_WIDTH)
frame.shift((-5, 0, 0))
sc.add(thumbnail)
sc.dither()
sc.animate(
Transform(big_frame, frame),
Transform(
thumbnail,
deepcopy(thumbnail).scale(0.15).shift((-5, 0, 0))
)
)
sc.add(frame, thumbnail)
sc.dither()
last = frame
for x in [-2, 1, 4]:
vi = VideoIcon().shift((x, 0, 0))
sc.animate(
Transform(deepcopy(last), vi),
Animation(thumbnail)#Keeps it from getting burried
)
sc.add(vi)
last = vi
return sc
def connect_points(*radians):
sc = Scene()
circle = Circle(density = CIRCLE_DENSITY).scale(RADIUS)
sc.add(circle)
points = [
(RADIUS * np.cos(angle), RADIUS * np.sin(angle), 0)
for angle in radians
]
dots = [Dot(point) for point in points]
sc.add(*dots)
anims = []
all_lines = []
for x in xrange(len(points)):
lines = [Line(points[x], points[y]) for y in range(len(points))]
lines = Mobject(*lines)
anims.append(Transform(deepcopy(dots[x]), lines, run_time = 3.0))
all_lines.append(lines)
sc.animate(*anims)
sc.add(*all_lines)
sc.dither()
return sc
def add(self, *mobjects):
Scene.add(self, *list(mobjects) + self.foreground_mobjects)
def add_foreground_mobjects(self, *mobjects):
self.foreground_mobjects += list(mobjects)
Scene.add(self, *mobjects)
class WhackAMole(object):
title = "Whack A Mole"
def __init__(self):
if not os.path.exists("data"): os.mkdir("data")
pyglet.resource.path.append('resources')
pyglet.resource.reindex()
pyglet.resource.add_font('cutouts.ttf')
pyglet.resource.add_font('scoreboard.ttf')
director.init(width=int(1024*1.0), height=int(768*1.1),
caption=self.title, visible=False, resizable=True)
director.window.set_size(int(1024*1.0), int(768*1.1))
director.window.pop_handlers()
director.window.push_handlers(DefaultHandler())
director.settings = {'overlay': False,
'eyetracker': True,
'eyetracker_ip': '127.0.0.1',
'eyetracker_out_port': '4444',
'eyetracker_in_port': '5555',
'calibration_speed': 1,
'calibration_wait': 1,
'calibration_random': 1,
'calibration_level': 3,
'calibration_auto': 1,
'calibration_points': 2,
'calibration_eye': 0
}
self.client = None
self.client = iViewXClient(director.settings['eyetracker_ip'], int(director.settings['eyetracker_out_port']))
self.listener = reactor.listenUDP(int(director.settings['eyetracker_in_port']), self.client)
director.set_show_FPS(False)
director.window.set_fullscreen(False)
if director.settings['eyetracker']:
director.window.set_mouse_visible(False)
else:
director.window.set_mouse_visible(True)
# Intro scene and its layers
self.introScene = Scene()
self.mainMenu = MainMenu()
self.optionsMenu = OptionsMenu()
self.eyetrackerScrim = EyetrackerScrim()
self.mplxLayer = MultiplexLayer(self.mainMenu, self.optionsMenu)
self.introScene.add(self.mplxLayer, 1)
self.introScene.register_event_type('start_task')
self.introScene.register_event_type('eyetracker_info_changed')
self.introScene.push_handlers(self)
# Task scene and its layers
self.taskScene = Scene()
self.taskLayer = Task(self.client)
self.calibrationLayer = CalibrationLayer(self.client)
self.calibrationLayer.register_event_type('show_headposition')
self.calibrationLayer.register_event_type('hide_headposition')
self.calibrationLayer.push_handlers(self)
self.taskLayer.register_event_type('new_trial')
self.taskLayer.register_event_type('start_calibration')
self.taskLayer.register_event_type('stop_calibration')
self.taskLayer.push_handlers(self)
self.taskScene.add(self.taskLayer, 1)
self.taskScene.register_event_type('show_intro_scene')
self.taskScene.push_handlers(self)
director.window.set_visible(True)
def start_calibration(self, on_success, on_failure):
self.calibrationLayer.on_success = on_success
self.calibrationLayer.on_failure = on_failure
self.calibrationLayer.points = director.settings['calibration_points']
self.calibrationLayer.eye = director.settings['calibration_eye']
self.calibrationLayer.level = director.settings['calibration_level']
self.calibrationLayer.speed = director.settings['calibration_speed']
self.calibrationLayer.auto = director.settings['calibration_auto']
self.calibrationLayer.wait = director.settings['calibration_wait']
self.calibrationLayer.random = director.settings['calibration_random']
self.taskScene.add(self.calibrationLayer, 2)
def stop_calibration(self):
self.taskScene.remove(self.calibrationLayer)
def eyetracker_listen(self, _):
self.listener = reactor.listenUDP(int(director.settings['eyetracker_in_port']), self.client)
self.introScene.remove(self.eyetrackerScrim)
self.introScene.enable_handlers(True)
def eyetracker_info_changed(self):
if self.client.remoteHost != director.settings['eyetracker_ip'] or \
self.client.remotePort != int(director.settings['eyetracker_out_port']):
self.client.remoteHost = director.settings['eyetracker_ip']
self.client.remotePort = int(director.settings['eyetracker_out_port'])
else:
self.introScene.add(self.eyetrackerScrim, 2)
self.introScene.enable_handlers(False)
d = self.listener.stopListening()
d.addCallback(self.eyetracker_listen)
def show_intro_scene(self):
self.mplxLayer.switch_to(0)
director.replace(self.introScene)
def start_task(self):
director.replace(SplitRowsTransition(self.taskScene))
Point(3, -5, -4),
2,
Phong(
Color.BLACK,
Color.BLACK,
Color.BLACK,
50,
transmittance=0.8,
ior=1.5,
reflect_bg=True
)
),
]
for o in objects:
scene.add(o)
for l in lights:
scene.add_light(l)
result = scene.render()
img = Image.new('RGB', (scene.width, scene.height), tuple(scene.background))
pixels = img.load()
for u in range(img.size[0]):
for v in range(img.size[1]):
pixels[u, v] = tuple(result[v][u])
img.save('output.png')
class WilliamsEnvironment(object):
title = "The Williams' Search Task"
def __init__(self):
if not os.path.exists("data"): os.mkdir("data")
pyglet.resource.path.append('resources')
pyglet.resource.reindex()
pyglet.resource.add_font('Pipe_Dream.ttf')
pyglet.resource.add_font('cutouts.ttf')
director.set_show_FPS(False)
director.init(fullscreen=True, caption=self.title, visible=True, resizable=True)
width = director.window.width
height = director.window.height
director.window.set_fullscreen(False)
director.window.set_size(int(width * .75), int(height * .75))
director.window.pop_handlers()
director.window.push_handlers(Handler())
director.settings = {'seed':'1',
'eyetracker': True,
'eyetracker_ip': '127.0.0.1',
'eyetracker_out_port': '4444',
'eyetracker_in_port': '5555',
'player': 'Human',
'players': ['Human'],
'mode': 'Insane',
'modes': ['Easy', 'Moderate', 'Hard', 'Insane', 'Experiment']}
self.client = None
self.client_actr = None
if ACTR6:
director.settings['players'].append("ACT-R")
#director.settings['player'] = "ACT-R"
director.settings['eyetracker'] = False
self.client_actr = JNI_Server(self)
self.listener_actr = reactor.listenTCP(6666, self.client_actr)
elif eyetracking:
self.client = iViewXClient(director.settings['eyetracker_ip'], int(director.settings['eyetracker_out_port']))
self.listener = reactor.listenUDP(int(director.settings['eyetracker_in_port']), self.client)
if platform.system() != 'Windows':
director.window.set_icon(pyglet.resource.image('logo.png'))
cursor = director.window.get_system_mouse_cursor(director.window.CURSOR_HAND)
director.window.set_mouse_cursor(cursor)
# Intro scene and its layers
self.introScene = Scene()
self.mainMenu = MainMenu()
self.optionsMenu = OptionsMenu()
self.participantMenu = ParticipantMenu()
self.introBackground = BackgroundLayer()
self.eyetrackerScrim = EyetrackerScrim()
self.introScene.add(self.introBackground)
self.mplxLayer = MultiplexLayer(self.mainMenu, self.optionsMenu, self.participantMenu)
self.introScene.add(self.mplxLayer, 1)
self.introScene.register_event_type('start_task')
self.introScene.register_event_type('eyetracker_info_changed')
self.introScene.push_handlers(self)
# Task scene and its layers
self.taskScene = Scene()
self.taskBackgroundLayer = TaskBackground()
self.taskLayer = Task(self.client, self.client_actr)
self.actrScrim = ACTRScrim()
if self.client:
self.calibrationLayer = CalibrationLayer(self.client)
self.calibrationLayer.register_event_type('show_headposition')
self.calibrationLayer.register_event_type('hide_headposition')
self.calibrationLayer.push_handlers(self)
self.headpositionLayer = HeadPositionLayer(self.client)
self.taskLayer.register_event_type('new_trial')
self.taskLayer.push_handlers(self.taskBackgroundLayer)
self.taskLayer.register_event_type('start_calibration')
self.taskLayer.register_event_type('stop_calibration')
self.taskLayer.register_event_type('show_headposition')
self.taskLayer.register_event_type('hide_headposition')
self.taskLayer.register_event_type('actr_wait_connection')
self.taskLayer.register_event_type('actr_wait_model')
self.taskLayer.register_event_type('actr_running')
self.taskLayer.push_handlers(self)
self.taskScene.add(self.taskBackgroundLayer)
self.taskScene.add(self.taskLayer, 1)
self.actrScrim.visible = False
self.taskScene.add(self.actrScrim, 3)
self.taskScene.register_event_type('show_intro_scene')
self.taskScene.push_handlers(self)
director.window.set_visible(True)
def actr_wait_connection(self):
self.actrScrim.setWaitConnection()
self.actrScrim.visible = True
def actr_wait_model(self):
self.actrScrim.setWaitModel()
self.actrScrim.visible = True
def actr_running(self):
self.actrScrim.visible = False
def start_calibration(self, on_success, on_failure):
self.calibrationLayer.on_success = on_success
self.calibrationLayer.on_failure = on_failure
self.taskScene.add(self.calibrationLayer, 2)
def stop_calibration(self):
self.taskScene.remove(self.calibrationLayer)
def show_headposition(self):
self.taskScene.add(self.headpositionLayer, 3)
def hide_headposition(self):
self.taskScene.remove(self.headpositionLayer)
def eyetracker_listen(self, _):
self.listener = reactor.listenUDP(int(director.settings['eyetracker_in_port']), self.client)
self.introScene.remove(self.eyetrackerScrim)
self.introScene.enable_handlers(True)
def eyetracker_info_changed(self):
if self.client.remoteHost != director.settings['eyetracker_ip'] or \
self.client.remotePort != int(director.settings['eyetracker_out_port']):
self.client.remoteHost = director.settings['eyetracker_ip']
self.client.remotePort = int(director.settings['eyetracker_out_port'])
else:
self.introScene.add(self.eyetrackerScrim, 2)
self.introScene.enable_handlers(False)
d = self.listener.stopListening()
d.addCallback(self.eyetracker_listen)
def show_intro_scene(self):
director.window.set_mouse_visible(True)
self.mplxLayer.switch_to(0)
director.replace(self.introScene)
def start_task(self):
director.window.set_mouse_visible(False)
director.replace(SplitRowsTransition(self.taskScene))
from scene import Scene
from player import Player
from ia import Ia
from ball import Ball
WIDTH = 800
HEIGHT = 600
BG = (255, 67, 0)
pygame.init()
screen = pygame.display.set_mode((WIDTH, HEIGHT))
scene = Scene(screen, BG)
scene.add(Player("player", 5, (WIDTH / 2) - 50, 10, 50))
scene.add(Ia("ia", WIDTH - 5 - 10, (HEIGHT / 2) - 50, 10, 50))
scene.add(Ball("ball", (WIDTH / 2) - (10 / 2), (HEIGHT / 2) - (10 / 2), 10, 10))
scene.draw()
clock = pygame.time.Clock()
totalTime = pygame.time.get_ticks()
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
timeChange = pygame.time.get_ticks() - totalTime
totalTime = pygame.time.get_ticks()
def add(self, *mobjects):
Scene.add(self, *list(mobjects)+self.foreground_mobjects)
def add_foreground_mobjects(self, *mobjects):
self.foreground_mobjects += list(mobjects)
Scene.add(self, *mobjects)
def main():
Config.load()
keepper = Keeper()
scene = Scene(Config.SceneConfig.DeltaTime, keepper,
Config.SceneConfig.BlastRadius)
#Primary conditions for rocket
rX = np.array([
Config.RocketConfig.x, Config.RocketConfig.y, Config.RocketConfig.z,
Config.RocketConfig.vx, Config.RocketConfig.vy, Config.RocketConfig.vz,
Config.RocketConfig.FuelMass
])
#Primary conditions for attack Aircraft
aX = np.array([
Config.AtackAircraftConfig.x, Config.AtackAircraftConfig.y,
Config.AtackAircraftConfig.z, Config.AtackAircraftConfig.vx,
Config.AtackAircraftConfig.vy, Config.AtackAircraftConfig.vz,
Config.AtackAircraftConfig.FuelMass
])
#Primary conditions for target Aircraft
tX = np.array([
Config.TargetAircraftConfig.x, Config.TargetAircraftConfig.y,
Config.TargetAircraftConfig.z, Config.TargetAircraftConfig.vx,
Config.TargetAircraftConfig.vy, Config.TargetAircraftConfig.vz,
Config.TargetAircraftConfig.FuelMass
])
#thrustcoff, FuelMassPerSecond, MassWithoutFuel, Vector, mediator
atackAircraft = Aircraft(Config.AtackAircraftConfig.thrustCoff,
Config.AtackAircraftConfig.FuelMassPerSecond,
Config.AtackAircraftConfig.MassWithoutFuel, aX,
keepper)
#:46,47s/AtackAircraft/TargetAircraft/g
targetAircraft = Aircraft(Config.TargetAircraftConfig.thrustCoff,
Config.TargetAircraftConfig.FuelMassPerSecond,
Config.TargetAircraftConfig.MassWithoutFuel, tX,
keepper)
for _ in range(Config.AtackAircraftConfig.rockets):
atackAircraft.add(
Rocket(Config.RocketConfig.thrustCoff,
Config.RocketConfig.FuelMassPerSecond,
Config.RocketConfig.MassWithoutFuel, rX, keepper))
scene.add(atackAircraft)
scene.add(targetAircraft)
scene.add(atackAircraft.dettachRocket())
while not scene.simulate():
print("Target: {}".format(keepper.X[7:10]))
print("Rocket: {}".format(keepper.X[14:17]))
# pass
print("The Target is striked\n")
print("Last Vector:")
print(
"---------------------------------------------------------------------"
)
print(scene.res[-1])
print(
"---------------------------------------------------------------------"
)
print("Target Coordinates:")
print(
"---------------------------------------------------------------------"
)
print(keepper.X[7:10])
print(
"---------------------------------------------------------------------"
)
print("Rocket Coordinates:")
print(
"---------------------------------------------------------------------"
)
print(keepper.X[14:17])
print(
"---------------------------------------------------------------------"
)
print("time: {}\n".format(scene.T[-1]))
T = np.linspace(0, float(scene.T[-1]), scene.count + 1)
a = 221
plt.subplot(a)
plt.plot(scene.res[:, 14], scene.res[:, 15], 'r', scene.res[:, 7],
scene.res[:, 8])
plt.title('Rocket X, Target X')
plt.subplot(222)
plt.plot(scene.res[:, 14], scene.res[:, 16], 'r', scene.res[:, 7],
scene.res[:, 9])
plt.title('Rocket Y, Target Y')
plt.subplot(223)
plt.plot(scene.res[:, 15], scene.res[:, 16], 'r', scene.res[:, 8],
scene.res[:, 9])
plt.title('Rocket Z, Target Z')
mpl.rcParams['legend.fontsize'] = 10
fig = plt.figure()
ax = fig.gca(projection='3d')
ax.plot(
scene.res[:, 14], scene.res[:, 15],
scene.res[:,
16]) #, scene.res[:, 7], scene.res[:, 8], scene.res[:, 9])
ax.plot(scene.res[:, 7], scene.res[:, 8], scene.res[:, 9])
ax.legend()
plt.show()
class SnakeEnvironment(object):
title = "Snake"
def __init__(self):
if not os.path.exists("data"): os.mkdir("data")
pyglet.resource.path.append('resources')
pyglet.resource.reindex()
pyglet.resource.add_font('Pipe_Dream.ttf')
pyglet.resource.add_font('cutouts.ttf')
pyglet.resource.add_font('scoreboard.ttf')
p = pyglet.window.get_platform()
d = p.get_default_display()
s = d.get_default_screen()
director.init(width=s.width, height=s.height,
caption=self.title, visible=False, resizable=True)
director.window.set_size(int(s.width * .75), int(s.height * .75))
director.window.pop_handlers()
director.window.push_handlers(DefaultHandler())
director.settings = {'eyetracker': True,
'eyetracker_ip': '127.0.0.1',
'eyetracker_out_port': '4444',
'eyetracker_in_port': '5555',
'board_size': '31',
'speed_factor': '0.990',
'fixation_overlay': False,
'player': 'Human',
'players': ['Human']}
self.client = None
self.client_actr = None
if ACTR6:
director.settings['players'].append("ACT-R")
#director.settings['player'] = "ACT-R"
director.settings['eyetracker'] = False
self.client_actr = JNI_Server(self)
self.listener_actr = reactor.listenTCP(6666, self.client_actr)
if eyetracking:
self.client = iViewXClient(director.settings['eyetracker_ip'], int(director.settings['eyetracker_out_port']))
self.listener = reactor.listenUDP(int(director.settings['eyetracker_in_port']), self.client)
director.fps_display = clock.ClockDisplay(font=font.load('', 18, bold=True))
#fps_display = FPSDisplay(director.window)
#fps_display.label.font_size = 12
#director.fps_display = fps_display
director.set_show_FPS(True)
director.window.set_fullscreen(False)
director.window.set_mouse_visible(False)
if platform.system() != 'Windows':
director.window.set_icon(pyglet.resource.image('logo.png'))
# Intro scene and its layers
self.introScene = Scene()
self.mainMenu = MainMenu()
self.optionsMenu = OptionsMenu()
self.participantMenu = ParticipantMenu()
self.introBackground = BackgroundLayer()
self.eyetrackerScrim = EyetrackerScrim()
self.introScene.add(self.introBackground)
self.mplxLayer = MultiplexLayer(self.mainMenu, self.optionsMenu, self.participantMenu)
self.introScene.add(self.mplxLayer, 1)
self.introScene.register_event_type('start_task')
self.introScene.register_event_type('eyetracker_info_changed')
self.introScene.push_handlers(self)
# Task scene and its layers
self.taskScene = Scene()
self.taskBackgroundLayer = TaskBackground()
self.taskLayer = Task(self.client, self.client_actr)
self.scoreLayer = self.taskLayer.score_layer
self.actrScrim = ACTRScrim()
if self.client:
self.calibrationLayer = CalibrationLayer(self.client)
self.calibrationLayer.register_event_type('show_headposition')
self.calibrationLayer.register_event_type('hide_headposition')
self.calibrationLayer.push_handlers(self)
self.headpositionLayer = HeadPositionLayer(self.client)
self.fixationLayer = FixationLayer(self.client)
self.taskLayer.register_event_type('new_trial')
self.taskLayer.push_handlers(self.taskBackgroundLayer)
self.taskLayer.register_event_type('start_calibration')
self.taskLayer.register_event_type('stop_calibration')
self.taskLayer.register_event_type('show_headposition')
self.taskLayer.register_event_type('hide_headposition')
self.taskLayer.register_event_type('show_fixation')
self.taskLayer.register_event_type('hide_fixation')
self.taskLayer.register_event_type('actr_wait_connection')
self.taskLayer.register_event_type('actr_wait_model')
self.taskLayer.register_event_type('actr_running')
self.taskLayer.push_handlers(self)
self.taskScene.add(self.taskBackgroundLayer)
self.taskScene.add(self.taskLayer, 1)
self.taskScene.add(self.scoreLayer, 1)
self.actrScrim.visible = False
self.taskScene.add(self.actrScrim, 3)
self.taskScene.register_event_type('show_intro_scene')
self.taskScene.push_handlers(self)
director.window.set_visible(True)
def actr_wait_connection(self):
self.actrScrim.setWaitConnection()
self.actrScrim.visible = True
def actr_wait_model(self):
self.actrScrim.setWaitModel()
self.actrScrim.visible = True
def actr_running(self):
self.actrScrim.visible = False
def start_calibration(self, on_success, on_failure):
self.calibrationLayer.on_success = on_success
self.calibrationLayer.on_failure = on_failure
self.taskScene.add(self.calibrationLayer, 2)
def stop_calibration(self):
self.taskScene.remove(self.calibrationLayer)
def show_headposition(self):
self.taskScene.add(self.headpositionLayer, 3)
def hide_headposition(self):
self.taskScene.remove(self.headpositionLayer)
def show_fixation(self):
self.taskScene.add(self.fixationLayer, 4)
def hide_fixation(self):
self.taskScene.remove(self.fixationLayer)
def eyetracker_listen(self, _):
self.listener = reactor.listenUDP(int(director.settings['eyetracker_in_port']), self.client)
self.introScene.remove(self.eyetrackerScrim)
self.introScene.enable_handlers(True)
def eyetracker_info_changed(self):
if self.client.remoteHost != director.settings['eyetracker_ip'] or \
self.client.remotePort != int(director.settings['eyetracker_out_port']):
self.client.remoteHost = director.settings['eyetracker_ip']
self.client.remotePort = int(director.settings['eyetracker_out_port'])
else:
self.introScene.add(self.eyetrackerScrim, 2)
self.introScene.enable_handlers(False)
d = self.listener.stopListening()
d.addCallback(self.eyetracker_listen)
def show_intro_scene(self):
self.mplxLayer.switch_to(0)
director.replace(self.introScene)
def start_task(self):
director.replace(SplitRowsTransition(self.taskScene))
class Renderer(object):
def __init__(self):
self.scene = Scene()
self.scene.add(Snowman())
sn2 = Snowman()
sn3 = Snowman()
sn2.x = 3
sn3.z = 2
self.scene.add(sn2)
self.scene.add(sn3)
self.scene.camera.translate(0, -.5, -4)
def setup(self):
"""Set up the OpenGL environment."""
# Initialize the drawing environment (create main windows, etc)
glutInit(sys.argv)
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH)
glutInitWindowSize(WINDOW_WIDTH, WINDOW_HEIGHT)
glutCreateWindow(name)
glShadeModel(GL_SMOOTH)
glClearDepth(1.0)
glDepthFunc(GL_LESS) # The Type Of Depth Test To Do
glEnable(GL_DEPTH_TEST) # Enables Depth Testing
glShadeModel(GL_SMOOTH) # Enables Smooth Color Shading
glMatrixMode(GL_PROJECTION)
glLoadIdentity() # Reset The Projection Matrix
# Calculate The Aspect Ratio Of The Window
gluPerspective(45.0, float(WINDOW_WIDTH)/float(WINDOW_HEIGHT), 0.1, 100.0)
glMatrixMode(GL_MODELVIEW)
# Set up keyboard listeners.
glutKeyboardFunc(self.on_key)
def start(self):
"""Begin the render."""
glutDisplayFunc(self.render)
glutMainLoop()
def render(self):
"""Render the scene."""
self.scene.render()
def on_key(self, key, x, y):
"""Handle a keypress."""
print "Received", key
if key == "a":
self.scene.camera.translate(x=0.05)
elif key == "d":
self.scene.camera.translate(x=-0.05)
elif key == "s":
self.scene.camera.translate(y=0.05)
elif key == "w":
self.scene.camera.translate(y=-0.05)
elif key == "e":
self.scene.camera.translate(z=0.05)
elif key == "q":
self.scene.camera.translate(z=-0.05)
elif key == "j":
self.scene.camera.rotate(y=-5)
elif key == "l":
self.scene.camera.rotate(y=5)
elif key == "k":
self.scene.camera.rotate(x=5)
elif key == "i":
self.scene.camera.rotate(x=-5)
elif key == "u":
self.scene.camera.rotate(z=5)
elif key == "o":
self.scene.camera.rotate(z=-5)
self.render()
