itkIndex.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright Insight Software Consortium
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
#ifndef itkIndex_h
#define itkIndex_h

#include "itkOffset.h"
#include "itkFixedArray.h"
#include "itkMath.h"

#include <memory>

namespace itk
{
namespace Functor
{
// Forward reference because of circular dependencies
template< unsigned int VIndexDimension >
class ITK_TEMPLATE_EXPORT IndexLexicographicCompare;
}

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

  typedef   Index< VIndexDimension > IndexType;
  typedef   ::itk::IndexValueType    IndexValueType;

  itkStaticConstMacro(Dimension, unsigned int, VIndexDimension);

  static unsigned int GetIndexDimension() { return VIndexDimension; }

  typedef   Size< VIndexDimension > SizeType;

  typedef   Offset< VIndexDimension >            OffsetType;
  typedef   ::itk::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;
  }

// false positive warnings with GCC 4.9
#if defined( __GNUC__ )
#if ( __GNUC__ == 4 ) && ( __GNUC_MINOR__ == 9 )
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Warray-bounds"
#endif
#endif

  IndexValueType & operator[](unsigned int dim)
  {
    return m_Index[dim];
  }
#if defined( __GNUC__ )
#if ( __GNUC__ == 4 ) && ( __GNUC_MINOR__ == 9 )
#pragma GCC diagnostic pop
#endif
#endif

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

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

  void SetIndex(const IndexValueType val[VIndexDimension])
  {
    std::copy(val,
              val+VIndexDimension,
              m_Index);
  }

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

  IndexValueType GetElement(unsigned long element) const
  { 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];

  template< typename TCoordRep >
  inline void CopyWithRound(const FixedArray< TCoordRep, VIndexDimension > & point)
  {
    itkForLoopRoundingAndAssignmentMacro(IndexType,
                                         ContinuousIndexType,
                                         IndexValueType,
                                         m_Index,
                                         point,
                                         VIndexDimension);
    /* NON TEMPLATE_META_PROGRAMMING_LOOP_UNROLLING data version
     * Leaving here for documentation purposes
     * for ( unsigned int i = 0; i < VIndexDimension; ++i )
     *   {
     *   m_Index[i] = Math::Round< IndexValueType >(point[i]);
     *   }
     */
  }

  template< typename 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] );
      }
  }

#if defined( ITK_WRAPPING_PARSER )
  // Do not use c++11 'delete' keyword here.  This code block is here to
  // explicitly provide the wrapping facilities with handles to the default and
  // copy constructors, and the assignment operator that are otherwise declared
  // implicitly.
  Index();
  Index(const Self&);
  void operator=(const Self&);
#endif
};

namespace Functor
{
template< unsigned int VIndexDimension >
class ITK_TEMPLATE_EXPORT 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