cmtkDataGrid.h

Go to the documentation of this file.

/*
//
//  Copyright 2004-2011 SRI International
//
//  Copyright 1997-2010 Torsten Rohlfing
//
//  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: 2752 $
//
//  $LastChangedDate: 2011-01-17 11:33:31 -0800 (Mon, 17 Jan 2011) $
//
//  $LastChangedBy: torstenrohlfing $
//
*/

#ifndef __cmtkDataGrid_h_included_
#define __cmtkDataGrid_h_included_

#include <cmtkconfig.h>

#include <Base/cmtkMacros.h>
#include <Base/cmtkTypes.h>
#include <Base/cmtkTypedArray.h>
#include <Base/cmtkFixedVector.h>
#include <Base/cmtkScalarImage.h>
#include <Base/cmtkRegion.h>
#include <Base/cmtkMetaInformationObject.h>
#include <Base/cmtkAnatomicalOrientation.h>

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

#include <vector>

namespace
cmtk
{


class DataGrid :
  public MetaInformationObject
{
public:
  typedef DataGrid Self;

  typedef SmartPointer<Self> SmartPtr;

  typedef SmartConstPointer<Self> SmartConstPtr;

  typedef Region<3,int> RegionType;

  typedef RegionType::IndexType IndexType;

  typedef FixedVector<3,Types::Coordinate> SpaceVectorType;

  Self::IndexType m_Dims;

  cmtkGetSetMacro(TypedArray::SmartPtr,Data);

public:
  DataGrid() : 
    m_Data( NULL )
  {}
  
  DataGrid( const Self::IndexType& dims, TypedArray::SmartPtr& data = TypedArray::SmartPtr::Null ) 
    : m_Dims( dims ), 
      m_Data( data )
  {
    this->m_CropRegion = this->GetWholeImageRegion();
  }
  
  virtual ~DataGrid() {}

  bool GridMatches( const Self& other ) const
  {
    return (this->m_Dims == other.m_Dims);
  }

  virtual DataGrid* GetDownsampledAndAveraged( const int (&downsample)[3] ) const;

  const DataGrid::SmartPtr GetReoriented( const char* newOrientation = AnatomicalOrientation::ORIENTATION_STANDARD ) const;
  
  void SetDims( const Self::IndexType& dims );

  const Self::IndexType GetDims() const
  {
    return this->m_Dims;
  }

  virtual TypedArray::SmartPtr CreateDataArray( const ScalarDataType dataType, const bool setToZero = false );

  size_t GetNumberOfPixels () const { return this->m_Dims[0]*this->m_Dims[1]*this->m_Dims[2]; }

  bool IndexIsInRange( const int x, const int y, const int z ) const
  {
    return (x>=0) && (x<this->m_Dims[0]) && (y>=0) && (y<this->m_Dims[1]) && (z>=0) && (z<this->m_Dims[2]);
  }

  size_t GetOffsetFromIndex( const int x, const int y, const int z ) const 
  {
    return x + nextJ * y + nextK * z;
  }

  void GetIndexFromOffset( const size_t offset, int& x, int& y, int& z ) const 
  {
    z = offset / nextK;
    y = (offset % nextK) / nextJ;
    x = (offset % nextK) % nextJ;
  }

  bool GetDataAt ( Types::DataItem& data, const size_t offset ) const 
  {
    return this->m_Data->Get( data, offset );
  }

  void SetDataAt ( const Types::DataItem data, const size_t offset )
  {
    this->m_Data->Set( data, offset );
  }
  
  bool GetDataAt ( Types::DataItem& data, const int x, const int y, const int z ) const
  {
    return this->GetDataAt( data, this->GetOffsetFromIndex( x, y, z ) );
  }

  void SetDataAt ( const Types::DataItem data, const int x, const int y, const int z )
  {
    this->SetDataAt( data, this->GetOffsetFromIndex( x, y, z ) );
  }

  Types::DataItem GetDataAt ( const int x, const int y, const int z, const Types::DataItem defaultValue = 0.0 ) const
  {
    Types::DataItem value;
    if ( this->GetDataAt( value, this->GetOffsetFromIndex( x, y, z ) ) )
      return value;
    else
      return defaultValue;
  }

  Types::DataItem GetDataAt ( const size_t offset, const Types::DataItem defaultValue = 0.0 ) const
  {
    Types::DataItem value;
    if ( this->GetDataAt( value, offset ) )
      return value;
    else
      return defaultValue;
  }

  TypedArray::SmartPtr GetDataMirrorPlane( const int axis = AXIS_X ) const;

  void ApplyMirrorPlane( const int axis = AXIS_X );

private:
  static void MirrorPlaneInPlace( TypedArray& data, const Self::IndexType& dims, const int axis = AXIS_X );

public:
  Self::RegionType& CropRegion()
  {
    return this->m_CropRegion;
  }

  virtual void SetCropRegion( const Self::RegionType& region );

  const Self::RegionType& CropRegion() const
  {
    return this->m_CropRegion;
  }

  int GetCropRegionNumVoxels() const;

  const RegionType GetWholeImageRegion() const;

  const Self::IndexType GetCropRegionIncrements() const;

  void AutoCrop( const Types::DataItem threshold, const bool recrop = false, const int margin = 0 );

  void FillCropBackground( const Types::DataItem value );

  TypedArray::SmartPtr GetCroppedData() const;

  int GetNextI() const { return nextI; }
  int GetNextJ() const { return nextJ; }
  int GetNextK() const { return nextK; }
  int GetNextIJ() const { return nextIJ; }
  int GetNextIK() const { return nextIK; }
  int GetNextJK() const { return nextJK; }
  int GetNextIJK() const { return nextIJK; }
  
  virtual FixedVector<3,Types::Coordinate> GetCenterOfMassGrid() const;
  
  virtual FixedVector<3,Types::Coordinate> GetCenterOfMassGrid( FixedVector<3,Types::Coordinate>& firstOrderMoment ) const;
  
  template<class TAccumulator>
  ScalarImage* ComputeProjection( const int axis ) const;
  
  virtual ScalarImage* GetOrthoSlice( const int axis, const unsigned int plane ) const;
  
  Self::SmartPtr ExtractSlice( const int axis, const int plane ) const
  {
    return Self::SmartPtr( this->ExtractSliceVirtual( axis, plane ) );
  }
  
  virtual void SetOrthoSlice( const int axis, const unsigned int idx, const ScalarImage* slice );

  TypedArray::SmartPtr GetDataMirrored( const int axis = AXIS_X ) const;

  void Print() const;

protected:
  bool TrilinearInterpolation( Types::DataItem& data, const int x, const int y, const int z, const Self::SpaceVectorType& location, const Types::Coordinate* cellFrom, const Types::Coordinate* cellTo ) const;

  template<class TData>
  inline TData TrilinearInterpolation
  ( const TData* dataPtr, const int x, const int y, const int z, const Self::SpaceVectorType& gridPosition, const Types::Coordinate* cellFrom, const Types::Coordinate* cellTo ) const;

  template<class TData,class TOutputIterator>
  inline void TrilinearInterpolation
  ( TOutputIterator result ,
    const std::vector<TData*>& dataPtr , 
    const int x , 
    const int y , 
    const int z ,
    const Types::Coordinate fracX , 
    const Types::Coordinate fracY , 
    const Types::Coordinate fracZ  ) const;

  int nextI;

  int nextJ;

  int nextK;

  int nextIJ;
  
  int nextIK;

  int nextJK;

  int nextIJK;

  virtual Self* ExtractSliceVirtual( const int axis , const int plane  ) const;

private:
  Self::RegionType m_CropRegion;
};


} // namespace cmtk

#include "cmtkDataGrid.txx"

#endif // #ifndef __cmtkDataGrid_h_included_