def save_ply(frame1):
series_prefix = "bunny.ply"
num_vertices = n_particles
np_pos = np.reshape(x.to_numpy(), (num_vertices, 3))
writer = ti.PLYWriter(num_vertices=num_vertices)
writer.add_vertex_pos(np_pos[:, 0], np_pos[:, 1], np_pos[:, 2])
writer.export_frame_ascii(frame1, series_prefix)
def visualize(self, simulator):
vertices = simulator.total_mk[None]
writer = ti.PLYWriter(num_vertices = vertices)
pos = simulator.p_x.to_numpy()
writer.add_vertex_pos(pos[0 : vertices, 0], pos[0 : vertices, 1], pos[0 : vertices, 2])
writer.export_frame_ascii(self.frame, "water.ply")
self.frame += 1
def save_ply(self, frame):
series_prefix = "smoke.ply"
num_vertices = self.resx * self.resy * self.resz
self.place_pos()
np_pos = np.reshape(self._pos.to_numpy(), (num_vertices, 3))
np_dens = np.reshape(self._dens_buffer.to_numpy(), (num_vertices, 1))
writer = ti.PLYWriter(num_vertices=num_vertices)
writer.add_vertex_pos(np_pos[:, 0], np_pos[:, 1], np_pos[:, 2])
writer.add_vertex_alpha(np_dens)
writer.export_frame_ascii(frame, series_prefix)
def output_PLY(self, frame_id):
np_px = self.px.to_numpy().copy()
np_px = np.reshape(np_px, (-1, 3))
np_px = np_px[np.where((np_px[:, 0] != 0.0) | (np_px[:, 1] != 0.0)
| (np_px[:, 2] != 0.0))]
nparticles = np_px.shape[0]
writer = ti.PLYWriter(num_vertices=nparticles)
writer.add_vertex_pos(np_px[:, 0], np_px[:, 1], np_px[:, 2])
writer.export_frame_ascii(frame_id, self.series_prefix)
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()
J[i] = 1
def T(a):
if dim == 2:
return a
phi, theta = np.radians(28), np.radians(32)
a = a - 0.5
x, y, z = a[:, 0], a[:, 1], a[:, 2]
c, s = np.cos(phi), np.sin(phi)
C, S = np.cos(theta), np.sin(theta)
x, z = x * c + z * s, z * c - x * s
u, v = x, y * C + z * S
return np.array([u, v]).swapaxes(0, 1) + 0.5
init()
gui = ti.GUI('MPM3D', background_color=0x112F41)
while gui.running and not gui.get_event(gui.ESCAPE):
for s in range(steps):
substep()
pos = x.to_numpy()
if export_file:
writer = ti.PLYWriter(num_vertices=n_particles)
writer.add_vertex_pos(pos[:, 0], pos[:, 1], pos[:, 2])
writer.export_frame(gui.frame, export_file)
gui.circles(T(pos), radius=1.5, color=0x66ccff)
gui.show()
import taichi as ti
# A 2D grid with quad faces
# y
# |
# z---/
# x
# 19---15---11---07---03
# | | | | |
# 18---14---10---06---02
# | | | | |
# 17---13---19---05---01
# | | | | |
# 16---12---08---04---00
writer = ti.PLYWriter(num_vertices=20, num_faces=12, face_type="quad")
# For the vertices, the only required channel is the position,
# which can be added by passing 3 np.array x, y, z into the following function.
x = np.zeros(20)
y = np.array(list(np.arange(0, 4)) * 5)
z = np.repeat(np.arange(5), 4)
writer.add_vertex_pos(x, y, z)
# For faces (if any), the only required channel is the list of vertex indices that each face contains.
indices = np.array([0, 1, 5, 4] * 12) + np.repeat(
np.array(list(np.arange(0, 3)) * 4) + 4 * np.repeat(np.arange(4), 3), 4)
writer.add_faces(indices)
# Add custome vertex channel, the input should include a key, a supported datatype and, the data np.array
for i in range(150):
for k in range(150):
for j in range(wall_size):
add_particle([i * dx + 0.05 * 5e-3, (15 - 0.05) * 5e-3 - j * dx, k * dx + 0.05 * 5e-3], [0, 0, 0], 0)
'''
'''
@ti.kernel
def gank():
block_size = 8
for i in range(block_size):
for j in range(block_size):
add_particle([i * dx + 4.0 * 5e-3, j * dx + 12.5 * 5e-3], [0, -350.0 * 5e-3], 0)
'''
initialize()
frame = 0
while frame < 114514:
for s in range(50):
substep()
writer = ti.PLYWriter(num_vertices=num_particles[None])
np_pos = x.to_numpy()
# print(num_particles[None])
print(np_pos[0])
writer.add_vertex_pos(np_pos[:, 0], np_pos[:, 1], np_pos[:, 2])
writer.export_frame_ascii(frame, "water.ply")
print('frame: ', frame)
frame += 1
def write_ply(self, fn, frame):
p_info = self.particle_info()
p_pos = p_info['position']
p_mat = p_info['material']
p_null = np.array([[np.nan]])
arr_water = np.where(p_mat == 0)
arr_elast = np.where(p_mat == 1)
arr_snow = np.where(p_mat == 2)
arr_sand = np.where(p_mat == 3)
series_prefix_0 = fn + "/water.ply"
series_prefix_1 = fn + "/elast.ply"
series_prefix_2 = fn + "/snow.ply"
series_prefix_3 = fn + "/sand.ply"
print(
"num_particles：{0}，elast：{1}，water：{2}，snow：{3}，sand：{4}，out_particles：{5}"
.format(
self.n_particles, len(arr_elast[0]), len(arr_water[0]),
len(arr_snow[0]), len(arr_sand[0]),
len(arr_water[0]) + len(arr_elast[0]) + len(arr_snow[0]) +
len(arr_sand[0])),
end='\n')
if len(arr_water[0]) > 0:
min_water = np.min(arr_water)
max_water = np.max(arr_water)
writer_0 = ti.PLYWriter(num_vertices=max_water - min_water + 1)
writer_0.add_vertex_pos(p_pos[min_water:max_water + 1, 0],
p_pos[min_water:max_water + 1, 1],
p_pos[min_water:max_water + 1, 2])
writer_0.export_frame_ascii(frame, series_prefix_0)
else:
writer_0 = ti.PLYWriter(num_vertices=1)
writer_0.add_vertex_pos(p_null[:, 0], p_null[:, 0], p_null[:, 0])
writer_0.export_frame_ascii(frame, series_prefix_0)
if len(arr_elast[0]) > 0:
min_elast = np.min(arr_elast)
max_elast = np.max(arr_elast)
writer_1 = ti.PLYWriter(num_vertices=max_elast - min_elast + 1)
writer_1.add_vertex_pos(p_pos[min_elast:max_elast + 1, 0],
p_pos[min_elast:max_elast + 1, 1],
p_pos[min_elast:max_elast + 1, 2])
writer_1.export_frame_ascii(frame, series_prefix_1)
else:
writer_1 = ti.PLYWriter(num_vertices=1)
writer_1.add_vertex_pos(p_null[:, 0], p_null[:, 0], p_null[:, 0])
writer_1.export_frame_ascii(frame, series_prefix_1)
if len(arr_snow[0]) > 0:
min_snow = np.min(arr_snow)
max_snow = np.max(arr_snow)
writer_2 = ti.PLYWriter(num_vertices=max_snow - min_snow + 1)
writer_2.add_vertex_pos(p_pos[min_snow:max_snow + 1,
0], p_pos[min_snow:max_snow + 1, 1],
p_pos[min_snow:max_snow + 1, 2])
writer_2.export_frame_ascii(frame, series_prefix_2)
else:
writer_2 = ti.PLYWriter(num_vertices=1)
writer_2.add_vertex_pos(p_null[:, 0], p_null[:, 0], p_null[:, 0])
writer_2.export_frame_ascii(frame, series_prefix_2)
if len(arr_sand[0]) > 0:
min_sand = np.min(arr_sand)
max_sand = np.max(arr_sand)
writer_3 = ti.PLYWriter(num_vertices=max_sand - min_sand + 1)
writer_3.add_vertex_pos(p_pos[min_sand:max_sand + 1,
0], p_pos[min_sand:max_sand + 1, 1],
p_pos[min_sand:max_sand + 1, 2])
writer_3.export_frame_ascii(frame, series_prefix_3)
else:
writer_3 = ti.PLYWriter(num_vertices=1)
writer_3.add_vertex_pos(p_null[:, 0], p_null[:, 0], p_null[:, 0])
writer_3.export_frame_ascii(frame, series_prefix_3)
@ti.kernel
def move_particles():
for i, j, k in pos:
pos[i, j, k] += ti.Vector([0.1, 0.1, 0.1])
@ti.kernel
def fill_rgba():
for i, j, k in rgba:
rgba[i, j, k] = ti.Vector(
[ti.random(), ti.random(),
ti.random(), ti.random()])
place_pos()
series_prefix = "example.ply"
for frame in range(10):
move_particles()
fill_rgba()
# now adding each channel only supports passing individual np.array
# so converting into np.ndarray, reshape
# remember to use a temp var to store so you dont have to convert back
np_pos = np.reshape(pos.to_numpy(), (num_vertices, 3))
np_rgba = np.reshape(rgba.to_numpy(), (num_vertices, 4))
# create a PLYWriter
writer = ti.PLYWriter(num_vertices=num_vertices)
writer.add_vertex_pos(np_pos[:, 0], np_pos[:, 1], np_pos[:, 2])
writer.add_vertex_rgba(np_rgba[:, 0], np_rgba[:, 1], np_rgba[:, 2],
np_rgba[:, 3])
writer.export_frame(frame, series_prefix)
