#ifndef TCG_PIXEL_OPS_H

#define TCG_PIXEL_OPS_H

// tcg includes

#include "base.h"

namespace tcg

{

//**************************************************************************

//    Pixel Categories

//**************************************************************************

struct grayscale_pixel_tag {

};

struct rgb_pixel_tag {

};

struct rgbm_pixel_tag : public rgb_pixel_tag {

};

struct indexed_pixel_tag {

};

//**************************************************************************

//    Pixel Traits Types

//**************************************************************************

template <typename pix,="" pix::pixel_category="" pixel_category="typename" typename=""></typename>

struct pixel_traits_types;

template <typename pix=""></typename>

struct pixel_traits_types<pix, grayscale_pixel_tag=""> {</pix,>

	typedef Pix pixel_type;

	typedef grayscale_pixel_tag pixel_category;

	typedef typename Pix::channel_type channel_type;

	enum { channels_count = 1 };

};

template <typename pix=""></typename>

struct pixel_traits_types<pix, rgb_pixel_tag=""> {</pix,>

	typedef Pix pixel_type;

	typedef rgb_pixel_tag pixel_category;

	typedef typename Pix::channel_type channel_type;

	enum { channels_count = 3 };

};

template <typename pix=""></typename>

struct pixel_traits_types<pix, rgbm_pixel_tag=""></pix,>

	: public pixel_traits_types<pix, rgb_pixel_tag=""> {</pix,>

	typedef Pix pixel_type;

	typedef rgbm_pixel_tag pixel_category;

	typedef typename Pix::channel_type channel_type;

	enum { channels_count = 4 };

};

template <typename pix=""></typename>

struct pixel_traits_types<pix, indexed_pixel_tag=""> {</pix,>

	typedef Pix pixel_type;

	typedef indexed_pixel_tag pixel_category;

	typedef typename Pix::index_type index_type;

};

//**************************************************************************

//    Pixel Traits

//**************************************************************************

template <typename pix,="" pix::pixel_category="" pixel_category="typename" typename=""></typename>

struct pixel_traits;

template <typename pix=""></typename>

struct pixel_traits<pix, grayscale_pixel_tag=""></pix,>

	: public pixel_traits_types<pix, grayscale_pixel_tag=""> {</pix,>

	typedef pixel_traits_types<pix, grayscale_pixel_tag=""> tr;</pix,>

public:

	static typename tr::channel_type max_channel_value();

	static typename tr::channel_type l(const typename tr::pixel_type &pix);

	static typename tr::channel_type &l(typename tr::pixel_type &pix);

};

template <typename pix=""></typename>

struct pixel_traits<pix, rgb_pixel_tag=""> {</pix,>

	typedef pixel_traits_types<pix, rgb_pixel_tag=""> tr;</pix,>

public:

	static typename tr::channel_type max_channel_value();

	static typename tr::channel_type r(const typename tr::pixel_type &pix);

	static typename tr::channel_type &r(typename tr::pixel_type &pix);

	static typename tr::channel_type g(const typename tr::pixel_type &pix);

	static typename tr::channel_type &g(typename tr::pixel_type &pix);

	static typename tr::channel_type b(const typename tr::pixel_type &pix);

	static typename tr::channel_type &b(typename tr::pixel_type &pix);

};

template <typename pix=""></typename>

struct pixel_traits<pix, rgbm_pixel_tag=""> : public pixel_traits<pix, rgb_pixel_tag=""> {</pix,></pix,>

	typedef pixel_traits_types<pix, rgbm_pixel_tag=""> tr;</pix,>

public:

	static typename tr::channel_type m(const typename tr::pixel_type &pix);

	static typename tr::channel_type &m(typename tr::pixel_type &pix);

};

template <typename pix=""></typename>

struct pixel_traits<pix, indexed_pixel_tag=""> {</pix,>

	typedef pixel_traits_types<pix, indexed_pixel_tag=""> tr;</pix,>

	typedef typename tr::pixel_type pixel_type;

	typedef typename tr::index_type index_type;

public:

	static typename tr::index_type index(const typename tr::pixel_type &pix);

	static typename tr::index_type &index(typename tr::pixel_type &pix);

};

namespace pixel_ops

{

//**************************************************************************

//    Pixel Functions

//**************************************************************************

template <typename pixin,="" pixout="" typename=""></typename>

inline PixOut _cast(const PixIn &pix, grayscale_pixel_tag)

{

	return PixOut(pixel_traits<pixin>::l(pix));</pixin>

}

template <typename pixin,="" pixout="" typename=""></typename>

inline PixOut _cast(const PixIn &pix, rgb_pixel_tag)

{

	return PixOut(pixel_traits<pixin>::r(pix), pixel_traits<pixin>::g(pix), pixel_traits<pixin>::b(pix));</pixin></pixin></pixin>

}

template <typename pixin,="" pixout="" typename=""></typename>

inline PixOut _cast(const PixIn &pix, rgbm_pixel_tag)

{

	return PixOut(pixel_traits<pixin>::r(pix), pixel_traits<pixin>::g(pix), pixel_traits<pixin>::b(pix),</pixin></pixin></pixin>

				  pixel_traits<pixin>::m(pix));</pixin>

}

template <typename pixin,="" pixout="" typename=""></typename>

inline PixOut cast(const PixIn &pix)

{

	return _cast<pixin, pixout="">(pix, typename pixel_traits<pixin>::pixel_category());</pixin></pixin,>

}

//------------------------------------------------------------------

template <typename pixin,="" pixout="" typename=""></typename>

inline void _assign(PixOut &pixout, const PixIn &pixin, grayscale_pixel_tag)

{

	pixel_traits<pixout>::l(pixout) = pixel_traits<pixin>::l(pixin);</pixin></pixout>

}

template <typename pixin,="" pixout="" typename=""></typename>

inline void _assign(PixOut &pixout, const PixIn &pixin, rgb_pixel_tag)

{

	pixel_traits<pixout>::r(pixout) = pixel_traits<pixin>::r(pixin);</pixin></pixout>

	pixel_traits<pixout>::g(pixout) = pixel_traits<pixin>::g(pixin);</pixin></pixout>

	pixel_traits<pixout>::b(pixout) = pixel_traits<pixin>::b(pixin);</pixin></pixout>

}

template <typename pixin,="" pixout="" typename=""></typename>

inline void _assign(PixOut &pixout, const PixIn &pixin, rgbm_pixel_tag)

{

	pixel_traits<pixout>::r(pixout) = pixel_traits<pixin>::r(pixin);</pixin></pixout>

	pixel_traits<pixout>::g(pixout) = pixel_traits<pixin>::g(pixin);</pixin></pixout>

	pixel_traits<pixout>::b(pixout) = pixel_traits<pixin>::b(pixin);</pixin></pixout>

	pixel_traits<pixout>::m(pixout) = pixel_traits<pixin>::m(pixin);</pixin></pixout>

}

template <typename pixin,="" pixout="" typename=""></typename>

inline void assign(PixOut &pixout, const PixIn &pixin)

{

	_assign<pixin, pixout="">(pixout, pixin, typename pixel_traits<pixin>::pixel_category());</pixin></pixin,>

}

//------------------------------------------------------------------

template <typename pix1,="" pix2="" typename=""></typename>

inline Pix1 _sum(const Pix1 &a, const Pix2 &b, grayscale_pixel_tag)

{

	return Pix1(pixel_traits<pix1>::l(a) + pixel_traits<pix2>::l(b));</pix2></pix1>

}

template <typename pix1,="" pix2="" typename=""></typename>

inline Pix1 _sum(const Pix1 &a, const Pix2 &b, rgb_pixel_tag)

{

	return Pix1(pixel_traits<pix1>::r(a) + pixel_traits<pix2>::r(b),</pix2></pix1>

				pixel_traits<pix1>::g(a) + pixel_traits<pix2>::g(b),</pix2></pix1>

				pixel_traits<pix1>::b(a) + pixel_traits<pix2>::b(b));</pix2></pix1>

}

template <typename pix1,="" pix2="" typename=""></typename>

inline Pix1 _sum(const Pix1 &a, const Pix2 &b, rgbm_pixel_tag)

{

	return Pix1(pixel_traits<pix1>::r(a) + pixel_traits<pix2>::r(b),</pix2></pix1>

				pixel_traits<pix1>::g(a) + pixel_traits<pix2>::g(b),</pix2></pix1>

				pixel_traits<pix1>::b(a) + pixel_traits<pix2>::b(b),</pix2></pix1>

				pixel_traits<pix1>::m(a) + pixel_traits<pix2>::m(b));</pix2></pix1>

}

template <typename pix1,="" pix2="" typename=""></typename>

inline Pix1 operator+(const Pix1 &a, const Pix2 &b)

{

	return _sum(a, b, typename pixel_traits<pix2>::pixel_category());</pix2>

}

//------------------------------------------------------------------

template <typename pix1,="" pix2="" typename=""></typename>

inline Pix1 _sub(const Pix1 &a, const Pix2 &b, grayscale_pixel_tag)

{

	return Pix1(pixel_traits<pix1>::l(a) - pixel_traits<pix2>::l(b));</pix2></pix1>

}

template <typename pix1,="" pix2="" typename=""></typename>

inline Pix1 _sub(const Pix1 &a, const Pix2 &b, rgb_pixel_tag)

{

	return Pix1(pixel_traits<pix1>::r(a) - pixel_traits<pix2>::r(b),</pix2></pix1>

				pixel_traits<pix1>::g(a) - pixel_traits<pix2>::g(b),</pix2></pix1>

				pixel_traits<pix1>::b(a) - pixel_traits<pix2>::b(b));</pix2></pix1>

}

template <typename pix1,="" pix2="" typename=""></typename>

inline Pix1 _sub(const Pix1 &a, const Pix2 &b, rgbm_pixel_tag)

{

	return Pix1(pixel_traits<pix1>::r(a) - pixel_traits<pix2>::r(b),</pix2></pix1>

				pixel_traits<pix1>::g(a) - pixel_traits<pix2>::g(b),</pix2></pix1>

				pixel_traits<pix1>::b(a) - pixel_traits<pix2>::b(b),</pix2></pix1>

				pixel_traits<pix1>::m(a) - pixel_traits<pix2>::m(b));</pix2></pix1>

}

template <typename pix1,="" pix2="" typename=""></typename>

inline Pix1 operator-(const Pix1 &a, const Pix2 &b)

{

	return _sub(a, b, typename pixel_traits<pix2>::pixel_category());</pix2>

}

//------------------------------------------------------------------

template <typename pix,="" scalar="" typename=""></typename>

inline Pix _mult(const Pix &a, Scalar k, grayscale_pixel_tag)

{

	return Pix(pixel_traits<pix>::l(a) * k);</pix>

}

template <typename pix,="" scalar="" typename=""></typename>

inline Pix _mult(const Pix &a, Scalar k, rgb_pixel_tag)

{

	return Pix(pixel_traits<pix>::r(a) * k,</pix>

			   pixel_traits<pix>::g(a) * k,</pix>

			   pixel_traits<pix>::b(a) * k);</pix>

}

template <typename pix,="" scalar="" typename=""></typename>

inline Pix _mult(const Pix &a, Scalar k, rgbm_pixel_tag)

{

	return Pix(pixel_traits<pix>::r(a) * k,</pix>

			   pixel_traits<pix>::g(a) * k,</pix>

			   pixel_traits<pix>::b(a) * k,</pix>

			   pixel_traits<pix>::m(a) * k);</pix>

}

template <typename pix,="" scalar="" typename=""></typename>

inline Pix operator*(Scalar k, const Pix &pix)

{

	return _mult(pix, k, typename pixel_traits<pix>::pixel_category());</pix>

}

//------------------------------------------------------------------

template <typename pix,="" scalar="" typename=""></typename>

inline Pix _div(const Pix &a, Scalar k, grayscale_pixel_tag)

{

	return Pix(pixel_traits<pix>::l(a) / k);</pix>

}

template <typename pix,="" scalar="" typename=""></typename>

inline Pix _div(const Pix &a, Scalar k, rgb_pixel_tag)

{

	return Pix(pixel_traits<pix>::r(a) / k,</pix>

			   pixel_traits<pix>::g(a) / k,</pix>

			   pixel_traits<pix>::b(a) / k);</pix>

}

template <typename pix,="" scalar="" typename=""></typename>

inline Pix _div(const Pix &a, Scalar k, rgbm_pixel_tag)

{

	return Pix(pixel_traits<pix>::r(a) / k,</pix>

			   pixel_traits<pix>::g(a) / k,</pix>

			   pixel_traits<pix>::b(a) / k,</pix>

			   pixel_traits<pix>::m(a) / k);</pix>

}

template <typename pix,="" scalar="" typename=""></typename>

inline Pix operator/(const Pix &pix, Scalar k)

{

	return _div(pix, k, typename pixel_traits<pix>::pixel_category());</pix>

}

//------------------------------------------------------------------

template <typename pix,="" scalar="" typename=""></typename>

inline void premultiply(Pix &pix, Scalar = 0)

{

	Scalar factor = pixel_traits<pix>::m(pix) / Scalar(pixel_traits<pix>::max_channel_value);</pix></pix>

	pixel_traits<pix>::r(pix) = pixel_traits<pix>::r(pix) * factor;</pix></pix>

	pixel_traits<pix>::g(pix) = pixel_traits<pix>::g(pix) * factor;</pix></pix>

	pixel_traits<pix>::b(pix) = pixel_traits<pix>::b(pix) * factor;</pix></pix>

}

//------------------------------------------------------------------

template <typename pix,="" scalar="" typename=""></typename>

inline void depremultiply(Pix &pix, Scalar = 0)

{

	if (pixel_traits<pix>::channel_type m = pixel_traits<pix>::m(pix)) {</pix></pix>

		Scalar factor = pixel_traits<pix>::max_channel_value / Scalar(m);</pix>

		pixel_traits<pix>::r(pix) = pixel_traits<pix>::r(pix) * factor;</pix></pix>

		pixel_traits<pix>::g(pix) = pixel_traits<pix>::g(pix) * factor;</pix></pix>

		pixel_traits<pix>::b(pix) = pixel_traits<pix>::b(pix) * factor;</pix></pix>

	}

}

//------------------------------------------------------------------

template <typename pix,="" scalar="" typename=""></typename>

inline Pix _blend(const Pix &p0, const Pix &p1, Scalar t, grayscale_pixel_tag)

{

	return Pix((1 - t) * pixel_traits<pix>::l(p0) + t * pixel_traits<pix>::l(p1));</pix></pix>

}

//------------------------------------------------------------------

template <typename pix,="" scalar="" typename=""></typename>

inline Pix _blend(const Pix &p0, const Pix &p1, Scalar t, rgb_pixel_tag)

{

	Scalar one_t = 1 - t;

	return Pix(

		one_t * pixel_traits<pix>::r(p0) + t * pixel_traits<pix>::r(p1),</pix></pix>

		one_t * pixel_traits<pix>::g(p0) + t * pixel_traits<pix>::g(p1),</pix></pix>

		one_t * pixel_traits<pix>::m(p0) + t * pixel_traits<pix>::b(p1));</pix></pix>

}

//------------------------------------------------------------------

template <typename pix,="" scalar="" typename=""></typename>

inline Pix _blend(const Pix &p0, const Pix &p1, Scalar t, rgbm_pixel_tag)

{

	Scalar one_t = 1 - t;

	return Pix(

		one_t * pixel_traits<pix>::r(p0) + t * pixel_traits<pix>::r(p1),</pix></pix>

		one_t * pixel_traits<pix>::g(p0) + t * pixel_traits<pix>::g(p1),</pix></pix>

		one_t * pixel_traits<pix>::b(p0) + t * pixel_traits<pix>::b(p1),</pix></pix>

		one_t * pixel_traits<pix>::m(p0) + t * pixel_traits<pix>::m(p1));</pix></pix>

}

//------------------------------------------------------------------

template <typename pix,="" scalar="" typename=""></typename>

inline Pix blend(const Pix &p0, const Pix &p1, Scalar t)

{

	return _blend(p0, p1, t, pixel_traits<pix>::pixel_category());</pix>

}

//------------------------------------------------------------------

template <typename pix,="" scalar="" typename=""></typename>

inline void over_premult(Pix &down, const Pix &up, Scalar = 0)

{

	Scalar t = (1 - pixel_traits<pix>::m(up) / Scalar(pixel_traits<pix>::max_channel_value));</pix></pix>

	pixel_traits<pix>::r(down) = pixel_traits<pix>::r(up) + t * pixel_traits<pix>::r(down);</pix></pix></pix>

	pixel_traits<pix>::g(down) = pixel_traits<pix>::g(up) + t * pixel_traits<pix>::g(down);</pix></pix></pix>

	pixel_traits<pix>::b(down) = pixel_traits<pix>::b(up) + t * pixel_traits<pix>::b(down);</pix></pix></pix>

	pixel_traits<pix>::m(down) = pixel_traits<pix>::m(up) + t * pixel_traits<pix>::m(down);</pix></pix></pix>

}

//------------------------------------------------------------------

template <typename pix,="" scalar="" typename=""></typename>

inline void over(Pix &down, const Pix &up, Scalar = 0)

{

	Scalar t = (1 - pixel_traits<pix>::m(up) / Scalar(pixel_traits<pix>::max_channel_value)) *</pix></pix>

			   pixel_traits<pix>::m(down);</pix>

	Scalar m = pixel_traits<pix>::m(up) + t;</pix>

	Scalar up_fac = pixel_traits<pix>::m(up) / m;</pix>

	Scalar dn_fac = t / m;

	pixel_traits<pix>::r(down) = up_fac * pixel_traits<pix>::r(up) + dn_fac * pixel_traits<pix>::r(down);</pix></pix></pix>

	pixel_traits<pix>::g(down) = up_fac * pixel_traits<pix>::g(up) + dn_fac * pixel_traits<pix>::g(down);</pix></pix></pix>

	pixel_traits<pix>::b(down) = up_fac * pixel_traits<pix>::b(up) + dn_fac * pixel_traits<pix>::b(down);</pix></pix></pix>

	pixel_traits<pix>::m(down) = m;</pix>

}

}

} // namespace tcg::pixel_ops

#endif // TCG_PIXEL_OPS_H