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 :(")
