def test_image_resize_sum(resx, resy, comp, scale):
shape = (resx, resy)
if comp != 1:
shape = shape + (comp, )
old_img = np.random.rand(*shape).astype(np.float32)
if resx == resy:
new_img = ti.imresize(old_img, resx * scale)
else:
new_img = ti.imresize(old_img, resx * scale, resy * scale)
assert np.sum(old_img) * scale**2 == ti._testing.approx(np.sum(new_img))
def main(self):
gui = ti.GUI('Marching cube')
while gui.running and not gui.get_event(gui.ESCAPE):
if self.use_sparse:
ti.deactivate_all_snodes()
else:
self.m.fill(0)
self.touch(*gui.get_cursor_pos())
ret_len = self.march()
ret = self.r.to_numpy()[:ret_len] / self.N
if self.dim == 2:
#gui.set_image(ti.imresize(self.m, *gui.res))
self.compute_grad()
gui.set_image(ti.imresize(self.g, *gui.res) * 0.5 + 0.5)
gui.lines(ret[:, 0], ret[:, 1], color=0xff66cc, radius=1.5)
else:
gui.triangles(ret[:, 0, 0:2],
ret[:, 1, 0:2],
ret[:, 2, 0:2],
color=0xffcc66)
gui.lines(ret[:, 0, 0:2],
ret[:, 1, 0:2],
color=0xff66cc,
radius=0.5)
gui.lines(ret[:, 1, 0:2],
ret[:, 2, 0:2],
color=0xff66cc,
radius=0.5)
gui.lines(ret[:, 2, 0:2],
ret[:, 0, 0:2],
color=0xff66cc,
radius=0.5)
gui.text(f'Press space to save mesh to PLY ({len(ret)} faces)',
(0, 1))
if gui.is_pressed(gui.SPACE):
num = ret.shape[0]
writer = ti.PLYWriter(num_vertices=num * 3, num_faces=num)
vertices = ret.reshape(num * 3, 3) * 2 - 1
writer.add_vertex_pos(vertices[:, 0], vertices[:, 1],
vertices[:, 2])
indices = np.arange(0, num * 3)
writer.add_faces(indices)
writer.export('mciso_output.ply')
print('Mesh saved to mciso_output.ply')
gui.show()
def main(self):
gui = ti.GUI('Marching cube')
while gui.running and not gui.get_event(gui.ESCAPE):
self.clear()
self.touch(*gui.get_cursor_pos())
self.march()
Jts = self.Jts.to_numpy()[:self.Js_n[None]]
vs = (self.vs.to_numpy()[:self.vs_n[None]] + 0.5) / self.N
ret = vs[Jts]
if self.dim == 2:
#gui.set_image(ti.imresize(self.m, *gui.res))
gui.set_image(ti.imresize(self.g, *gui.res) + 0.5)
gui.lines(ret[:, 0], ret[:, 1], color=0xff66cc, radius=1.25)
#gui.circles(vs, color=0xffff33, radius=1.5)
else:
#gui.triangles(ret[:, 0, 0:2],
#ret[:, 1, 0:2],
#ret[:, 2, 0:2],
#color=0xffcc66)
gui.lines(ret[:, 0, 0:2],
ret[:, 1, 0:2],
color=0xff66cc,
radius=0.5)
gui.lines(ret[:, 1, 0:2],
ret[:, 2, 0:2],
color=0xff66cc,
radius=0.5)
gui.lines(ret[:, 2, 0:2],
ret[:, 0, 0:2],
color=0xff66cc,
radius=0.5)
gui.text(
f'Press space to save mesh to PLY ({len(vs)} verts, {len(Jts)} faces)',
(0, 1))
if gui.is_pressed(gui.SPACE):
writer = ti.PLYWriter(num_vertices=len(vs),
num_faces=len(Jts))
writer.add_vertex_pos(vs[:, 0], vs[:, 1], vs[:, 2])
writer.add_faces(Jts)
writer.export('mciso_output.ply')
print('Mesh saved to mciso_output.ply')
gui.show()
def main(self, export_result=None):
gui = ti.GUI('Marching cube')
while gui.running and not gui.get_event(gui.ESCAPE):
if self.use_sparse:
ti.root.deactivate_all()
else:
self.m.fill(0)
self.touch(*gui.get_cursor_pos())
ret_len = self.march()
ret = self.r.to_numpy()[:ret_len] / self.N
if self.dim == 2:
gui.set_image(ti.imresize(self.m, *gui.res))
gui.lines(ret[:, 0], ret[:, 1], color=0xff66cc, radius=1.5)
else:
gui.triangles(ret[:, 0, 0:2],
ret[:, 1, 0:2],
ret[:, 2, 0:2],
color=0xffcc66)
gui.lines(ret[:, 0, 0:2],
ret[:, 1, 0:2],
color=0xff66cc,
radius=0.5)
gui.lines(ret[:, 1, 0:2],
ret[:, 2, 0:2],
color=0xff66cc,
radius=0.5)
gui.lines(ret[:, 2, 0:2],
ret[:, 0, 0:2],
color=0xff66cc,
radius=0.5)
if export_result is not None:
num = ret.shape[0]
writer = ti.PLYWriter(num_vertices=num * 3, num_faces=num)
vertices = ret.reshape(num * 3, 3) * 2 - 1
writer.add_vertex_pos(vertices[:, 0], vertices[:, 1],
vertices[:, 2])
indices = np.arange(0, num * 3)
writer.add_faces(indices)
writer.export_frame(gui.frame, export_result)
gui.show()
for i, j in ti.ndrange(N - 1, N - 1):
id = 0
if m[i, j] > 1: id |= 1
if m[i + 1, j] > 1: id |= 2
if m[i, j + 1] > 1: id |= 4
if m[i + 1, j + 1] > 1: id |= 8
E = [ti.Vector(_) + .5 for _ in [(.5, 0), (0, .5), (1, .5), (.5, 1)]]
for k in range(2):
if et[id, k][0] == -1:
break
n = ti.atomic_add(r_n, 1)
for l in ti.static(range(2)):
e = et[id, k][l]
r[n, l] = ti.Vector([i, j]) + list_subscript(E, e)
return r_n
gui = ti.GUI('Marching rect')
while gui.running and not gui.get_event(gui.ESCAPE):
touch(*gui.get_cursor_pos())
ret_len = march()
ret = r.to_numpy()[:ret_len] / N
gui.set_image(ti.imresize(m, *gui.res))
gui.lines(ret[:, 0], ret[:, 1], color=0xff66cc, radius=1.5)
gui.show()
ret += vel[x, y, z].norm() * 4
cnt += 1
img[x, y] = ret / cnt
#'''
initialize()
gui = ti.GUI('LBM', (1024, 256))
while gui.running and not gui.get_event(gui.ESCAPE):
t0 = time.time()
for subs in range(28):
substep()
render()
ti.sync()
print(time.time() - t0)
gui.set_image(ti.imresize(img, *gui.res))
gui.show()
'''
initialize()
for frame in range(24 * 24):
print('compute for', frame); t0 = time.time()
for subs in range(28):
#print('substep', subs)
substep()
print('compute time', time.time() - t0)
#grid = np.empty(res + (4,), dtype=np.float32)
#grid[..., 3] = rho.to_numpy()
#grid[..., :3] = vel.to_numpy()
gui = ti.GUI('Game of Life', (img_size, img_size))
gui.fps_limit = 15
print('[Hint] Press `r` to reset')
print('[Hint] Press SPACE to pause')
print('[Hint] Click LMB, RMB and drag to add alive / dead cells')
init()
paused = False
while gui.running:
for e in gui.get_events(gui.PRESS, gui.MOTION):
if e.key == gui.ESCAPE:
gui.running = False
elif e.key == gui.SPACE:
paused = not paused
elif e.key == 'r':
alive.fill(0)
if gui.is_pressed(gui.LMB, gui.RMB):
mx, my = gui.get_cursor_pos()
alive[int(mx * n), int(my * n)] = gui.is_pressed(gui.LMB)
paused = True
if not paused:
run()
gui.set_image(ti.imresize(alive, img_size).astype(np.uint8) * 255)
gui.show()
if pixels[i + 1, j] > level: case_id |= 2
if pixels[i + 1, j + 1] > level: case_id |= 4
if pixels[i, j + 1] > level: case_id |= 8
for k in range(2):
if edge_table[case_id, k][0] == -1:
break
n = ti.atomic_add(n_edges, 1)
for l in ti.static(range(2)):
vertex_id = edge_table[case_id, k][l]
edge_coords[n, l] = ti.Vector([i, j
]) + get_vertex(vertex_id) + 0.5
return n_edges
level = 0.2
gui = ti.GUI('Marching squares')
while gui.running and not gui.get_event(gui.ESCAPE):
touch(*gui.get_cursor_pos(), 0.05)
n_edges = march(level)
edge_coords_np = edge_coords.to_numpy()[:n_edges] / N
gui.set_image(ti.imresize(pixels, *gui.res) / level)
gui.lines(edge_coords_np[:, 0],
edge_coords_np[:, 1],
color=0xff66cc,
radius=1.5)
gui.show()
