itkLevelSetBase.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright Insight Software Consortium
 *
 *  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 __itkLevelSetBase_h
#define __itkLevelSetBase_h

#include "itkIntTypes.h"
#include "itkCovariantVector.h"
#include "itkMatrix.h"
#include "itkNumericTraits.h"
#include "itkDataObject.h"

namespace itk
{
template< class TInput, unsigned int VDimension, typename TOutput, class TDomain >
class LevelSetBase : public DataObject
{
public:
  typedef LevelSetBase               Self;
  typedef DataObject                 Superclass;
  typedef SmartPointer< Self >       Pointer;
  typedef SmartPointer< const Self > ConstPointer;

  itkTypeMacro ( LevelSetBase, DataObject );

  itkStaticConstMacro ( Dimension, unsigned int, VDimension );

  typedef TInput                                           InputType;
  typedef TOutput                                          OutputType;
  typedef typename NumericTraits< OutputType >::RealType   OutputRealType;
  typedef CovariantVector< OutputRealType, VDimension >    GradientType;
  typedef Matrix< OutputRealType, VDimension, VDimension > HessianType;

  typedef TDomain DomainType;

  typedef IdentifierType RegionType;

  virtual OutputType    Evaluate( const InputType& iP ) const = 0;

  virtual GradientType  EvaluateGradient( const InputType& iP ) const = 0;

  virtual HessianType   EvaluateHessian( const InputType& iP ) const = 0;

  virtual OutputRealType EvaluateLaplacian( const InputType& iP ) const = 0;
  virtual OutputRealType EvaluateGradientNorm( const InputType& iP ) const;
  virtual OutputRealType EvaluateMeanCurvature( const InputType& iP ) const = 0;

  template< class T >
  class DataType
    {
    public:
      DataType( const std::string& iName ) :
        m_Name( iName ), m_Computed( false )
        {}
      DataType( const DataType& iData ) : m_Name( iData.m_Name ),
        m_Value( iData.m_Value ), m_Computed( iData.m_Computed )
      {}

      ~DataType() {}

      std::string m_Name;
      T           m_Value;
      bool        m_Computed;

      void operator =( const DataType& iData )
        {
        this->m_Name = iData.m_Name;
        this->m_Value = iData.m_Value;
        this->m_Computed = iData.m_Computed;
        }

    private:
      DataType();
    };

  struct LevelSetDataType
    {
    LevelSetDataType() : Value( "Value" ), Gradient( "Gradient" ),
      Hessian( "Hessian" ), Laplacian( "Laplacian" ),
      GradientNorm( "GradientNorm" ), MeanCurvature( "MeanCurvature" ),
      ForwardGradient( "ForwardGradient" ), BackwardGradient( "BackwardGradient" )
      {
      Value.m_Value = NumericTraits< OutputType >::Zero;
      Gradient.m_Value.Fill( NumericTraits< OutputRealType >::Zero );
      Hessian.m_Value.Fill( NumericTraits< OutputRealType >::Zero );
      Laplacian.m_Value = NumericTraits< OutputRealType >::Zero;
      GradientNorm.m_Value = NumericTraits< OutputRealType >::Zero;
      MeanCurvature.m_Value = NumericTraits< OutputRealType >::Zero;
      ForwardGradient.m_Value.Fill( NumericTraits< OutputRealType >::Zero );
      BackwardGradient.m_Value.Fill( NumericTraits< OutputRealType >::Zero );
      }

    LevelSetDataType( const LevelSetDataType& iData ) : Value( iData.Value ),
      Gradient( iData.Gradient ), Hessian( iData.Hessian ),
      Laplacian( iData.Laplacian ), GradientNorm( iData.GradientNorm ),
      MeanCurvature( iData.MeanCurvature ), ForwardGradient( iData.ForwardGradient ),
      BackwardGradient( iData.BackwardGradient ) {}

    ~LevelSetDataType() {}

    void operator = ( const LevelSetDataType& iData )
      {
      Value = iData.Value;
      Gradient = iData.Gradient;
      Hessian = iData.Hessian;
      Laplacian = iData.Laplacian;
      GradientNorm = iData.GradientNorm;
      MeanCurvature = iData.MeanCurvature;
      ForwardGradient = iData.ForwardGradient;
      BackwardGradient = iData.BackwardGradient;
      }

    DataType< OutputType >      Value;
    DataType< GradientType >    Gradient;
    DataType< HessianType >     Hessian;
    DataType< OutputRealType >  Laplacian;
    DataType< OutputRealType >  GradientNorm;
    DataType< OutputRealType >  MeanCurvature;
    DataType< GradientType >    ForwardGradient;
    DataType< GradientType >    BackwardGradient;
    };

  virtual void Evaluate( const InputType& iP, LevelSetDataType& ioData ) const = 0;
  virtual void EvaluateGradient( const InputType& iP, LevelSetDataType& ioData ) const = 0;
  virtual void EvaluateHessian( const InputType& iP, LevelSetDataType& ioData ) const = 0;
  virtual void EvaluateLaplacian( const InputType& iP, LevelSetDataType& ioData ) const = 0;
  virtual void EvaluateGradientNorm( const InputType& iP, LevelSetDataType& ioData ) const;
  virtual void EvaluateMeanCurvature( const InputType& iP, LevelSetDataType& ioData ) const;
  virtual void EvaluateForwardGradient( const InputType& iP, LevelSetDataType& ioData ) const = 0;
  virtual void EvaluateBackwardGradient( const InputType& iP, LevelSetDataType& ioData ) const = 0;

  virtual bool IsInside( const InputType& iP ) const;

  itkGetConstMacro(MaximumNumberOfRegions, RegionType);

  virtual void Initialize();

  virtual void UpdateOutputInformation();

  virtual void SetRequestedRegionToLargestPossibleRegion();

  virtual void CopyInformation(const DataObject *data);

  virtual void Graft(const DataObject *data);

  virtual bool RequestedRegionIsOutsideOfTheBufferedRegion();

  virtual bool VerifyRequestedRegion();

  virtual void SetRequestedRegion( const DataObject *data);

  virtual void SetRequestedRegion(const RegionType & region);

  itkGetConstMacro(RequestedRegion, RegionType);

  virtual void SetBufferedRegion(const RegionType & region);

  itkGetConstMacro(BufferedRegion, RegionType);

protected:
  LevelSetBase();
  virtual ~LevelSetBase() {}

  // If the RegionType is ITK_UNSTRUCTURED_REGION, then the following
  // variables represent the maximum number of region that the data
  // object can be broken into, which region out of how many is
  // currently in the buffered region, and the number of regions and
  // the specific region requested for the update. Data objects that
  // do not support any division of the data can simply leave the
  // MaximumNumberOfRegions as 1. The RequestedNumberOfRegions and
  // RequestedRegion are used to define the currently requested
  // region. The LargestPossibleRegion is always requested region = 0
  // and number of regions = 1;
  RegionType m_MaximumNumberOfRegions;
  RegionType m_NumberOfRegions;
  RegionType m_RequestedNumberOfRegions;
  RegionType m_BufferedRegion;
  RegionType m_RequestedRegion;

private:
  LevelSetBase( const Self& ); // purposely left unimplemented
  void operator = ( const Self& ); // purposely left unimplemented

};
}

#ifndef ITK_MANUAL_INSTANTIATION
#include "itkLevelSetBase.hxx"
#endif

#endif // __itkLevelSetBase_h