self.offset_y = y
self.offset_z = z
def finalize(self):
global n_particles, n_solid_particles
n_particles = self.n_particles
n_solid_particles = max(self.n_solid_particles, 1)
print('n_particles', n_particles)
print('n_solid', n_solid_particles)
def set_n_actuators(self, n_act):
global n_actuators
n_actuators = n_act
gui = tc.core.GUI("Differentiable MPM", tc.Vectori(1024, 1024))
canvas = gui.get_canvas()
@ti.kernel
def splat(t: ti.i32):
for i in range(n_particles):
pos = ti.cast(x[t, i] * visualize_resolution, ti.i32)
screen[pos[0], pos[1]][0] += 0.1
res = [visualize_resolution, visualize_resolution]
@ti.kernel
def copy_back_and_clear(img: np.ndarray):
def read_image(fn, linearize=False):
img = taichi.core.Array2DVector3(taichi.Vectori(0, 0),
taichi.Vector(0.0, 0.0, 0.0))
img.read(fn, linearize)
return img
gravitational_force = ti.Vector([0.0, 0.0])
for i in ti.static(range(n_gravitation)): # instead of this one
r = x[t - 1] - ti.Vector(gravitation_position[i])
len_r = ti.max(r.norm(), 1e-1)
gravitational_force += K * gravitation[t, i] / (len_r * len_r *
len_r) * r
v[t] = v[t - 1] * math.exp(-dt * damping) + dt * gravitational_force
x[t] = x[t - 1] + dt * v[t]
@ti.kernel
def compute_loss(t: ti.i32):
ti.atomic_add(loss[None], dt * (x[t] - goal[t]).norm_sqr())
gui = tc.core.GUI("Gravity", tc.Vectori(1024, 1024))
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)
def imread(fn, bgr=False):
img = taichi.core.Array2DVector3(taichi.Vectori(0, 0),
taichi.Vector(0.0, 0.0, 0.0))
img.read(fn)
return image_buffer_to_ndarray(img, bgr)[::-1]
def advance(t: ti.i32):
for i in range(n_objects):
s = math.exp(-dt * damping)
v[t, i] = s * v[t - 1, i] + v_inc[t, i] + dt * gravity * ti.Vector(
[0.0, 1.0])
x[t, i] = x[t - 1, i] + dt * v[t, i]
omega[t, i] = s * omega[t - 1, i] + omega_inc[t, i]
rotation[t, i] = rotation[t - 1, i] + dt * omega[t, i]
@ti.kernel
def compute_loss(t: ti.i32):
loss[None] = x[t, head_id][0]
gui = tc.core.GUI("Rigid Body", tc.Vectori(1024, 1024))
canvas = gui.get_canvas()
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)
x[t, i] = x[t - 1, i] + dt * v[t, i]
@ti.kernel
def compute_loss(t: ti.i32):
loss[None] = ti.sqr(x[t, target_ball][0] - goal[0]) + ti.sqr(
x[t, target_ball][1] - goal[1])
@ti.kernel
def initialize():
x[0, 0] = init_x
v[0, 0] = init_v
gui = tc.core.GUI("Billiards", tc.Vectori(1024, 1024))
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,
depth = old_x[1] - ground_height
if depth < 0 and new_v[1] < 0:
# friction projection
new_v[0] = 0
new_v[1] = 0
new_x = old_x + dt * new_v
v[t, i] = new_v
x[t, i] = new_x
@ti.kernel
def compute_loss(t: ti.i32):
ti.atomic_add(loss[None], dt * ti.sqr(target_v[t][0] - v[t, head_id][0]))
gui = tc.core.GUI("Mass Spring Robot", tc.Vectori(1024, 1024))
canvas = gui.get_canvas()
from renderer_vector import rgb_to_hex
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
for i in range(n_objects):
s = math.exp(-dt * damping)
v[t, i] = s * v[t - 1, i] + v_inc[t, i] + dt * gravity * ti.Vector(
[0.0, 1.0])
x[t, i] = x[t - 1, i] + dt * v[t, i]
omega[t, i] = s * omega[t - 1, i] + omega_inc[t, i]
rotation[t, i] = rotation[t - 1, i] + dt * omega[t, i]
@ti.kernel
def compute_loss(t: ti.i32):
loss[None] = (x[t, head_id] - goal[None]).norm()
import taichi as tc
gui = tc.core.GUI('Rigid Body Simulation', tc.Vectori(1024, 1024))
canvas = gui.get_canvas()
from renderer_vector import rgb_to_hex
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)
