itkFullSearchOptimizer.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright UMC Utrecht and contributors
 *
 *  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 itkFullSearchOptimizer_h
#define itkFullSearchOptimizer_h
 
#include "itkSingleValuedNonLinearOptimizer.h"
#include "itkMapContainer.h"
#include "itkImage.h"
#include "itkArray.h"
#include "itkFixedArray.h"
 
namespace itk
{
 
class FullSearchOptimizer : public SingleValuedNonLinearOptimizer
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(FullSearchOptimizer);
 
  using Self = FullSearchOptimizer;
  using Superclass = SingleValuedNonLinearOptimizer;
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;
 
  itkNewMacro(Self);
 
  itkTypeMacro(FullSearchOptimizer, SingleValuedNonLinearOptimizer);
 
  enum StopConditionType
  {
    FullRangeSearched,
    MetricError
  };
 
  /* Typedefs inherited from superclass */
  using Superclass::ParametersType;
  using Superclass::CostFunctionType;
  using Superclass::CostFunctionPointer;
  using Superclass::MeasureType;
 
  using ParameterValueType = ParametersType::ValueType; // = double
  using RangeValueType = ParameterValueType;
  using RangeType = FixedArray<RangeValueType, 3>;
  using SearchSpaceType = MapContainer<unsigned int, RangeType>;
  using SearchSpacePointer = SearchSpaceType::Pointer;
  using SearchSpaceIteratorType = SearchSpaceType::ConstIterator;
 
  using SearchSpacePointType = Array<ParameterValueType>;
 
  using SearchSpaceIndexType = Array<IndexValueType>;
 
  using SearchSpaceSizeType = Array<SizeValueType>;
 
  itkGetConstMacro(Maximize, bool);
  itkSetMacro(Maximize, bool);
  itkBooleanMacro(Maximize);
  bool
  GetMinimize() const
  {
    return !m_Maximize;
  }
  void
  SetMinimize(bool v)
  {
    this->SetMaximize(!v);
  }
  void
  MinimizeOn()
  {
    this->MaximizeOff();
  }
  void
  MinimizeOff()
  {
    this->MaximizeOn();
  }
 
  virtual void
  UpdateCurrentPosition();
 
  void
  StartOptimization() override;
 
  virtual void
  ResumeOptimization();
 
  virtual void
  StopOptimization();
 
  itkSetObjectMacro(SearchSpace, SearchSpaceType);
  itkGetModifiableObjectMacro(SearchSpace, SearchSpaceType);
 
  virtual void
  AddSearchDimension(unsigned int param_nr, RangeValueType minimum, RangeValueType maximum, RangeValueType step);
 
  virtual void
  RemoveSearchDimension(unsigned int param_nr);
 
  virtual unsigned long
  GetNumberOfIterations();
 
  virtual unsigned int
  GetNumberOfSearchSpaceDimensions();
 
  virtual const SearchSpaceSizeType &
  GetSearchSpaceSize();
 
  virtual ParametersType
  PointToPosition(const SearchSpacePointType & point);
 
  virtual ParametersType
  IndexToPosition(const SearchSpaceIndexType & index);
 
  virtual SearchSpacePointType
  IndexToPoint(const SearchSpaceIndexType & index);
 
  itkGetConstMacro(CurrentIteration, unsigned long);
 
  itkGetConstReferenceMacro(CurrentPointInSearchSpace, SearchSpacePointType);
  itkGetConstReferenceMacro(CurrentIndexInSearchSpace, SearchSpaceIndexType);
 
  itkGetConstReferenceMacro(BestPointInSearchSpace, SearchSpacePointType);
  itkGetConstReferenceMacro(BestIndexInSearchSpace, SearchSpaceIndexType);
 
  itkGetConstMacro(Value, double);
 
  itkGetConstMacro(BestValue, double);
 
  itkGetConstMacro(StopCondition, StopConditionType);
 
protected:
  FullSearchOptimizer();
  ~FullSearchOptimizer() override = default;
 
  // void PrintSelf(std::ostream& os, Indent indent) const;
 
  bool              m_Maximize{ false };
  bool              m_Stop{ false };
  double            m_Value{ 0.0 };
  double            m_BestValue{ 0.0 };
  StopConditionType m_StopCondition{ FullRangeSearched };
 
  SearchSpacePointer   m_SearchSpace{ nullptr };
  SearchSpacePointType m_CurrentPointInSearchSpace{};
  SearchSpaceIndexType m_CurrentIndexInSearchSpace{};
  SearchSpacePointType m_BestPointInSearchSpace{};
  SearchSpaceIndexType m_BestIndexInSearchSpace{};
  SearchSpaceSizeType  m_SearchSpaceSize{};
  unsigned int         m_NumberOfSearchSpaceDimensions{ 0 };
 
  unsigned long m_LastSearchSpaceChanges{ 0 };
  virtual void
  ProcessSearchSpaceChanges();
 
private:
  unsigned long m_CurrentIteration{ 0 };
};
 
} // end namespace itk
 
#endif