cmtkTemplateArray.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 __cmtkTemplateArray_h_included_
#define __cmtkTemplateArray_h_included_

#include <cmtkconfig.h>

#include <Base/cmtkTypedArray.h>
#include <Base/cmtkTypedArrayFunction.h>

#include <System/cmtkConsole.h>

namespace
cmtk
{


template<class T>
class TemplateArray : 
  public TypedArray
{
public:
  typedef TemplateArray<T> Self;

  typedef TypedArray Superclass;

  typedef SmartPointer<Self> SmartPtr;

  typedef DataTypeTraits<T> TypeTraits;

  static typename Self::SmartPtr Create( const size_t size )
  {
    return typename Self::SmartPtr( new Self( size ) );
  }

  const T* GetDataPtrConcrete() const { return this->Data; }

  T* GetDataPtrConcrete() { return this->Data; }

  void SetPaddingValueTemplate ( const T paddingData ) 
  {
    this->Padding = paddingData;
    this->PaddingFlag = true;
  }
  
  TemplateArray ( void *const data, const size_t datasize, const bool freeArray, const bool paddingflag, const void* paddingData ) 
  {
    m_DataType = TypeTraits::GetScalarDataType();
    Data = static_cast<T*>( data );
    DataSize = datasize;
    FreeArray = freeArray;
    PaddingFlag = paddingflag;
    if ( paddingData )
      Padding = *((T*)paddingData);
    else
      Padding = (T) 0;
  }

  TemplateArray ( const size_t datasize = 0 ) 
  {
    m_DataType = TypeTraits::GetScalarDataType();
    Data = NULL;
    this->Alloc( datasize ); 
  }

  virtual ~TemplateArray () 
  {    
    this->FreeData();
  }
  
  virtual void SetPaddingValue ( const Types::DataItem paddingData ) 
  {
    this->SetPaddingValueTemplate( TypeTraits::Convert( paddingData ) );
  }

  virtual void SetPaddingPtr ( const void* paddingData ) 
  {
    this->SetPaddingValueTemplate( *((T*) paddingData) );
  }

  virtual void ReplacePaddingData ( const Types::DataItem value = 0 ) 
  {
    if ( PaddingFlag ) 
      {
      T v = TypeTraits::Convert( value );
      for ( size_t i = 0; i < DataSize; ++i )
        if ( Data[i] == Padding ) 
          {
          Data[i] = v;
          }
      }
  }
  
  virtual bool IsPaddingAt( const size_t index ) const 
  {
    return PaddingFlag && (Data[index]==Padding);
  }
  
  virtual bool IsPaddingOrZeroAt( const size_t index ) const 
  {
    return (PaddingFlag && (Data[index]==Padding)) || Data[index] == (T)0;
  }
  
  virtual void SetPaddingAt ( const size_t index = 0 ) 
  {
    if ( !PaddingFlag ) 
      {
      Padding = TypeTraits::ChoosePaddingValue();
      PaddingFlag = true;
      }
    Data[index] = Padding;
  }
  
  virtual ScalarDataType GetType () const { return TypeTraits::GetScalarDataType(); }

  virtual size_t GetItemSize () const { return sizeof(T); }

  virtual void* GetDataPtr( const size_t offset = 0 ) 
  {
    return Data + offset; 
  }

  virtual const void* GetDataPtr( const size_t offset = 0 ) const 
  {
    return Data + offset; 
  }
  
  virtual T* GetDataPtrTemplate( const size_t offset = 0 ) 
  {
    return Data + offset; 
  }
  
  virtual const T* GetDataPtrTemplate( const size_t offset = 0 ) const 
  {
    return Data + offset; 
  }
  
  virtual Types::DataItem* GetSubArray( Types::DataItem *const toPtr, const size_t fromIdx , const size_t len, const Types::DataItem substPadding = 0 ) const 
  {
    int index = fromIdx;
    
    if ( PaddingFlag ) 
      {
      for ( size_t i = 0; i<len; ++i, ++index ) 
        {
        T value = Data[index];
        if (value == Padding)
          toPtr[i] = substPadding;
        else
          toPtr[i] = static_cast<Types::DataItem>( value );
        }
      } 
    else
      {
      for ( size_t i = 0; i<len; ++i, ++index )
        toPtr[i] = static_cast<Types::DataItem>( Data[index] );
      }
    return toPtr;
  }

  virtual Types::DataItem* GetSubArray( const size_t fromIdx, const size_t len, const Types::DataItem substPadding = 0 ) const 
  {
    Types::DataItem* buffer = Memory::AllocateArray<Types::DataItem>( len );
    return this->GetSubArray( buffer, fromIdx, len, substPadding );
  }

  virtual T ConvertItem ( const Types::DataItem value ) 
  {
    return TypeTraits::Convert( value, PaddingFlag, Padding );
  }

  virtual TypedArray::SmartPtr Convert(  const ScalarDataType dtype ) const;


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

  virtual void ChangeEndianness();

  virtual void Rescale( const Types::DataItem scale = 1, const Types::DataItem offset = 0 ) 
  {
#pragma omp parallel for    
    for ( size_t i = 0; i < this->DataSize; ++i )
      if ( ! PaddingFlag || (Data[i] != Padding ) )
        Data[i] = TypeTraits::Convert( (scale * Data[i]) + offset );
  }
  
  virtual void RescaleAndShift( const Types::DataItem scale = 1, const Types::DataItem offset = 0, const size_t shiftBits = 0 ) 
  {
    const long int shiftMultiplier = (1<<shiftBits);
#pragma omp parallel for    
    for ( size_t i = 0; i < this->DataSize; ++i )
      if ( ! PaddingFlag || (Data[i] != Padding ) )
        Data[i] = TypeTraits::Convert( ((scale * Data[i]) + offset) * shiftMultiplier );
  }
  
  virtual void Rescale( const Types::DataItem scale, const Types::DataItem offset, const Types::DataItem truncLo, const Types::DataItem truncHi = CMTK_ITEM_MAX ) 
  {
#pragma omp parallel for    
    for ( size_t i = 0; i < this->DataSize; ++i )
      if ( ! PaddingFlag || (Data[i] != Padding ) ) 
        {
        Data[i] = TypeTraits::Convert( (scale * Data[i]) + offset );
        if ( Data[i] < truncLo )
          Data[i] = TypeTraits::Convert( truncLo );
        else
          if ( Data[i] > truncHi )
            Data[i] = TypeTraits::Convert( truncHi );
        }
  }

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

  virtual void ApplyFunctionFloat( typename Self::FunctionTypeFloat f );

  virtual void ApplyFunctionDouble( typename Self::FunctionTypeDouble f );

  virtual void Threshold( const Types::DataItemRange& range ) 
  {
    const T lo = TypeTraits::Convert( range.m_LowerBound );
    const T hi = TypeTraits::Convert( range.m_UpperBound );
#pragma omp parallel for    
    for ( size_t i = 0; i < this->DataSize; ++i )
      if ( ! PaddingFlag || (Data[i] != Padding ) ) 
        {
        if ( Data[i] < lo )
          Data[i] = lo;
        else
          if ( Data[i] > hi )
            Data[i] = hi;
        }
  }
  
  virtual void ThresholdToPadding( const Types::DataItemRange& range ) 
  {
    const T lo = TypeTraits::Convert( range.m_LowerBound );
    const T hi = TypeTraits::Convert( range.m_UpperBound );
#pragma omp parallel for    
    for ( size_t i = 0; i < this->DataSize; ++i )
      if ( ! PaddingFlag || (Data[i] != Padding ) ) 
        {
        if ( (Data[i] < lo) || (Data[i] > hi) )
          Data[i] = this->Padding;
        }
  }
  
  virtual void Binarize( const Types::DataItem threshold = 0 ) 
  {
    T thresh = TypeTraits::Convert( threshold );
    
    T one = TypeTraits::Convert( 1.0 ), zero = TypeTraits::Convert( 0.0 );
#pragma omp parallel for    
    for ( size_t i = 0; i < this->DataSize; ++i )
      if ( ! PaddingFlag || (Data[i] != Padding ) ) 
        {
        if ( Data[i] > thresh )
          Data[i] = one;
        else
          Data[i] = zero;
        }
  }
  
  virtual void MakeAbsolute()
  {
#pragma omp parallel for    
    for ( size_t i = 0; i < this->DataSize; ++i )
      if ( ! PaddingFlag || (Data[i] != Padding ) )
        Data[i] = TypeTraits::Abs( Data[i] );
  }
  
  virtual bool Get ( Types::DataItem& value, const size_t index ) const 
  {
    CheckBounds( index, DataSize );
    if (PaddingFlag && (Padding==Data[index])) 
      {
      value = 0;
      return false;
      }
    value = static_cast<Types::DataItem>( Data[index] );
    return true;
  }

  virtual void GetSequence ( Types::DataItem *const values, const size_t index, const size_t length ) const
  {
    CheckBounds( index+length-1, DataSize );
    for ( size_t i = 0; i < index+length; ++i )
      if (PaddingFlag && (Padding==Data[index]))
        values[i] = 0;
      else
        values[i] = static_cast<Types::DataItem>( Data[index] );
  }

  virtual void Set ( const Types::DataItem value, const size_t index ) 
  {
    CheckBounds( index, DataSize );
    Data[index] = this->ConvertItem( value );
  }

  virtual void* GetPaddingPtr () const { return (void*)&Padding; }

  virtual Types::DataItem GetPaddingValue() const { return static_cast<Types::DataItem>( Padding ); }

  virtual bool PaddingDataAt ( const size_t index ) const 
  {
    return PaddingFlag && (Data[index] == Padding);
  }
  
  virtual Types::DataItem* GetData () const 
  {
    Types::DataItem* Result = Memory::AllocateArray<Types::DataItem>( DataSize );
    if ( Result ) 
      {
      for ( size_t idx = 0; idx < DataSize; ++idx )
        Result[idx] = (Types::DataItem) Data[idx];
      }
    return Result;
  }

  virtual void SetData ( Types::DataItem *const data ) 
  {
#pragma omp parallel for    
    for ( size_t idx = 0; idx < this->DataSize; ++idx )
      Data[idx] = this->ConvertItem( data[idx] );
  }

  virtual void ClearArray ( const bool usePaddingData = false ) 
  {
    if ( usePaddingData && PaddingFlag ) 
      {
      for ( size_t idx = 0; idx < DataSize; ++idx )
        Data[idx] = Padding;
      } 
    else
      {
      memset( Data, 0, sizeof( *Data ) * this->GetDataSize() );
      }
  }

  virtual const Types::DataItemRange GetRange() const;

  virtual const Types::Range<T> GetRangeTemplate() const;

  virtual double GetEntropy( const bool fractional = CMTK_HISTOGRAM_DISCRETE, const int numberOfBins = 128 ) const;
  
  virtual double GetEntropy( Histogram<unsigned int>& histogram ) const;
  virtual double GetEntropy( Histogram<double>& histogram, const bool fractional = CMTK_HISTOGRAM_DISCRETE ) const;
  virtual double GetEntropy( Histogram<double>& histogram, const double* kernel, const size_t kernelRadius ) const;

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

  virtual void BlockSet( const Types::DataItem value, const size_t fromOffset, const size_t toOffset );

  virtual Histogram<unsigned int>::SmartPtr GetHistogram( const unsigned int numberOfBins ,
                                                          const bool centeredBins = false  ) const;

  virtual void ApplyFunctionObject( const TypedArrayFunction& f );

protected:
  virtual Self* CloneVirtual() const
  {
    Self* clone = new Self( this->DataSize );
    memcpy( clone->Data, this->Data, this->DataSize * sizeof( T ) );
    clone->Padding = this->Padding;
    clone->PaddingFlag = this->PaddingFlag;
    clone->m_DataClass = this->m_DataClass;
    return clone;
  }

private:
  T *Data;

  T Padding;

  virtual void Alloc ( const size_t datasize ) 
  {
    DataSize = datasize;
    if ( DataSize ) 
      {
      if ( Data ) 
        {
        Memory::DeleteArray( Data );
        }
      Data = Memory::AllocateArray<T>( DataSize );
      if ( Data == NULL ) 
        {
        this->DataSize = 0;
        }
      FreeArray = true;
      } 
    else
      {
      Data = NULL;
      FreeArray = false;
      }
  }
  
  virtual void FreeData() 
  {
    if ( Data && FreeArray ) 
      {
      Memory::DeleteArray( Data );
      } 
    Data = NULL;
  }
};


typedef TemplateArray<byte>   ByteArray;

typedef TemplateArray<char>   CharArray;

typedef TemplateArray<short>  ShortArray;

typedef TemplateArray<unsigned short> UShortArray;

typedef TemplateArray<int>    IntArray;

typedef TemplateArray<float>  FloatArray;

typedef TemplateArray<double> DoubleArray;



} // namespace cmtk

#include "cmtkTemplateArray.txx"
#include "cmtkTemplateArray_Statistics.txx"

#endif // #ifndef __cmtkTemplateArray_h_included_