def calculate_image(triangles, colors, render_to_window=False): renderer = Renderer() # should be trivial assignment from locally stored instance renderer.data( triangles, np.tile(colors, (1, 3)).reshape((-1, 4)) ) return renderer.render(render_to_window=render_to_window)
def render_document(): request_data = json.loads(request.data) template_name = request_data['template_name'] CWD = os.getcwd() data_path = '{0}/{1}'.format(CWD, 'data.json') file = open(data_path, 'r') data_string = file.read() file.close() data = json.loads(data_string) renderer = Renderer(template_name, data) rendered_html_document = renderer.render_html() rendered_pdf_document = renderer.render_pdf(rendered_html_document) html_file_path = '{0}/output/{1}'.format( CWD, 'Rendered_{0}.html'.format(template_name)) html_file = open(html_file_path, 'w') html_file.write(rendered_html_document) html_file.close() pdf_file_path = '{0}/output/{1}'.format( CWD, 'Rendered_{0}.pdf'.format(template_name)) pdf_file = open(pdf_file_path, 'wb') pdf_file.write(rendered_pdf_document) pdf_file.close() return 'Documents Rendered!'
def get(self): items_q = Items.all() template_values = { 'items' : items_q } page = Renderer(self, 'ediciones.html') page.render(template_values)
class Test(unittest.TestCase): def setUp(self): pygame.init() # @UndefinedVariable screen = pygame.display.set_mode((PRAM.DISPLAY_WIDTH, PRAM.DISPLAY_HEIGHT)) buttonMap = ButtonMap() actor = SimpleBox() musicPlayer, soundPlayer = soundPlayerFactory() self.renderer = Renderer(screen) player = playerFactory(actor) self.game = Game(player, musicPlayer, soundPlayer, self.renderer) self.inputHandler = InputHandler(self.game, player, buttonMap) self.eventHandler = EventHandler(self.game) self.game.eventHandler = self.eventHandler self.game.inputHandler = self.inputHandler def test_renderScenery(self): self.game.gameStartup() self.eventHandler.handleEvents() self.renderer.renderScenery(self.game.gameScene.sceneryWrapper) pygame.display.flip() def test_renderActors(self): self.game.gameStartup() self.game.addEvent(EventLoadLevel(PRAM.LEV_TEST1)) self.eventHandler.handleEvents() self.renderer.renderActors(self.game.gameScene.actorsWrapper) pygame.display.flip()
def render(self): Renderer.rect(0, 0, self.width, self.height, color='#F1E7DC') # background grid_gap = min(self.width / self.grid.cols, self.height / self.grid.rows) self.grid.render(self.width, self.height, grid_gap) for cell in self.grid.cells: if cell.is_alive: cell.render(grid_gap)
def get(self): blogPosts_query = blogPost.all().order('-date') blogPosts = blogPosts_query.fetch(10) template_values = { 'blogPosts' : blogPosts } page = Renderer(self, 'news.html') page.render(template_values)
def __init__(self, grid): # fill in missing cells max_width = max(len(row) for row in grid) for row in grid: row += [None for _ in range(max_width - len(row))] self.grid = grid self.n_rows = len(grid) self.n_cols = len(grid[0]) self.positions = self._positions() self.renderer = Renderer(self.grid)
def __init__(self): self.main_window = Window(100, 100) self.game = Game(self.main_window.width, self.main_window.height) self.canvas = tk.Canvas(self.main_window, width=self.game.width, height=self.game.height, bg='#EEE', highlightthickness=0) self.canvas.pack() self.bind_keys() Renderer.set_canvas(self.canvas)
def setUp(self): pygame.init() # @UndefinedVariable screen = pygame.display.set_mode((PRAM.DISPLAY_WIDTH, PRAM.DISPLAY_HEIGHT)) buttonMap = ButtonMap() actor = SimpleBox() musicPlayer, soundPlayer = soundPlayerFactory() self.renderer = Renderer(screen) player = playerFactory(actor) self.game = Game(player, musicPlayer, soundPlayer, self.renderer) self.inputHandler = InputHandler(self.game, player, buttonMap) self.eventHandler = EventHandler(self.game) self.game.eventHandler = self.eventHandler self.game.inputHandler = self.inputHandler
def get_renderer(self): renderer = Renderer() for item in self._get_all_items(): if item.data(CustomDataRole.ITEMTYPE) == TreeWidgetType.ALBUM: renderer.add_render_album_job(item) elif item.data(CustomDataRole.ITEMTYPE) == TreeWidgetType.SONG: renderer.add_render_song_job(item) return renderer
def __init__(self): from ambry.library import Library from render import Renderer from ambry.run import get_runconfig rc = get_runconfig() self.library = Library(rc, read_only=True, echo = False) self.renderer = Renderer(self.library) import logging path = self.library.filesystem.logs() logging.basicConfig(filename=path, level=logging.DEBUG)
def __init__(self, rendererPath='./data', loadingTarget=True): self.crane_list = [] self.target_list = [] self.data = loadData() self.loadingTarget = loadingTarget if loadingTarget: self.target_data0 = loadTargetData() self.target_data = None for line in self.data: crane = Crane() crane.ID = line[0] crane.x = line[1] crane.y = line[2] crane.R1 = line[3] crane.R2 = line[4] self.crane_list.append(crane) for crane in self.crane_list: target = Target(crane) self.target_list.append(target) self.observation_space = 4 * len( self.crane_list ) # (arm_theta, delta_theta, arm_omega) * of other cranes self.action_space = 3 self.reward_sharing_ratio = 0.1 self.collision_pairs = [(0, 1), (0, 2), (2, 3), (1, 3)] self.t = 0 self.max_t = 720 self.score = 0 self.collision = False self.renderer = Renderer(rendererPath) self.reset()
def main(args): sdl2.ext.init() ip = args[1] port = int(args[2]) num = args[3] num_windows = int(args[4]) client = Client(ip, port, num) events = Events() renderer = Renderer('looongpooong', (800, 600), num_windows) game = Game(client, events, renderer) game.start() return 0
class AmbryAppContext(object): """Ambry specific objects for the application context""" def __init__(self): from ambry.library import Library from render import Renderer from ambry.run import get_runconfig rc = get_runconfig() self.library = Library(rc, read_only=True, echo = False) self.renderer = Renderer(self.library) import logging path = self.library.filesystem.logs() logging.basicConfig(filename=path, level=logging.DEBUG) def render(self, template, *args, **kwargs): return self.renderer.render(template, *args, **kwargs)
class Environment(): def __init__(self, grid): # fill in missing cells max_width = max(len(row) for row in grid) for row in grid: row += [None for _ in range(max_width - len(row))] self.grid = grid self.n_rows = len(grid) self.n_cols = len(grid[0]) self.positions = self._positions() self.renderer = Renderer(self.grid) def actions(self, pos): """possible actions for a state (position)""" r, c = pos actions = ['stay'] if r > 0 and self.grid[r - 1][c] is not None: actions.append('up') if r < self.n_rows - 1 and self.grid[r + 1][c] is not None: actions.append('down') if c > 0 and self.grid[r][c - 1] is not None: actions.append('left') if c < self.n_cols - 1 and self.grid[r][c + 1] is not None: actions.append('right') return actions def value(self, pos): r, c = pos return self.grid[r][c] def render(self, pos=None): return self.renderer.render(pos) def _positions(self): """all valid positions""" positions = [] for r, row in enumerate(self.grid): for c, _ in enumerate(row): if self.grid[r][c] is not None: positions.append((r, c)) return positions
def __init__(self): self.layout = Layout().init_layout() self.border = self.layout.field["border"] self.field = Point(x=self.border.x, y=self.border.y-1) self.screen = self.create_window(x=self.border.x, y=self.border.y) #utils. self.renderer = Renderer() self.spaceship = Spaceship(self.layout.field["spaceship"], self.field, self) self.renderer.add_object(self.spaceship) #gui self.hbar = Bar("Hull", self.layout.gui["hbar"], self.spaceship.get_hinfo, self.spaceship.max_hull) self.sbar = Bar("Shield", self.layout.gui["sbar"], self.spaceship.get_sinfo, self.spaceship.max_shield) #temp... or not? self.sbar.status_style["good"] = curses.color_pair(Color.sh_ok) | curses.A_BOLD self.sbar.status_style["dmgd"] = curses.color_pair(Color.sh_mid) | curses.A_BOLD self.renderer.add_object(self.hbar) self.renderer.add_object(self.sbar)
def main(*args): if (not args) or '--help' in args: return usage() cache_main, *args = list(args) cache_add = tiles_path = world_name = worlds_json_path = batch_key = '' only_worlds = set() ignored_worlds = ['spawn', 'ulca'] flags = '' while len(args) > 0 and '-' == args[0][0]: new_flags, *args = args if 'd' in new_flags or 'm' in new_flags: cache_add, *args = args if 't' in new_flags or 'z' in new_flags: tiles_path, *args = args if 'b' in new_flags: world_name, tiles_json_path, *args = args if 'k' in new_flags: batch_key, *args = args if 'o' in new_flags: new_only, *args = args only_worlds = only_worlds.union(new_only.split(',')) if 'i' in new_flags: new_ignored, *args = args ignored_worlds += new_ignored.split(',') flags += new_flags if args: print('Leftover args:', *args) return usage() print('Ignored worlds:', ','.join(ignored_worlds)) if only_worlds: print('and all except', ','.join(only_worlds)) batch_id = str(time.time()) + batch_key world_names = set(os.listdir(cache_main)) if cache_add: world_names = world_names.union(shard_names[w] for w in os.listdir(cache_add) if w in shard_names) for world_name in world_names: if only_worlds and world_name not in only_worlds: continue if world_name in ignored_worlds: continue if world_name not in shard_ids: print('Unknown world', world_name) continue world_id = shard_ids[world_name] print('Processing world', world_name, world_id) world_main = cache_main + '/' + world_name world_tiles = tiles_path + '/' + world_name if 'd' in flags or 'm' in flags: try: world_add = get_cache_path(cache_add + '/' + world_id) except FileNotFoundError as e: print('ERROR', e.__class__.__name__, e) continue if 'd' in flags: diff_img = 'diffs/diff-%s/diff-%s.png' % (batch_id, world_name) print('Creating diff image at', diff_img) os.makedirs('diffs/diff-%s' % batch_id, exist_ok=True) try: diff_worlds(diff_img, world_main, world_add) except FileNotFoundError as e: print('ERROR', e.__class__.__name__, e) continue if 'm' in flags: print('Merging from', world_add) try: merge_worlds(world_main, world_main, world_add, by_time=True) except FileNotFoundError as e: print('ERROR', e.__class__.__name__, e) continue if 't' in flags: r = Renderer(world_main, get_simple_block_color) r.render_tiles(world_tiles) print_missing_blocks() if 'z' in flags: try: for i in range(3): print('Creating zoomed-out tiles, level', -i - 1) stitch_all('%s/z%i' % (world_tiles, -i - 1), '%s/z%i' % (world_tiles, -i)) except (FileNotFoundError, IndexError) as e: print('ERROR', e.__class__.__name__, e) if 'b' in flags: print('Writing bounds to', tiles_json_path) write_bounds(world_name, world_main, tiles_json_path)
environment = Environment(preset.lasers, obstacles, preset.max_laser_length, preset.safe_vel, preset.safe_angle) # Initialise None lists in environment and drone environment.update(drone, False) drone.recieveLaserDistances(environment.laser_distances) # Initialise Renderer and Plots #Render Window limits draw_scene = True # Flag to draw live simulation draw_graphs = False # Flag to draw live data stream draw_final_graph = True # Flag to show data at the end of simulation xlims = [-11, 11] ylims = [0, 40] renderer = Renderer(obstacles, drone, xlims, ylims, draw_scene) data_stream = DataStream(preset.input_limit, draw_graphs) #Simulation collision = False total_t = 0 def loadStabiliser(N): # Load stabiliser network local_dir = os.path.dirname(__file__) folder_paths = [ 'first_stabiliser', 'second_stabiliser', 'third_stabiliser', 'fourth_stabiliser', 'fifth_stabiliser' ]
from render import Renderer SPEED = 16 INPUT = { pygame.K_UP: 'up', pygame.K_DOWN: 'down', pygame.K_RIGHT: 'right', pygame.K_LEFT: 'left' } done = False clock = pygame.time.Clock() direction = 'none' frame = 1 tetris = Game() drawer = Renderer() while not done: for event in pygame.event.get(): if event.type == pygame.QUIT: done = True elif event.type == pygame.KEYDOWN: if tetris.game_over: if event.key == pygame.K_SPACE: tetris.__init__() tetris.game_over = False else: try: direction = INPUT[event.key] except: pass elif event.type == pygame.KEYUP:
import ctypes import random import time from render import Window, SDL_SetWindowIcon, IMG_Load, Renderer, SpriteFactory, SDL_SetRenderDrawColor, \ SDL_RenderClear, SDL_SetTextureAlphaMod, SDL_RenderPresent, SDL_Event, SDL_QUIT, SDL_PollEvent, SDL_Delay, \ SDL_Color, TTF_OpenFont, TTF_RenderUTF8_Blended_Wrapped, SDL_FreeSurface, SDL_BLENDMODE_ADD, \ SDL_SetTextureBlendMode, SDL_CreateTextureFromSurface, SDL_RenderCopy, SDL_Rect, SDL_QueryTexture, TTF_Init, \ Mix_OpenAudio, MIX_DEFAULT_FORMAT, Mix_VolumeMusic, Mix_PlayMusic, Mix_LoadMUS, SDL_TEXTINPUT, SDL_TEXTEDITING, \ SDL_SetTextureColorMod, SDL_RenderDrawLine, SDL_RenderDrawPoint, SDL_KEYUP, SDL_GetKeyName if __name__ == "__main__": window = Window("🐍 贪吃蛇 🐍 🐕 🐱 🐻 🐏", size=(960, 640)) renderer = Renderer(window) factory = SpriteFactory(renderer) bg = factory.create("./data/block.png") body = factory.create("./data/body.png") head = factory.create("./data/head.png") h1 = factory.create("./data/1.png") tri = factory.create("./data/tri.png") water_drop = factory.create("./data/water_drop.png") circle = factory.create("./data/circle.png") TTF_Init() font = TTF_OpenFont('data/b.ttf'.encode("utf8"), 30) text = "🐍 贪吃蛇 🐍 🐕 🐱 🐻 🐏" text_surface = TTF_RenderUTF8_Blended_Wrapped( font, text.replace(" ", "\n").encode("utf8"), SDL_Color(255, 0, 0, 255), 255) text_texture = SDL_CreateTextureFromSurface(renderer.renderer,
def renderer(content_type='html'): from render import Renderer return Renderer(content_type=content_type)
class App(object): def __init__(self): self.layout = Layout().init_layout() self.border = self.layout.field["border"] self.field = Point(x=self.border.x, y=self.border.y-1) self.screen = self.create_window(x=self.border.x, y=self.border.y) #utils. self.renderer = Renderer() self.spaceship = Spaceship(self.layout.field["spaceship"], self.field, self) self.renderer.add_object(self.spaceship) #gui self.hbar = Bar("Hull", self.layout.gui["hbar"], self.spaceship.get_hinfo, self.spaceship.max_hull) self.sbar = Bar("Shield", self.layout.gui["sbar"], self.spaceship.get_sinfo, self.spaceship.max_shield) #temp... or not? self.sbar.status_style["good"] = curses.color_pair(Color.sh_ok) | curses.A_BOLD self.sbar.status_style["dmgd"] = curses.color_pair(Color.sh_mid) | curses.A_BOLD self.renderer.add_object(self.hbar) self.renderer.add_object(self.sbar) def create_window(self, x, y, a=0, b=0): curses.initscr() curses.start_color() #user interface curses.init_pair(Color.ui_norm, curses.COLOR_WHITE, curses.COLOR_BLACK) curses.init_pair(Color.ui_yellow, curses.COLOR_YELLOW, curses.COLOR_BLACK) #damage panel curses.init_pair(Color.dp_blank, curses.COLOR_BLACK, curses.COLOR_BLACK) curses.init_pair(Color.dp_ok, curses.COLOR_WHITE, curses.COLOR_GREEN) curses.init_pair(Color.dp_middle, curses.COLOR_WHITE, curses.COLOR_YELLOW) curses.init_pair(Color.dp_critical, curses.COLOR_WHITE, curses.COLOR_RED) curses.init_pair(Color.sh_ok, curses.COLOR_WHITE, curses.COLOR_BLUE) curses.init_pair(Color.sh_mid, curses.COLOR_WHITE, curses.COLOR_CYAN) #weapons curses.init_pair(Color.blaster, curses.COLOR_GREEN, curses.COLOR_BLACK) curses.init_pair(Color.laser, curses.COLOR_BLACK, curses.COLOR_RED) curses.init_pair(Color.um, curses.COLOR_MAGENTA, curses.COLOR_BLACK) screen = curses.newwin(y, x, a, b) screen.keypad(1) screen.nodelay(1) curses.noecho() curses.cbreak() curses.curs_set(0) return screen def deinit(self): self.screen.nodelay(0) self.screen.keypad(0) curses.nocbreak() curses.echo() curses.curs_set(1) curses.endwin() def events(self): c = self.screen.getch() if c == K_ESCAPE: self.deinit() sys.exit(1) elif c == K_A: self.spaceship.move_left() elif c == K_D: self.spaceship.move_right() elif c == K_E: self.spaceship.next_weapon() elif c == K_Q: self.spaceship.prev_weapon() elif c == K_SPACE: self.spaceship.fire() def update(self): self.spaceship.update() self.hbar.update() self.sbar.update() def render(self): self.screen.erase() self.screen.border(0) self.screen.addstr(0, 2, "Score: {} ".format(0)) self.screen.addstr(0, self.field.x // 2 - 4, "XOInvader", curses.A_BOLD) weapon_info = self.spaceship.get_weapon_info() self.screen.addstr(self.field.y, self.field.x - len(weapon_info) - 2, weapon_info, (curses.color_pair(Color.ui_yellow) | curses.A_BOLD)) self.renderer.render_all(self.screen) self.screen.refresh() def loop(self): while True: start_time = time.perf_counter() self.events() self.update() self.render() finish_time = time.perf_counter() delta = finish_time - start_time if delta <= MILLISECONDS_PER_FRAME: time.sleep((MILLISECONDS_PER_FRAME - delta) / 1000.0) else: message = ''' Main loop iteration took longer than expected! Took: {0} Expected: {1}'''.format(delta, MILLISECONDS_PER_FRAME) log.warning(message)
def render(self, grid_gap): Renderer.rect(self.x * grid_gap, self.y * grid_gap, grid_gap, grid_gap, color='#aaa')
import pygame from model import Game from render import Renderer INPUT = { pygame.K_UP: 'up', pygame.K_RIGHT: 'right', pygame.K_LEFT: 'left', pygame.K_SPACE: 'space' } FPS = 60 done = False clock = pygame.time.Clock() game = Game() drawer = Renderer(game) direction = 'none' while not done: for event in pygame.event.get(): if event.type == pygame.QUIT: done = True elif event.type == pygame.KEYDOWN: try: input = INPUT[event.key] except: pass elif event.type == pygame.KEYUP: input = 'none' game.read_input(input) game.integrate() drawer.draw_game(game)
print 'time_elapsed:', total_elapsed print 'updates/render:', updates/float(renders) print 'updates/second:', updates/total_elapsed print 'fps:', renders/total_elapsed print 'actors:', actor_count if __name__ == "__main__": updates = 0 input_processes = 0 renders = 0 start = time() previous = time() lag = 0.0 state = State() renderer = Renderer() t = handle_input(None, renderer.screen) drawable = [] state.active_things = [actors.Ball() for x in range(100)] try: while updates < 1000: current = time() elapsed = current - previous previous = current lag += elapsed t = handle_input(t, renderer.screen) while lag >= MS_PER_UPDATE: drawable = update(state.active_things, renderer.screen) updates += 1 lag -= MS_PER_UPDATE renderer.render(drawable)
def render(self, width, height, grid_gap): for x in range(self.cols): Renderer.line(x * grid_gap, 0, x * grid_gap, height, color='#aaa') for y in range(self.rows): Renderer.line(0, y * grid_gap, width, y * grid_gap, color='#aaa')
try: targ = utils.sort_array(i.get_target(40),2)[0] i.move(-targ[3],i.get_speed()) pygame.draw.line(sc,[255,0,0],i.pos,targ[1]) except IndexError: i.move_random() su = pygame.Surface([10,10]) su.fill((255,0,0)) sc.blit(su,[int(x)-5 for x in i.pos]) pygame.display.flip() pygame.event.pump()''' #render tests wld = utils.World(cfg, 300) r = Renderer(wld, [500, 500]) pygame.key.set_repeat(100) screen = pygame.display.set_mode([500, 500]) pos = [0, 0] while True: for event in pygame.event.get(): if event.type == pygame.QUIT: exit(0) if event.type == pygame.KEYDOWN: if event.key == pygame.K_UP: pos[1] -= 1 if event.key == pygame.K_DOWN: pos[1] += 1 if event.key == pygame.K_LEFT: pos[0] -= 1
class World(object): def __init__(self, rendererPath='./data', loadingTarget=True): self.crane_list = [] self.target_list = [] self.data = loadData() self.loadingTarget = loadingTarget if loadingTarget: self.target_data0 = loadTargetData() self.target_data = None for line in self.data: crane = Crane() crane.ID = line[0] crane.x = line[1] crane.y = line[2] crane.R1 = line[3] crane.R2 = line[4] self.crane_list.append(crane) for crane in self.crane_list: target = Target(crane) self.target_list.append(target) self.observation_space = 4 * len( self.crane_list ) # (arm_theta, delta_theta, arm_omega) * of other cranes self.action_space = 3 self.reward_sharing_ratio = 0.1 self.collision_pairs = [(0, 1), (0, 2), (2, 3), (1, 3)] self.t = 0 self.max_t = 720 self.score = 0 self.collision = False self.renderer = Renderer(rendererPath) self.reset() def reset(self): self.t = 0 self.score = 0 self.collision = False if self.loadingTarget: self.target_data = copyTargetData(self.target_data0) for target in self.target_list: target_state = None if self.loadingTarget and not self.target_data[target.ID].empty(): target_state = self.target_data[target.ID].get() target.reset(target_state) clear = False while not clear: clear = True for crane in self.crane_list: crane.reset() for pair in [(0, 1), (0, 2), (2, 3), (1, 3)]: clear = clear and not self.checkCollision(pair[0], pair[1]) if not clear: break return self.getState() def step(self, action): """ paras: action(list of int): index of each agent's action, 0 to 2 """ r = [-1 for crane in self.crane_list] for crane in self.crane_list: ID = crane.ID target = self.target_list[ID] car_power = 0 hook_power = 0 if target.done: r[ID] += 1 if crane.car_pos > target.x: car_power = -1 elif crane.car_pos < target.x: car_power = 1 if crane.hook_height > target.h: hook_power = -1 elif crane.hook_height < target.h: hook_power = 1 rotate_power = 0 if action[ID] == 1: rotate_power = 1 if target.done: r[ID] -= 0.05 elif action[ID] == 2: rotate_power = -1 if target.done: r[ID] -= 0.05 crane.rotate(rotate_power) crane.moveCar(car_power) crane.moveHook(hook_power) if crane.arm_theta == target.theta and not target.done: r[ID] += 200 - abs(crane.arm_omega) * 10 target.done = True if self.loadingTarget and not self.target_data[ crane.ID].empty(): target_state = self.target_data[crane.ID].get() target.reset(target_state) # share reward s = sum(r) for crane in self.crane_list: r[crane.ID] += s * self.reward_sharing_ratio done = True for target in self.target_list: done = done and target.done # 碰撞检测,手动写一下哪些有必要检测的 for pair in [(0, 1), (0, 2), (2, 3), (1, 3)]: if self.checkCollision(pair[0], pair[1]): r[pair[0]] -= 1000 r[pair[1]] -= 1000 done = True self.collision = True if self.t > self.max_t: done = True for ID in range(len(self.crane_list)): if not self.target_list[ID].done: r[ID] -= 200 for i in range(len(self.crane_list)): r[i] -= 200 # return state, r, done, _ self.score += sum(r) # print(r,"Target0: ", self.target_list[0].done," Target1: ", self.target_list[1].done) self.renderer.collision = self.collision return (self.getState(), r, done, { 'score': self.score, 'collision': self.collision }) def getState(self): """ get the state of n * (arm_theta, delta_theta, arm_omega) """ state = [] for crane in self.crane_list: delta_theta = crane.arm_theta - self.target_list[crane.ID].theta if delta_theta >= 360: delta_theta -= 360 if delta_theta < 0: delta_theta += 360 state.append(crane.arm_theta) state.append(delta_theta) state.append(crane.arm_omega) state.append(self.target_list[crane.ID].done) return np.array(state) def render(self): """ render the visualization """ return self.renderer.render(self.crane_list, self.target_list, { 'score': self.score, 'time': self.t }) # print(self.crane.arm_theta, " ", self.crane.car_pos) # time.sleep(0.2) def getAgentNum(self): """ return the number of the agents """ return len(self.data) def checkCollision(self, craneID1, craneID2): """ check collision of two cranes """ crane = self.crane_list[craneID1] l1 = Line(crane.x - math.cos(crane.arm_theta / 180 * pi) * crane.R2, crane.y - math.sin(crane.arm_theta / 180 * pi) * crane.R2, crane.x + math.cos(crane.arm_theta / 180 * pi) * crane.R1, crane.y + math.sin(crane.arm_theta / 180 * pi) * crane.R1) crane = self.crane_list[craneID2] l2 = Line(crane.x - math.cos(crane.arm_theta / 180 * pi) * crane.R2, crane.y - math.sin(crane.arm_theta / 180 * pi) * crane.R2, crane.x + math.cos(crane.arm_theta / 180 * pi) * crane.R1, crane.y + math.sin(crane.arm_theta / 180 * pi) * crane.R1) # 快速排斥实验 if max(l1.x1, l1.x2) < min(l2.x1, l2.x2) or\ max(l1.y1, l1.y2) < min(l2.y1, l2.y2) or\ max(l2.x1, l2.x2) < min(l1.x1, l1.x2) or\ max(l2.y1, l2.y2) < min(l1.y1, l1.y2): return False # 跨越实验 if (((l1.x1 - l2.x1)*(l2.y2 - l2.y1) - (l1.y1 - l2.y1)*(l2.x2 - l2.x1))*\ ((l1.x2 - l2.x1)*(l2.y2 - l2.y1) - (l1.y2 - l2.y1)*(l2.x2 - l2.x1))) > 0 or\ (((l2.x1 - l1.x1)*(l1.y2 - l1.y1) - (l2.y1 - l1.y1)*(l1.x2 - l1.x1))*\ ((l2.x2 - l1.x1)*(l1.y2 - l1.y1) - (l2.y2 - l1.y1)*(l1.x2 - l1.x1))) > 0: return False else: return True
sys.path.append(os.path.join(os.path.dirname(__file__), os.pardir)) from render import Renderer if __name__ == '__main__': template_name = 'Menu' CWD = os.getcwd() data_path = '{0}/{1}'.format(CWD, 'data.json') file = open(data_path, 'r') data_string = file.read() file.close() data = json.loads(data_string) renderer = Renderer(template_name, data) rendered_html_document = renderer.render_html() rendered_pdf_document = renderer.render_pdf(rendered_html_document) html_file_path = '{0}/output/{1}'.format(CWD, 'Rendered_{0}.html'.format(template_name)) html_file = open(html_file_path, 'w') html_file.write(rendered_html_document) html_file.close() pdf_file_path = '{0}/output/{1}'.format(CWD, 'Rendered_{0}.pdf'.format(template_name)) pdf_file = open(pdf_file_path, 'wb') pdf_file.write(rendered_pdf_document) pdf_file.close() print('Document Rendered!')
def get(self): page = Renderer(self, 'admin.html') page.render()
def get(self): page = Renderer(self, 'notfound.html') page.render()
def get(self): page = Renderer(self, 'index.html') page.render()
class App: def __init__(self): self.cube = c.Cube(radius=2) self.distance = 13 self.renderer = Renderer(width, height + 60, self.distance) self.color_bg = (150, 150, 150) self.x_color = (150, 50, 50) self.y_color = (50, 150, 50) self.z_color = (50, 50, 150) self.space = [ # ejes [c.Point3d(-self.distance, 0, 0), c.Point3d(self.distance, 0, 0)], [c.Point3d(0, 0, -self.distance), c.Point3d(0, 0, self.distance)], [c.Point3d(0, -self.distance, 0), c.Point3d(0, self.distance, 0)], # lines de referencia segun 'distace' [ c.Point3d(-self.distance, -self.distance, -self.distance), c.Point3d(-self.distance, self.distance, -self.distance) ], [ c.Point3d(-self.distance, -self.distance, -self.distance), c.Point3d(self.distance, -self.distance, -self.distance) ], [ c.Point3d(-self.distance, -self.distance, self.distance), c.Point3d(-self.distance, self.distance, self.distance) ], [ c.Point3d(-self.distance, -self.distance, self.distance), c.Point3d(self.distance, -self.distance, self.distance) ], [ c.Point3d(-self.distance, self.distance, self.distance), c.Point3d(-self.distance, self.distance, -self.distance) ], [ c.Point3d(-self.distance, -self.distance, self.distance), c.Point3d(-self.distance, -self.distance, -self.distance) ], [ c.Point3d(self.distance, -self.distance, self.distance), c.Point3d(self.distance, -self.distance, -self.distance) ], [ c.Point3d(-self.distance, self.distance, -self.distance), c.Point3d(self.distance, self.distance, -self.distance) ], [ c.Point3d(self.distance, self.distance, -self.distance), c.Point3d(self.distance, -self.distance, -self.distance) ] ] self.space_shapes = [ # planos de referencia [ self.space[3][0], self.space[3][1], self.space[5][1], self.space[8][0] ], [ self.space[3][0], self.space[5][0], self.space[6][1], self.space[9][1] ], [ self.space[3][0], self.space[9][1], self.space[11][0], self.space[7][1] ] ] self.x_state = 0 self.y_state = 0 self.z_state = 0 def init(self): pass def _order_faces(self): p = c.Point3d(self.distance, self.distance, self.distance) faces = self.cube.faces faces = sorted(faces, key=lambda x: x.dist_center_to_mid(p), reverse=True) return faces def update(self, x_state, y_state, z_state): self.cube.rotate('x', PI * 2 / 100 * (x_state - self.x_state)) self.x_state = x_state self.cube.rotate('y', PI * 2 / 100 * (y_state - self.y_state)) self.y_state = y_state self.cube.rotate('z', PI * 2 / 100 * (z_state - self.z_state)) self.z_state = z_state def draw(self): pg.draw.rect(screen, self.color_bg, pg.Rect(0, 60, width, height - 60)) self.renderer.render_shape(screen, self.space_shapes[0], (200, 200, 200)) self.renderer.render_shape(screen, self.space_shapes[1], (200, 200, 200)) self.renderer.render_shape(screen, self.space_shapes[2], (200, 200, 200)) for line in self.space: self.renderer.render_line(screen, line) for point in self.cube.vertex: self.renderer.render_point(screen, point) grey = 100 for f in self._order_faces(): self.renderer.render_shape(screen, f.vertex, (grey, grey, grey)) for line in f.edges: self.renderer.render_line(screen, line) for v in self.cube.vertex: # proyect x point = c.Point3d(-self.distance, v.cords[1], v.cords[2]) self.renderer.render_point(screen, point, self.x_color) # proyect y point = c.Point3d(v.cords[0], -self.distance, v.cords[2]) self.renderer.render_point(screen, point, self.y_color) # proyect z point = c.Point3d(v.cords[0], v.cords[1], -self.distance) self.renderer.render_point(screen, point, self.z_color)
import os import threading from render import Renderer from client import Client # Configurable constants c = Client() r = Renderer(c) r.main()
import pygame import parameters as PRAM from setup import soundPlayerFactory, playerFactory, eventHandlerFactory from render import Renderer from game import Game from input import InputHandler, ButtonMap from camera import GameCamera ### SETUP ### pygame.init() # @UndefinedVariable screen = pygame.display.set_mode((PRAM.DISPLAY_WIDTH, PRAM.DISPLAY_HEIGHT)) CLOCK = pygame.time.Clock() DONE = False ### GAME ENGINE ### musicPlayer, soundPlayer = soundPlayerFactory() renderer = Renderer(screen) gameCamera = GameCamera() player = playerFactory() game = Game(player, musicPlayer, soundPlayer, renderer, gameCamera) inputHandler = InputHandler(game, player, ButtonMap()) eventHandler = eventHandlerFactory(game) game.inputHandler = inputHandler game.gameStartup() while not DONE: for event in pygame.event.get(): if event.type == pygame.QUIT: # @UndefinedVariable DONE = True #TODO make this an input that creates a quit event? if event.type == pygame.KEYDOWN: # @UndefinedVariable game.keydownEvents.append(event) #TODO can tell pygame to only check fro specific events
def get(self): page = Renderer(self, 'posteador.html') page.render()
def __init__(self): self.cube = c.Cube(radius=2) self.distance = 13 self.renderer = Renderer(width, height + 60, self.distance) self.color_bg = (150, 150, 150) self.x_color = (150, 50, 50) self.y_color = (50, 150, 50) self.z_color = (50, 50, 150) self.space = [ # ejes [c.Point3d(-self.distance, 0, 0), c.Point3d(self.distance, 0, 0)], [c.Point3d(0, 0, -self.distance), c.Point3d(0, 0, self.distance)], [c.Point3d(0, -self.distance, 0), c.Point3d(0, self.distance, 0)], # lines de referencia segun 'distace' [ c.Point3d(-self.distance, -self.distance, -self.distance), c.Point3d(-self.distance, self.distance, -self.distance) ], [ c.Point3d(-self.distance, -self.distance, -self.distance), c.Point3d(self.distance, -self.distance, -self.distance) ], [ c.Point3d(-self.distance, -self.distance, self.distance), c.Point3d(-self.distance, self.distance, self.distance) ], [ c.Point3d(-self.distance, -self.distance, self.distance), c.Point3d(self.distance, -self.distance, self.distance) ], [ c.Point3d(-self.distance, self.distance, self.distance), c.Point3d(-self.distance, self.distance, -self.distance) ], [ c.Point3d(-self.distance, -self.distance, self.distance), c.Point3d(-self.distance, -self.distance, -self.distance) ], [ c.Point3d(self.distance, -self.distance, self.distance), c.Point3d(self.distance, -self.distance, -self.distance) ], [ c.Point3d(-self.distance, self.distance, -self.distance), c.Point3d(self.distance, self.distance, -self.distance) ], [ c.Point3d(self.distance, self.distance, -self.distance), c.Point3d(self.distance, -self.distance, -self.distance) ] ] self.space_shapes = [ # planos de referencia [ self.space[3][0], self.space[3][1], self.space[5][1], self.space[8][0] ], [ self.space[3][0], self.space[5][0], self.space[6][1], self.space[9][1] ], [ self.space[3][0], self.space[9][1], self.space[11][0], self.space[7][1] ] ] self.x_state = 0 self.y_state = 0 self.z_state = 0