def renderTrainAndTestSet(blenderFiles, renderedDir, num_samples_train, num_samples_test, num_rotations_train, num_rotations_test, res_x, res_y, cameraPositions): global renderList renderedDir = os.path.abspath(renderedDir) renderList.append( Render(blenderFiles, renderedDir + "_train", num_samples_train, num_rotations_train, cameraPositions, res_x, res_y)) renderList.append( Render(blenderFiles, renderedDir + "_test", num_samples_test, num_rotations_test, cameraPositions, res_x, res_y))
def main(): model = init_model( os.path.dirname(os.path.abspath(__file__)), getpass.getuser(), os.uname().nodename ) def resize(signum, frame): Render(model) # Re-renders Terminal in case of SIGWINCH(resize) event signal.signal(signal.SIGWINCH, resize) while not model.exit: try: Render(model) try: model = EventHandler(model, blesses.get_key()) except KeyboardInterrupt: model = replace(model, exit=1) except Exception as e: with open("crash.json", "w+") as f: f.write(json.dumps(asdict(model),indent=4)) raise e
def render_model_net(root, output_dir, output_views=12, use_dodecahedron=False): # traversal the directors sub_dirs = sorted(get_immediate_subdirectories(root)) render = Render() for sub_dir in sub_dirs: print("dealing " + sub_dir + "...") # make output dirs out_sub_dir = output_dir + "/" + sub_dir make_dir_not_exist(out_sub_dir + "/test") make_dir_not_exist(out_sub_dir + "/train") # ready to convert source_dir = root + "/" + sub_dir for d in ["/test", "/train"]: print(d) curr_dir = source_dir + d off_files = list(get_off_file_in_dir(curr_dir)) for i, off_file in enumerate(off_files): render.render_and_save(curr_dir + "/" + off_file, out_sub_dir + d, output_views, use_dodecahedron) if i % 10 == 0: print("%d/%d" % (i, len(off_files)))
def stars(): width = 800 height = 600 r = Render(width, height) def star(s, y, size): c = random.randint(0, 255) r.set_color(color(c, c, c)) if size == 1: r.point(x, y) elif size == 2: r.point(x, y) r.point(x + 1, y) r.point(x, y + 1) r.point(x + 1, y + 1) elif size == 3: r.point(x, y) r.point(x + 1, y) r.point(x, y + 1) r.point(x - 1, y) r.point(x, y - 1) for x in range(width - 4): for y in random(height - 4): if random.random() < 0.001: star(x + 2, y + 2, random.randint(1, 3)) r.display('out.bmp')
def main(): args = init_args() try: dict_data = json.loads(open(args.json_file).read()) except IOError: print('Error: no such file {}'.format(args.json_file)) exit() mantle = JSONMantle() mantle.class_prefix = args.prefix if args.prefix else '' if args.author: mantle.meta_data['author'] = args.author # Get the file base name file_basename = os.path.basename(args.json_file) # Eliminating filename extension class_name = file_basename.split('.')[0] mantle.generate_properties(dict_data, class_name) render_h, render_m = mantle.get_template_data() render = Render(render_h, render_m, args.output_dir) render.render_objc()
def check_inputs(): invalid_positions = [ 0, 1, 2, 3, 4, 5, 6, 7, 14, 21, 28, 35, 42, 13, 20, 27, 34, 41, 48, 43, 44, 45, 46, 47 ] key = input() if key == 'w': Player.pos -= 7 elif key == 's': Player.pos += 7 elif key == 'a': Player.pos -= 1 elif key == 'd': Player.pos += 1 for position in invalid_positions: if position == Player.pos: if key == 'w': Player.pos += 7 elif key == 's': Player.pos -= 7 elif key == 'a': Player.pos += 1 elif key == 'd': Player.pos -= 1 print('You hit a wall!') if key == 'q': exit() remove = Render() remove.remove_player()
def save_DET(dc, path, file_name, plot_options={}): if isinstance(dc, DataContainer): dc = [dc] rd = Render(plot_type="det") fig = rd.plot(dc, display=False, plot_options=plot_options) fig.savefig("{}/{}".format(path, file_name)) rd.close_fig(fig)
def start_game(): #needs to be called before pygame.init pygame.mixer.pre_init(22050, -16, 2, 1024) window = Window() window.init() pygame.init() sounds = Sounds() sounds.init() window.sounds = sounds pygame.mixer.set_num_channels(32) # meta game loop while True: sounds.play_music("intro", loop=1) intro_main(window, handle_events) # so we can mix more channels at once. pygame defaults to 8. #sounds.play("jump1") #sounds.play("hit1") #sounds.play("goal1") sounds.set_music_tracks(['track-one', 'track-two']) world = World() world.stage = 2 populate(world, window) def count_leaves(): no_leaves = 0 for item in world.items: if item.role == "Bough": no_leaves = no_leaves + 1 return no_leaves CleanUp_Event = pygame.event.Event(CLEANUP, message="Cleaning Up Your shit") pygame.time.set_timer(CLEANUP, 1000) TickTock = pygame.event.Event( TICK_TOCK, message="TickTock goes the Ticking Clock") pygame.time.set_timer(TICK_TOCK, int(90000 / count_leaves())) AddCherry = pygame.event.Event(ADDCHERRY, message="Ooooo Cherry") pygame.time.set_timer(ADDCHERRY, int(90000 / 5)) AddOwange = pygame.event.Event(ADDOWANGE, message="Ooooo owange") pygame.time.set_timer(ADDOWANGE, int(1000 * 5)) for i in range(3): event.post(AddOwange) pygame.time.set_timer(BIRDY, 1000 * 7) render = Render(window, world) quit = runloop(window, world, render) if quit: return
def main(): os.chdir(os.path.dirname(os.path.realpath(__file__))) pygame.init() # Ignore mouse motion (greatly reduces resources when not needed) pygame.event.set_blocked(pygame.MOUSEMOTION) available_maps = glob.glob(os.path.join(MAPS_DIR, '*.map')) available_maps = map(lambda m: os.path.basename(m), available_maps) selected = { 'players_count': 1, 'map': available_maps[0], 'exit': False, 'toggle_fullscreen': False } render = Render() while 42: selected = main_menu(render, available_maps, selected) if selected['exit']: break if selected['toggle_fullscreen']: render.toggle_full_screen() continue pygame.mixer.init(buffer=512) main_loop(render, players_count=selected['players_count'], map_name=selected['map']) pygame.mixer.stop() render.quit() pygame.quit() sys.exit(0)
async def req1(req): print("req1", req.url) if '/get/' in req.path or '/do/' in req.path or '/post/' in req.path: return ext = req.path.split('.')[-1] if ext in ('mp3', 'js', 'jpg', 'css', 'ttf', 'png', 'woff', 'woff2', 'ico', 'gif', 'map', 'mem', 'pck', 'mp4', 'csv'): pfil = './web' + req.path return await response_file( location=pfil, headers={"cache-control": "public,max-age=216000"}) elif ext in 'html': pfil = './web' + req.path tmp = Render(pfil) rtn = await tmp.parse() return response_html( body=rtn, headers={"cache-control": "public,max-age=216000"}) elif ext in 'py': pfil = '.' + req.path # /w*.py y /vs_widgets will be served not server side .py if (req.path[:2] == '/w' or "/vs_widgets" in req.path) and ".." not in req.path: return await response_file( pfil, headers={"cache-control": "public,max-age=216000"}) else: return response_text("error") else: return response_text("error")
def tick(self, viz=False): self.timeline += 1 n = len(self.agents) for i, agent in enumerate(reversed(self.agents)): observ, optimalAction = self.observe() action = agent.forward(observ) self.update(agent, action, optimalAction) agent.backward(optimalAction) # erase dead if agent.entropy < self._minEntropy: del self.agents[n - i - 1] # sort according to entropy self.sortAgents() # hybrid or erase if len(self.agents) < self.agentNum: self.addAgent(self.hybrid(self.agents[0], self.agents[1])) elif len(self.agents) > self.agentNum: del self.agents[-1] elif np.random.rand() > 1 - self.eraseProb: idx = np.random.randint(0, len(self.agents)) del self.agents[idx] if viz and len(self.agents) > 0: if self.renderObj is None: self.renderObj = Render() self.renderObj.update(self.agents[0])
def main(): from render import Render from tree import Tree from time import time render = Render(SIZE, FRONT, BACK, TRUNK, TRUNK_STROKE, GRAINS) render.ctx.set_source_rgba(*FRONT) render.ctx.set_line_width(ONE) while True: render.clear_canvas() tree = Tree(MID, 0.9, INIT_BRANCH, -pi * 0.5, ONE, ONE, BRANCH_SPLIT_ANGLE, BRANCH_PROB_SCALE, BRANCH_DIMINISH, BRANCH_SPLIT_DIMINISH, BRANCH_ANGLE_MAX, BRANCH_ANGLE_EXP) i = 1 while tree.Q: i += 1 tree.step() map(render.branch2, tree.Q) if not i % 1000: print i render.sur.write_to_png( '/media/var/andreas_tree/test_52_{:10.0f}.png'.format(time()))
def __init__(self): self.render = Render(self) self.totals = {} self.pure8 = False self.mirror = True self.createScore() self.calcMapping()
def test_export_aaf(): r = Render( JSON_EXAMPLE, './tmp', no_clean=True, # readable=True, verbose=False, vcodec='aaf') r.export()
def __init__(self, planet, agents, viz=True): self._minEntropy = 1 self._invEntropy = 5 self.viz = viz self.planet = planet self.agents = [self.addAgent(agent) for agent in agents] self._agent = None if viz: self.renderObj = Render()
def save_DET(dc, path, file_name, no_ppf, plot_options={}): if type(dc) is {}.values().__class__: dc = list(dc) if isinstance(dc, DataContainer): dc = [dc] rd = Render(plot_type="det") fig = rd.plot(dc, display=False, plot_options=plot_options, no_ppf=no_ppf) fig.savefig("{}/{}".format(path, file_name)) rd.close_fig(fig)
def test_export_fcpxml(): r = Render( JSON_EXAMPLE, './tmp', no_clean=True, # markers=True, # readable=True, verbose=False, vcodec='fcpxml') r.export()
def main(): text_list = get_text_list() if len(text_list) == 0: raise RuntimeError('ocr请求失败') contours, img = ImgProess(PROCESS_IMG_PATH).get_contours(True) dropdown_cnt = get_dropdown_contour() feature_classfication = FeatureClassification(cnts=contours, text_list=text_list, dropdown_cnt=dropdown_cnt, img=img) categorys_list = feature_classfication.run() schema = GetSchema(categorys_list=categorys_list, img=img).run() Render(TMEPLATE_PATH, TEMPLATE_OUT_PATH, schema)
def diagonal(): width = 800 height = 600 r = Render(width, height) for x in range(width): for y in range(height): if x == y: r.point(x, y) r.display('out.bmp')
def dispatch(self): if (not self.params.has_key("id")) or (not self.params.has_key("type") or (not self.params.has_key("text"))): return Render.render_400() try: pa = self.params speech_obj = Speech(pa["id"], pa["text"], pa["lan"], pa["type"]) speech_obj.speak() # response back to client response = Render(speech_obj) return response.render() except Exception, e: return Render.render_400(e)
def static(): width = 800 height = 600 r = Render(width, height) for x in range(width): for y in range(height): if random.random() > 0.5: r.point(x, y) r.display('out.bmp')
def main(): try: init_global_config() r = Thread(target=Render().render) r.daemon = True r.start() monitor = Thread(target=validate_nginx_config) monitor.daemon = True monitor.start() while True: sleep(5) except KeyboardInterrupt: return
async def route1(req, tag): print(req) print('module', tag) print('params', req.raw_args) if '&' in tag: module = tag.split('&')[0] else: module = tag pfil = './web/' + module + '.html' tmp = Render(pfil) rtn = await tmp.parse() return response_html(body=rtn, headers={"cache-control": "public,max-age=216000"})
def __init__(self, save_prev_names: bool = False): self.game_field = [str(i + 1) for i in range(9)] self.moves_count = 0 if not save_prev_names: self.first_player, self.second_player = None, None self.victory_counter = [0, 0] self.curr_player_mark = "O" self.render = Render() logging.basicConfig(level=logging.INFO, format="%(asctime)s, %(levelname)s - %(message)s", datefmt="%d-%b-%y %H:%M:%S", filename="game_logs.log")
def run(self): # get data data = TextDataset(self.src) # preprocess r = RuleBased() e = Evaluate() # nltk as baseline print("Processsing NLTK as baseline ... ") nltk_sentences = r.get_nltk_tokenized_sentences(data.clean_text) query_list = [s.split(" ") for s in nltk_sentences] begin, end, indexed_sentences = e.find_query_index(data.clean_idx_tokens, query_list) evaluation = e.evaluate(data, begin, end) result = {"key":"nltk", "begin":begin, "end":end, "sentences":indexed_sentences, "evaluation":evaluation} self.results.append(result) #import pdb; pdb.set_trace() # #rule_based methods print("Processsing rule based (Subject) ... ") filtered = r.filter_subject(nltk_sentences) query_list = [s.split(" ") for s in filtered] begin, end, indexed_sentences = e.find_query_index(data.clean_idx_tokens, query_list) evaluation = e.evaluate(data, begin, end) result = {"key":"has_subject", "begin":begin, "end":end, "sentences":indexed_sentences, "evaluation":evaluation} self.results.append(result) print("Processsing rule based (Verb)... ") filtered = r.filter_verb(nltk_sentences) query_list = [s.split(" ") for s in filtered] begin, end, indexed_sentences = e.find_query_index(data.clean_idx_tokens, query_list) evaluation = e.evaluate(data, begin, end) result = {"key":"has_verb", "begin":begin, "end":end, "sentences":indexed_sentences, "evaluation":evaluation} self.results.append(result) print("Processsing rule based (Subject & Verb)... ") filtered = r.filter_subject(nltk_sentences) filtered = r.filter_verb(filtered) query_list = [s.split(" ") for s in filtered] begin, end, indexed_sentences = e.find_query_index(data.clean_idx_tokens, query_list) evaluation = e.evaluate(data, begin, end) result = {"key":"has_subjectVerb", "begin":begin, "end":end, "sentences":indexed_sentences, "evaluation":evaluation} self.results.append(result) # write result print("Writing data to: " + str(self.dst) + "\033[1m" + str(self.filename) + "\033[0m") render = Render(self.dst, self.filename, data, data.ground_truth, self.results) render.save()
def render_scale_diagram(self, render=None, px_per_mm=2): fork_path = self._fork_path() if render is None: inf = array([self.left_cs.tube_top[0], 0]) sup = array([fork_path[-1][0], self.head_tube.tube_top[1]]) r = Render(inf, sup, px_per_mm) else: r = render for tube in (self.seat_tube, self.top_tube, self.head_tube, self.down_tube): r.draw_tube(tube) for mitre in (self.tt_ht, self.dt_ht, self.dt_st, self.tt_st): r.draw_mitre(mitre) # Draw the lower stack path = self._lower_stack_path() r.polyline(self._lower_stack_path(), "black") # The fork r.polyline(fork_path, "darkblue") # And the centreline start = array([self.right_drop.end[0], self.bb_drop]) end = array([fork_path[-1][0], self.bb_drop]) r.polyline((start, end), "black") # The chainstays r.draw_tube(self.right_cs) r.draw_tube(self.right_ss) # The CS dropout do_top = self.right_drop.end + \ self.right_ss.vecn * self.right_drop.ss_length r.polyline((self.right_drop.start, self.right_drop.end, do_top), "purple") # The wheels r.draw_wheel(self.right_cs.top + self.right_drop.vec, self.wheel_diameter, self.tyre_height) r.draw_wheel(fork_path[1], self.wheel_diameter, self.tyre_height) # And finally the BB shell r.circle(array([0, 0]), self.bb_tube.radius, "brown") r.draw_point(self.dt_bb_mitre_corner[INSIDE], "red") r.draw_point(self.dt_bb_mitre_corner[OUTSIDE], "cyan") return r
def color_static(): width = 800 height = 600 r = Render(width, height) for x in range(width): for y in range(height): r.point( x, y, r.color(random.randint(0, 255), random.randint(0, 255), random.randint(0, 255))) r.display('out.bmp')
def draw(self, px_per_mm): inf = array([0, 0]) points = [inf.copy()] sup = inf.copy() for attr in ("hip", "shoulder", "elbow", "wrist", "top_of_ht"): point = getattr(self, attr) points.append(point) for i in range(2): sup[i] = max(sup[i], point[i]) inf[i] = min(inf[i], point[i]) render = Render(inf, sup, px_per_mm) render.polyline(points, "black") return render
def __init__(self, numDrones, numMobileRobs): self.drones = self.initDrones(numDrones) self.mobilerobots = self.initMobileRobs(numMobileRobs) self.numCollectionPts = 20 self.areaLength = 20 # in meters self.timeStep = timeStep self.collectionPts = self.genCollectionPts(self.numCollectionPts) #CONSTANTS self.screen_width = screenWidth self.screen_height = screenHeight #MAIN LOOP self.display = Render(len(self.drones), len(self.mobilerobots), self.drones, self.mobilerobots, self.collectionPts)
def build(default, resume): Renderer = Render() if default: try: posts = parse.Post_parser() Renderer.Render_posts(posts) logging.info(" Build successful. Check your output folder.") except: logging.exception(" Build failed :(") elif resume: try: details = parse.Resume_parser() Renderer.Render_resume(details) logging.info(" Build successful. Check your output folder.") except: logging.exception(" Build failed :(")