Skip to content

Libs/Optimize/Constraints/Constraints.h

Namespaces

Name
shapeworks
User usage reporting (telemetry)

Classes

Name
class shapeworks::Constraints

Source code

```cpp

pragma once

include

include "Constraint.h"

include "Eigen/Dense"

include "FreeFormConstraint.h"

include "Libs/Mesh/Mesh.h"

include "PlaneConstraint.h"

include "itkPoint.h"

include "vnl/vnl_cross.h"

include "vnl/vnl_inverse.h"

namespace shapeworks {

/ Constraints Roadmap * For future tinkerers, this is a guide to all the code relevant to constraints to help you navigate the optimizer and change things if desired. In simple terms, * constraints define areas of interest by getting violation regions to repel particles by attaching a mechanism to all gradient updates that push them back * if a violation does occur. "Look up quadratic penalty method" for more information. * * - Reading json constraints: From Libs/Optimize/OptimizeParameters::set_up_optimize -> Libs/Optimize/Constraints/Constraints::read * * - Initialization: The various steps in the constraints initialization are * +Libs/Optimize/Optimize::Initialize and ParticleSystem::AdvancedAllParticleSplitting initialize quadratic penalty mus. * +Libs/Optimize/Domain/{Image,Contour,Mesh}Domain determine the picking of the initial particle position to be optimized which is assured not to violate any constraint here * +Libs/Optimize/Sampler::AllocateDomainsAndNeighborhoods sets the constraints within the constraints class via Libs/Optimize/Constraints/Constraints::addSphere and addPlane, and initializes FFCs via Sampler::initialize_ffcs -> Constraints::addFreeFormConstraint * +Libs/Optimize/Sampler::initialize_ffcs also computes the gradient fields to allow distance and gradient queries * * - Optimization: For optimization, the relevant constraints code is in Libs/Optimize/GradientDescentOptimizer::StartAdaptiveGaussSeidelOptimization in Step B, * where it calls GradientDescentOptimizer::AugmentedLagrangianConstraints to tweak any updates by our constraints class corrections to not violate constraints. * See constraints class. * * - Constraints class: This class implements a quadratic penalty style optimizer for the entire ShapeWorks particle system to apply boundary constraints. * This Libs/Optimize/Constraints/ directory contains the following files * +Constraints: Contains the processing of multiple interacting constraints and computing gradients for the optimizer. Constains all constraints for a full particle system (multiple shapes/domains). * +Constraint: A general class for any type of constraint. Contains only one constraint, but has quadratic penalty equations to facilitate any single-constraint operations. * PlaneConstraint: Cutting plane constraints that use the equation of a plane to compute distances and gradients. * SphereConstraint(deprecated): It uses the equation of a sphere. * Free-form constraints: Use a signed geodesic mesh field to represent regions of interest of arbitrary shape, see below. * * - Mesh fields used for FFCs: FFCs use mesh field representations which are of class shapeworks::Mesh, located in Libs/Mesh/Mesh. Within Libs/Mesh/Mesh, the relevant functions are * +Mesh::clip: Clips by cutting plane * +Mesh::clipByField: Clips by a value field * +Mesh::getFFCValue: Allows getting the shortest signed geodesic distance of a point to any boundary * +Mesh::getFFCGradient: Allows getting the direction to the boundary. This might be the opposite direction for violated * * - The Parameter mesh_ffc_mode is exposed through Libs/Optimize/OptimizeParameters and are passed to Libs/Optimize/Optimize * +mesh_ffc_mode: when running on meshes, 0 is for mesh clipping (default) and 1 is for the quadratic penalty * * - DEPRECATED: Reading xml constraints: Constraints from xmls are read via Libs/Optimize/OptimizeParameterFile::read_cutting_planes and read_cutting_spheres, * then go through Optimize.cpp::SetCuttingPlane -> Sampler->SetCuttingPlane and Libs/Optimize/Constraints/Constraints::addPlane. Same for spheres and FFCs (both deprecated). * */

class Constraints { public: using Point3 = itk::Point;

Constraints() { active_ = false; }

~Constraints() {}

// Set constraints void addPlane(const vnl_vector &a, const vnl_vector &b, const vnl_vector &c); void addFreeFormConstraint(std::shared_ptr mesh);

// Transforms bool transformConstraints(const vnl_matrix_fixed &transform); bool transformPlanes(const vnl_matrix_fixed &transform);

// Constraint get function std::vector &getPlaneConstraints() { return planeConstraints_; } FreeFormConstraint& getFreeformConstraint();

bool isAnyViolated(const Point3 &pos);

void printAll();

std::string violationReport(const Point3 &pos, size_t index);

std::vector> violationReportData(const Point3 &pos);

// ============================ // Augmented Lagragian Fuctions // ============================

vnl_vector_fixed constraintsLagrangianGradient(const Point3 &pos, const Point3 &prepos, double C, size_t index);

void InitializeLagrangianParameters(std::vector mus);

void UpdateMus(const Point3 &pos, double C, size_t index);

bool GetActive() { return active_; } void SetActive(bool ac) { active_ = ac; }

void read(std::string filename); void write(std::string filename);

bool hasConstraints();

void clipMesh(Mesh& mesh);

private: std::vector planeConstraints_; FreeFormConstraint freeFormConstraint_;

bool active_; };

} // namespace shapeworks ```

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