Libs/Optimize/GradientDescentOptimizer.h

Namespaces

Name
shapeworks User usage reporting (telemetry)

Classes

	Name
class	shapeworks::GradientDescentOptimizer Optimizes particle system positions using gradient descent.

Source code

```cpp

pragma once

include

include

include "EarlyStoppingConfig.h"

include "Libs/Optimize/Domain/ImageDomainWithGradients.h"

include "Libs/Optimize/Function/EarlyStop/EarlyStopping.h"

include "Libs/Optimize/Function/VectorFunction.h"

include "ParticleSystem.h"

namespace shapeworks {

class GradientDescentOptimizer { public: static constexpr unsigned int Dimension = 3;

using VectorType = VectorFunction::VectorType;

using PointType = ParticleSystem::PointType;

void start_optimization() { start_adaptive_gauss_seidel_optimization(); } void start_adaptive_gauss_seidel_optimization(); void set_early_stopping_config(const EarlyStoppingConfig& config); void initialize_early_stopping_score_function(const ParticleSystem* p);

void augmented_lagrangian_constraints(VectorType& gradient, const PointType& pt, const size_t& dom, const double& maximum_update_allowed, size_t index);

void stop_optimization() { stop_optimization_ = true; }

void abort_processing() { stop_optimization_ = true; abort_processing_ = true; }

unsigned int get_number_of_iterations() const { return number_of_iterations_; }

void set_number_of_iterations(unsigned int val) { number_of_iterations_ = val; }

void set_verbosity(unsigned int val) { verbosity_ = val; }

unsigned int get_verbosity() const { return verbosity_; }

double get_time_step() const { return time_step_; }

void set_time_step(double val) { time_step_ = val; }

unsigned int get_maximum_number_of_iterations() const { return max_iterations_; }

void set_maximum_number_of_iterations(unsigned int val) { max_iterations_ = val; }

double get_tolerance() const { return tolerance_; }

void set_tolerance(double val) { tolerance_ = val; }

ParticleSystem* get_particle_system() { return particle_system_.GetPointer(); }

const ParticleSystem* get_particle_system() const { return particle_system_.GetPointer(); }

void set_particle_system(ParticleSystem* val) { particle_system_ = val; }

std::shared_ptr get_gradient_function() { return gradient_function_; }

std::shared_ptr get_gradient_function() const { return gradient_function_; }

void set_gradient_function(std::shared_ptr val) { gradient_function_ = val; }

void set_initialization_mode(bool b) { initialization_mode_ = b; }

void set_check_iterations(size_t si) { check_iterations_ = si; }

void set_initialization_start_scaling_factor(double si) { init_start_scaling_factor_ = si; }

void set_iteration_callback(std::function callback) { iteration_callback_ = callback; }

std::function get_iteration_callback() const { return iteration_callback_; }

GradientDescentOptimizer();

~GradientDescentOptimizer() = default;

private: GradientDescentOptimizer(const GradientDescentOptimizer&) = delete;

GradientDescentOptimizer& operator=(const GradientDescentOptimizer&) = delete;

void reset_time_step_vectors();

ParticleSystem::Pointer particle_system_; std::shared_ptr gradient_function_; bool stop_optimization_ = false; bool abort_processing_ = false; unsigned int number_of_iterations_ = 0; unsigned int max_iterations_ = 0; double tolerance_ = 0.0; double time_step_ = 1.0; std::vector> time_steps_; unsigned int verbosity_ = 0; EarlyStopping early_stopping_; bool early_stopping_enabled_ = false; bool early_stopping_score_ready_ = false;

// Adaptive Initialization variables bool initialization_mode_ = false; size_t check_iterations_ = 50; double init_start_scaling_factor_ = 0.0;

// Iteration callback std::function iteration_callback_; };

} // namespace shapeworks ```

---

Updated on 2026-03-31 at 16:02:11 +0000