itkOffset.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkOffset.h,v $
  Language:  C++
  Date:      $Date: 2009-02-06 20:53:15 $
  Version:   $Revision: 1.19 $

  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 __itkOffset_h
#define __itkOffset_h

#include "itkMacro.h"
#include "itkSize.h"

#include <memory>

#include "itkExceptionObject.h"

#if defined(_MSC_VER)

// local variable may be used without having been initialized
#pragma warning ( disable : 4701 )
#endif
namespace itk
{

namespace Functor
{
template<unsigned int VOffsetDimension> class OffsetLexicographicCompare;
}


template<unsigned int VOffsetDimension=2>
class Offset {
public:
  typedef Offset  Self;
  
  static unsigned int GetOffsetDimension() { return VOffsetDimension; }

  typedef   Offset<VOffsetDimension>  OffsetType;
  typedef   long                      OffsetValueType;
    
  typedef Functor::OffsetLexicographicCompare<VOffsetDimension> LexicographicCompare;

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

  const Self
  operator+(const Size<VOffsetDimension> &size) const
    {
    Self result;
    for (unsigned int i=0; i < VOffsetDimension; i++)
      { result[i] = m_Offset[i] + size[i]; }
    return result;
    }

  const Self &
  operator+=(const Size<VOffsetDimension> &size)
    {
    for (unsigned int i=0; i < VOffsetDimension; i++)
      { m_Offset[i] += size[i]; }
    return *this;
    }

  const Self &
  operator-=(const Size<VOffsetDimension> &size)
    {
    for (unsigned int i=0; i < VOffsetDimension; i++)
      { m_Offset[i] -= size[i]; }
    return *this;
    }

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

  const Self &
  operator+=(const Self &vec)
    {
    for (unsigned int i=0; i < VOffsetDimension; i++)
      { m_Offset[i] += vec.m_Offset[i]; }
    return *this;
    }

  const Self &
  operator-=(const Self &vec)
    {
    for (unsigned int i=0; i < VOffsetDimension; i++)
      { m_Offset[i] -= vec.m_Offset[i]; }
    return *this;
    }

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

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

  OffsetValueType & operator[](unsigned int dim)
    { return m_Offset[dim]; }

  OffsetValueType operator[](unsigned int dim) const
    { return m_Offset[dim]; }

  const OffsetValueType *GetOffset() const { return m_Offset; };

  void SetOffset(const OffsetValueType val[VOffsetDimension])
    { memcpy(m_Offset, val, sizeof(OffsetValueType)*VOffsetDimension); }

  static Self GetBasisOffset(unsigned int dim); 

  void Fill(OffsetValueType value)
    { for(unsigned int i=0;i < VOffsetDimension; ++i) m_Offset[i] = value; }
  
  OffsetValueType m_Offset[VOffsetDimension];


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

};


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

template<unsigned int VOffsetDimension>
Offset<VOffsetDimension> 
Offset<VOffsetDimension>
::GetBasisOffset(unsigned int dim)
{
  Self ind;
  
  memset(ind.m_Offset, 0, sizeof(OffsetValueType)*VOffsetDimension);
  ind.m_Offset[dim] = 1;
  return ind;
}

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

} // end namespace itk

#endif