Scanline.hh

/*
This file is part of the BIAS library (Basic ImageAlgorithmS).

Copyright (C) 2003-2009    (see file CONTACT for details)
  Multimediale Systeme der Informationsverarbeitung
  Institut fuer Informatik
  Christian-Albrechts-Universitaet Kiel


BIAS is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.

BIAS 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with BIAS; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/


#ifndef __Scanline_hh__
#define __Scanline_hh__

#include <bias_config.h>
#include "Bresenham.hh"

namespace BIAS
{
/** @brief Class for scanning a region given by a line and
 *  a distance ca. perpendicular to the line
 *  GetNext() return on successive calls all image coordinates
 *  within +-epsilon from line given by start and end
 *  Fast implementation based on Bresenhams algorithm
 *  @ingroup g_image_other
 *  @note This is the old ScanLine2 class replacing ScanLine.
 *  @author Felix Woelk
 *  @date 01/2003
 */
  class Scanline : public Bresenham
  {

  public:
    inline Scanline();

    inline ~Scanline();

    inline Scanline(const int start[2], const int end[2], const int epsilon);

    inline Scanline(const unsigned int start[2], const unsigned int end[2],
                    const unsigned int epsilon);

    inline Scanline(const double start[2], const double end[2],
                    const double epsilon);

    inline void Init(const int start[2], const int end[2], const int epsilon);

    inline void Init(const unsigned int start[2], const unsigned int end[2],
                     const unsigned int epsilon)
    { Init((int *)start, (int *)end, (int)epsilon); };

    inline void Init(const double start[2], const double end[2],
                     double epsilon);

    inline bool GetNext(int next[2]);

    inline bool GetNext(unsigned int next[2])
    { return GetNext((int *)next); };

    inline bool GetNext(double next[2]);

  protected:
    int _iEpsilon;
    double _dDEpsilon;
    int _iEpsCount;
    int _iTransformedUpDown[2];

  }; // class

  Scanline::Scanline() : Bresenham() {}

  Scanline::~Scanline() {}

  Scanline::Scanline(const int start[2], const int end[2], const int epsilon)
  { Init(start, end, epsilon); }

  Scanline::Scanline(const unsigned int start[2], const unsigned int end[2],
                     const unsigned int epsilon)
  { Init(start, end, epsilon); }

  Scanline::Scanline(const double start[2], const double end[2],
                     const double epsilon)
  { Init(start, end, epsilon); }

  void Scanline::Init(const int start[2], const int end[2], const int epsilon)
  {
#ifdef BIAS_DEBUG
    if (epsilon<0){
      BIASERR("Epsilon should be greater or equal to zero!");
    }
#endif
    Bresenham::Init(start, end);
    _iEpsilon = epsilon;
    _iEpsCount = -1;

    _iTransformedCurrent[0]=_iTransformedStart[0];
    _iTransformedCurrent[1]=_iTransformedStart[1];
    // remember
    _iTransformedUpDown[0]=_iTransformedStart[0];
    _iTransformedUpDown[1]=_iTransformedStart[1];
    _iTransformedUpDown[1]-=_iEpsilon+1;
  }

  void Scanline::Init(const double start[2], const double end[2],
                      double epsilon)
  {
#ifdef BIAS_DEBUG
    if (epsilon<0){
      BIASERR("Epsilon should be greater or equal to zero!");
    }
#endif
    Bresenham::Init(start, end);
    _iEpsilon = (int)floor(epsilon);
    _dDEpsilon = epsilon - _iEpsilon;
    _iEpsCount = -1;
    _iTransformedUpDown[0]=_iTransformedStart[0];
    _iTransformedUpDown[1]=_iTransformedStart[1];
    _iTransformedUpDown[1]-=_iEpsilon;
  }

  bool Scanline::GetNext(int next[2])
  {
#ifdef BIAS_DEBUG
    if (!_bInitialized)
      BIASERR("call Init befor GetNext");
#endif
    bool result=true;
    if (_iEpsCount>=2*_iEpsilon){ // this is from bresenham
      _iEpsCount=0;
      _iTransformedCurrent[0]++;
      _iEps += _iDy;
      if ((_iEps << 1) >= _iDx){
        _iTransformedCurrent[1]++;
        _iEps -= _iDx;
      }
      if (_iTransformedCurrent[0]>_iTransformedEnd[0] ||
          _iTransformedCurrent[1]>_iTransformedEnd[1]){
        result=false;
      } else {
        _iTransformedUpDown[0]=_iTransformedCurrent[0];
        _iTransformedUpDown[1]=_iTransformedCurrent[1];
        _iTransformedUpDown[1]-=_iEpsilon;
        _iSym.InverseTransform(_eLineType, _iTransformedUpDown, next);
        result=true;
      }
    } else { // just go up and down
      _iTransformedUpDown[1]++;
      _iSym.InverseTransform(_eLineType, _iTransformedUpDown, next);
      _iEpsCount++;
    }
    return result;
  }

  bool Scanline::GetNext(double next[2])
  {
    bool result;
    int inext[2] = { 0, 0 };
    result = GetNext(inext);
    next[0]=(double)inext[0] + _dDx;
    next[1]=(double)inext[1] + _dDy;

    return result;
  }

} // namespace

#endif // __Scanline_hh__