cmtkReformatVolume.h

Go to the documentation of this file.

/*
//
//  Copyright 1997-2009 Torsten Rohlfing
//
//  Copyright 2004-2010 SRI International
//
//  This file is part of the Computational Morphometry Toolkit.
//
//  http://www.nitrc.org/projects/cmtk/
//
//  The Computational Morphometry Toolkit is free software: you can
//  redistribute it and/or modify it under the terms of the GNU General Public
//  License as published by the Free Software Foundation, either version 3 of
//  the License, or (at your option) any later version.
//
//  The Computational Morphometry Toolkit is distributed in the hope that it
//  will be useful, but WITHOUT ANY WARRANTY; without even the implied
//  warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License along
//  with the Computational Morphometry Toolkit.  If not, see
//  <http://www.gnu.org/licenses/>.
//
//  $Revision: 2320 $
//
//  $LastChangedDate: 2010-08-27 11:10:17 -0700 (Fri, 27 Aug 2010) $
//
//  $LastChangedBy: torstenrohlfing $
//
*/

#ifndef __cmtkReformatVolume_h_included_
#define __cmtkReformatVolume_h_included_

#include <cmtkconfig.h>

#ifdef HAVE_VALUES_H
#  include <values.h>
#endif

#include <Base/cmtkVolume.h>
#include <Base/cmtkUniformVolume.h>
#include <Base/cmtkInterpolator.h>
#include <Base/cmtkUniformVolumeInterpolator.h>
#include <Base/cmtkTypedArray.h>
#include <Base/cmtkAffineXform.h>
#include <Base/cmtkWarpXform.h>
#include <Base/cmtkSplineWarpXform.h>
#include <Base/cmtkMathUtil.h>
#include <Base/cmtkMacros.h>
#include <Base/cmtkBitVector.h>
#include <Base/cmtkXformList.h>

#include <System/cmtkThreads.h>
#include <System/cmtkProgress.h>

#include <cstddef>
#include <math.h>
#include <vector>

namespace
cmtk
{


class ReformatVolume 
{
public:
  typedef ReformatVolume Self;

  typedef SmartPointer<Self> SmartPtr;

  cmtkGetSetMacroDefault(float,LowerThresholdReference,FLT_MIN);

  cmtkGetSetMacroDefault(float,LowerThresholdFloating,FLT_MIN);

  cmtkGetSetMacroDefault(float,UpperThresholdReference,FLT_MAX);

  cmtkGetSetMacroDefault(float,UpperThresholdFloating,FLT_MAX);

  cmtkGetSetMacroDefault(bool,UsePaddingValue,true);

  cmtkGetSetMacro(Types::DataItem,PaddingValue);

  ReformatVolume();

  void SetInterpolation( const cmtk::Interpolators::InterpolationEnum interpolation ) 
  {
    Interpolation = interpolation;
  }

  UniformVolumeInterpolatorBase::SmartPtr CreateInterpolator( const UniformVolume::SmartConstPtr& volume );

  static UniformVolumeInterpolatorBase::SmartPtr CreateInterpolator( const cmtk::Interpolators::InterpolationEnum interpolation, const UniformVolume::SmartConstPtr& volume );

  void SetUserDataType( const ScalarDataType dataType ) 
  {
    this->m_UserDataType = dataType;
  }

  void SetReferenceVolume( const UniformVolume::SmartConstPtr& referenceVolume );

  void SetFloatingVolume( const UniformVolume::SmartConstPtr& floatingVolume );

  void SetAffineXform( const AffineXform::SmartPtr& affineXform );

  void SetWarpXform( const WarpXform::SmartPtr& warpXform );

  const UniformVolume::SmartPtr PlainReformat();

  TypedArray::SmartPtr PlainReformat( const int plane, TypedArray::SmartPtr& target = TypedArray::SmartPtr::Null, const size_t targetOffset = 0 );
  
  typedef enum 
  {
    MODE_MEAN,
    MODE_MEDIAN,
    MODE_ROBUST90
  } AveragingMode;
  
  UniformVolume* GetTransformedReference
  ( const std::vector<SplineWarpXform::SmartPtr>* xformList, std::vector<UniformVolume::SmartPtr>* volumeList, 
    Types::Coordinate *const volumeOffset = NULL, const bool includeReferenceData = true );

  UniformVolume* GetTransformedReference( Types::Coordinate *const volumeOffset = NULL );

  UniformVolume* GetTransformedReferenceJacobianAvg
  ( const std::vector<SplineWarpXform::SmartPtr>* xformList, Types::Coordinate *const volumeOffset = NULL, const bool includeReferenceData = true );
  
  template<class TInterpolator, class Fct> static TypedArray::SmartPtr ReformatMasked
  ( const UniformVolume* target, const cmtk::XformList& targetToRef, const cmtk::XformList& refToFloat, Fct& fct, const UniformVolume* floating = NULL, TInterpolator& interpolator = TInterpolator::Null );
  
  template<class TInterpolator, class Fct> static TypedArray::SmartPtr ReformatUnmasked
  ( const UniformVolume* target, const cmtk::XformList& targetToRef, const cmtk::XformList& refToFloat, Fct& fct, const UniformVolume* floating = NULL, TInterpolator& interpolator = TInterpolator::Null );
  
  typedef enum 
  {
    REFORMAT_PLAIN,
    REFORMAT_JACOBIAN
  } Mode;
  
  class Plain
  {
  public:
    Plain( const ScalarDataType dataType = TYPE_NONE ) 
      : DataType( dataType ),
        PaddingValue( 0 ),
        UsePaddingValue( false )
      {};
    
    void SetPaddingValue( const Types::DataItem paddingValue )
    {
      this->PaddingValue = paddingValue;
      this->UsePaddingValue = true;
    }

    template <class TInterpolatorInstantiationPtr>
    bool operator()( Types::DataItem& value, const Vector3D& inRef, const cmtk::XformList& refToFloat, TInterpolatorInstantiationPtr& interpolator );
    
    ScalarDataType GetDataType( const UniformVolume& fltImage ) const
    { 
      if ( this->DataType != TYPE_NONE )
        return this->DataType;
      else
        return fltImage.GetData()->GetType(); 
    }

  protected:
    ScalarDataType DataType;

  public:
    Types::DataItem PaddingValue;

    bool UsePaddingValue;
  };
  
  class Jacobian :
    public ReformatVolume::Plain
  {
  public:
    Jacobian( const ScalarDataType dataType = TYPE_FLOAT, const bool correctGlobalScale = true ) 
      : Plain( dataType ), CorrectGlobalScale( correctGlobalScale ) {};
    
    template <class TInterpolatorInstantiationPtr>
    bool operator()( Types::DataItem& value, const Vector3D& inRef, const cmtk::XformList& refToFloat, TInterpolatorInstantiationPtr& interpolator );
    
    ScalarDataType GetDataType( const UniformVolume& ) const
    { 
      if ( this->DataType != TYPE_NONE )
        return this->DataType;
      else
        return TYPE_FLOAT;
    }
    
  private:
    bool CorrectGlobalScale;
  };

private:
  cmtk::Interpolators::InterpolationEnum Interpolation;

  ScalarDataType m_UserDataType;

  UniformVolume::SmartConstPtr ReferenceVolume;

  UniformVolume::SmartConstPtr FloatingVolume;

  const UniformVolume::SmartPtr MakeTargetVolume() const;

  AffineXform::SmartConstPtr m_AffineXform;
  
  WarpXform::SmartConstPtr m_WarpXform;

  class GetTransformedReferenceTP : 
    public ThreadParameters<ReformatVolume>
  {
  public:
    GetTransformedReferenceTP() : m_Offset( 0 ), m_Stride( 1 ) {};
    TypedArray::SmartPtr dataArray;
    const SplineWarpXform* splineXform;
    DataGrid::IndexType dims;
    size_t m_Offset;
    size_t m_Stride;
    const Types::Coordinate* delta;
    const Types::Coordinate* bbFrom;
    unsigned int numberOfImages;
    const std::vector<SplineWarpXform::SmartPtr>* xformList;
    const std::vector<UniformVolume::SmartPtr>* volumeList;
    const std::vector<UniformVolumeInterpolatorBase::SmartConstPtr>* interpolatorList;
    const UniformVolumeInterpolatorBase* referenceInterpolator;
    int maxLabel;
    AveragingMode avgMode;
    bool IncludeReferenceData;
  };

  static CMTK_THREAD_RETURN_TYPE GetTransformedReferenceGrey( void *const arg );

  static CMTK_THREAD_RETURN_TYPE GetTransformedReferenceGreyAvg( void *const arg );

  static CMTK_THREAD_RETURN_TYPE GetTransformedReferenceLabel( void *const arg );

  static CMTK_THREAD_RETURN_TYPE GetTransformedReferenceJacobianAvgThread( void *const arg );

  UniformVolume* CreateTransformedReference( Types::Coordinate *const bbFrom, Types::Coordinate *const delta, Types::Coordinate *const volumeOffset = NULL );

};


} // namespace cmtk

#include "cmtkReformatVolumeReformat.txx"
#include "cmtkReformatVolumePlain.txx"
#include "cmtkReformatVolumeJacobian.txx"

#endif // #ifndef __cmtkReformatVolume_h_included_