def transformColors(c, colormap): if colormap == "jet": color = igl.eigen.MatrixXd() igl.jet(p2e(c.astype(np.float64)), True, color) else: # colormap: "blue", "red", "green", "default" color = colorMap(c, colormap=colormap) color = p2e(color.astype(np.float64)) return color
def solve(viewer): global Q, B, b, bc, Aeq, Beq, Aieq, Bieq, lx, ux, Z params = igl.active_set_params() params.max_iter = 8 igl.active_set(Q, B, b, bc, Aeq, Beq, Aieq, Bieq, lx, ux, params, Z) C = igl.eigen.MatrixXd() igl.jet(Z, 0, 1, C) viewer.data.set_colors(C)
def solve(viewer): global Q,B,b,bc,Aeq,Beq,Aieq,Bieq,lx,ux,Z params = igl.active_set_params() params.max_iter = 8 igl.active_set(Q,B,b,bc,Aeq,Beq,Aieq,Bieq,lx,ux,params,Z) C = igl.eigen.MatrixXd() igl.jet(Z,0,1,C) viewer.data.set_colors(C)
def key_down(viewer, key, modifier): if key == ord('1'): # Draw the triangulated quad mesh viewer.data().set_mesh(VQC, FQCtri) # Assign a color to each quad that corresponds to its planarity planarity = igl.eigen.MatrixXd() igl.quad_planarity(VQC, FQC, planarity) Ct = igl.eigen.MatrixXd() igl.jet(planarity, 0, 0.01, Ct) C = igl.eigen.MatrixXd(FQCtri.rows(), 3) C.setTopRows(Ct.rows(), Ct) C.setBottomRows(Ct.rows(), Ct) viewer.data().set_colors(C) # Plot a line for each edge of the quad mesh viewer.data().add_edges(PQC0, PQC1, igl.eigen.MatrixXd([[0, 0, 0]])) viewer.data().add_edges(PQC1, PQC2, igl.eigen.MatrixXd([[0, 0, 0]])) viewer.data().add_edges(PQC2, PQC3, igl.eigen.MatrixXd([[0, 0, 0]])) viewer.data().add_edges(PQC3, PQC0, igl.eigen.MatrixXd([[0, 0, 0]])) elif key == ord('2'): # Draw the planar quad mesh viewer.data().set_mesh(VQCplan, FQCtri) # Assign a color to each quad that corresponds to its planarity planarity = igl.eigen.MatrixXd() igl.quad_planarity(VQCplan, FQC, planarity) Ct = igl.eigen.MatrixXd() igl.jet(planarity, 0, 0.01, Ct) C = igl.eigen.MatrixXd(FQCtri.rows(), 3) C.setTopRows(Ct.rows(), Ct) C.setBottomRows(Ct.rows(), Ct) viewer.data().set_colors(C) # Plot a line for each edge of the quad mesh viewer.data().add_edges(PQC0plan, PQC1plan, igl.eigen.MatrixXd([[0, 0, 0]])) viewer.data().add_edges(PQC1plan, PQC2plan, igl.eigen.MatrixXd([[0, 0, 0]])) viewer.data().add_edges(PQC2plan, PQC3plan, igl.eigen.MatrixXd([[0, 0, 0]])) viewer.data().add_edges(PQC3plan, PQC0plan, igl.eigen.MatrixXd([[0, 0, 0]])) else: return False return True
def key_down(viewer, key, modifier): if key < ord('1') or key > ord('8'): return False viewer.data.lines.resize(0, 9) num = key - ord('0') # Interpolate print("Interpolating " + repr(num * 2) + "-PolyVector field") b = igl.eigen.MatrixXi([[4550, 2321, 5413, 5350]]).transpose() bc = igl.eigen.MatrixXd(b.size(), num * 3) for i in range(0, b.size()): t = random_constraints(B1.row(b[i]), B2.row(b[i]), num) bc.setRow(i, t) # Interpolated PolyVector field pvf = igl.eigen.MatrixXd() igl.n_polyvector(V, F, b, bc, pvf) # Highlight in red the constrained faces C = igl.eigen.MatrixXd.Constant(F.rows(), 3, 1) for i in range(0, b.size()): C.setRow(b[i], igl.eigen.MatrixXd([[1, 0, 0]])) viewer.data.set_colors(C) for n in range(0, num): VF = igl.eigen.MatrixXd.Zero(F.rows(), 3) for i in range(0, b.size()): VF.setRow(b[i], bc.block(i, n * 3, 1, 3)) for i in range(0, samples.rows()): VF.setRow(samples[i], pvf.block(samples[i], n * 3, 1, 3)) c = VF.rowwiseNorm() C2 = igl.eigen.MatrixXd() igl.jet(c, 1, 1 + rand_factor, C2) viewer.data.add_edges(B - global_scale * VF, B + global_scale * VF, C2) return False
def key_down(viewer, key, modifier): if key < ord('1') or key > ord('8'): return False viewer.data.lines.resize(0,9) num = key - ord('0') # Interpolate print("Interpolating " + repr(num * 2) + "-PolyVector field") b = igl.eigen.MatrixXi([[4550, 2321, 5413, 5350]]).transpose() bc = igl.eigen.MatrixXd(b.size(),num*3) for i in range(0,b.size()): t = random_constraints(B1.row(b[i]),B2.row(b[i]),num) bc.setRow(i,t) # Interpolated PolyVector field pvf = igl.eigen.MatrixXd() igl.n_polyvector(V, F, b, bc, pvf) # Highlight in red the constrained faces C = igl.eigen.MatrixXd.Constant(F.rows(),3,1) for i in range(0,b.size()): C.setRow(b[i],igl.eigen.MatrixXd([[1, 0, 0]])) viewer.data.set_colors(C) for n in range(0,num): VF = igl.eigen.MatrixXd.Zero(F.rows(),3) for i in range(0,b.size()): VF.setRow(b[i],bc.block(i,n*3,1,3)) for i in range(0,samples.rows()): VF.setRow(samples[i],pvf.block(samples[i],n*3,1,3)) c = VF.rowwiseNorm() C2 = igl.eigen.MatrixXd() igl.jet(c,1,1+rand_factor,C2) viewer.data.add_edges(B - global_scale*VF, B + global_scale*VF , C2) return False
def key_down(viewer, key, modifier): if key == ord('1'): # Draw the triangulated quad mesh viewer.data.set_mesh(VQC, FQCtri) # Assign a color to each quad that corresponds to its planarity planarity = igl.eigen.MatrixXd() igl.quad_planarity(VQC, FQC, planarity) Ct = igl.eigen.MatrixXd() igl.jet(planarity, 0, 0.01, Ct) C = igl.eigen.MatrixXd(FQCtri.rows(), 3) C.setTopRows(Ct.rows(), Ct) C.setBottomRows(Ct.rows(), Ct) viewer.data.set_colors(C) # Plot a line for each edge of the quad mesh viewer.data.add_edges(PQC0, PQC1, igl.eigen.MatrixXd([[0, 0, 0]])) viewer.data.add_edges(PQC1, PQC2, igl.eigen.MatrixXd([[0, 0, 0]])) viewer.data.add_edges(PQC2, PQC3, igl.eigen.MatrixXd([[0, 0, 0]])) viewer.data.add_edges(PQC3, PQC0, igl.eigen.MatrixXd([[0, 0, 0]])) elif key == ord('2'): # Draw the planar quad mesh viewer.data.set_mesh(VQCplan, FQCtri) # Assign a color to each quad that corresponds to its planarity planarity = igl.eigen.MatrixXd() igl.quad_planarity(VQCplan, FQC, planarity) Ct = igl.eigen.MatrixXd() igl.jet(planarity, 0, 0.01, Ct) C = igl.eigen.MatrixXd(FQCtri.rows(), 3) C.setTopRows(Ct.rows(), Ct) C.setBottomRows(Ct.rows(), Ct) viewer.data.set_colors(C) # Plot a line for each edge of the quad mesh viewer.data.add_edges(PQC0plan, PQC1plan, igl.eigen.MatrixXd([[0, 0, 0]])) viewer.data.add_edges(PQC1plan, PQC2plan, igl.eigen.MatrixXd([[0, 0, 0]])) viewer.data.add_edges(PQC2plan, PQC3plan, igl.eigen.MatrixXd([[0, 0, 0]])) viewer.data.add_edges(PQC3plan, PQC0plan, igl.eigen.MatrixXd([[0, 0, 0]])) else: return False return True
def triMesh(V,F,c = np.array([0]), colormap = "default"): if (c.shape[0] != V.shape[0]): c = np.zeros((V.shape[0],3)) + 0.7 color = p2e(c.astype(np.float64)) elif ((c.shape[0] == V.shape[0]) and colormap == "jet"): color = igl.eigen.MatrixXd() igl.jet(p2e(c.astype(np.float64)), True, color) elif c.shape == V.shape: color = p2e(c.astype(np.float64)) else: # colormap: "blue", "red", "green", "default" color = colorMap(c, colormap = colormap) color = p2e(color.astype(np.float64)) viewer = igl.viewer.Viewer() viewer.data.set_mesh(p2e(V.astype(np.float64)), p2e(F.astype(np.int32))) viewer.core.show_lines = False viewer.data.set_colors(color) backColor = p2e(np.array([1,1,1,1]).astype(np.float64)) viewer.core.background_color = backColor viewer.launch()
def scatter3(p, c = np.array([0]), size = 3, colormap = "default"): if (c.shape[0] != p.shape[0]): c = np.zeros((p.shape[0],3)) + 0.7 color = p2e(c.astype(np.float64)) elif ((c.shape[0] == p.shape[0]) and colormap == "jet"): color = igl.eigen.MatrixXd() igl.jet(p2e(c.astype(np.float64)), True, color) elif c.shape == p.shape: color = p2e(c.astype(np.float64)) else: from colorMap import * # colormap: "blue", "red", "green", "default" color = colorMap(c, colormap = colormap) color = p2e(color.astype(np.float64)) p = np.ascontiguousarray(p, dtype=np.float64) backColor = p2e(np.array([1,1,1,1]).astype(np.float64)) viewer = igl.viewer.Viewer() viewer.data.set_points(p2e(p.astype(np.float64)), color) viewer.core.point_size = size viewer.core.background_color = backColor viewer.launch()
G = igl.eigen.SparseMatrixd() igl.grad(V, F, G) # Compute gradient of U GU = (G * U).MapMatrix(F.rows(), 3) # Compute gradient magnitude GU_mag = GU.rowwiseNorm() viewer = igl.glfw.Viewer() viewer.data().set_mesh(V, F) # Compute pseudocolor for original function C = igl.eigen.MatrixXd() igl.jet(U, True, C) # Or for gradient magnitude # igl.jet(GU_mag,True,C) viewer.data().set_colors(C) # Average edge length divided by average gradient (for scaling) max_size = igl.avg_edge_length(V, F) / GU_mag.mean() # Draw a black segment in direction of gradient at face barycenters BC = igl.eigen.MatrixXd() igl.barycenter(V, F, BC) black = igl.eigen.MatrixXd([[0.0, 0.0, 0.0]]) viewer.data().add_edges(BC, BC + max_size * GU, black)
# Pseudo-color based on solution global C C = igl.eigen.MatrixXd() global C_const C_const = igl.eigen.MatrixXd() global toggle toggle = True # Use same color axes min_z = min(Z.minCoeff(),Z_const.minCoeff()) max_z = max(Z.maxCoeff(),Z_const.maxCoeff()) igl.jet( Z,min_z,max_z,C); igl.jet(Z_const,min_z,max_z,C_const); # Plot the mesh with pseudocolors viewer = igl.viewer.Viewer() viewer.data.set_mesh(V, F) viewer.core.show_lines = False viewer.data.set_colors(C) def key_down(viewer,key,mode): if key == ord(' '): global toggle global C global C_const if toggle:
Z_in = solver.solve(L_in_b*bc) # slice into solution igl.slice_into(Z_in,vin,Z) # Alternative, short hand mqwf = igl.min_quad_with_fixed_data() # Linear term is 0 B = igl.eigen.MatrixXd() B.setZero(V.rows(),1); # Empty constraints Beq = igl.eigen.MatrixXd() Aeq = igl.eigen.SparseMatrixd() # Our cotmatrix is _negative_ definite, so flip sign igl.min_quad_with_fixed_precompute(-L,b,Aeq,True,mqwf) igl.min_quad_with_fixed_solve(mqwf,B,bc,Beq,Z) # Pseudo-color based on solution C = igl.eigen.MatrixXd() igl.jet(Z,True,C) # Plot the mesh with pseudocolors viewer = igl.viewer.Viewer() viewer.data.set_mesh(V, F) viewer.core.show_lines = False viewer.data.set_colors(C) viewer.launch()
Beq = igl.eigen.MatrixXd([[0]]) igl.min_quad_with_fixed_precompute(Q, b, Aeq, True, mqwf) igl.min_quad_with_fixed_solve(mqwf, B, bc, Beq, Z_const) # Global definitions for viewer # Pseudo-color based on solution C = igl.eigen.MatrixXd() C_const = igl.eigen.MatrixXd() toggle = True # Use same color axes min_z = min(Z.minCoeff(), Z_const.minCoeff()) max_z = max(Z.maxCoeff(), Z_const.maxCoeff()) igl.jet(Z, min_z, max_z, C) igl.jet(Z_const, min_z, max_z, C_const) # Plot the mesh with pseudocolors viewer = igl.viewer.Viewer() viewer.data.set_mesh(V, F) viewer.core.show_lines = False viewer.data.set_colors(C) def key_down(viewer, key, mode): if key == ord(' '): global toggle, C, C_const if toggle: viewer.data.set_colors(C)
def set_color(viewer): global selected, W C = igl.eigen.MatrixXd() igl.jet(W.col(selected), True, C) viewer.data.set_colors(C)
sys.path.insert(0, os.getcwd() + "/../") import pyigl as igl from shared import TUTORIAL_SHARED_PATH, check_dependencies dependencies = ["viewer"] check_dependencies(dependencies) V = igl.eigen.MatrixXd() F = igl.eigen.MatrixXi() C = igl.eigen.MatrixXd() # Load a mesh in OFF format igl.readOFF(TUTORIAL_SHARED_PATH + "screwdriver.off", V, F) # Plot the mesh viewer = igl.viewer.Viewer() viewer.data.set_mesh(V, F) # Use the z coordinate as a scalar field over the surface Z = V.col(2) # Compute per-vertex colors igl.jet(Z, True, C) # Add per-vertex colors viewer.data.set_colors(C) # Launch the viewer viewer.launch()
def main(): global verts_sample initial_verts, initial_faces = get_initial_verts_and_faces() numpy_base_verts = e2p(initial_verts).flatten() start = time.time() num_samples = 250 numpy_verts_sample = load_samples(num_samples) numpy_displacements_sample = numpy_verts_sample - initial_verts num_verts = len(numpy_verts_sample[0]) print(num_verts) print('Loading...') verts_sample = [p2e(m) for m in numpy_verts_sample] displacements_sample = [p2e(m) for m in numpy_displacements_sample] print("Took:", time.time() - start) use_pca = False if use_pca: ### PCA Version print("Doing PCA...") train_size = num_samples test_size = num_samples test_data = numpy_displacements_sample[:test_size] * 1.0 test_data_eigen = verts_sample[:test_size] numpy.random.shuffle(numpy_displacements_sample) # train_data = numpy_verts_sample[test_size:test_size+train_size] train_data = numpy_displacements_sample[0:train_size] pca = PCA(n_components=3) pca.fit(train_data.reshape((train_size, 3 * num_verts))) # def encode(q): # return pca.transform(numpy.array([q.flatten() - numpy_base_verts]))[0] # def decode(z): # return (numpy_base_verts + pca.inverse_transform(numpy.array([z]))[0]).reshape((num_verts, 3)) # print(numpy.equal(test_data[0].flatten().reshape((len(test_data[0]),3)), test_data[0])) # print(encode(test_data[0])) test_data_encoded = pca.transform( test_data.reshape(test_size, 3 * num_verts)) test_data_decoded = (numpy_base_verts + pca.inverse_transform(test_data_encoded)).reshape( test_size, num_verts, 3) test_data_decoded_eigen = [p2e(m) for m in test_data_decoded] ### End of PCA version else: ### Autoencoder import keras from keras.layers import Input, Dense from keras.models import Model, load_model import datetime start_time = time.time() train_size = num_samples test_size = num_samples test_data = numpy_displacements_sample[:test_size].reshape( test_size, 3 * num_verts) test_data_eigen = verts_sample[:test_size] # numpy.random.shuffle(numpy_displacements_sample) # train_data = numpy_verts_sample[test_size:test_size+train_size] train_data = numpy_displacements_sample[0:train_size].reshape( (train_size, 3 * num_verts)) mean = numpy.mean(train_data, axis=0) std = numpy.std(train_data, axis=0) mean = numpy.mean(train_data) std = numpy.std(train_data) s_min = numpy.min(train_data) s_max = numpy.max(train_data) def normalize(data): return numpy.nan_to_num((data - mean) / std) # return numpy.nan_to_num((train_data - s_min) / (s_max - s_min)) def denormalize(data): return data * std + mean # return data * (s_max - s_min) + s_min train_data = normalize(train_data) test_data = normalize(test_data) # print(train_data) # print(mean) # print(std) # exit() # this is the size of our encoded representations encoded_dim = 3 # Single autoencoder # initializer = keras.initializers.RandomUniform(minval=0.0, maxval=0.01, seed=5) # bias_initializer = initializer activation = keras.layers.advanced_activations.LeakyReLU( alpha=0.3) #'relu' input = Input(shape=(len(train_data[0]), )) output = input output = Dense(30, activation=activation)(input) output = Dense(512, activation=activation)(output) output = Dense(64, activation=activation)(output) output = Dense(encoded_dim, activation=activation, name="encoded")(output) output = Dense(64, activation=activation)(output) output = Dense(512, activation=activation)(output) output = Dense(30, activation=activation)(output) output = Dense(len(train_data[0]), activation='linear')( output ) #'linear',)(output) # First test seems to indicate no change on output with linear autoencoder = Model(input, output) optimizer = keras.optimizers.Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0) autoencoder.compile(optimizer=optimizer, loss='mean_squared_error') model_start_time = time.time() autoencoder.fit(train_data, train_data, epochs=1000, batch_size=num_samples, shuffle=True, validation_data=(test_data, test_data)) # output_path = 'trained_models/' + datetime.datetime.now().strftime("%I %M%p %B %d %Y") + '.h5' # autoencoder.save(output_path) print("Total model time: ", time.time() - model_start_time) # Display decoded_samples = denormalize(autoencoder.predict(test_data)) #decoded_samples = autoencoder.predict(test_data) * std + mean test_data_decoded = (numpy_base_verts + decoded_samples).reshape( test_size, num_verts, 3) test_data_decoded_eigen = [p2e(m) for m in test_data_decoded] ### End of Autoencoder # Error colours error = numpy.sum((test_data_decoded - numpy_verts_sample)**2, axis=2) colours = [igl.eigen.MatrixXd() for _ in range(num_samples)] for i in range(num_samples): igl.jet(p2e(error[i]), True, colours[i]) # Set up viewer = igl.viewer.Viewer() viewer.data.set_mesh(initial_verts, initial_faces) def pre_draw(viewer): global current_frame, verts_sample, show_decoded if viewer.core.is_animating: print(current_frame) print(show_decoded) if show_decoded: viewer.data.set_vertices( test_data_decoded_eigen[current_frame]) viewer.data.set_colors(colours[current_frame]) else: viewer.data.set_vertices(test_data_eigen[current_frame]) viewer.data.compute_normals() current_frame = (current_frame + 1) % test_size return False viewer.callback_pre_draw = pre_draw viewer.callback_key_down = key_down viewer.core.is_animating = False # viewer.core.camera_zoom = 2.5 viewer.core.animation_max_fps = 30.0 viewer.launch()
# Add the igl library to the modules search path import sys, os sys.path.insert(0, os.getcwd() + "/../") import pyigl as igl # Load mesh V = igl.eigen.MatrixXd() F = igl.eigen.MatrixXi() igl.readOFF("../../tutorial/shared/bumpy.off",V,F); # Compute Gaussian curvature K = igl.eigen.MatrixXd(); igl.gaussian_curvature(V,F,K); # Compute pseudocolor C = igl.eigen.MatrixXd(); igl.jet(K,True,C); # Plot the mesh with pseudocolors viewer = igl.viewer.Viewer() viewer.data.set_mesh(V, F) viewer.data.set_colors(C) viewer.launch()
import sys, os # Add the igl library to the modules search path sys.path.insert(0, os.getcwd() + "/../") import pyigl as igl from shared import TUTORIAL_SHARED_PATH, check_dependencies dependencies = ["glfw"] check_dependencies(dependencies) # Load mesh V = igl.eigen.MatrixXd() F = igl.eigen.MatrixXi() igl.readOFF(TUTORIAL_SHARED_PATH + "bumpy.off", V, F) # Compute Gaussian curvature K = igl.eigen.MatrixXd() igl.gaussian_curvature(V, F, K) # Compute pseudocolor C = igl.eigen.MatrixXd() igl.jet(K, True, C) # Plot the mesh with pseudocolors viewer = igl.glfw.Viewer() viewer.data().set_mesh(V, F) viewer.data().set_colors(C) viewer.launch()
igl.readOFF(TUTORIAL_SHARED_PATH + "decimated-knight.off", V, F) # Sort barycenters lexicographically BC = igl.eigen.MatrixXd() sorted_BC = igl.eigen.MatrixXd() igl.barycenter(V, F, BC) I = igl.eigen.MatrixXi() J = igl.eigen.MatrixXi() # sorted_BC = BC(I,:) igl.sortrows(BC, True, sorted_BC, I) # Get sorted "place" from sorted indices J.resize(I.rows(), 1) # J(I) = 1:numel(I) igl.slice_into(igl.coloni(0, I.size() - 1), I, J) # Pseudo-color based on sorted place C = igl.eigen.MatrixXd() igl.jet(J.castdouble(), True, C) # Plot the mesh with pseudocolors viewer = igl.viewer.Viewer() viewer.data.set_mesh(V, F) viewer.data.set_colors(C) viewer.launch()