def main():
from iutils.render import Render
render = Render(SIZE, BACK, FRONT)
render.clear_canvas()
# from iutils.colors import get_colors
# colors = get_colors('./colors/img.gif') # point to your source image
# nc = len(colors)
for i in range(N):
for j in range(N):
# random colors
# rgba = colors[(i*N+j)%nc] + [1]
# render.set_front(rgba)
# bw checkers
if not (i+j)%2:
continue
a = (i*W)*ONE
b = (j*W)*ONE
print(a,b, W*ONE)
render.ctx.rectangle(a,b,W*ONE,W*ONE)
render.ctx.fill()
render.write_to_png('checkers.png')
def main():
from iutils.render import Render
render = Render(SIZE, BACK, FRONT)
render.clear_canvas()
# from iutils.colors import get_colors
# colors = get_colors('./colors/img.gif') # point to your source image
# nc = len(colors)
for i in range(N):
for j in range(N):
# random colors
# rgba = colors[(i*N+j)%nc] + [1]
# render.set_front(rgba)
# bw checkers
if not (i + j) % 2:
continue
a = (i * W) * ONE
b = (j * W) * ONE
print(a, b, W * ONE)
render.ctx.rectangle(a, b, W * ONE, W * ONE)
render.ctx.fill()
render.write_to_png('checkers.png')
def main():
from numpy.random import random
from numpy.random import randint
from iutils.render import Render
from modules.linear import Linear
render = Render(SIZE, BACK, FRONT)
render.clear_canvas()
nsteps = 500
height = 1.0
for i in range(20):
start = random(size=(1, 2))
start_w = 0
grains = randint(20, 150)
scale = 0.005 + random() * 0.02
L = Linear(SIZE, height, start, start_w)
L.steps(nsteps, scale=scale)
show(render, L, grains)
render.write_to_png('./linear.png')
def main():
from time import time
from itertools import count
from differentialLine import DifferentialLine
from iutils.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)
angles = sorted(random(INIT_NUM) * TWOPI)
DF.init_circle_segment(MID, MID, 0.025, angles)
# 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 % 500 == 0:
fn = './res/chris_bd_{: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)
dots(render, np_vert_coords[:vert_num, :], fn)
t_stop = time()
print_stats(i, t_stop - t_start, DF)
def main():
from differentialMesh import DifferentialMesh
from iutils.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 range(10000):
t1 = time()
for _ in range(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
def main():
from time import time
from itertools import count
from iutils.render import Render
from modules.helpers import print_stats
from modules.show import show
# from modules.show import show_closed
from differentialLine import DifferentialLine
from modules.helpers import get_exporter
from numpy.random import random
from fn import Fn
DF = DifferentialLine(NMAX, FARL*2, NEARL, FARL, PROCS)
fn = Fn(prefix='./res/')
exporter = get_exporter(
NMAX,
{
'nearl': NEARL,
'farl': FARL,
'stp': STP,
'size': SIZE,
'procs': PROCS
}
)
render = Render(SIZE, BACK, FRONT)
render.ctx.set_source_rgba(*FRONT)
render.ctx.set_line_width(LINEWIDTH)
angles = sorted(random(INIT_NUM)*TWOPI)
DF.init_circle_segment(MID,MID,INIT_RAD, angles)
t_start = time()
for i in count():
DF.optimize_position(STP)
# spawn_curl(DF,NEARL)
spawn(DF, NEARL, 0.03)
if i % STAT_ITT == 0:
print_stats(i,time()-t_start,DF)
if i % EXPORT_ITT == 0:
name = fn.name()
num = DF.np_get_edges_coordinates(np_edges)
show(render,np_edges[:num,:],name+'.png')
exporter(
DF,
name+'.2obj'
)
def main():
from differentialMesh import DifferentialMesh
from iutils.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)
fn = Fn(prefix='./res/')
# st = named_sub_timers()
tsum = 0
for i in range(10000000):
t1 = time()
for _ in range(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)
name = fn.name()
## export png
show(render, DM, name+'.png')
## export obj
exporter(
DM,
name + '.2obj',
{
'procs': PROCS,
'nearl': NEARL,
'farl': FARL,
'reject_stp': 0,
'attract_stp': 0,
'triangle_stp': 0,
'size': SIZE
},
i*STEPS_ITT
)
tsum = 0
def main():
from differentialMesh import DifferentialMesh
from iutils.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 range(10000):
t1 = time()
for _ in range(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
def main():
from sand import Sand
size = 1000
s = Sand(size)
s.set_bg(BACK)
t = time()
aa = random((1000000,2))
aa[:,0]*=0.5
bb = random((1000000,2))
bb[:,1]*=0.5
cc = random((1000000,2))*0.5
cc[:,0] += 0.1
s.paint_dots(aa, GREEN)
s.paint_dots(bb, BLUE)
s.paint_dots(cc, RED)
s.write_to_png('./out.png')
t1 = time()-t
print('time', t1)
from iutils.render import Render
render = Render(size, BACK, FRONT)
t = time()
render.set_front(GREEN)
for x,y in aa:
render.dot(x,y)
render.set_front(BLUE)
for x,y in bb:
render.dot(x,y)
render.set_front(RED)
for x,y in cc:
render.dot(x,y)
render.write_to_png('./out2.png')
t2 = time()-t
print('time2', t2)
print('speedup', t2/t1)
def main():
from time import time
from itertools import count
from differentialLine import DifferentialLine
from iutils.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)
# angles = sorted(random(INIT_NUM)*TWOPI)
# DF.init_circle_segment(MID,MID,0.2, angles)
## 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/chris_bd_{: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 main():
from time import time
from iutils.render import Render
from differentialMesh import DifferentialMesh
from modules.helpers import darts
from modules.helpers import print_stats
from numpy import array
DM = DifferentialMesh(NMAX, 2*FARL, NEARL, FARL, PROCS)
DM.new_faces_in_ngon(MID,MID, H, 7, 0)
DM.set_edge_intensity(1, 1)
sources = [(x,y) for x,y in darts(NUM_SOURCES, MID, MID, 0.43, 0.002)]
DM.initialize_sources(sources, NEARL)
render = Render(SIZE, BACK, FRONT)
for i in range(1000000):
t1 = time()
for _ in range(STEPS_ITT):
DM.find_nearby_sources()
henum = DM.get_henum()
surface_edges = array(
[DM.is_surface_edge(e)>0 and r<DM.get_edge_intensity(e)
for e,r in enumerate(random(size=henum))],
'bool').nonzero()[0]
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
DM.new_triangles_from_surface_edges(
surface_edges,
len(surface_edges),
H,
dx,
dy,
MINIMUM_LENGTH,
MAXIMUM_LENGTH,
1
)
DM.optimize_position(
ATTRACT_STP,
REJECT_STP,
TRIANGLE_STP,
ALPHA,
DIMINISH,
-1
)
henum = DM.get_henum()
DM.optimize_edges(
SPLIT_LIMIT,
FLIP_LIMIT
)
if DM.safe_vertex_positions(3*H)<0:
show_circles(render, DM, sources)
print('vertices reached the boundary. stopping.')
return
show_circles(render, DM, sources)
t2 = time()
print_stats(i*STEPS_ITT, t2-t1, DM)
