// #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=""></typename>

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;</pixel_type>

  typedef TRasterPT<pixel_type> raster_typeP;</pixel_type>

  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