#pragma once
 
#ifndef TCG_PIXEL_H
#define TCG_PIXEL_H
 
// tcg includes
#include "pixel_ops.h"
 
// STD includes
#include <limits>
 
namespace tcg
{
 
//***********************************************************
//    Tcg Pixel Types  definition
//***********************************************************
 
template <typename Chan, typename pixel_category>
struct Pixel;
 
template <typename Chan>
struct Pixel<Chan, grayscale_pixel_tag> {
	typedef grayscale_pixel_tag pixel_category;
	typedef Chan channel_type;
 
public:
	channel_type l;
 
public:
	Pixel() : l() {}
	Pixel(channel_type _l) : l(_l) {}
 
	bool operator==(const Pixel &other) const { return l == other.l; }
	bool operator!=(const Pixel &other) const { return l != other.l; }
};
 
template <typename Chan>
struct Pixel<Chan, rgb_pixel_tag> {
	typedef rgb_pixel_tag pixel_category;
	typedef Chan channel_type;
 
public:
	channel_type r, g, b;
 
public:
	Pixel() : r(), g(), b() {}
	Pixel(channel_type _r, channel_type _g, channel_type _b)
		: r(_r), g(_g), b(_b) {}
 
	bool operator==(const Pixel &other) const
	{
		return (r == other.r) && (g == other.g) && (g == other.g);
	}
	bool operator!=(const Pixel &other) const
	{
		return (r != other.r) || (g != other.g) || (g != other.g);
	}
};
 
template <typename Chan>
struct Pixel<Chan, rgbm_pixel_tag> {
	typedef rgbm_pixel_tag pixel_category;
	typedef Chan channel_type;
 
public:
	channel_type r, g, b, m;
 
public:
	Pixel() : r(), g(), b(), m() {}
	Pixel(channel_type _r, channel_type _g, channel_type _b, channel_type _m)
		: r(_r), g(_g), b(_b), m(_m) {}
 
	bool operator==(const Pixel &other) const
	{
		return (r == other.r) && (g == other.g) && (g == other.g) && (m == other.m);
	}
	bool operator!=(const Pixel &other) const
	{
		return (r != other.r) || (g != other.g) || (g != other.g) || (m != other.m);
	}
};
 
//***********************************************************
//    Tcg Pixel  traits
//***********************************************************
 
namespace pixel_ops
{
 
template <typename Chan>
struct pixel_traits<Pixel<Chan, grayscale_pixel_tag>, grayscale_pixel_tag> {
	typedef Pixel<Chan, grayscale_pixel_tag> pixel_type;
	typedef grayscale_pixel_tag pixel_category;
	typedef Chan channel_type;
 
	enum { channels_count = 1 };
 
	static channel_type max_channel_value() { return (std::numeric_limits<channel_type>::max)(); }
 
	static channel_type l(const pixel_type &pix) { return pix.l; }
	static channel_type &l(pixel_type &pix) { return pix.l; }
};
 
template <typename Chan>
struct pixel_traits<Pixel<Chan, rgb_pixel_tag>, rgb_pixel_tag> {
	typedef Pixel<Chan, rgb_pixel_tag> pixel_type;
	typedef rgb_pixel_tag pixel_category;
	typedef Chan channel_type;
 
	enum { channels_count = 3 };
 
	static channel_type max_channel_value() { return (std::numeric_limits<channel_type>::max)(); }
 
	static channel_type r(const pixel_type &pix) { return pix.r; }
	static channel_type &r(pixel_type &pix) { return pix.r; }
 
	static channel_type g(const pixel_type &pix) { return pix.g; }
	static channel_type &g(pixel_type &pix) { return pix.g; }
 
	static channel_type b(const pixel_type &pix) { return pix.b; }
	static channel_type &b(pixel_type &pix) { return pix.b; }
};
 
template <typename Chan>
struct pixel_traits<Pixel<Chan, rgbm_pixel_tag>, rgbm_pixel_tag>
	: public pixel_traits<Pixel<Chan, rgb_pixel_tag>, rgb_pixel_tag> {
	typedef Pixel<Chan, rgbm_pixel_tag> pixel_type;
	typedef rgbm_pixel_tag pixel_category;
	typedef Chan channel_type;
 
	enum { channels_count = 4 };
 
	static channel_type m(const pixel_type &pix) { return pix.m; }
	static channel_type &m(pixel_type &pix) { return pix.m; }
};
}
} // namespace tcg::pixel_ops
 
#endif // TCG_PIXEL_H