def main():
    # initialize the pygame module
    pygame.init()
    pygame.display.set_caption("Graph Theory Epidemic")
    screen = pygame.display.set_mode((data.WIDTH, data.HEIGHT))
    graphics.init_graphics()
    make_buttons()

    # Make new graph
    data.main_graph = graph.Graph()

    # main loop
    running = True
    while running:
        render(screen)

        # event handling, gets all event from the event queue
        for event in pygame.event.get():
            if event.type == pygame.MOUSEBUTTONUP:
                pos = pygame.mouse.get_pos()
                handle_click(pos)

            if event.type == pygame.QUIT:
                # change the value to False, to exit the main loop
                running = False

            if event.type == pygame.KEYDOWN:
                if active_input_box is not None and active_input_box.selected:
                    active_input_box.key_event(event)
Exemple #2
0
def run():
    data = tempdata.init_data()
    screens = graphics.init_graphics(data)

    cont = True
    while cont:
        screens, data, cont = game_logic.cycle(screens, data)
Exemple #3
0
def main():

    # Get command-line arguments.
    args = parse_args()

    ## Create renderer and graphics window.
    win_width = 500
    win_height = 500
    renderer, renderer_window = gr.init_graphics(win_width, win_height)

    ## Read in the segmentation surface.
    surface_file_name = args.surface_file
    surface = Surface(gr, renderer_window, renderer)
    surface.read(surface_file_name)
    gr_geom = gr.add_geometry(renderer,
                              surface.geometry,
                              color=[0.8, 0.8, 1.0])
    surface.vtk_actor = gr_geom
    #gr_geom.GetProperty().SetOpacity(0.5)

    ## Create a Centerlines object used to clip the surface.
    centerlines = Centerlines()
    centerlines.graphics = gr
    centerlines.surface = surface
    centerlines.window = renderer_window
    centerlines.renderer = renderer
    centerlines.clip_distance = args.clip_distance
    centerlines.clip_width_scale = args.clip_width_scale
    centerlines.remesh_scale = args.remesh_scale
    centerlines.mesh_scale = args.mesh_scale

    print("---------- Alphanumeric Keys ----------")
    print(
        "a - Compute model automatically for a three vessel surface with flat ends."
    )
    print("c - Compute centerlines.")
    print("m - Create a model from the surface and centerlines.")
    print("q - Quit")
    print("s - Select a centerline source point.")
    print("t - Select a centerline target point.")
    print("u - Undo the selection of a centerline source or target point.")

    ## Create a mouse interactor for selecting centerline points.
    picking_keys = ['s', 't']
    event_table = {
        'a': (surface.create_model_automatically, centerlines),
        'c': (surface.compute_centerlines, surface),
        'm': (centerlines.create_model, surface),
        's': surface.add_centerlines_source_node,
        't': surface.add_centerlines_target_node
    }
    interactor = gr.init_picking(renderer_window, renderer, surface.geometry,
                                 picking_keys, event_table)

    ## Display window.
    interactor.Start()
def draw_solid(polydata):
    win_width = 500
    win_height = 500
    renderer, renderer_window = gr.init_graphics(win_width, win_height)
    gr.add_geometry(renderer,
                    polydata,
                    color=[0.0, 1.0, 0.0],
                    wire=False,
                    edges=True)
    gr.display(renderer_window)
Exemple #5
0
def map_test(stdscr):
    graphics.init_graphics(stdscr, 'graphics_config')
    map_height = 50
    map_width = 120
    player_pos = Position(map_height/2, map_width/2)
    M = Map(name = 'map0', height = map_height, width = map_width, player_pos = Position(5, 5))
    
    for pos in positions(map_height, map_width):
        if random.randint(0,1) == 0:
            M.set_tile(pos, Terrain('grass'))
        else:
            M.set_tile(pos, Terrain('wall'))  

    M.set_player(player_pos, Monster('dog'))
    
    graphics.use_map(M)
    old_pos = Position(0, 0)

    graphics.draw_map(player_pos)
    while True:
        key = graphics.getch()
        old_pos.y = player_pos.y
        old_pos.x = player_pos.x
        if key == ord('d') and player_pos.x < map_width-1:
            player_pos.e()
        elif key == ord('a') and player_pos.x > 0:
            player_pos.w()
        elif key == ord('w') and player_pos.y > 0:
            player_pos.n()
        elif key == ord('s') and player_pos.y < map_height-1:
            player_pos.s()
        else:
            if chr(key) not in ['w', 'a', 's', 'd']:
                break
          
        M.update_player_pos(player_pos)
        graphics.update_map(M, [old_pos, player_pos])
        graphics.draw_map(player_pos)
        #graphics.debug_output(M.player_pos.y, M.player_pos.x, old_pos.y, old_pos.x)
        
    time.sleep(1)
 def sort_by_time():
     global photo, canvas
     canvas.delete("all")
     bars = graphics.init_graphics(height, width, arr, canvas)
     start = timeit.default_timer()
     if algo == ALGO_OPTIONS[0]:
         bubble_sort(bars, canvas)
     elif algo == ALGO_OPTIONS[1]:
         heap_sort(bars, canvas)
     elif algo == ALGO_OPTIONS[2]:
         quick_sort(bars, 0, len(bars) - 1, start, canvas)
     sort_btn["state"] = tk.NORMAL
Exemple #7
0
def main(args=None):
    '''App entry point
        <args> is a list of command line arguments, defaults to sys.argv[1:]
    '''

    logging.basicConfig(
        format="[%(levelname)-8s] %(asctime)s %(module)s: %(message)s",
        datefmt="%Y-%m-%d %H:%M:%S",
    )

    g.load_options(args)
    pygame.display.init()
    pygame.font.init()

    themes.init_themes(g.datadirs('themes') + ['/usr/share/aisleriot/cards'])
    graphics.init_graphics()

    gui = ui.Gui()
    gui.run(g.window_size, g.full_screen, g.gamename)

    pygame.quit()
    g.save_options()
def main():

    seed(time())

    for i in range(1, 16):
        Pool_ball([60 + 50 * i, graphics.SCREEN_DIM[1] // 2],
                  graphics.BALL_COLORS[(i - 1) % 8], i)

    graphics.init_graphics()

    while graphics.RUNNING:
        graphics.render()

        # TODO TESTING
        i = 0
        while i < 1 and random() < 0.1:
            choice(Pool_ball.pool_balls).apply_force(random() * 1.2,
                                                     random() * 360)
            i += 1

        threads = thread_movement()
        for thread in threads:
            thread.join()
        check_collisions()
def draw_segmentations(contours):
    num_segs = len(contours)

    ## Create renderer and graphics window.
    win_width = 500
    win_height = 500
    renderer, renderer_window = gr.init_graphics(win_width, win_height)
    ## Show contours.
    for sid in range(num_segs):
        seg = contours[sid]
        control_points = seg.get_control_points()
        gr.create_segmentation_geometry(renderer, seg)

    # Display window.
    gr.display(renderer_window)
Exemple #10
0
def main():
    file_name = sys.argv[1]
    file_prefix, file_extension = os.path.splitext(file_name)

    ## Create renderer and graphics window.
    win_width = 500
    win_height = 500
    renderer, renderer_window = gr.init_graphics(win_width, win_height)

    ## Read in surface.
    surface = Surface()
    surface.read(file_name)
    model_polydata = surface.geometry
    gr_geom = gr.add_geometry(renderer, model_polydata, color=[0.8, 0.8, 8.0])
    print("Num nodes: {0:d}".format(model_polydata.GetNumberOfPoints()))
    print("Num faces: {0:d}".format(model_polydata.GetNumberOfCells()))

    ## Display window.
    interactor = gr.init_picking(renderer_window, renderer, surface.geometry,
                                 {'c': (compute_centerlines, file_prefix)})
    interactor.Start()
Exemple #11
0
box_pd = box.get_polydata()
print("  Box: num nodes: {0:d}".format(box_pd.GetNumberOfPoints()))

## Create a cylinder.
print("Create a cylinder ...") 
center = [0.0, 0.0, 1.0]
axis = [0.0, 0.0, 1.0]
radius = 1.5
length = 10.0
cylinder = modeler.cylinder(center, axis, radius, length)
cylinder_pd = cylinder.get_polydata() 

## Subtract the cylinder from the box.
print("Union the cylinder and the box ...")
result = modeler.union(model1=box, model2=cylinder)
result_pd = result.get_polydata()

## Create renderer and graphics window.
win_width = 500
win_height = 500
renderer, renderer_window = gr.init_graphics(win_width, win_height)

## Add model polydata.
gr.add_geometry(renderer, box_pd, color=[0.0, 1.0, 0.0], wire=True, edges=False)
gr.add_geometry(renderer, cylinder_pd, color=[0.0, 0.0, 1.0], wire=True, edges=False)
#gr.add_geometry(renderer, result_pd, color=[1.0, 0.0, 0.0], wire=False, edges=False)

# Display window.
gr.display(renderer_window)

Exemple #12
0
def main():
    init_graphics()
    gameloop(ParentComponent())
#Fifth step. Each unavailable node v computes the rank r of ID v in
#	S v and colors itself r. Each available node colors itself
#	1. Let this coloring of vertices be denoted χ  . Note that
#	this vertex coloring need not be proper.


def func():
    for vert in vertices:
        g.pygame.draw.rect(g.image, g.WHITE,
                           vert + [vertex_width, vertex_width])
    # for edge in edges:
    # g.pygame.draw.line(g.image,g.RED,vertices[edge[0]],vertices[edge[1]],edge_width)
    for edge in edges:
        # pass
        g.pygame.draw.line(g.image, g.RED, vertices[edge[0]],
                           vertices[edge[1]], edge_width)
    for i in range(len(vertices)):
        g.text_to_screen(g.image,
                         texts[i],
                         vertices[i][0],
                         vertices[i][1],
                         size=text_size)


# Graphics
g.init_graphics(500, 500)

g.add_loop_function(func)

g.display()
Exemple #14
0
import graphics

# Current location
location = 1 # 0 - World Map, 1 - Level

# Update event loop
def update(dt):
    if location == 0:
        worlds.update(dt)
    elif location == 1:
        level.update(dt)
    else:
        print("Invalid location")
        
        while True:
            pass

# Initialize the savefiles, worlds, levels, and graphics
save.init_savefiles()
worlds.init_worlds()
level.init_levels()
graphics.init_graphics()

# Begin playing the title screen
worlds.worlds[0]["title"].play()

# Start the event loop
pyglet.clock.schedule_interval(level.update, 1/120)
pyglet.app.run()