itkObjectToObjectOptimizerBase.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright NumFOCUS
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
#ifndef itkObjectToObjectOptimizerBase_h
#define itkObjectToObjectOptimizerBase_h
 
#include "ITKOptimizersv4Export.h"
 
#include "itkOptimizerParameters.h"
#include "itkOptimizerParameterScalesEstimator.h"
#include "itkObjectToObjectMetricBase.h"
#include "itkIntTypes.h"
 
namespace itk
{
class ObjectToObjectOptimizerBaseTemplateEnums
{
public:
  enum class StopConditionObjectToObjectOptimizer : uint8_t
  {
    MAXIMUM_NUMBER_OF_ITERATIONS,
    COSTFUNCTION_ERROR,
    UPDATE_PARAMETERS_ERROR,
    STEP_TOO_SMALL,
    CONVERGENCE_CHECKER_PASSED,
    GRADIENT_MAGNITUDE_TOLEARANCE,
    OTHER_ERROR
  };
};
// Define how to print enumeration
using StopConditionObjectToObjectOptimizerEnum =
  ObjectToObjectOptimizerBaseTemplateEnums::StopConditionObjectToObjectOptimizer;
extern ITKOptimizersv4_EXPORT std::ostream &
                              operator<<(std::ostream &                                                                       out,
           const ObjectToObjectOptimizerBaseTemplateEnums::StopConditionObjectToObjectOptimizer value);
 
template <typename TInternalComputationValueType = double>
class ITK_TEMPLATE_EXPORT ObjectToObjectOptimizerBaseTemplate : public Object
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(ObjectToObjectOptimizerBaseTemplate);
 
  using Self = ObjectToObjectOptimizerBaseTemplate;
  using Superclass = Object;
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;
 
  itkTypeMacro(ObjectToObjectOptimizerBaseTemplate, Object);
 
  using ScalesType = OptimizerParameters<TInternalComputationValueType>;
  using ScalesEstimatorType = OptimizerParameterScalesEstimatorTemplate<TInternalComputationValueType>;
 
  using ParametersType = OptimizerParameters<TInternalComputationValueType>;
 
  using MetricType = ObjectToObjectMetricBaseTemplate<TInternalComputationValueType>;
  using MetricTypePointer = typename MetricType::Pointer;
 
  using DerivativeType = typename MetricType::DerivativeType;
 
  using NumberOfParametersType = typename MetricType::NumberOfParametersType;
 
  using MeasureType = typename MetricType::MeasureType;
 
  using StopConditionReturnStringType = std::string;
 
  using StopConditionDescriptionType = std::ostringstream;
 
  itkSetObjectMacro(Metric, MetricType);
  itkGetModifiableObjectMacro(Metric, MetricType);
 
  itkGetConstReferenceMacro(CurrentMetricValue, MeasureType);
 
  virtual const MeasureType &
  GetValue() const;
 
  // itkSetMacro( Scales, ScalesType );
  virtual void
  SetScales(const ScalesType & scales)
  {
    this->m_Scales = scales;
  }
 
  itkGetConstReferenceMacro(Scales, ScalesType);
 
  itkGetConstReferenceMacro(ScalesAreIdentity, bool);
 
  itkSetMacro(Weights, ScalesType);
 
  itkGetConstReferenceMacro(Weights, ScalesType);
 
  itkGetConstReferenceMacro(WeightsAreIdentity, bool);
 
  bool
  GetScalesInitialized() const;
 
  itkSetObjectMacro(ScalesEstimator, ScalesEstimatorType);
 
  itkSetMacro(DoEstimateScales, bool);
  itkGetConstReferenceMacro(DoEstimateScales, bool);
  itkBooleanMacro(DoEstimateScales);
 
  virtual void
  SetNumberOfWorkUnits(ThreadIdType number);
 
#if !defined(ITK_LEGACY_REMOVE)
 
  itkLegacyMacro(virtual void SetNumberOfThreads(ThreadIdType number)) { return this->SetNumberOfWorkUnits(number); }
  itkLegacyMacro(virtual const ThreadIdType & GetNumberOfThreads() const) { return this->m_NumberOfWorkUnits; }
#endif // !ITK_LEGACY_REMOVE
 
 
  itkGetConstReferenceMacro(NumberOfWorkUnits, ThreadIdType);
 
  itkGetConstMacro(CurrentIteration, SizeValueType);
 
  itkSetMacro(NumberOfIterations, SizeValueType);
 
  itkGetConstMacro(NumberOfIterations, SizeValueType);
 
  virtual const ParametersType &
  GetCurrentPosition() const;
 
  virtual void
  StartOptimization(bool doOnlyInitialization = false);
 
  virtual const StopConditionReturnStringType
  GetStopConditionDescription() const = 0;
 
protected:
  ObjectToObjectOptimizerBaseTemplate();
  ~ObjectToObjectOptimizerBaseTemplate() override;
 
  MetricTypePointer m_Metric;
  ThreadIdType      m_NumberOfWorkUnits;
  SizeValueType     m_CurrentIteration;
  SizeValueType     m_NumberOfIterations;
 
  MeasureType m_CurrentMetricValue;
 
  ScalesType m_Scales;
 
  ScalesType m_Weights;
 
  bool m_ScalesAreIdentity;
 
  typename ScalesEstimatorType::Pointer m_ScalesEstimator;
 
  bool m_WeightsAreIdentity;
 
  bool m_DoEstimateScales;
 
  void
  PrintSelf(std::ostream & os, Indent indent) const override;
};
 
using ObjectToObjectOptimizerBase = ObjectToObjectOptimizerBaseTemplate<double>;
 
} // end namespace itk
 
#endif
 
#ifndef ITK_TEMPLATE_EXPLICIT_ObjectToObjectOptimizerBaseTemplate
// Explicit instantiation is required to ensure correct dynamic_cast
// behavior across shared libraries.
//
// IMPORTANT: Since within the same compilation unit,
//            ITK_TEMPLATE_EXPLICIT_<classname> defined and undefined states
//            need to be considered. This code *MUST* be *OUTSIDE* the header
//            guards.
//
#if defined(ITKOptimizersv4_EXPORTS)
//   We are building this library
#  define ITKOptimizersv4_EXPORT_EXPLICIT ITK_FORWARD_EXPORT
#else
//   We are using this library
#  define ITKOptimizersv4_EXPORT_EXPLICIT ITKOptimizersv4_EXPORT
#endif
namespace itk
{
 
ITK_GCC_PRAGMA_DIAG_PUSH()
ITK_GCC_PRAGMA_DIAG(ignored "-Wattributes")
 
#if defined(_MSC_VER)
#  pragma warning(disable : 4661) // no suitable definition provided for explicit template instantiation request
#endif
extern template class ITKOptimizersv4_EXPORT_EXPLICIT ObjectToObjectOptimizerBaseTemplate<double>;
extern template class ITKOptimizersv4_EXPORT_EXPLICIT ObjectToObjectOptimizerBaseTemplate<float>;
 
ITK_GCC_PRAGMA_DIAG_POP()
 
} // end namespace itk
#undef ITKOptimizersv4_EXPORT_EXPLICIT
#endif