def main(args): from dddUtils.ioOBJ import load_2d as load from render.render import Render fn = args.fn dot_size = args.dotSize data = load(fn) vertices = data['vertices'] render = Render(SIZE, BACK, FRONT) draw(render, vertices, dot_size) out = fn + '.png' render.write_to_png(out)
def main():
from time import time
from itertools import count
from render.render import Render
from modules.helpers import print_stats
from modules.show import show
from modules.show import show_closed
from differentialLine import DifferentialLine
DF = DifferentialLine(NMAX, FARL*2, NEARL, FARL, PROCS)
render = Render(SIZE, BACK, FRONT)
render.ctx.set_source_rgba(*FRONT)
render.ctx.set_line_width(LINEWIDTH)
angles = sorted(random(NINIT)*TWOPI)
DF.init_circle_segment(MID,MID,RAD, angles)
t_start = time()
for i in count():
DF.optimize_position(STP)
spawn_curl(DF,NEARL)
if i % STAT_ITT == 0:
print_stats(i,time()-t_start,DF)
if i % EXPORT_ITT == 0:
fn = './res/oryx_bb_{:010d}.png'.format(i)
num = DF.np_get_edges_coordinates(np_edges)
show(render,np_edges[:num,:],fn)
fn = './res/oryx_bb_closed_{:010d}.png'.format(i)
num = DF.np_get_sorted_vert_coordinates(np_verts)
show_closed(render,np_verts[:num,:],fn)
def main():
from time import time
from itertools import count
from render.render import Render
from modules.helpers import print_stats
from modules.show import show
from modules.show import show_closed
from differentialLine import DifferentialLine
DF = DifferentialLine(NMAX, FARL * 2, NEARL, FARL, PROCS)
render = Render(SIZE, BACK, FRONT)
render.ctx.set_source_rgba(*FRONT)
render.ctx.set_line_width(LINEWIDTH)
angles = sorted(random(NINIT))
DF.init_circle_segment(MID, MID, RAD, angles)
for i in count():
t_start = time()
steps(DF, STEPS_ITT)
t_stop = time()
print_stats(i * STEPS_ITT, t_stop - t_start, DF)
fn = './res/oryx_bb_{:010d}.png'.format(i * STEPS_ITT)
edges_coordinates = DF.get_edges_coordinates()
show(render, edges_coordinates, fn)
fn = './res/oryx_bb_closed_{:010d}.png'.format(i * STEPS_ITT)
sorted_vert_coordinates = DF.get_sorted_vert_coordinates()
show_closed(render, sorted_vert_coordinates, fn)
def main():
from differentialMesh import DifferentialMesh
from render.render import Render
from time import time
from modules.helpers import print_stats
from numpy.random import randint, random
from numpy import unique
DM = DifferentialMesh(NMAX, 2 * FARL, NEARL, FARL, PROCS)
DM.new_faces_in_ngon(MID, MID, H, 6, 0.0)
render = Render(SIZE, BACK, FRONT)
render.set_line_width(LINEWIDTH)
tsum = 0
for i in xrange(10000):
t1 = time()
for _ in xrange(STEPS_ITT):
DM.optimize_position(ATTRACT_STP, REJECT_STP, TRIANGLE_STP, ALPHA,
DIMINISH, -1)
henum = DM.get_henum()
edges = unique(randint(henum, size=(henum)))
en = len(edges)
rnd = 1 - 2 * random(size=en * 2)
make_island = random(size=en) > 0.85
for i, (he, isl) in enumerate(zip(edges, make_island)):
if DM.is_surface_edge(he) > 0:
the = pi * rnd[2 * i]
rad = rnd[2 * i + 1] * 0.5
dx = cos(the) * rad * H
dy = sin(the) * rad * H
if not isl:
DM.new_triangle_from_surface_edge(
he,
H,
dx * rad * H,
dy * rad * H,
minimum_length=MINIMUM_LENGTH,
maximum_length=MAXIMUM_LENGTH,
merge_ragged_edge=1)
else:
DM.throw_seed_triangle(he, H, dx * rad * H,
dy * rad * H, NEARL * 0.5, the)
DM.optimize_edges(SPLIT_LIMIT, FLIP_LIMIT)
tsum += time() - t1
print_stats(render.num_img, tsum, DM)
show(render, DM)
tsum = 0
from render.jsonloader import JsonLoader as JsonLoader
from render.render import Render as Render
if __name__ == '__main__':
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--directory',
type=str,
default='/Users/sameriksson/temp/screensgen/')
parser.add_argument('--save', type=bool, default=True)
args = parser.parse_args()
rend = Render(args.directory)
rend.render(args.save)
def __init__(self, game):
super().__init__(game, game.width / 2, game.height / 2, game.width,
game.height)
self.elements = []
self.update_while_tween = False
self.in_tween = False
margin_top = 50
margin_left = 100
carousel_width = SkillView.width * 3 + SkillGroupElement.gap * 2
group_elements = []
for skill_group in SkillManager.get_instance().groups.values():
group = SkillGroupElement(game, margin_left + 50, 0, skill_group,
self)
group_elements.append(group)
self.carousel = Carousel(game, margin_left + 50, margin_top + 300,
carousel_width, SkillView.height,
group_elements)
self.skill_name = Tween(
Label(self.game,
margin_left + carousel_width + 300,
margin_top,
350,
80,
"<>",
80,
color=(52, 152, 219)).set_fade_tick(30, "pause"),
{'opacity': 255}, [])
self.font = Render.load_font()
empty_surface = Surface((500, self.game.height - margin_top - 150))
empty_surface.set_colorkey((240, 240, 240))
empty_surface.fill((240, 240, 240))
empty_surface.set_alpha(0)
self.empty_surface = empty_surface
self.skill_desc = Tween(
Image(self.game, margin_left + carousel_width + 300,
margin_top + 150, empty_surface), {'opacity': 255}, [])
self.skill_price = Tween(
Label(self.game,
margin_left + carousel_width + 300,
margin_top + 150 + 150,
350,
80,
"필요 SP 1",
32,
color=(52, 152, 219)).set_fade_tick(30, "pause"),
{'opacity': 255}, [])
self.current_sp = Tween(
Label(self.game,
margin_left + carousel_width + 300,
margin_top + 150 + 150 + 40,
350,
80,
"현재 SP 0",
32,
color=(52, 152, 219)).set_fade_tick(30, "pause"),
{'opacity': 255}, [])
self.skill_score = Tween(
Label(self.game,
margin_left + carousel_width + 300 + 500 - 250,
margin_top + 150 + 150,
350,
80,
"필요 점수 0",
32,
color=(52, 152, 219)).set_fade_tick(30, "pause"),
{'opacity': 255}, [])
self.current_score = Tween(
Label(self.game,
margin_left + carousel_width + 300 + 500 - 250,
margin_top + 150 + 150 + 40,
350,
80,
"현재 점수 0",
32,
color=(52, 152, 219)).set_fade_tick(30, "pause"),
{'opacity': 255}, [])
self.buy_button_image = Surface((500, 100))
Render(self.buy_button_image)\
.fill((52, 152, 219))\
.write_text(250, 50, "Enter 키로 구매", color=(240, 240, 240), size=50)
self.disabled_button_image = Surface((500, 100))
Render(self.disabled_button_image)\
.fill((220, 220, 220))\
.write_text(250, 50, "구매할 수 없음", color=(180, 180, 180), size=50)
self.already_bought_button_image = Surface((500, 100))
Render(self.already_bought_button_image)\
.fill((220, 220, 220))\
.write_text(250, 50, "이미 구매함", color=(180, 180, 180), size=50)
self.buy_button = Tween(
Image(self.game, margin_left + carousel_width + 300,
margin_top + 150 + 150 + 40 + 100, self.buy_button_image),
{'opacity': 255}, [])
self.skill_ui = [
self.skill_name, self.skill_desc, self.skill_price,
self.current_sp, self.skill_score, self.current_score,
self.buy_button
]
self.update_skill()
self.elements.extend(
(self.carousel,
Label(self.game, margin_left, margin_top, 250, 50, "SkillTree",
50).set_fade_tick(30, "pause")))
self.elements.extend(self.skill_ui)
IMPROVISER_HOST = "https://api.improviser.education"
ENDPOINT_RIFFS = IMPROVISER_HOST + "/v1/riffs"
RENDER_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)),
'rendered')
API_USER = os.getenv('API_USER')
API_PASS = os.getenv('API_PASS')
AWS_ACCESS_KEY_ID = os.getenv('AWS_ACCESS_KEY_ID')
AWS_SECRET_ACCESS_KEY = os.getenv('AWS_SECRET_ACCESS_KEY')
AWS_BUCKET_NAME = "improviser.education"
KEYS = [
'c', 'cis', 'd', 'dis', 'ees', 'e', 'f', 'fis', 'g', 'gis', 'aes', 'a',
'ais', 'bes', 'b'
]
renderer = Render(renderPath=RENDER_PATH)
logger = structlog.get_logger(__name__)
if not LOCAL_RUN:
if not API_USER or not API_PASS or not AWS_ACCESS_KEY_ID or not AWS_SECRET_ACCESS_KEY:
sys.exit('Please set needed environment vars.')
def render(riff):
rendered_riff_ids = []
for key in KEYS:
renderer.name = "riff_%s_%s" % (riff["id"], key)
notes = riff["notes"]
chords = riff["chord_info"] if riff["chord_info"] else ""
renderer.addNotes(notes)
renderer.addChords(chords)
def main():
from time import time
from itertools import count
from differentialLine import DifferentialLine
from render.render import Render
from modules.helpers import print_stats
from modules.show import sandstroke
from modules.show import show
from modules.show import dots
np_coords = zeros(shape=(NMAX, 4), dtype='float')
np_vert_coords = zeros(shape=(NMAX, 2), dtype='float')
DF = DifferentialLine(NMAX, FARL * 2, NEARL, FARL, PROCS)
render = Render(SIZE, BACK, FRONT)
render.ctx.set_source_rgba(*FRONT)
render.ctx.set_line_width(LINEWIDTH)
## arc
angles = sorted(random(INIT_NUM) * pi * 1.5)
xys = []
for a in angles:
x = 0.5 + cos(a) * 0.2
y = 0.5 + sin(a) * 0.2
xys.append((x, y))
DF.init_line_segment(xys, lock_edges=1)
## vertical line
#yy = sorted(MID + 0.2*(1-2*random(INIT_NUM)))
#xx = MID+0.005*(0.5-random(INIT_NUM))
#xys = []
#for x,y in zip(xx,yy):
#xys.append((x,y))
#DF.init_line_segment(xys, lock_edges=1)
## diagonal line
# yy = sorted(MID + 0.2*(1-2*random(INIT_NUM)))
# xx = sorted(MID + 0.2*(1-2*random(INIT_NUM)))
# xys = []
# for x,y in zip(xx,yy):
# xys.append((x,y))
# DF.init_line_segment(xys, lock_edges=1)
for i in count():
t_start = time()
DF.optimize_position(STP)
spawn_curl(DF, NEARL, 0.016)
if i % 100 == 0:
fn = './res/sider_arc_ac_{:04d}.png'.format(i)
else:
fn = None
render.set_front(FRONT)
num = DF.np_get_edges_coordinates(np_coords)
sandstroke(render, np_coords[:num, :], 20, fn)
if random() < 0.05:
sandstroke(render, np_coords[:num, :], 30, None)
vert_num = DF.np_get_vert_coordinates(np_vert_coords)
dots(render, np_vert_coords[:vert_num, :], None)
t_stop = time()
print_stats(i, t_stop - t_start, DF)
def setUp(self):
self.render = Render()
def prepare_surface(self):
self.surface = pygame.Surface((self.width, self.height))
self.surface_renderer = Render(self.surface)
def main():
from differentialMesh import DifferentialMesh
from render.render import Render
from time import time
from modules.helpers import print_stats
from numpy import array
# from modules.utils import get_exporter
# exporter = get_exporter(NMAX)
DM = DifferentialMesh(NMAX, 2 * FARL, NEARL, FARL, PROCS)
DM.new_faces_in_ngon(MID, MID, H, 6, 0.0)
render = Render(SIZE, BACK, FRONT)
render.set_line_width(LINEWIDTH)
# st = named_sub_timers()
tsum = 0
for i in xrange(10000000):
t1 = time()
for _ in xrange(STEPS_ITT):
# st.start()
DM.optimize_position(ATTRACT_STP, REJECT_STP, TRIANGLE_STP, ALPHA,
DIMINISH, -1)
# st.t('opt')
henum = DM.get_henum()
# st.t('rnd')
surface_edges = array(
[DM.is_surface_edge(e) > 0 for e in range(henum)],
'bool').nonzero()[0]
# st.t('surf')
rnd = random(size=len(surface_edges) * 2)
the = (1. - 2 * rnd[::2]) * pi
rad = rnd[1::2] * 0.5 * H
dx = cos(the) * rad
dy = sin(the) * rad
# st.t('rnd2')
DM.new_triangles_from_surface_edges(surface_edges,
len(surface_edges), H, dx, dy,
MINIMUM_LENGTH, MAXIMUM_LENGTH,
1)
# st.t('tri')
# st.start()
DM.optimize_edges(SPLIT_LIMIT, FLIP_LIMIT)
# st.t('opte')
tsum += time() - t1
print_stats(i * STEPS_ITT, tsum, DM)
## export png
show(render, DM)
## export obj
# exporter(
# DM,
# {
# 'procs': PROCS,
# 'nearl': NEARL,
# 'farl': FARL,
# 'prefix': PREFIX,
# 'reject_stp': 0,
# 'attract_stp': 0,
# 'triangle_stp': 0,
# 'size': SIZE
# },
# i*STEPS_ITT
# )
tsum = 0
