// #pragma once // could not use by INCLUDE_HPP
 
#ifndef RASTER_EDGE_ITERATOR_H
#define RASTER_EDGE_ITERATOR_H
 
#include "traster.h"
 
namespace TRop {
namespace borders {
 
//*********************************************************************************************************
//    RasterEdgeIterator class
//*********************************************************************************************************
 
/*!
  The RasterEdgeIterator class models a forward iterator traversing a border of
  a
  raster image.
*/
template <typename PixelSelector>
class RasterEdgeIterator {
public:
  typedef PixelSelector selector_type;
  typedef typename PixelSelector::pixel_type pixel_type;
  typedef typename PixelSelector::value_type value_type;
  typedef TRasterT<pixel_type> raster_type;
  typedef TRasterPT<pixel_type> raster_typeP;
 
  enum {
    STRAIGHT        = 0x0,
    LEFT            = 0x1,
    RIGHT           = 0x2,
    AMBIGUOUS       = 0x4,
    AMBIGUOUS_LEFT  = LEFT | AMBIGUOUS,
    AMBIGUOUS_RIGHT = RIGHT | AMBIGUOUS,
    UNKNOWN         = 0x8
  };
 
private:
  raster_typeP m_ras;
  selector_type m_selector;
 
  int m_lx_1, m_ly_1, m_wrap;
 
  value_type m_leftColor, m_rightColor, m_elbowColor;
  pixel_type *m_leftPix, *m_rightPix;
 
  bool m_rightSide;
  int m_turn;
 
  TPoint m_pos, m_dir;
 
public:
  RasterEdgeIterator(const raster_typeP &rin, const selector_type &selector,
                     const TPoint &pos, const TPoint &dir,
                     int adherence = RIGHT);
 
  void setEdge(const TPoint &pos, const TPoint &dir);
 
  const raster_typeP &raster() const { return m_ras; }
  const selector_type &selector() const { return m_selector; }
 
  const TPoint &pos() const { return m_pos; }
  const TPoint &dir() const { return m_dir; }
 
  const value_type &leftColor() const { return m_leftColor; }
  const value_type &rightColor() const { return m_rightColor; }
 
  const value_type &color() const {
    return m_rightSide ? m_rightColor : m_leftColor;
  }
  const value_type &otherColor() const {
    return m_rightSide ? m_leftColor : m_rightColor;
  }
  const value_type &elbowColor() const { return m_elbowColor; }
 
  pixel_type *leftPix() const { return m_leftPix; }
  pixel_type *rightPix() const { return m_rightPix; }
 
  pixel_type *pix() const { return m_rightSide ? m_rightPix : m_leftPix; }
  pixel_type *otherPix() const { return m_rightSide ? m_leftPix : m_rightPix; }
 
  int turn() const { return m_turn; }
 
  void setAdherence(int side) { m_rightSide = (side == RIGHT); }
  int adherence() const { return m_rightSide ? RIGHT : LEFT; }
 
  RasterEdgeIterator &operator++();
 
  bool operator==(const RasterEdgeIterator &it) const {
    return m_pos == it.m_pos && m_dir == it.m_dir;
  }
  bool operator!=(const RasterEdgeIterator &it) const {
    return !operator==(it);
  }
 
private:
  void pixels(pixel_type *&pixLeft, pixel_type *&pixRight);
  void colors(value_type &leftColor, value_type &rightColor);
  void turn(const value_type &newLeftColor, const value_type &newRightColor);
  void turnLeft() {
    int temp = m_dir.x;
    m_dir.x  = -m_dir.y;
    m_dir.y  = temp;
    m_turn   = LEFT;
  }
  void turnRight() {
    int temp = m_dir.x;
    m_dir.x  = m_dir.y;
    m_dir.y  = -temp;
    m_turn   = RIGHT;
  }
  void turnAmbiguous(const value_type &newLeftColor,
                     const value_type &newRightColor);
};
}
}  // namespace TRop::borders
 
#endif  // RASTER_EDGE_ITERATOR_H
 
//=====================================================================================
 
#ifdef INCLUDE_HPP
#include "raster_edge_iterator.hpp"
#endif  // INCLUDE_HPP