Example #1
0
def pre_draw(viewer):
    global anim_t

    bc = igl.eigen.MatrixXd(b.size(), V.cols())
    for i in range(0, b.size()):
        bc.setRow(i, V.row(b[i]))
        if S[b[i]] == 0:
            r = mid[0] * 0.25
            bc[i, 0] = bc[i, 0] + r * sin(0.5 * anim_t * 2. * pi)
            bc[i, 1] = bc[i, 1] - r + r * cos(pi + 0.5 * anim_t * 2. * pi)
        elif S[b[i]] == 1:
            r = mid[1] * 0.15
            bc[i, 1] = bc[i, 1] + r + r * cos(pi + 0.15 * anim_t * 2. * pi)
            bc[i, 2] = bc[i, 2] - r * sin(0.15 * anim_t * 2. * pi)
        elif S[b[i]] == 2:
            r = mid[1] * 0.15
            bc[i, 2] = bc[i, 2] + r + r * cos(pi + 0.35 * anim_t * 2. * pi)
            bc[i, 0] = bc[i, 0] + r * sin(0.35 * anim_t * 2. * pi)

    igl.arap_solve(bc, arap_data, U)
    viewer.data.set_vertices(U)
    viewer.data.compute_normals()

    if viewer.core.is_animating:
        anim_t += anim_t_dir

    return False
def pre_draw(viewer):
    global anim_t

    bc = igl.eigen.MatrixXd(b.size(),V.cols())
    for i in range(0,b.size()):
        bc.setRow(i,V.row(b[i]))
        if S[b[i]] == 0:
            r = mid[0]*0.25
            bc[i,0] = bc[i,0] + r*sin(0.5*anim_t*2.*pi)
            bc[i,1] = bc[i,1] - r+r*cos(pi+0.5*anim_t*2.*pi)
        elif S[b[i]] == 1:
            r = mid[1]*0.15
            bc[i,1] = bc[i,1] + r + r*cos(pi + 0.15*anim_t*2.*pi)
            bc[i,2] = bc[i,2] - r*sin(0.15*anim_t*2.*pi)
        elif S[b[i]] == 2:
            r = mid[1]*0.15
            bc[i,2] = bc[i,2] + r+r*cos(pi+0.35*anim_t*2.*pi)
            bc[i,0] = bc[i,0] + r*sin(0.35*anim_t*2.*pi)

    igl.arap_solve(bc,arap_data,U)
    viewer.data.set_vertices(U)
    viewer.data.compute_normals()

    if viewer.core.is_animating:
        anim_t += anim_t_dir

    return False
# Add dynamic regularization to avoid to specify boundary conditions
arap_data = igl.ARAPData()
arap_data.with_dynamics = True
b  = igl.eigen.MatrixXi.Zero(0,0);
bc = igl.eigen.MatrixXd.Zero(0,0);

# Initialize ARAP
arap_data.max_iter = 100

# 2 means that we're going to *solve* in 2d
igl.arap_precomputation(V,F,2,b,arap_data)

# Solve arap using the harmonic map as initial guess
V_uv = igl.eigen.MatrixXd(initial_guess) # important, make a copy of it!

igl.arap_solve(bc,arap_data,V_uv)

# Scale UV to make the texture more clear
V_uv *= 20

# Plot the mesh
viewer = igl.viewer.Viewer()
viewer.data.set_mesh(V, F)
viewer.data.set_uv(V_uv)
viewer.callback_key_down = key_down

# Disable wireframe
viewer.core.show_lines = False

# Draw checkerboard texture
viewer.core.show_texture = True