spiralindex.h

Go to the documentation of this file.

#ifndef SPIRALINDEX_H
#define SPIRALINDEX_H

#include <point.h>
#include <typedefs.h>

template< typename T = int >
class spiralindex
{
  T count;
  T const countend;
  point2<T> current;
  point2<T> start;

  point2<T> xrange;
  point2<T> yrange;

  void directionclockwise();
  void directionanticlockwise();
public:

  T const rows;
  T const columns;
  point2<T> di[4];
  uint direction;

  spiralindex
  (
    T const _rows, 
    T const _columns, 
    boolc anticlockwise=true
  );

  void reset();
  boolc operator !() const
    { return count < countend; }
  void operator ++ ();
  void pos(T & row, T & col) const
    { row=current.x; col=current.y; }
  void pos(T & k2) const
    { k2 = current.x*columns+current.y; }
  boolc valid(point2<T> const & p) const;

  void indexsequence(T* seq);

};

template< typename T = int >
class spiralindex3D
{
  T* square0;
  T* square1;
  T* squarei;
  T zcount;
  T icount;
public:

  T const rows;
  T const columns;
  T const rectanglelength;

  spiralindex3D
  (
    T const _rows, 
    T const _columns, 
    T const _rectanglelength,
    boolc anticlockwise=true
  );
  ~spiralindex3D();

  void reset();
  boolc operator !() const
    { if (zcount<rectanglelength) return true; return false; }
  void pos(T & row, T & col, T & z) const;
  void pos(T & k2) const
    { k2 = zcount*rows*columns + icount; }

  void operator ++ ();

};

//---------------------------------------------------------
// Implementation


template< typename T >
void spiralindex3D<T>::pos(T & row, T & col, T & z) const
{
  T k(*squarei);
  col = k % columns;
  row = (k-col)/columns;
  z = zcount;
}

template< typename T >
void spiralindex3D<T>::operator ++ ()
{
  ++icount;

  // Reverse spiral incrementation.
  if ((zcount % 2)==1)
  {
    --squarei;
    if (squarei+1==square0)
    {
      ++zcount;
      icount=0;
      ++squarei;
    }

    return;
  }

  ++squarei;
  if (squarei==square1)
  {
    ++zcount;
    icount=0;
    --squarei;
  }
}


template< typename T >
void spiralindex3D<T>::reset()
{
  icount=0;
  zcount=0;
  squarei = square0;
}

template< typename T >
spiralindex3D<T>::~spiralindex3D()
{
  delete[] square0;
}


template< typename T >
spiralindex3D<T>::spiralindex3D
(
  T const _rows, 
  T const _columns, 
  T const _rectanglelength,
  boolc anticlockwise
)
  : rows(_rows), columns(_columns),
  rectanglelength(_rectanglelength)
{
  assert(rows>0);
  assert(columns>0);

  square0 = new T[rows*columns];
  square1 = square0 + rows*columns;
  spiralindex<T> spi(rows,columns,anticlockwise);
  spi.indexsequence(square0);

/*
cout << "square" << endl;
for (int i=0; i<rows*columns; ++i)
  cout << square0[i] << " ";
cout << endl << endl;
*/
}





template< typename T >
void spiralindex<T>::indexsequence(T* seq)
{
  //T k2;
  for ( reset(); operator !(); operator++() )
  {
    pos(*seq);
    ++seq;
  }
}

template< typename T >
void spiralindex<T>::directionclockwise()
{
  di[0] = point2<T>(0,1);
  di[1] = point2<T>(1,0);
  di[2] = point2<T>(0,-1);
  di[3] = point2<T>(-1,0);
}

template< typename T >
void spiralindex<T>::directionanticlockwise()
{
  di[0] = point2<T>(1,0);
  di[1] = point2<T>(0,1);
  di[2] = point2<T>(-1,0);
  di[3] = point2<T>(0,-1);
}

template< typename T >
spiralindex<T>::spiralindex
(
  T const _rows, 
  T const _columns, 
  boolc anticlockwise
)
  : count(0), countend(_rows*_columns), current(0,0), 
    rows(_rows), columns(_columns)
{
  assert(rows>0);
  assert(columns>0);

  if (anticlockwise)
    directionanticlockwise();
  else
    directionclockwise();
}

template< typename T >
boolc spiralindex<T>::valid(point2<T> const & p) const
{
  if (p.x==start.x)
  {
    if (p.y==start.y)
      return false;
  }

  if (p.x<yrange.x)
    return false;

  if (p.y<xrange.x)
    return false;

  if (p.x>yrange.y)
    return false;

  if (p.y>xrange.y)
    return false;

  return true;
}

template< typename T >
void spiralindex<T>::reset()
{
  current.x = 0;
  current.y = 0;
  count = 0;

  direction=0;

  start.x = 0;
  start.y = 0;

  xrange.x = 0;
  xrange.y = columns-1;
  yrange.x = 0;
  yrange.y = rows-1;
}

template< typename T >
void spiralindex<T>::operator ++ ()
{
  ++count;

  point2<T> c2 = current + di[direction];
  if (valid(c2)==false)
  {
    if (c2==start)
    {
      ++direction;
      direction %= 4;

      current += di[direction];
      start = current;

      ++xrange.x;
      --xrange.y;
      ++yrange.x;
      --yrange.y;
    }
    else
    {
      ++direction;
      direction %= 4;

      //start = current;
      current += di[direction];
    }
  }
  else
    current = c2;
}



#endif