cmtkScalarImage.h

Go to the documentation of this file.

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

#ifndef __cmtkScalarImage_h_included_
#define __cmtkScalarImage_h_included_

#include <cmtkconfig.h>

#include <Base/cmtkMacros.h>
#include <Base/cmtkTypes.h>
#include <Base/cmtkTypedArray.h>
#include <Base/cmtkRegion.h>
#include <Base/cmtkFixedVector.h>
#include <Base/cmtkMatrix3x3.h>
#include <Base/cmtkInterpolator.h>

#include <cassert>
#include <vector>

#include <System/cmtkSmartPtr.h>

namespace
cmtk
{


class ScalarImage
{
  cmtkGetSetMacro(int,NumberOfFrames);

  cmtkGetSetMacro(TypedArray::SmartPtr,PixelData);

  cmtkGetSetMacro2Array(Types::Coordinate,PixelSize);

  cmtkGetSetMacro(Types::Coordinate,FrameToFrameSpacing);

public:
  typedef ScalarImage Self;

  typedef SmartPointer<Self> SmartPtr;

  typedef SmartConstPointer<Self> SmartConstPtr;

  typedef Region<2,int> RegionType;

  typedef RegionType::IndexType IndexType;

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

  ScalarImage();

  ScalarImage( const int dimsx, const int dimsy, const int numberOfFrames = 1 );

  ScalarImage( const ScalarImage& source, const int* roiFrom = NULL, const int* roiTo = NULL );

  ScalarImage( const ScalarImage& other, const Self::RegionType& roi );  

  virtual ~ScalarImage() {}

  virtual void SetDims( const Self::IndexType& dims )
  {
    this->m_Dims = dims;
  }

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

  virtual ScalarImage* InterpolateFrom
  ( const ScalarImage* grid, const CoordinateMatrix3x3* matrix, const cmtk::Interpolators::InterpolationEnum interpolation = cmtk::Interpolators::LINEAR )
    const;

  void SetROI( const Self::RegionType& roi ) 
  {
    ROI = roi;
    HasROI = true;
  }

  void UnsetROI() 
  {
    HasROI = false;
  }

  virtual ScalarImage* GetCropped() const 
  { 
    if ( HasROI )
      return new ScalarImage( *this, ROI );
    else
      return new ScalarImage( *this );
  }
  
  void CreatePixelData( const ScalarDataType dtype ) 
  {
    this->m_PixelData = TypedArray::SmartPtr( TypedArray::Create( dtype, this->m_Dims[0] * this->m_Dims[1] * this->m_NumberOfFrames ) );
  }

  Self::SpaceVectorType m_ImageOrigin;

  void SetImageOrigin( const Self::SpaceVectorType& imageOrigin ) 
  {
    this->m_ImageOrigin = imageOrigin;
  }

  Self::SpaceVectorType GetImageOrigin( const int frame = 0 ) const;

  cmtkGetSetMacro(Self::SpaceVectorType,ImageDirectionX);

  cmtkGetSetMacro(Self::SpaceVectorType,ImageDirectionY);

  cmtkGetSetMacro(Types::Coordinate,ImageSlicePosition);

  cmtkGetSetMacro(Types::Coordinate,ImageTiltAngle);

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

  Types::DataItem GetPixelAt( const int i, const int j ) const 
  {
    Types::DataItem value;
    if ( this->m_PixelData->Get( value, i + this->m_Dims[0] * j ) ) 
      return value;
    return 0;
  }

  bool GetPixelAt( Types::DataItem& value, const Types::Coordinate i, const Types::Coordinate j ) const;

  bool GetPixelAtCubic( Types::DataItem& value, const Types::Coordinate i, const Types::Coordinate j ) const;

  void SetPixelAt( const int i, const int j, const Types::DataItem data ) 
  {
    this->m_PixelData->Set( data, i + this->m_Dims[0] * j );
  }

  virtual ScalarImage* Clone() const;

  virtual ScalarImage* Clone( const bool clonePixelData );

  ScalarImage* Downsample( const int factorX, int factorY = 0, ScalarImage *const target = NULL ) const;

  virtual void ApplyBinaryMask( const ScalarImage* maskImage, const bool invert = false );

  TypedArray::SmartPtr GetMedianFiltered( const byte range ) const;

  ScalarImage* ApplyMedianFilter( const byte range ) 
  {
    this->SetPixelData( TypedArray::SmartPtr( this->GetMedianFiltered( range ) ) );
    return this;
  }
  
  TypedArray::SmartPtr GetGaussFiltered( const Types::Coordinate stdDev ) const;

  ScalarImage* ApplyGaussFilter( const Types::Coordinate stdDev ) 
  {
    this->SetPixelData( TypedArray::SmartPtr( this->GetGaussFiltered( stdDev ) ) );
    return this;
  }

  TypedArray::SmartPtr GetSobel2DFiltered() const;

  ScalarImage* ApplySobel2DFilter() 
  {
    this->SetPixelData( TypedArray::SmartPtr( this->GetSobel2DFiltered() ) );
    return this;
  }

  TypedArray::SmartPtr GetLaplace2DFiltered() const;

  ScalarImage* ApplyLaplace2DFilter() 
  {
    this->SetPixelData( TypedArray::SmartPtr( this->GetLaplace2DFiltered() ) );
    return this;
  }
  
  TypedArray::SmartPtr GetSobelFiltered( const bool horizontal, const bool absolute = false ) const;
  
  ScalarImage* ApplySobelFilter( const bool horizontal, const bool absolute = false ) 
  {
    this->SetPixelData( TypedArray::SmartPtr( this->GetSobelFiltered( horizontal, absolute ) ) );
    return this;
  }

  void Mirror( const bool horizontal, const bool vertical );

  void AdjustAspect( const bool interpolate = false );

  void AdjustToIsotropic( const Types::Coordinate pixelSize, const bool interpolate = false );

  void ProjectPixel( const Self::SpaceVectorType& v, int& i, int& j ) const;
  
  ScalarImage& operator-=( const ScalarImage& );

  virtual void Print() const;

private:
  Self::IndexType m_Dims;

  Self::RegionType ROI;

  bool HasROI;

  // Return filtered image data using client-provided symmetric kernels.
  TypedArray::SmartPtr GetFilteredData( const std::vector<Types::DataItem>& filterX, const std::vector<Types::DataItem>& filterY ) const;

  void AdjustAspectY( const bool interpolate = false );

  void AdjustAspectX( const bool interpolate = false );

  friend ScalarImage* operator- ( const ScalarImage&, const ScalarImage& );
};


#define CMTK_SCALARIMAGE_NOCLONEDATA false

#define CMTK_SCALARIMAGE_CLONEDATA true

#define CMTK_SCALARIMAGE_HORIZONTAL true

#define CMTK_SCALARIMAGE_VERTICAL false

#define CMTK_SCALARIMAGE_ABSOLUTE true

#define CMTK_SCALARIMAGE_SIGNED false



} // namespace cmtk

#endif // #ifndef __cmtkScalarImage_h_included_