Add optimizer parameter, controls, etc for geodesic remeshing option

Author: akenmorris

Libs/Optimize/Domain/MeshDomain.cpp

@@ -80,16 +80,19 @@ bool MeshDomain::IsWithinDistance(const PointType &a, int idx_a, const PointType
 }
 
 //-------------------------------------------------------------------
-void MeshDomain::SetMesh(std::shared_ptr<MeshWrapper> mesh_) {
+void MeshDomain::SetMesh(std::shared_ptr<MeshWrapper> mesh, double geodesic_remesh_percent) {
   m_FixedDomain = false;
-  mesh_wrapper_ = mesh_;
+  mesh_wrapper_ = mesh;
   sw_mesh_ = std::make_shared<Mesh>(mesh_wrapper_->GetPolydata());
 
-  auto poly_data = mesh_wrapper_->GetPolydata();
-  Mesh mesh_copy(poly_data);
-  mesh_copy.remeshPercent(50, 1.0);
-
-  geodesics_mesh_ = std::make_shared<MeshWrapper>(mesh_copy.getVTKMesh());
+  if (geodesic_remesh_percent >= 100.0) { // no remeshing
+    geodesics_mesh_ = mesh_wrapper_;
+  } else {
+    auto poly_data = mesh_wrapper_->GetPolydata();
+    Mesh mesh_copy(poly_data);
+    mesh_copy.remeshPercent(geodesic_remesh_percent, 1.0);
+    geodesics_mesh_ = std::make_shared<MeshWrapper>(mesh_copy.getVTKMesh());
+  }
 }
 
 //-------------------------------------------------------------------

Libs/Optimize/Domain/MeshDomain.h

@@ -73,7 +73,7 @@ class MeshDomain : public ParticleDomain {
     // TODO Change this to a generic delete function
   }
 
-  void SetMesh(std::shared_ptr<MeshWrapper> mesh_);
+  void SetMesh(std::shared_ptr<MeshWrapper> mesh_, double geodesic_remesh_percent);
 
   std::shared_ptr<Mesh> GetSWMesh() const { return sw_mesh_; }
 

Libs/Optimize/Optimize.cpp

@@ -1876,9 +1876,11 @@ void Optimize::AddMesh(vtkSmartPointer<vtkPolyData> poly_data) {
     // fixed domain
     m_sampler->AddMesh(nullptr);
   } else {
+    double geodesic_remesh_percent = m_geodesics_enabled ? m_geodesic_remesh_percent : 100;
+
     const auto mesh =
         std::make_shared<shapeworks::MeshWrapper>(poly_data, m_geodesics_enabled, m_geodesic_cache_size_multiplier);
-    m_sampler->AddMesh(mesh);
+    m_sampler->AddMesh(mesh, geodesic_remesh_percent);
   }
   this->m_num_shapes++;
   this->m_spacing = 0.5;
@@ -2087,6 +2089,9 @@ void Optimize::SetGeodesicsEnabled(bool is_enabled) { this->m_geodesics_enabled
 //---------------------------------------------------------------------------
 void Optimize::SetGeodesicsCacheSizeMultiplier(size_t n) { this->m_geodesic_cache_size_multiplier = n; }
 
+//---------------------------------------------------------------------------
+void Optimize::SetGeodesicsRemeshPercent(double percent) { m_geodesic_remesh_percent = percent; }
+
 //---------------------------------------------------------------------------
 vnl_vector_fixed<double, 3> Optimize::TransformPoint(int domain, vnl_vector_fixed<double, 3> input) {
   // If initial transform provided, transform cutting plane points

Libs/Optimize/Optimize.h

@@ -288,6 +288,9 @@ class Optimize {
   //! n * number_of_triangles
   void SetGeodesicsCacheSizeMultiplier(size_t n);
 
+  //! Set the remeshing percent for the mesh used for computing geodesics (0-100)
+  void SetGeodesicsRemeshPercent(double percent);
+
   OptimizationVisualizer& GetVisualizer();
   void SetShowVisualizer(bool show);
   bool GetShowVisualizer();
@@ -420,6 +423,7 @@ class Optimize {
   std::string m_python_filename;
   bool m_geodesics_enabled = false;             // geodesics disabled by default
   size_t m_geodesic_cache_size_multiplier = 0;  // 0 => MeshWrapper will use a heuristic to determine cache size
+  double m_geodesic_remesh_percent = 100.0;    // 100% by default (e.g. no remeshing)
 
   // m_spacing is used to scale the random update vector for particle splitting.
   double m_spacing = 0;

Libs/Optimize/OptimizeParameters.cpp

@@ -50,6 +50,7 @@ const std::string field_attribute_weights = "field_attribute_weights";
 const std::string use_geodesics_to_landmarks = "use_geodesics_to_landmarks";
 const std::string geodesics_to_landmarks_weight = "geodesics_to_landmarks_weight";
 const std::string particle_format = "particle_format";
+const std::string geodesic_remesh_percent = "geodesic_remesh_percent";
 }  // namespace Keys
 
 //---------------------------------------------------------------------------
@@ -90,7 +91,8 @@ OptimizeParameters::OptimizeParameters(ProjectHandle project) {
                                          Keys::geodesics_to_landmarks_weight,
                                          Keys::keep_checkpoints,
                                          Keys::use_disentangled_ssm,
-                                         Keys::particle_format};
+                                         Keys::particle_format,
+                                         Keys::geodesic_remesh_percent};
 
   // check if params_ has any unknown keys
   for (auto& param : params_.get_map()) {
@@ -412,6 +414,7 @@ bool OptimizeParameters::set_up_optimize(Optimize* optimize) {
   optimize->SetOptimizationIterations(get_optimization_iterations());
   optimize->SetGeodesicsEnabled(get_use_geodesic_distance());
   optimize->SetGeodesicsCacheSizeMultiplier(get_geodesic_cache_multiplier());
+  optimize->SetGeodesicsRemeshPercent(get_geodesic_remesh_percent());
   optimize->SetNarrowBand(get_narrow_band());
   optimize->SetOutputDir(get_output_prefix());
   optimize->SetMeshFFCMode(get_mesh_ffc_mode());
@@ -802,3 +805,11 @@ std::string OptimizeParameters::get_particle_format() { return params_.get(Keys:
 
 //---------------------------------------------------------------------------
 void OptimizeParameters::set_particle_format(std::string format) { params_.set(Keys::particle_format, format); }
+
+//---------------------------------------------------------------------------
+double OptimizeParameters::get_geodesic_remesh_percent() { return params_.get(Keys::geodesic_remesh_percent, 100); }
+
+//---------------------------------------------------------------------------
+void OptimizeParameters::set_geodesic_remesh_percent(double value) {
+  params_.set(Keys::geodesic_remesh_percent, value);
+}

Libs/Optimize/OptimizeParameters.h

@@ -129,6 +129,9 @@ class OptimizeParameters {
   std::string get_particle_format();
   void set_particle_format(std::string format);
 
+  double get_geodesic_remesh_percent();
+  void set_geodesic_remesh_percent(double value);
+
 
  private:
   std::string get_output_prefix();

Libs/Optimize/Sampler.cpp

@@ -282,12 +282,12 @@ void Sampler::ReInitialize() {
   this->m_MeanCurvatureCache->ZeroAllValues();
 }
 
-void Sampler::AddMesh(std::shared_ptr<shapeworks::MeshWrapper> mesh) {
+void Sampler::AddMesh(std::shared_ptr<shapeworks::MeshWrapper> mesh, double geodesic_remesh_percent) {
   auto domain = std::make_shared<MeshDomain>();
   m_NeighborhoodList.push_back(ParticleSurfaceNeighborhood::New());
   if (mesh) {
     this->m_Spacing = 1;
-    domain->SetMesh(mesh);
+    domain->SetMesh(mesh, geodesic_remesh_percent);
     this->m_meshes.push_back(mesh->GetPolydata());
     m_NeighborhoodList.back()->SetWeightingEnabled(!mesh->IsGeodesicsEnabled());  // disable weighting for geodesics
   }

Libs/Optimize/Sampler.h

@@ -101,7 +101,7 @@ class Sampler {
     }
   }
 
-  void AddMesh(std::shared_ptr<shapeworks::MeshWrapper> mesh);
+  void AddMesh(std::shared_ptr<shapeworks::MeshWrapper> mesh, double geodesic_remesh_percent = 100);
 
   void AddContour(vtkSmartPointer<vtkPolyData> poly_data);
 

Studio/Interface/ShapeWorksStudioApp.cpp

@@ -1740,8 +1740,6 @@ void ShapeWorksStudioApp::action_export_screenshot_triggered() {
 
 //---------------------------------------------------------------------------
 void ShapeWorksStudioApp::closeEvent(QCloseEvent* event) {
-  // close error dialog in case it is open
-  error_message_dialog_.close();
   // close the preferences window in case it is open
   preferences_window_->close();
   if (preferences_.not_saved() && ui_->action_save_project->isEnabled()) {
@@ -1769,6 +1767,8 @@ void ShapeWorksStudioApp::closeEvent(QCloseEvent* event) {
   optimize_tool_->shutdown_threads();
   deepssm_tool_->shutdown();
   SW_CLOSE_LOG();
+
+  QCoreApplication::quit();
 }
 
 //---------------------------------------------------------------------------

Studio/Optimize/OptimizeTool.cpp

@@ -33,6 +33,8 @@ OptimizeTool::OptimizeTool(Preferences& prefs, Telemetry& telemetry) : preferenc
   connect(ui_->use_normals, &QCheckBox::toggled, this, &OptimizeTool::update_ui_elements);
   connect(ui_->procrustes, &QCheckBox::toggled, this, &OptimizeTool::update_ui_elements);
   connect(ui_->multiscale, &QCheckBox::toggled, this, &OptimizeTool::update_ui_elements);
+  connect(ui_->use_geodesics_from_landmarks, &QCheckBox::toggled, this, &OptimizeTool::update_ui_elements);
+  connect(ui_->use_geodesic_distance, &QCheckBox::toggled, this, &OptimizeTool::update_ui_elements);
 
   ui_->number_of_particles->setToolTip("Number of correspondence points to generate");
   ui_->initial_relative_weighting->setToolTip("Relative weighting of correspondence term during initialization");
@@ -44,6 +46,7 @@ OptimizeTool::OptimizeTool(Preferences& prefs, Telemetry& telemetry) : preferenc
   ui_->use_geodesic_distance->setToolTip(
       "Use geodesic distances for sampling term: may be more effective for capturing thin features. "
       "Requires ~10x more time, and larger memory footprint. Only supported for mesh inputs");
+  ui_->geodesic_remesh_percent->setToolTip("Percent remesh reduction to use for geodesic distance");
   ui_->use_normals->setToolTip("Use surface normals as part of optimization");
   ui_->normals_strength->setToolTip("Strength of surface normals relative to position");
   ui_->procrustes->setToolTip("Use procrustes registration during optimization");
@@ -257,6 +260,7 @@ void OptimizeTool::load_params() {
   ui_->optimization_iterations->setText(QString::number(params.get_optimization_iterations()));
 
   ui_->use_geodesic_distance->setChecked(params.get_use_geodesic_distance());
+  ui_->geodesic_remesh_percent->setText(QString::number(params.get_geodesic_remesh_percent()));
   ui_->use_normals->setChecked(params.get_use_normals()[0]);
   ui_->normals_strength->setText(QString::number(params.get_normals_strength()));
   ui_->use_geodesics_from_landmarks->setChecked(params.get_use_geodesics_to_landmarks());
@@ -302,6 +306,7 @@ void OptimizeTool::store_params() {
   params.set_optimization_iterations(ui_->optimization_iterations->text().toDouble());
 
   params.set_use_geodesic_distance(ui_->use_geodesic_distance->isChecked());
+  params.set_geodesic_remesh_percent(ui_->geodesic_remesh_percent->text().toDouble());
   params.set_use_normals({ui_->use_normals->isChecked()});
   params.set_normals_strength(ui_->normals_strength->text().toDouble());
   params.set_use_geodesics_to_landmarks(ui_->use_geodesics_from_landmarks->isChecked());
@@ -354,6 +359,7 @@ void OptimizeTool::update_ui_elements() {
   ui_->procrustes_interval->setEnabled(ui_->procrustes->isChecked());
   ui_->multiscale_particles->setEnabled(ui_->multiscale->isChecked());
   ui_->geodesics_to_landmarks_weight->setEnabled(ui_->use_geodesics_from_landmarks->isChecked());
+  ui_->geodesic_remesh_percent->setEnabled(ui_->use_geodesic_distance->isChecked());
 }
 
 //---------------------------------------------------------------------------
@@ -446,7 +452,8 @@ void OptimizeTool::setup_domain_boxes() {
   QWidget::setTabOrder(ui_->ending_regularization, ui_->iterations_per_split);
   QWidget::setTabOrder(ui_->iterations_per_split, ui_->optimization_iterations);
   QWidget::setTabOrder(ui_->optimization_iterations, ui_->use_geodesic_distance);
-  QWidget::setTabOrder(ui_->use_geodesic_distance, ui_->use_normals);
+  QWidget::setTabOrder(ui_->use_geodesic_distance, ui_->geodesic_remesh_percent);
+  QWidget::setTabOrder(ui_->geodesic_remesh_percent, ui_->use_normals);
   QWidget::setTabOrder(ui_->use_normals, ui_->normals_strength);
   QWidget::setTabOrder(ui_->normals_strength, ui_->use_geodesics_from_landmarks);
   QWidget::setTabOrder(ui_->use_geodesics_from_landmarks, ui_->geodesics_to_landmarks_weight);