cmtkTypedArray.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 __cmtkTypedArray_h_included_
#define __cmtkTypedArray_h_included_

#include <cmtkconfig.h>

#include <Base/cmtkMacros.h>
#include <Base/cmtkTypes.h>
#include <Base/cmtkMathUtil.h>
#include <Base/cmtkDataTypeTraits.h>
#include <Base/cmtkHistogram.h>
#include <Base/cmtkTypedArrayFunction.h>

#include <System/cmtkSmartPtr.h>
#include <System/cmtkSmartConstPtr.h>
#include <System/cmtkException.h>

#include <math.h>
#include <stdlib.h>
#include <stdio.h>
#include <limits.h>

#include <memory.h>

#include <vector>

#ifdef DEBUG
#define CheckBounds(index,bound) \
  if (!(index<bound)) throw( Exception( "Index is outside bounds", this ) );
#else
#define CheckBounds(index,bound)
#endif

namespace
cmtk
{


class TypedArray
{
  cmtkGetSetMacro(DataClass,DataClass);

public:
  typedef TypedArray Self;

  typedef SmartPointer<Self> SmartPtr;

  typedef SmartConstPointer<Self> SmartConstPtr;

  static Self::SmartPtr Create
  ( const ScalarDataType dtype, void *const data, const size_t size, const bool freeArray = true, const bool paddingFlag = false, const void* paddingData = NULL );
  
  static Self::SmartPtr Create( const ScalarDataType dtype, const size_t size );

  static void Free( void *const data )
  {
    free( data );
  }
  
  virtual bool Get ( Types::DataItem&, const size_t ) const = 0;

  virtual void GetSequence ( Types::DataItem *const values, const size_t index, const size_t length ) const = 0;

  virtual void Set ( const Types::DataItem, const size_t ) = 0;

  virtual ScalarDataType GetType () const = 0;

  virtual size_t GetItemSize () const = 0;

  virtual void* GetPaddingPtr () const = 0;

  virtual Types::DataItem GetPaddingValue () const = 0;

  virtual bool PaddingDataAt ( const size_t index ) const = 0;

  virtual Types::DataItem* GetData () const = 0;

  virtual void SetData( Types::DataItem *const data ) = 0;

  virtual Self::SmartPtr Convert(  const ScalarDataType dtype ) const = 0;

  virtual void* ConvertSubArray( const ScalarDataType dtype, const size_t fromIdx, const size_t len ) const = 0;

  virtual void ConvertSubArray( void *const destination, const ScalarDataType dtype, const size_t fromIdx, const size_t len ) const = 0;

  virtual void* ConvertArray ( const ScalarDataType dtype ) const 
  {
    return this->ConvertSubArray( dtype, 0, DataSize );
  }
  
  virtual void ClearArray ( const bool usePaddingData = false ) = 0;

  virtual void ChangeEndianness() = 0;

  virtual void Rescale( const Types::DataItem scale = 1, const Types::DataItem offset = 0 ) = 0;

  virtual void RescaleAndShift( const Types::DataItem scale = 1, const Types::DataItem offset = 0, const size_t shiftBits = 0 ) = 0;

  virtual void RescaleToRange( const Types::DataItemRange& toRange );

  virtual void GammaCorrection( const Types::DataItem gamma ) = 0;

  typedef double (*FunctionTypeDouble)(const double);

  typedef float (*FunctionTypeFloat)(const float);

  virtual void ApplyFunction( Self::FunctionTypeFloat f )        
  {      
    this->ApplyFunctionFloat( f );       
  }      
  
  virtual void ApplyFunction( Self::FunctionTypeDouble f )       
  {      
    this->ApplyFunctionDouble( f );      
  }      
                 
  virtual void ApplyFunctionFloat( Self::FunctionTypeFloat f ) = 0;

  virtual void ApplyFunctionDouble( Self::FunctionTypeDouble f ) = 0;

  virtual void MakeAbsolute() = 0;

  virtual void Rescale( const Types::DataItem scale, const Types::DataItem offset, const Types::DataItem truncLo, const Types::DataItem truncHi = CMTK_ITEM_MAX ) = 0;

  virtual void Threshold( const Types::DataItemRange& range ) = 0;

  virtual void ThresholdToPadding( const Types::DataItemRange& range ) = 0;

  virtual void PruneHistogram( const bool pruneHi, const bool pruneLo, const size_t numberOfBinsTarget, const size_t numberOfBinsInternal = 1024 );

  virtual void Binarize( const Types::DataItem threshold = 0 ) = 0;

  Self::SmartPtr Clone() const 
  {
    return Self::SmartPtr( this->CloneVirtual() );
  }
  
  TypedArray () 
  {
    DataSize = 0;
    PaddingFlag = false;
    FreeArray = false;
    this->m_DataClass = DATACLASS_GREY;
  }
  
  virtual ~TypedArray () {}
  
  virtual void FreeData() = 0;

  void ReleaseDataPointer () 
  {
    FreeArray = false;
  }
  
  size_t GetDataSize () const { return DataSize; }

  size_t GetDataSizeBytes () const
  { 
    return this->GetItemSize() * DataSize;
  }

  virtual void* GetDataPtr( const size_t offset = 0) = 0;

  virtual const void* GetDataPtr( const size_t offset = 0) const = 0;

  virtual Types::DataItem* GetSubArray( Types::DataItem *const, const size_t, const size_t, const Types::DataItem = 0 ) const = 0;

  virtual Types::DataItem* GetSubArray( const size_t, const size_t, const Types::DataItem = 0 ) const = 0;

  bool GetPaddingFlag () const { return PaddingFlag; }

  void ClearPaddingFlag()
  {
    this->PaddingFlag = false;
  }

  virtual void SetPaddingAt ( const size_t ) = 0;

  virtual void SetPaddingValue ( const Types::DataItem paddingData ) = 0;

  virtual void SetPaddingPtr ( const void* paddingData ) = 0;

  virtual void ReplacePaddingData ( const Types::DataItem value = 0 ) = 0;

  virtual bool IsPaddingAt( const size_t index ) const = 0;

  virtual bool IsPaddingOrZeroAt( const size_t index ) const = 0;

  virtual const Types::DataItemRange GetRange() const = 0;

  virtual double GetEntropy( const bool fractional = CMTK_HISTOGRAM_DISCRETE, const int numberOfBins = 128 ) const = 0;

  virtual double GetEntropy( Histogram<unsigned int>& histogram ) const = 0;

  virtual double GetEntropy( Histogram<double>& histogram, const bool fractional = CMTK_HISTOGRAM_DISCRETE ) const = 0;

  virtual double GetEntropy( Histogram<double>& histogram, const double* kernel, const size_t kernelRadius  ) const = 0;

  virtual size_t GetStatistics ( Types::DataItem& mean, Types::DataItem& variance ) const = 0;

  virtual Types::DataItem GetPercentile
  ( const Types::DataItem percentile, 
    const size_t nBins = 256 
    ) const;

  virtual std::vector<Types::DataItem> GetPercentileList
  ( const std::vector<Types::DataItem>& percentileList, 
    const size_t nBins = 256 
    ) const;

  virtual Histogram<unsigned int>::SmartPtr GetHistogram( const unsigned int numberOfBins ,
                                                          const bool centeredBins = false  ) const = 0;
  
  virtual void BlockSet( const Types::DataItem value, const size_t fromOffset, const size_t toOffset ) = 0;

  virtual void Fill( const Types::DataItem value )
  {
    this->BlockSet( value, 0, this->GetDataSize() );
  }

  virtual void BlockCopy( Self& target, const size_t toOffset, const size_t fromOffset, const size_t blockLength ) const 
  {
    this->ConvertSubArray( target.GetDataPtr( toOffset ), target.GetType(), fromOffset, blockLength );
  }

  virtual void BlockSwap( const size_t fromOffset, const size_t toOffset, const size_t blockLength );

  virtual void BlockReverse( const size_t fromOffset, const size_t blockLength );

  virtual void ApplyFunctionObject( const TypedArrayFunction& f ) = 0;

protected:
  ScalarDataType m_DataType;

  bool FreeArray;

  size_t DataSize;

  bool PaddingFlag;

  virtual void Alloc ( const size_t datasize ) = 0;

  virtual Self* CloneVirtual() const = 0; 
};


} // namespace cmtk

#endif // #ifndef __cmtkTypedArray_h_included_