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)