main.cpp 4.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133
  1. #include <igl/avg_edge_length.h>
  2. #include <igl/barycenter.h>
  3. #include <igl/jet.h>
  4. #include <igl/shapeup.h>
  5. #include <igl/shapeup_local_projections.h>
  6. #include <igl/quad_planarity.h>
  7. #include <igl/readDMAT.h>
  8. #include <igl/readOFF.h>
  9. #include <igl/slice.h>
  10. #include <igl/viewer/Viewer.h>
  11. #include <vector>
  12. #include <cstdlib>
  13. #include "tutorial_shared_path.h"
  14. // Quad mesh loaded
  15. Eigen::MatrixXd VQC;
  16. Eigen::MatrixXi FQC;
  17. Eigen::MatrixXi E;
  18. Eigen::MatrixXi FQCtri;
  19. Eigen::MatrixXd PQC0, PQC1, PQC2, PQC3;
  20. // Euclidean-regular quad mesh
  21. Eigen::MatrixXd VQCregular;
  22. Eigen::MatrixXi FQCtriregular;
  23. Eigen::MatrixXd PQC0regular, PQC1regular, PQC2regular, PQC3regular;
  24. igl::ShapeupData su_data;
  25. // Scale for visualizing the fields
  26. double global_scale; //TODO: not used
  27. bool key_down(igl::viewer::Viewer& viewer, unsigned char key, int modifier)
  28. {
  29. using namespace std;
  30. using namespace Eigen;
  31. // Plot the original quad mesh
  32. if (key == '1')
  33. {
  34. // Draw the triangulated quad mesh
  35. viewer.data.set_mesh(VQC, FQCtri);
  36. // Assign a color to each quad that corresponds to its planarity
  37. VectorXd planarity;
  38. igl::quad_planarity( VQC, FQC, planarity);
  39. MatrixXd Ct;
  40. igl::jet(planarity, 0, 0.01, Ct);
  41. MatrixXd C(FQCtri.rows(),3);
  42. C << Ct, Ct;
  43. viewer.data.set_colors(C);
  44. // Plot a line for each edge of the quad mesh
  45. viewer.data.add_edges(PQC0, PQC1, Eigen::RowVector3d(0,0,0));
  46. viewer.data.add_edges(PQC1, PQC2, Eigen::RowVector3d(0,0,0));
  47. viewer.data.add_edges(PQC2, PQC3, Eigen::RowVector3d(0,0,0));
  48. viewer.data.add_edges(PQC3, PQC0, Eigen::RowVector3d(0,0,0));
  49. }
  50. // Plot the planarized quad mesh
  51. if (key == '2')
  52. {
  53. // Draw the triangulated quad mesh
  54. viewer.data.set_mesh(VQCregular, FQCtri);
  55. // Assign a color to each quad that corresponds to its planarity
  56. VectorXd planarity;
  57. igl::quad_planarity( VQCregular, FQC, planarity);
  58. MatrixXd Ct;
  59. igl::jet(planarity, 0, 0.01, Ct);
  60. MatrixXd C(FQCtri.rows(),3);
  61. C << Ct, Ct;
  62. viewer.data.set_colors(C);
  63. // Plot a line for each edge of the quad mesh
  64. viewer.data.add_edges(PQC0regular, PQC1regular, Eigen::RowVector3d(0,0,0));
  65. viewer.data.add_edges(PQC1regular, PQC2regular, Eigen::RowVector3d(0,0,0));
  66. viewer.data.add_edges(PQC2regular, PQC3regular, Eigen::RowVector3d(0,0,0));
  67. viewer.data.add_edges(PQC3regular, PQC0regular, Eigen::RowVector3d(0,0,0));
  68. }
  69. return false;
  70. }
  71. int main(int argc, char *argv[])
  72. {
  73. using namespace Eigen;
  74. using namespace std;
  75. // Load a quad mesh
  76. igl::readOFF(TUTORIAL_SHARED_PATH "/halftunnel.off", VQC, FQC);
  77. // Convert it in a triangle mesh
  78. FQCtri.resize(2*FQC.rows(), 3);
  79. FQCtri << FQC.col(0),FQC.col(1),FQC.col(2),
  80. FQC.col(2),FQC.col(3),FQC.col(0);
  81. igl::slice( VQC, FQC.col(0).eval(), 1, PQC0);
  82. igl::slice( VQC, FQC.col(1).eval(), 1, PQC1);
  83. igl::slice( VQC, FQC.col(2).eval(), 1, PQC2);
  84. igl::slice( VQC, FQC.col(3).eval(), 1, PQC3);
  85. // Create a planar version with ShapeUp
  86. //igl::planarize_quad_mesh(VQC, FQC, 100, 0.005, VQCregular);
  87. E.resize(FQC.size(),2);
  88. E.col(0)<<FQC.col(0),FQC.col(1),FQC.col(2),FQC.col(3);
  89. E.col(1)<<FQC.col(1),FQC.col(2),FQC.col(3),FQC.col(0);
  90. VectorXi b;
  91. VectorXi w(FQC.rows());
  92. VectorXd bc;
  93. VectorXi array_of_fours=VectorXi::Constant(FQC.rows(),4);
  94. //shapeup_precomputation(VQC, array_of_fours,FQC,E,b,w, igl::shapeup_identity_projection,su_data);
  95. //shapeup_solve(bc,VQC,su_data,VQCregular);
  96. // Convert the planarized mesh to triangles
  97. igl::slice( VQCregular, FQC.col(0).eval(), 1, PQC0regular);
  98. igl::slice( VQCregular, FQC.col(1).eval(), 1, PQC1regular);
  99. igl::slice( VQCregular, FQC.col(2).eval(), 1, PQC2regular);
  100. igl::slice( VQCregular, FQC.col(3).eval(), 1, PQC3regular);
  101. // Launch the viewer
  102. igl::viewer::Viewer viewer;
  103. key_down(viewer,'2',0);
  104. viewer.core.invert_normals = true;
  105. viewer.core.show_lines = false;
  106. viewer.callback_key_down = &key_down;
  107. viewer.launch();
  108. }