#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