shapeworks::CorrespondenceFunction

Correspondence term.

#include <CorrespondenceFunction.h>

Inherits from shapeworks::VectorFunction

Public Types

	Name
typedef shapeworks::ShapeMatrix	ShapeDataType
typedef shapeworks::ShapeGradientMatrix	ShapeGradientType
typedef ShapeDataType::DataType	DataType
typedef VectorFunction::VectorType	VectorType
typedef ParticleSystem::PointType	PointType
typedef vnl_vector< DataType >	vnl_vector_type
typedef vnl_matrix< DataType >	vnl_matrix_type

Public Functions

	Name
std::shared_ptr< CorrespondenceFunction >	New() Factory method for creating instances.
void	SetShapeData(ShapeDataType * s) Access the shape matrix.
ShapeDataType *	GetShapeData()
const ShapeDataType *	GetShapeData() const
void	SetShapeGradient(ShapeGradientType * s) Access the shape gradient matrix.
ShapeGradientType *	GetShapeGradient()
const ShapeGradientType *	GetShapeGradient() const
virtual VectorType	evaluate(unsigned int , unsigned int , const ParticleSystem * , double & , double & ) const
virtual VectorType	evaluate(unsigned int , unsigned int , const ParticleSystem * , double & maxtimestep) const
virtual double	energy(unsigned int a, unsigned int b, const ParticleSystem * c) const
virtual void	before_iteration()
virtual void	after_iteration()
void	SetMinimumVarianceDecay(double initial_value, double final_value, double time_period)
void	SetMinimumVariance(double d)
double	GetMinimumVariance() const
bool	GetHoldMinimumVariance() const
void	SetHoldMinimumVariance(bool b)
void	SetRecomputeCovarianceInterval(int i)
int	GetRecomputeCovarianceInterval() const
void	SetAttributeScales(const std::vector< double > & s)
void	SetDomainsPerShape(int i)
int	GetDomainsPerShape() const
void	SetAttributesPerDomain(const std::vector< int > & i)
void	UseMeanenergy()
void	UseEntropy()
void	SetXYZ(int i, bool val)
void	SetNormals(int i, bool val)
void	PrecomputeForFixedDomains(const ParticleSystem * ps) Precompute data for fixed domains to accelerate optimization.
bool	HasPrecomputedFixedDomains() const Check if precomputed fixed domain data is available.
void	ClearPrecomputedFixedDomains() Clear precomputed fixed domain data (e.g., if fixed domains change).
void	RequestPrecomputeForFixedDomains() Request lazy precomputation on first iteration. The actual precomputation will happen on the first call to ComputeUpdates() when the shape data is guaranteed to be populated.
bool	CheckForNans(vnl_matrix_type mat)
virtual std::shared_ptr< VectorFunction >	clone() override
	CorrespondenceFunction()
	~CorrespondenceFunction() override =default

Protected Functions

	Name
	CorrespondenceFunction(const CorrespondenceFunction & ) =delete
CorrespondenceFunction &	operator=(const CorrespondenceFunction & ) =delete
virtual void	ComputeUpdates(const ParticleSystem * c)

Public Attributes

	Name
constexpr static int	VDimension
constexpr static unsigned int	Dimension

Protected Attributes

	Name
ShapeDataType::Pointer	m_ShapeData
ShapeGradientType::Pointer	m_ShapeGradient
std::shared_ptr< vnl_matrix_type >	m_PointsUpdate
double	m_MinimumVariance
double	m_MinimumEigenValue
bool	m_HoldMinimumVariance
int	m_RecomputeCovarianceInterval
double	m_MinimumVarianceDecayConstant
int	m_Counter
std::vector< double >	m_AttributeScales
int	m_DomainsPerShape
std::vector< int >	m_AttributesPerDomain
double	m_CurrentEnergy
bool	m_UseMeanEnergy
std::vector< bool >	m_UseXYZ
std::vector< bool >	m_UseNormals
std::shared_ptr< vnl_matrix_type >	m_points_mean
int	num_dims
int	num_samples
bool	m_NeedsPrecomputation
bool	m_HasPrecomputedFixedDomains
int	m_PrecomputedNumFixedSamples
int	m_PrecomputedNumDims
std::shared_ptr< vnl_matrix_type >	m_FixedMean
std::shared_ptr< vnl_matrix_type >	m_FixedY
std::shared_ptr< vnl_matrix_type >	m_FixedPinvMat
std::shared_ptr< vnl_matrix_type >	m_FixedGradientBasis
std::shared_ptr< vnl_matrix_type >	m_FixedU
std::shared_ptr< vnl_diag_matrix< double > >	m_FixedW
std::vector< int >	m_FixedDomainIndices

Additional inherited members

Public Functions inherited from shapeworks::VectorFunction

	Name
virtual void	reset_buffers() May be called by the solver class.
virtual void	before_evaluate(unsigned int , unsigned int , const ParticleSystem * )
virtual void	set_particle_system(ParticleSystem * p) Some subclasses may require a pointer to the particle system and its domain number.
virtual ParticleSystem *	get_particle_system() const
virtual void	set_domain_number(unsigned int i)
virtual int	get_domain_number() const
virtual double	get_relative_energy_scaling() const
virtual void	set_relative_energy_scaling(double r)
virtual	~VectorFunction() =default Virtual destructor for proper cleanup of derived classes.

Protected Functions inherited from shapeworks::VectorFunction

	Name
	VectorFunction()
	VectorFunction(const VectorFunction & ) =delete

Protected Attributes inherited from shapeworks::VectorFunction

	Name
ParticleSystem *	particle_system_
unsigned int	domain_number_

Public Types Documentation

typedef ShapeDataType

cpp typedef shapeworks::ShapeMatrix shapeworks::CorrespondenceFunction::ShapeDataType;

typedef ShapeGradientType

cpp typedef shapeworks::ShapeGradientMatrix shapeworks::CorrespondenceFunction::ShapeGradientType;

typedef DataType

cpp typedef ShapeDataType::DataType shapeworks::CorrespondenceFunction::DataType;

typedef VectorType

cpp typedef VectorFunction::VectorType shapeworks::CorrespondenceFunction::VectorType;

Vector & Point types.

typedef PointType

cpp typedef ParticleSystem::PointType shapeworks::CorrespondenceFunction::PointType;

typedef vnl_vector_type

cpp typedef vnl_vector<DataType> shapeworks::CorrespondenceFunction::vnl_vector_type;

typedef vnl_matrix_type

cpp typedef vnl_matrix<DataType> shapeworks::CorrespondenceFunction::vnl_matrix_type;

Public Functions Documentation

function New

cpp static inline std::shared_ptr< CorrespondenceFunction > New()

Factory method for creating instances.

function SetShapeData

cpp inline void SetShapeData( ShapeDataType * s )

Access the shape matrix.

function GetShapeData

cpp inline ShapeDataType * GetShapeData()

function GetShapeData

cpp inline const ShapeDataType * GetShapeData() const

function SetShapeGradient

cpp inline void SetShapeGradient( ShapeGradientType * s )

Access the shape gradient matrix.

function GetShapeGradient

cpp inline ShapeGradientType * GetShapeGradient()

function GetShapeGradient

cpp inline const ShapeGradientType * GetShapeGradient() const

function evaluate

cpp virtual VectorType evaluate( unsigned int , unsigned int , const ParticleSystem * , double & , double & ) const

Reimplements: shapeworks::VectorFunction::evaluate

The first argument is a pointer to the particle system. The second argument is the index of the domain within that particle system. The third argument is the index of the particle location within the given domain.

function evaluate

cpp inline virtual VectorType evaluate( unsigned int , unsigned int , const ParticleSystem * , double & maxtimestep ) const

Reimplements: shapeworks::VectorFunction::evaluate

The first argument is a pointer to the particle system. The second argument is the index of the domain within that particle system. The third argument is the index of the particle location within the given domain.

function energy

cpp inline virtual double energy( unsigned int a, unsigned int b, const ParticleSystem * c ) const

Reimplements: shapeworks::VectorFunction::energy

function before_iteration

cpp inline virtual void before_iteration()

Reimplements: shapeworks::VectorFunction::before_iteration

Called before each iteration of a solver.

function after_iteration

cpp inline virtual void after_iteration()

Reimplements: shapeworks::VectorFunction::after_iteration

Called after each iteration of the solver.

function SetMinimumVarianceDecay

cpp inline void SetMinimumVarianceDecay( double initial_value, double final_value, double time_period )

function SetMinimumVariance

cpp inline void SetMinimumVariance( double d )

function GetMinimumVariance

cpp inline double GetMinimumVariance() const

function GetHoldMinimumVariance

cpp inline bool GetHoldMinimumVariance() const

function SetHoldMinimumVariance

cpp inline void SetHoldMinimumVariance( bool b )

function SetRecomputeCovarianceInterval

cpp inline void SetRecomputeCovarianceInterval( int i )

function GetRecomputeCovarianceInterval

cpp inline int GetRecomputeCovarianceInterval() const

function SetAttributeScales

cpp inline void SetAttributeScales( const std::vector< double > & s )

function SetDomainsPerShape

cpp inline void SetDomainsPerShape( int i )

Set/Get the number of domains per shape.

function GetDomainsPerShape

cpp inline int GetDomainsPerShape() const

function SetAttributesPerDomain

cpp inline void SetAttributesPerDomain( const std::vector< int > & i )

function UseMeanenergy

cpp inline void UseMeanenergy()

function UseEntropy

cpp inline void UseEntropy()

function SetXYZ

cpp inline void SetXYZ( int i, bool val )

function SetNormals

cpp inline void SetNormals( int i, bool val )

function PrecomputeForFixedDomains

cpp void PrecomputeForFixedDomains( const ParticleSystem * ps )

Precompute data for fixed domains to accelerate optimization.

Parameters:

ps The particle system containing both fixed and non-fixed domains

When optimizing with fixed domains (e.g., adding 1 new shape to 99 existing), this method precomputes the covariance structure from the fixed shapes. Subsequent calls to ComputeUpdates() will use this precomputed data, avoiding expensive recomputation of the SVD and related matrices.

function HasPrecomputedFixedDomains

cpp inline bool HasPrecomputedFixedDomains() const

Check if precomputed fixed domain data is available.

function ClearPrecomputedFixedDomains

cpp void ClearPrecomputedFixedDomains()

Clear precomputed fixed domain data (e.g., if fixed domains change).

function RequestPrecomputeForFixedDomains

cpp inline void RequestPrecomputeForFixedDomains()

Request lazy precomputation on first iteration. The actual precomputation will happen on the first call to ComputeUpdates() when the shape data is guaranteed to be populated.

function CheckForNans

cpp inline bool CheckForNans( vnl_matrix_type mat )

function clone

cpp inline virtual std::shared_ptr< VectorFunction > clone() override

Reimplements: shapeworks::VectorFunction::clone

function CorrespondenceFunction

cpp inline CorrespondenceFunction()

function ~CorrespondenceFunction

cpp ~CorrespondenceFunction() override =default

Protected Functions Documentation

function CorrespondenceFunction

cpp CorrespondenceFunction( const CorrespondenceFunction & ) =delete

function operator=

cpp CorrespondenceFunction & operator=( const CorrespondenceFunction & ) =delete

function ComputeUpdates

cpp virtual void ComputeUpdates( const ParticleSystem * c )

Public Attributes Documentation

variable VDimension

cpp static constexpr static int VDimension = 3;

variable Dimension

cpp static constexpr static unsigned int Dimension = VDimension;

Protected Attributes Documentation

variable m_ShapeData

cpp ShapeDataType::Pointer m_ShapeData;

variable m_ShapeGradient

cpp ShapeGradientType::Pointer m_ShapeGradient;

variable m_PointsUpdate

cpp std::shared_ptr< vnl_matrix_type > m_PointsUpdate;

variable m_MinimumVariance

cpp double m_MinimumVariance;

variable m_MinimumEigenValue

cpp double m_MinimumEigenValue;

variable m_HoldMinimumVariance

cpp bool m_HoldMinimumVariance;

variable m_RecomputeCovarianceInterval

cpp int m_RecomputeCovarianceInterval;

variable m_MinimumVarianceDecayConstant

cpp double m_MinimumVarianceDecayConstant;

variable m_Counter

cpp int m_Counter;

variable m_AttributeScales

cpp std::vector< double > m_AttributeScales;

variable m_DomainsPerShape

cpp int m_DomainsPerShape;

variable m_AttributesPerDomain

cpp std::vector< int > m_AttributesPerDomain;

variable m_CurrentEnergy

cpp double m_CurrentEnergy;

variable m_UseMeanEnergy

cpp bool m_UseMeanEnergy;

variable m_UseXYZ

cpp std::vector< bool > m_UseXYZ;

variable m_UseNormals

cpp std::vector< bool > m_UseNormals;

variable m_points_mean

cpp std::shared_ptr< vnl_matrix_type > m_points_mean;

variable num_dims

cpp int num_dims;

variable num_samples

cpp int num_samples;

variable m_NeedsPrecomputation

cpp bool m_NeedsPrecomputation = false;

variable m_HasPrecomputedFixedDomains

cpp bool m_HasPrecomputedFixedDomains = false;

variable m_PrecomputedNumFixedSamples

cpp int m_PrecomputedNumFixedSamples = 0;

variable m_PrecomputedNumDims

cpp int m_PrecomputedNumDims = 0;

variable m_FixedMean

cpp std::shared_ptr< vnl_matrix_type > m_FixedMean;

variable m_FixedY

cpp std::shared_ptr< vnl_matrix_type > m_FixedY;

variable m_FixedPinvMat

cpp std::shared_ptr< vnl_matrix_type > m_FixedPinvMat;

variable m_FixedGradientBasis

cpp std::shared_ptr< vnl_matrix_type > m_FixedGradientBasis;

variable m_FixedU

cpp std::shared_ptr< vnl_matrix_type > m_FixedU;

variable m_FixedW

cpp std::shared_ptr< vnl_diag_matrix< double > > m_FixedW;

variable m_FixedDomainIndices

cpp std::vector< int > m_FixedDomainIndices;

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