def forward(output=None, visualize=True):
if random.random() > 0.5:
goal[None] = [0.9, 0.2]
else:
goal[None] = [0.1, 0.2]
goal[None] = [0.9, 0.2]
interval = vis_interval
if output:
interval = output_vis_interval
os.makedirs('mass_spring/{}/'.format(output), exist_ok=True)
total_steps = steps if not output else steps * 2
for t in range(1, total_steps):
compute_center(t - 1)
nn1(t - 1)
nn2(t - 1)
apply_spring_force(t - 1)
if use_toi:
advance_toi(t)
else:
advance_no_toi(t)
if (t + 1) % interval == 0 and visualize:
canvas.clear(0xFFFFFF)
canvas.path(tc.vec(0, ground_height), tc.vec(1, ground_height)).color(0x0).radius(3).finish()
def circle(x, y, color):
canvas.circle(tc.vec(x, y)).color(rgb_to_hex(color)).radius(7).finish()
for i in range(n_springs):
def get_pt(x):
return tc.vec(x[0], x[1])
a = act[t - 1, i] * 0.5
r = 2
if spring_actuation[i] == 0:
a = 0
c = 0x222222
else:
r = 4
c = rgb_to_hex((0.5 + a, 0.5 - abs(a), 0.5 - a))
canvas.path(get_pt(x[t, spring_anchor_a[i]]),
get_pt(x[t, spring_anchor_b[i]])).color(c).radius(r).finish()
for i in range(n_objects):
color = (0.4, 0.6, 0.6)
if i == head_id:
color = (0.8, 0.2, 0.3)
circle(x[t, i][0], x[t, i][1], color)
# circle(goal[None][0], goal[None][1], (0.6, 0.2, 0.2))
gui.update()
if output:
gui.screenshot('mass_spring/{}/{:04d}.png'.format(output, t))
loss[None] = 0
compute_loss(steps - 1)
def forward(visualize=False, output=None):
interval = vis_interval
if output:
interval = output_vis_interval
os.makedirs('gravity/{}/'.format(output), exist_ok=True)
canvas = gui.get_canvas()
for t in range(1, steps):
nn1(t)
nn2(t)
advance(t)
compute_loss(t)
if (t + 1) % interval == 0 and visualize:
canvas.clear(0x3C733F)
for i in range(n_gravitation):
r = (gravitation[t, i] + 1) * 30
canvas.circle(tc.vec(*gravitation_position[i])).radius(
r).color(0xccaa44).finish()
canvas.circle(tc.vec(x[t][0],
x[t][1])).radius(30).color(0xF20530).finish()
canvas.circle(tc.vec(
goal[t][0], goal[t][1])).radius(10).color(0x3344cc).finish()
gui.update()
if output:
gui.screenshot('gravity/{}/{:04d}.png'.format(output, t))
def forward(output=None, visualize=True):
interval = vis_interval
total_steps = steps
if output:
interval = output_vis_interval
# os.makedirs('rigid_body/{}/'.format(output), exist_ok=True)
total_steps *= 2
for t in range(1, total_steps):
if use_toi:
advance_toi(t)
else:
advance_no_toi(t)
if (t + 1) % interval == 0 and visualize:
canvas.clear(0xFFFFFF)
canvas.circle(tc.vec(x[t, 0][0],
x[t, 0][1])).radius(10).color(0x0).finish()
offset = 0.003
canvas.path(tc.vec(0.05, ground_height - offset),
tc.vec(0.95, ground_height -
offset)).radius(2).color(0xAAAAAA).finish()
if output:
gui.screenshot('rigid_body/{}/{:04d}.png'.format(output, t))
gui.update()
loss[None] = 0
compute_loss(steps - 1)
def forward(output=None, visualize=True, dy=0, i=0):
x[0, 0] = [0.8, 0.4 + dy]
v[0, 0] = [-2, -2]
interval = vis_interval
total_steps = steps
if output:
os.makedirs('rigid_body_toi/{}/'.format(output), exist_ok=True)
canvas.clear(0xFFFFFF)
for t in range(1, total_steps):
if use_toi:
advance_toi(t)
else:
advance_no_toi(t)
if (t + 1) % interval == 0 and visualize:
color = 0x010101 * min(
255, max(0, int((1 - t * dt / total_t) * 0.7 * 255)))
canvas.circle(tc.vec(x[t, 0][0],
x[t, 0][1])).radius(80).color(color).finish()
offset = 0.077
canvas.path(tc.vec(0.05, ground_height - offset),
tc.vec(0.95, ground_height -
offset)).radius(2).color(0x000000).finish()
if output:
gui.screenshot('rigid_body_toi/{}/{:04d}.png'.format(output, i))
gui.update()
def text(self, content, pos, font_size=15, color=0xFFFFFF):
import taichi as ti
# TODO: refactor Canvas::text
font_size = float(font_size)
pos = ti.vec(*pos)
r, g, b = (color >> 16) & 0xff, (color >> 8) & 0xff, color & 0xff
color = ti.vec(r / 255, g / 255, b / 255, 1)
self.canvas.text(content, pos, font_size, color)
def render(gui, canvas):
canvas.clear(bg_color)
for pos in positions.to_numpy():
for j in range(dim):
pos[j] *= screen_to_world_ratio / screen_res[j]
canvas.circle(ti.vec(pos[0], pos[1])).radius(
particle_radius).color(particle_color).finish()
canvas.rect(ti.vec(0, 0), ti.vec(
board_states[None][0] / boundary[0], 1.0)).radius(1.5).color(boundary_color).close().finish()
gui.update()
def render(gui):
canvas = gui.canvas
canvas.clear(bg_color)
pos_np = positions.to_numpy()
for pos in pos_np:
for j in range(dim):
pos[j] *= screen_to_world_ratio / screen_res[j]
gui.circles(pos_np, radius=particle_radius, color=particle_color)
canvas.rect(ti.vec(
0, 0), ti.vec(board_states[None][0] / boundary[0],
1.0)).radius(1.5).color(boundary_color).close().finish()
gui.show()
def main():
for i in range(n_particle_x):
for j in range(n_particle_y):
t = mesh(i, j)
x[t] = [0.1 + i * dx * 0.5, 0.7 + j * dx * 0.5]
v[t] = [0, -1]
# build mesh
for i in range(n_particle_x - 1):
for j in range(n_particle_y - 1):
# element id
eid = (i * (n_particle_y - 1) + j) * 2
vertices[eid, 0] = mesh(i, j)
vertices[eid, 1] = mesh(i + 1, j)
vertices[eid, 2] = mesh(i, j + 1)
eid = (i * (n_particle_y - 1) + j) * 2 + 1
vertices[eid, 0] = mesh(i, j + 1)
vertices[eid, 1] = mesh(i + 1, j + 1)
vertices[eid, 2] = mesh(i + 1, j)
compute_rest_T()
os.makedirs('tmp', exist_ok=True)
for f in range(600):
canvas.clear(0x112F41)
for s in range(50):
clear_grid()
# Note that we are now differentiating the total energy w.r.t. the particle position.
# Recall that F = - \partial (total_energy) / \partial x
with ti.Tape(total_energy):
# Do the forward computation of total energy and backward propagation for x.grad, which is later used in p2g
compute_total_energy()
# It's OK not to use the computed total_energy at all, since we only need x.grad
p2g()
grid_op()
g2p()
canvas.circle(ti.vec(0.5, 0.5)).radius(70).color(0x068587).finish()
# TODO: why is visualization so slow?
for i in range(n_elements):
for j in range(3):
a, b = vertices[i, j], vertices[i, (j + 1) % 3]
canvas.path(ti.vec(x[a][0], x[a][1]), ti.vec(
x[b][0], x[b][1])).radius(1).color(0x4FB99F).finish()
for i in range(n_particles):
canvas.circle(ti.vec(x[i][0],
x[i][1])).radius(2).color(0xF2B134).finish()
gui.update()
gui.screenshot("tmp/{:04d}.png".format(f))
ti.profiler_print()
def forward(output=None, visualize=True):
initialize_properties()
interval = vis_interval
total_steps = steps
if output:
interval = output_vis_interval
os.makedirs('rigid_body/{}/'.format(output), exist_ok=True)
total_steps *= 2
for t in range(1, total_steps):
collide(t - 1)
advance(t)
if (t + 1) % interval == 0 and visualize:
canvas.clear(0xFFFFFF)
for i in range(n_objects):
points = []
for k in range(4):
offset_scale = [[-1, -1], [1, -1], [1, 1], [-1, 1]][k]
rot = rotation[t, i]
rot_matrix = np.array([[math.cos(rot), -math.sin(rot)],
[math.sin(rot),
math.cos(rot)]])
pos = np.array([x[t, i][0], x[t, i][1]
]) + offset_scale * rot_matrix @ np.array(
[halfsize[i][0], halfsize[i][1]])
points.append((pos[0], pos[1]))
for k in range(4):
canvas.path(
ti.vec(*points[k]),
ti.vec(*points[(k + 1) %
4])).radius(2).color(0x0).finish()
offset = 0.003
canvas.path(ti.vec(0.05, ground_height - offset),
ti.vec(0.95, ground_height -
offset)).radius(2).color(0xAAAAAA).finish()
if output:
gui.screenshot('rigid_body/{}/{:04d}.png'.format(output, t))
gui.update()
loss[None] = 0
compute_loss(steps - 1)
def visualize(s, folder):
canvas.clear(0xFFFFFF)
vec = tc.vec
for i in range(n_particles):
color = 0x111111
aid = actuator_id[i]
if aid != -1:
act = actuation[s - 1, aid]
color = rgb_to_hex((0.5 - act, 0.5 - abs(act), 0.5 + act))
canvas.circle(vec(x[s, i][0], x[s, i][1])).radius(2).color(color).finish()
canvas.path(tc.vec(0.05, 0.02), tc.vec(0.95, 0.02)).radius(3).color(0x0).finish()
gui.update()
os.makedirs(folder, exist_ok=True)
gui.screenshot('{}/{:04d}.png'.format(folder, s))
def main():
for i in range(n_particle_x):
for j in range(n_particle_y):
t = mesh(i, j)
x[t] = [0.1 + i * dx * 0.5, 0.7 + j * dx * 0.5]
v[t] = [0, -1]
# build mesh
for i in range(n_particle_x - 1):
for j in range(n_particle_y - 1):
# element id
eid = (i * (n_particle_y - 1) + j) * 2
vertices[eid, 0] = mesh(i, j)
vertices[eid, 1] = mesh(i + 1, j)
vertices[eid, 2] = mesh(i, j + 1)
eid = (i * (n_particle_y - 1) + j) * 2 + 1
vertices[eid, 0] = mesh(i, j + 1)
vertices[eid, 1] = mesh(i + 1, j + 1)
vertices[eid, 2] = mesh(i + 1, j)
compute_rest_T()
os.makedirs('tmp', exist_ok=True)
for f in range(600):
canvas.clear(0x112F41)
for s in range(50):
clear_grid()
with ti.Tape(total_energy):
compute_total_energy()
p2g()
grid_op()
g2p()
canvas.circle(ti.vec(0.5, 0.5)).radius(70).color(0x068587).finish()
# TODO: why is visualization so slow?
for i in range(n_elements):
for j in range(3):
a, b = vertices[i, j], vertices[i, (j + 1) % 3]
canvas.path(ti.vec(x[a][0], x[a][1]), ti.vec(
x[b][0], x[b][1])).radius(1).color(0x4FB99F).finish()
for i in range(n_particles):
canvas.circle(ti.vec(x[i][0],
x[i][1])).radius(2).color(0xF2B134).finish()
gui.update()
gui.screenshot("tmp/{:04d}.png".format(f))
ti.profiler_print()
def main():
for i in range(n_particles):
x[i] = [random.random() * 0.4 + 0.2, random.random() * 0.4 + 0.2]
v[i] = [0, -1]
J[i] = 1
for f in range(200):
canvas.clear(0x112F41)
t = time.time()
for s in range(150):
clear_grid()
p2g()
grid_op()
g2p()
print('{:.1f} ms per frame'.format(1000 * (time.time() - t)))
pos = np.empty((2 * n_particles), dtype=np.float32)
copy_x(pos)
for i in range(n_particles):
# canvas.circle(ti.vec(x[i][0], x[i][1])).radius(1).color(0x068587).finish()
# Python binding here is still a bit slow...
canvas.circle(ti.vec(pos[i * 2],
pos[i * 2 +
1])).radius(1).color(0x068587).finish()
gui.update()
ti.profiler_print()
def animate(total_steps: int, output=None):
"""Animate a the policy controlling the robot.
* `total_steps` controls the number of time steps to animate for. This is
necessary since the final animation is run for more time steps than in
training.
* `output` controls whether or not frames of the animation are screenshotted
and dumped to a results directory.
"""
if output:
os.makedirs("{}/{}/".format(RESULTS_DIR, output))
for t in range(1, total_steps):
canvas.clear(0xFFFFFF)
canvas.path(ti.vec(0, ground_height),
ti.vec(1, ground_height)).color(0x0).radius(3).finish()
def circle(x, y, color):
canvas.circle(ti.vec(x, y)).color(
ti.rgb_to_hex(color)).radius(7).finish()
for i in range(n_springs):
def get_pt(x):
return ti.vec(x[0], x[1])
a = act[t - 1, i] * 0.5
r = 2
if spring_actuation[i] == 0:
a = 0
c = 0x222222
else:
r = 4
c = ti.rgb_to_hex((0.5 + a, 0.5 - abs(a), 0.5 - a))
canvas.path(
get_pt(x[t, spring_anchor_a[i]]),
get_pt(x[t, spring_anchor_b[i]])).color(c).radius(r).finish()
for i in range(n_objects):
color = (0.4, 0.6, 0.6)
if i == head_id:
color = (0.8, 0.2, 0.3)
circle(x[t, i][0], x[t, i][1], color)
gui.update()
if output:
gui.screenshot("{}/{}/{:04d}.png".format(RESULTS_DIR, output, t))
def forward(visualize=False, output=None):
initialize()
interval = vis_interval
if output:
interval = output_vis_interval
os.makedirs('billiards/{}/'.format(output), exist_ok=True)
count = 0
for i in range(billiard_layers):
for j in range(i + 1):
count += 1
x[0, count] = [
i * 2 * radius + 0.5, j * 2 * radius + 0.5 - i * radius * 0.7
]
pixel_radius = int(radius * 1024) + 1
canvas = gui.get_canvas()
for t in range(1, steps):
collide(t - 1)
advance(t)
if (t + 1) % interval == 0 and visualize:
canvas.clear(0x3C733F)
canvas.circle(tc.vec(goal[0], goal[1])).radius(
pixel_radius // 2).color(0x00000).finish()
for i in range(n_balls):
if i == 0:
color = 0xCCCCCC
elif i == n_balls - 1:
color = 0x3344cc
else:
color = 0xF20530
canvas.circle(tc.vec(
x[t, i][0],
x[t, i][1])).radius(pixel_radius).color(color).finish()
gui.update()
if output:
gui.screenshot('billiards/{}/{:04d}.png'.format(output, t))
compute_loss(steps - 1)
def main():
for i in range(n_particles):
x[i] = [random.random() * 0.4 + 0.2, random.random() * 0.4 + 0.2]
v[i] = [0, -1]
J[i] = 1
for f in range(200):
canvas.clear(0x112F41)
for s in range(150):
clear_grid()
p2g()
grid_op()
g2p()
# TODO: why is visualization so slow?
for i in range(n_particles):
canvas.circle(ti.vec(x[i][0],
x[i][1])).radius(1).color(0x068587).finish()
gui.update()
ti.profiler_print()
def circle(self, pos, color, radius=1):
import taichi as ti
self.canvas.circle(ti.vec(
pos[0], pos[1])).radius(radius).color(color).finish()
g_v = grid_v[base + ti.Vector([i, j])]
weight = w[i][0] * w[j][1]
new_v += weight * g_v
new_C += 4 * weight * ti.outer_product(g_v, dpos) * inv_dx
v[p] = new_v
x[p] += dt * v[p]
J[p] *= 1 + dt * new_C.trace()
C[p] = new_C
gui = ti.core.GUI("MPM88", ti.veci(512, 512))
canvas = gui.get_canvas()
for i in range(n_particles):
x[i] = [random.random() * 0.4 + 0.2, random.random() * 0.4 + 0.2]
v[i] = [0, -1]
J[i] = 1
for frame in range(200):
for s in range(50):
grid_v.fill([0, 0])
grid_m.fill(0)
substep()
canvas.clear(0x112F41)
pos = x.to_numpy(as_vector=True)
for i in range(n_particles):
canvas.circle(ti.vec(pos[i, 0],
pos[i, 1])).radius(1.5).color(0x068587).finish()
gui.update()
def circle(x, y, color):
canvas.circle(tc.vec(x, y)).color(
rgb_to_hex(color)).radius(7).finish()
x = ti.Vector(dim, dt=ti.f32, shape=n_particles)
for i in range(n_particles):
x[i] = x_logo[i]
@ti.func
def complexMul(a: ti.f32, b: ti.f32, c: ti.f32, d: ti.f32): # 复数乘法，用于旋转
return [a * c - b * d, b * c + a * d]
@ti.kernel
def substep():
for p in x:
x[p] = x[p] - 0.5
x[p] = complexMul(x[p][0], x[p][1], spin[0], spin[1])
x[p] = x[p] + 0.5
gui = ti.core.GUI("SYSU_CG_COURSE", ti.veci(512, 512))
canvas = gui.get_canvas()
for frame in range(19260817):
substep()
canvas.clear(0)
pos = x.to_numpy(as_vector=True)
for i in range(n_particles):
canvas.circle(ti.vec(pos[i, 0],
pos[i, 1])).radius(7).color(87 * 256 +
33).finish() # 中大绿
gui.update()
def imread(fn, bgr=False):
img = taichi.core.Array2DVector3(
taichi.veci(0, 0), taichi.vec(0.0, 0.0, 0.0))
img.read(fn)
return image_buffer_to_ndarray(img, bgr)[::-1]
def forward(output=None, visualize=True):
initialize_properties()
interval = vis_interval
total_steps = steps
if output:
print(output)
interval = output_vis_interval
os.makedirs('rigid_body/{}/'.format(output), exist_ok=True)
total_steps *= 2
goal[None] = [0.9, 0.15]
for t in range(1, total_steps):
nn1(t - 1)
nn2(t - 1)
collide(t - 1)
apply_spring_force(t - 1)
if use_toi:
advance_toi(t)
else:
advance_no_toi(t)
if (t + 1) % interval == 0 and visualize:
canvas.clear(0xFFFFFF)
for i in range(n_objects):
points = []
for k in range(4):
offset_scale = [[-1, -1], [1, -1], [1, 1], [-1, 1]][k]
rot = rotation[t, i]
rot_matrix = np.array([[math.cos(rot), -math.sin(rot)],
[math.sin(rot),
math.cos(rot)]])
pos = np.array([x[t, i][0], x[t, i][1]
]) + offset_scale * rot_matrix @ np.array(
[halfsize[i][0], halfsize[i][1]])
points.append((pos[0], pos[1]))
for k in range(4):
canvas.path(tc.vec(*points[k]), tc.vec(
*points[(k + 1) % 4])).color(0x0).radius(2).finish()
for i in range(n_springs):
def get_world_loc(i, offset):
rot = rotation[t, i]
rot_matrix = np.array([[math.cos(rot), -math.sin(rot)],
[math.sin(rot),
math.cos(rot)]])
pos = np.array([[x[t, i][0]], [
x[t, i][1]
]]) + rot_matrix @ np.array([[offset[0]], [offset[1]]])
return pos
pt1 = get_world_loc(spring_anchor_a[i], spring_offset_a[i])
pt2 = get_world_loc(spring_anchor_b[i], spring_offset_b[i])
color = 0xFF2233
if spring_actuation[i] != 0 and spring_length[i] != -1:
a = actuation[t - 1, i] * 0.5
color = rgb_to_hex((0.5 + a, 0.5 - abs(a), 0.5 - a))
if spring_length[i] == -1:
canvas.path(
tc.vec(*pt1),
tc.vec(*pt2)).color(0x000000).radius(9).finish()
canvas.path(tc.vec(*pt1),
tc.vec(*pt2)).color(color).radius(7).finish()
else:
canvas.path(
tc.vec(*pt1),
tc.vec(*pt2)).color(0x000000).radius(7).finish()
canvas.path(tc.vec(*pt1),
tc.vec(*pt2)).color(color).radius(5).finish()
canvas.path(tc.vec(0.05, ground_height - 5e-3),
tc.vec(0.95, ground_height -
5e-3)).color(0x0).radius(5).finish()
gui.update()
if output:
gui.screenshot('rigid_body/{}/{:04d}.png'.format(output, t))
loss[None] = 0
compute_loss(steps - 1)
def read_image(fn, linearize=False):
img = taichi.core.Array2DVector3(
taichi.veci(0, 0), taichi.vec(0.0, 0.0, 0.0))
img.read(fn, linearize)
return img
def get_pt(x):
return tc.vec(x[0], x[1])
def line(self, begin, end, radius, color): import taichi as ti self.canvas.path(ti.vec(*begin), ti.vec(*end)).radius(radius).color(color).finish()
g_v = grid_v[base + ti.Vector([i, j])]
weight = w[i][0] * w[j][1]
new_v += weight * g_v
new_C += 4 * weight * ti.outer_product(g_v, dpos) * inv_dx
v[p] = new_v
x[p] += dt * v[p]
J[p] *= 1 + dt * new_C.trace()
C[p] = new_C
gui = ti.core.GUI("MPM99", ti.veci(512, 512))
canvas = gui.get_canvas()
for i in range(n_particles):
x[i] = [random.random() * 0.4 + 0.2, random.random() * 0.4 + 0.2]
v[i] = [0, -1]
J[i] = 1
for frame in range(200):
for s in range(50):
grid_v.fill([0, 0])
grid_m.fill(0)
substep()
canvas.clear(0x112F41)
pos = x.to_numpy(as_vector=True)
for i in range(n_particles):
canvas.circle(ti.vec(pos[i, 0], pos[i, 1])).radius(
1.5).color(0x068587).finish()
gui.update()
def circles(self, pos, color, radius=1):
import taichi as ti
for i in range(len(pos)):
self.canvas.circle(ti.vec(
pos[i, 0], pos[i, 1])).radius(radius).color(color[i]).finish()
