itkIndex.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkIndex.h,v $
  Language:  C++
  Date:      $Date: 2009-05-17 02:31:26 $
  Version:   $Revision: 1.62 $

  Copyright (c) Insight Software Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even 
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/
#ifndef __itkIndex_h
#define __itkIndex_h

#include "itkMacro.h"
#include "itkOffset.h"
#include "itkSize.h"
#include "itkFixedArray.h"

#include <memory>

#include "itkExceptionObject.h"

namespace itk
{

namespace Functor
{
template<unsigned int VIndexDimension> class IndexLexicographicCompare;
}

template<unsigned int VIndexDimension=2>
class Index {
public:
  typedef Index  Self;

  typedef   Index<VIndexDimension>  IndexType;
  typedef   long                    IndexValueType;

  static unsigned int GetIndexDimension() { return VIndexDimension; }

  typedef   Size<VIndexDimension>  SizeType;

  typedef   Offset<VIndexDimension>              OffsetType;
  typedef   typename OffsetType::OffsetValueType OffsetValueType;

  typedef Functor::IndexLexicographicCompare<VIndexDimension> LexicographicCompare;

  const Self
  operator+(const SizeType &size) const
    {
    Self result;
    for (unsigned int i=0; i < VIndexDimension; i++)
      { result[i] = m_Index[i] + static_cast<IndexValueType>(size[i]); }
    return result;
    }

  const Self &
  operator+=(const SizeType &size)
    {
    for (unsigned int i=0; i < VIndexDimension; i++)
      { m_Index[i] += static_cast<IndexValueType>(size[i]); }
    return *this;
    }

  const Self
  operator-(const SizeType &size) const
    {
    Self result;
    for (unsigned int i=0; i < VIndexDimension; i++)
      { result[i] = m_Index[i] - static_cast<IndexValueType>(size[i]); }
    return result;
    }

  const Self &
  operator-=(const SizeType &size)
    {
    for (unsigned int i=0; i < VIndexDimension; i++)
      { m_Index[i] -= static_cast<IndexValueType>(size[i]); }
    return *this;
    }

  const Self
  operator+(const OffsetType &offset) const
    {
    Self result;
    for (unsigned int i=0; i < VIndexDimension; i++)
      { result[i] = m_Index[i] + offset[i]; }
    return result;
    }

  const Self &
  operator+=(const OffsetType &offset)
    {
    for (unsigned int i=0; i < VIndexDimension; i++)
      { m_Index[i] += offset[i]; }
    return *this;
    }

  const Self &
  operator-=(const OffsetType &offset)
    {
    for (unsigned int i=0; i < VIndexDimension; i++)
      { m_Index[i] -= offset[i]; }
    return *this;
    }

  const Self
  operator-(const OffsetType &off) const
    {
    Self result;
    for (unsigned int i=0; i < VIndexDimension; i++)
      { result[i] = m_Index[i] - off.m_Offset[i]; }
    return result;
    }

  const OffsetType
  operator-(const Self &vec) const
    {
    OffsetType result;
    for (unsigned int i=0; i < VIndexDimension; i++)
      { result[i] = m_Index[i] - vec.m_Index[i]; }
    return result;
    }

  const Self
  operator*(const SizeType &vec) const
    {
    Self result;
    for (unsigned int i=0; i < VIndexDimension; i++)
      { result[i] = m_Index[i] * static_cast<IndexValueType>(vec.m_Size[i]); }
    return result;
    }

  bool
  operator==(const Self &vec) const
    {
    bool same=true;
    for (unsigned int i=0; i < VIndexDimension && same; i++)
      { same = (m_Index[i] == vec.m_Index[i]); }
    return same;
    }

  bool
  operator!=(const Self &vec) const
    {
    bool same=true;
    for (unsigned int i=0; i < VIndexDimension && same; i++)
      { same = (m_Index[i] == vec.m_Index[i]); }
    return !same;
    }

  IndexValueType & operator[](unsigned int dim)
    { return m_Index[dim]; }

  IndexValueType operator[](unsigned int dim) const
    { return m_Index[dim]; }

  const IndexValueType *GetIndex() const { return m_Index; };

  void SetIndex(const IndexValueType val[VIndexDimension])
    { memcpy(m_Index, val, sizeof(IndexValueType)*VIndexDimension); }

  void SetElement(unsigned long element, IndexValueType val )
    { m_Index[ element ] = val;  }

  IndexValueType GetElement( unsigned long element )
    { return m_Index[ element ]; }

  static Self GetBasisIndex(unsigned int dim); 

  void Fill(IndexValueType value)
    { for(unsigned int i=0;i < VIndexDimension; ++i) m_Index[i] = value; }

  IndexValueType m_Index[VIndexDimension];

#ifndef ITK_USE_PORTABLE_ROUND
  // The Windows implementaton of vnl_math_rnd() does not round the
  // same way as other versions. It has an assembly "fast" implementation
  // but with the drawback of rounding to the closest even number.
  // See: http://www.musicdsp.org/showone.php?id=170
  // For example 0.5 is rounded down to 0.0.
  // This conditional code replaces the standard vnl implementation that uses
  // assembler code. The code below will be slower for windows but will
  // produce consistent results. This can be removed once vnl_math_rnd is
  // fixed in VXL.
#if (defined (VCL_VC) && !defined(__GCCXML__)) || (defined(_MSC_VER) && (_MSC_VER <= 1310))
#define vnl_math_rnd_halfintup(x) ((x>=0.0)?(int)(x + 0.5):(int)(x - 0.5))
#endif
#endif

  template <class TCoordRep>
  inline void CopyWithRound( const FixedArray<TCoordRep,VIndexDimension> & point )
    {
#ifdef ITK_USE_TEMPLATE_META_PROGRAMMING_LOOP_UNROLLING
    itkForLoopRoundingAndAssignmentMacro(IndexType,ContinuousIndexType,IndexValueType,m_Index,point,VIndexDimension);
#else
    for(unsigned int i=0;i < VIndexDimension; ++i)
      {
#ifdef ITK_USE_PORTABLE_ROUND
      m_Index[i] = static_cast< IndexValueType>( itk::Math::Round( point[i] ) );
#else
      m_Index[i] = static_cast< IndexValueType>( vnl_math_rnd_halfintup( point[i] ) );
#endif
      }
#endif
    }
#ifndef ITK_USE_PORTABLE_ROUND
#if (defined (VCL_VC) && !defined(__GCCXML__)) || (defined(_MSC_VER) && (_MSC_VER <= 1310))
#undef vnl_math_rnd_halfintup
#endif
#endif


  template <class TCoordRep>
  inline void CopyWithCast( const FixedArray<TCoordRep,VIndexDimension> & point )
    {
    for(unsigned int i=0;i < VIndexDimension; ++i)
      {
      m_Index[i] = static_cast< IndexValueType>( point[i] );
      }
    }

// force gccxml to find the constructors found before the internal upgrade to gcc 4.2
#if defined(CABLE_CONFIGURATION)
  Index(); //purposely not implemented
  Index(const Self&); //purposely not implemented
  void operator=(const Self&); //purposely not implemented
#endif

};

namespace Functor
{
template<unsigned int VIndexDimension>
class IndexLexicographicCompare
{
public:
  bool operator()(Index<VIndexDimension> const& l,
                  Index<VIndexDimension> const& r) const
    {
    for(unsigned int i=0; i < VIndexDimension; ++i)
      {
      if(l.m_Index[i] < r.m_Index[i])
        {
        return true;
        }
      else if(l.m_Index[i] > r.m_Index[i])
        {
        return false;
        }
      }
    return false;
    }
};
}

template<unsigned int VIndexDimension>
Index<VIndexDimension> 
Index<VIndexDimension>
::GetBasisIndex(unsigned int dim)
{
  Self ind;
  
  memset(ind.m_Index, 0, sizeof(IndexValueType)*VIndexDimension);
  ind.m_Index[dim] = 1;
  return ind;
}

template<unsigned int VIndexDimension>
std::ostream & operator<<(std::ostream &os, const Index<VIndexDimension> &ind)
{
  os << "[";
  for (unsigned int i=0; i+1 < VIndexDimension; ++i)
    {
    os << ind[i] << ", ";
    }
  if (VIndexDimension >= 1)
    {
    os << ind[VIndexDimension-1];
    }
  os << "]";
  return os;
}

} // end namespace itk

#endif 

---