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 differentialMesh3d import DifferentialMesh3d
from modules.ioOBJ import load_move_scale as load_obj
from modules.random import random_unit_vec
from modules.geometry import get_show_geometry
from modules.utils import get_seed_selector
from modules.utils import print_stats
from modules.utils import get_exporter
from fn import Fn
fn = Fn(prefix='./res/', postfix='.obj')
DM = DifferentialMesh3d(
nmax=NMAX,
zonewidth=ZONEWIDTH,
nearl=NEARL,
farl=FARL,
procs=PROCS
)
data = load_obj(
OBJ,
s=SCALE,
mx=[0.5] * 3
)
info = DM.initiate_faces(list(data['vertices']), list(data['faces']))
if info['min_edge'] < NEARL:
print('all edges are too short. try scaling up initial size.')
return
seed_selector = get_seed_selector(DM, SEEDTYPE, SEEDRATIO)
noise = random_unit_vec(DM.get_vnum(), STP*100.)
DM.position_noise(noise, scale_intensity=-1)
DM.optimize_edges(SPLIT_LIMIT, FLIP_LIMIT, FLIP_CURVATURE)
for he in range(DM.get_henum()):
DM.set_edge_intensity(he, 1.0)
show_geometry = get_show_geometry(DM, NMAX)
def geometry_generator():
seeds = seed_selector()
i = 0
k = 0
box = array((-1, -1, -1, 1, 1), 'float')
while True:
i += 1
for _ in range(SPEEDUP):
k += 1
DM.optimize_position(
REJECT,
ATTRACT,
DIMINISH,
SMOOTH,
scale_intensity=1
)
DM.optimize_edges(SPLIT_LIMIT, FLIP_LIMIT, FLIP_CURVATURE)
if len(seeds) > 0:
DM.set_vertices_intensity(seeds, 1.0)
if k%SEED_FREQ == 0:
seeds = seed_selector()
print_stats(k, DM, meta='alive v: {:d}'.format(len(seeds)))
box = show_geometry()
yield box
from view3d import View3d
v3d = View3d(
size=SCREEN_SIZE,
initial_scale=INITIAL_SCALE,
autorotate=AUTOROTATE,
save_img=SAVE_IMG
)
v3d.start(geometry_generator)
export = get_exporter(DM, fn, NMAX)
export()
def main():
from time import time
from itertools import count
from numpy import pi
from numpy.random import random
from modules.growth import spawn_curl
from modules.utils import get_exporter
from modules.helpers import env_or_default
from modules.helpers import print_stats
from differentialLine import DifferentialLine
comm = MPI.COMM_WORLD
nodes = comm.Get_size()
rank = comm.Get_rank()
if rank == 0:
size = env_or_default('SIZE', SIZE)
nmax = env_or_default('NMAX', NMAX)
one = 1.0/size
export_itt = env_or_default('EXPORT_ITT', EXPORT_ITT)
stat_itt = env_or_default('STAT_ITT', STAT_ITT)
data = {
'size': size,
'nmax': nmax,
'vmax': env_or_default('VMAX', NMAX),
'procs': env_or_default('PROCS', PROCS),
'nodes': nodes,
'prefix': env_or_default('PREFIX', PREFIX),
'ninit': env_or_default('NINIT', NINIT),
'rad': env_or_default('RAD', RAD),
'one': one,
'stp': env_or_default('STP', STP)*one,
'nearl': env_or_default('NEARL', NEARL)*one,
'farl': env_or_default('FARL', FARL)*one
}
else:
data = None
data = comm.bcast(data, root=0)
DF = DifferentialLine(
data['nmax'],
zonewidth = data['farl'],
nearl = data['nearl'],
farl = data['farl'],
procs = data['procs'],
nodes = data['nodes']
)
if rank == 0:
angles = sorted(random(data['ninit'])*pi*2)
DF.init_circle_segment(0.5, 0.5, data['rad'], angles)
t_start = time()
do_export = get_exporter(nmax, t_start)
for i in count():
DF.optimize_position(data['stp'])
if DF.get_vnum()>data['vmax']:
if rank == 0:
do_export(DF, data, i, final=True)
return
if rank == 0:
spawn_curl(DF,data['nearl'])
if i % stat_itt == 0:
print_stats(i,time()-t_start,DF)
if i % export_itt == 0:
do_export(DF, data, i)
