| 
						
						
							
								
							
						
						
					 | 
				
				 | 
				
					@ -16,9 +16,7 @@ | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					#include <igl/png/writePNG.h> | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					#include <igl/jet.h> | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					#include <igl/colormap.h> | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					#include <igl/unproject_ray.h> | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					#include <igl/ray_mesh_intersect.h> | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					#include <igl/intersect.h> | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					//#include <igl/opengl
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					#include <viewer/igl_viewer_ext.hpp> | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					#include "UISimState.hpp" | 
				
			
			
		
	
	
		
			
				
					| 
						
						
						
							
								
							
						
					 | 
				
				 | 
				
					@ -33,6 +31,7 @@ namespace ipc { | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					            bool is_modified = false; | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					            bool is_solved = false; | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					            bool is_loaded_json = false; | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					            bool is_visible_BC = false; | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					            bool mesh_visible = true; | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					            bool single_color = false; | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					            ssim::SimTargetOption::Target target_to_evaluate = ssim::SimTargetOption::U_NORM; | 
				
			
			
		
	
	
		
			
				
					| 
						
							
								
							
						
						
							
								
							
						
						
					 | 
				
				 | 
				
					@ -63,6 +62,12 @@ namespace ipc { | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                // back_color
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                m_viewer.core().background_color << 0.9f, 0.9f, 0.9f, 0.4f; | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                for (int i = 0; i < 1 + sp_StaticSim_->DirichletBCs.size() + sp_StaticSim_->NeumannBCs.size(); ++i) { | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                    viewer->append_mesh(); | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                    if (i > 0) { | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                        viewer->data(i).show_lines = false; | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                    } | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                } | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					            } | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					
 | 
				
			
			
		
	
	
		
			
				
					| 
						
						
						
							
								
							
						
					 | 
				
				 | 
				
					@ -75,7 +80,8 @@ namespace ipc { | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                const Eigen::MatrixXi &F = model.F; | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                // plot
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                viewer->data().set_mesh(V, F); | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                viewer->data(0).set_mesh(V, F); | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					//                viewer->data().add_edges(V.topRows(10),V.topRows(10).array()+10,Eigen::RowVector3d(0,0,1));
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					//                viewer->data().set_colors(Eigen::Vector3d(0.5,0.5,1));
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                m_has_scene = true; | 
				
			
			
		
	
	
		
			
				
					| 
						
							
								
							
						
						
							
								
							
						
						
					 | 
				
				 | 
				
					@ -131,6 +137,7 @@ namespace ipc { | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					//            void load_scene();
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					            void redraw_scene() override { | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                // get V, F
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                ssim::Model model = sp_StaticSim_->get_mesh(); | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                const Eigen::MatrixXd &V = model.V; | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                const Eigen::MatrixXi &F = model.F; | 
				
			
			
		
	
	
		
			
				
					| 
						
						
						
							
								
							
						
					 | 
				
				 | 
				
					@ -138,32 +145,105 @@ namespace ipc { | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                Eigen::MatrixXd target = sp_StaticSim_->EvaluateTarget(gui_ctrl_.target_to_evaluate); | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                // plot
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                viewer->data().set_mesh(V, F); | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                viewer->data(0).set_mesh(V, F); | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                viewer->data(0).show_lines = gui_ctrl_.mesh_visible; | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                if (!gui_ctrl_.mesh_visible) { | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                    viewer->data().show_overlay = false; | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                    viewer->data().show_lines = false; | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                } | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                if (!gui_ctrl_.single_color) { | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                    //  colormap
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                    Eigen::MatrixXd C; | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                    igl::jet(target, true, C); | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                    viewer->data().set_colors(C); | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                    viewer->data(0).set_colors(C); | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                } else { | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                    // single color
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                    viewer->data().set_colors(Eigen::RowVector3d(1, 0, 0)); | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                    viewer->data(0).set_colors(Eigen::RowVector3d(1, 0, 0)); | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					//                    colorbar_plugin_.draw_colorbar(igl::ColorMapType::COLOR_MAP_TYPE_JET,0,1,/*background_color=*/Eigen::Vector4f(1,1,1,0));
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                } | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					            } | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					            void load_bc() { | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                auto get_V_F_from_bd_box = [](const Eigen::Vector3d &v_min, | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                                              const Eigen::Vector3d &v_max) -> std::tuple<Eigen::MatrixXd, Eigen::MatrixXi> { | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                    Eigen::MatrixXd V(8, 3); | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                    V << -1, -1, -1, | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                            1, -1, -1, | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                            1, 1, -1, | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                            -1, 1, -1, | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                            -1, -1, 1, | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                            1, -1, 1, | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                            1, 1, 1, | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                            -1, 1, 1; | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                    // Define the faces of the cube
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                    static Eigen::MatrixXi F(12, 3); | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                    F << 0, 2, 1, | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                            0, 3, 2, | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                            4, 5, 6, | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                            4, 6, 7, | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                            3, 6, 2, | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                            3, 7, 6, | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                            0, 1, 5, | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                            0, 5, 4, | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                            5, 1, 2, | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                            5, 2, 6, | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                            4, 7, 3, | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                            5, 4, 3; | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                    Eigen::Vector3d transform = (v_max + v_min) / 2.0; | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                    Eigen::Vector3d scaled_factor = (v_max - v_min) / 2.0; | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                    V = V.array().rowwise() * scaled_factor.transpose().array(); | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                    V = V.array().rowwise() + transform.transpose().array(); | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                    return {V, F}; | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                }; | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					//                // get model size
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					//                Eigen::Vector3d model_size = sp_StaticSim_->get_mesh().V.colwise().maxCoeff() -
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					//                                             sp_StaticSim_->get_mesh().V.colwise().minCoeff();
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					//                double longest_size = model_size.maxCoeff();
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					////                spdlog::warn("longest_size: {}", longest_size);
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					//
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					//                // DBC, NBC
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					//                ssim::Model mesh_in_DBC = sp_StaticSim_->GetMeshInDBC();
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					//                // Normal
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					//                Eigen::MatrixXd N;
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					//                igl::per_vertex_normals(mesh_in_DBC.V, mesh_in_DBC.F, N);
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					////                spdlog::warn("VFN: {}, {}, {}", mesh_in_DBC.V.rows(), mesh_in_DBC.F.rows(), N.rows());
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					//
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					//
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					//                // Draw arrows toward the vertex normals
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					//                Eigen::MatrixXd starts = mesh_in_DBC.V;
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					//                Eigen::MatrixXd ends = starts.array() + 0.1 * longest_size * N.array();
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					//                viewer->data().add_edges(starts, ends, Eigen::RowVector3d(0, 0, 1));
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                for (int i = 0; i < sp_StaticSim_->DirichletBCs.size(); ++i) { | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                    auto [V, F] = get_V_F_from_bd_box(sp_StaticSim_->DirichletBCs[i].relMinBBox, | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                                                      sp_StaticSim_->DirichletBCs[i].relMaxBBox); | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                    viewer->data(i + 1).set_mesh(V, F); | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                    viewer->data(i + 1).set_colors(Eigen::RowVector3d(1, 0, 0)); | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                    viewer->data(i + 1).is_visible = gui_ctrl_.is_visible_BC; | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                } | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                for (int i = 0; i < sp_StaticSim_->NeumannBCs.size(); ++i) { | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                    auto [V, F] = get_V_F_from_bd_box(sp_StaticSim_->NeumannBCs[i].relMinBBox, | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                                                      sp_StaticSim_->NeumannBCs[i].relMaxBBox); | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                    viewer->data(i + 1 + sp_StaticSim_->DirichletBCs.size()).set_mesh(V, F); | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                    viewer->data(i + 1 + sp_StaticSim_->DirichletBCs.size()).set_colors(Eigen::RowVector3d(0, 0, 1)); | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                    viewer->data(i + 1 + sp_StaticSim_->DirichletBCs.size()).is_visible = gui_ctrl_.is_visible_BC; | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                } | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					            } | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					            bool pre_draw_loop() { | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                if (gui_ctrl_.is_loaded_json && !gui_ctrl_.is_solved && gui_ctrl_.is_init) { | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                    load_scene(); | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                    gui_ctrl_.is_init = false; | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                } | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                viewer->data(0).show_lines = gui_ctrl_.mesh_visible; | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                load_bc(); | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                if (gui_ctrl_.is_modified) { | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                    redraw_scene(); | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					                    gui_ctrl_.is_modified = false; | 
				
			
			
		
	
	
		
			
				
					| 
						
							
								
							
						
						
							
								
							
						
						
					 | 
				
				 | 
				
					@ -196,7 +276,6 @@ namespace ipc { | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					            } | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					
 | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					        private: | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					            std::shared_ptr<ssim::StaticSim> sp_StaticSim_; | 
				
			
			
		
	
		
			
				
					 | 
					 | 
				
				 | 
				
					            GUICtrl gui_ctrl_; | 
				
			
			
		
	
	
		
			
				
					| 
						
							
								
							
						
						
						
					 | 
				
				 | 
				
					
  |