#include "HSL.h"
#include "RGB.h"
#include "YUV.h"
#include "../utility.h"
namespace meow{
template<class T>
inline HSL<T>::HSL(){ }
template<class T>
inline HSL<T>::HSL(T const& h, T const& s, T const& l){
hsl_[0] = h; hsl_[1] = s; hsl_[2] = l;
}
template<class T>
inline HSL<T>::HSL(T const* hsl){
for(int i = 0; i < 3; i++) hsl_[i] = hsl[i];
}
template<class T>
inline T HSL<T>::h() const { return hsl_[0]; }
template<class T>
inline T HSL<T>::s() const { return hsl_[1]; }
template<class T>
inline T HSL<T>::l() const { return hsl_[2]; }
template<class T>
inline T HSL<T>::hsl(size_t i) const {
return hsl_[std::min((size_t)3 - 1, i)];
}
template<class T>
inline T HSL<T>::lsh(size_t i)const{return hsl(2-i);}
template<class T>
inline T HSL<T>::h(T const& val){return (hsl_[0]=val);}
template<class T>
inline T HSL<T>::s(T const& val){return (hsl_[1]=val);}
template<class T>
inline T HSL<T>::l(T const& val){return (hsl_[2]=val);}
template<class T>
inline T HSL<T>::hsl(size_t i, T const& val){
return (hsl_[std::min((size_t)3 - 1, i)] = val);
}
template<class T>
inline T HSL<T>::lsh(size_t i, T const& val){
return hsl(2 - i, val);
}
inline HSLf:: HSLf(): HSL(){ }
inline HSLf::~HSLf(){ }
inline HSLf::HSLf(double const&h,double const&s,double const&l):HSL(h,s,l){}
inline HSLf::HSLf(double const* hsl):HSL(hsl){}
inline double HSLf::hMin() const { return 0.0; }
inline double HSLf::hMax() const { return 2.0 * PI; }
inline double HSLf::sMin() const { return 0.0; }
inline double HSLf::sMax() const { return 1.0; }
inline double HSLf::lMin() const { return 0.0; }
inline double HSLf::lMax() const { return 1.0; }
template<class RGB_T, class HSL_T>
inline void RGB_to_HSL(RGB<RGB_T> const& rgb, HSL<HSL_T>* hsl){
double r = normalize(rgb.rMin(), rgb.rMax(), rgb.r());
double g = normalize(rgb.gMin(), rgb.gMax(), rgb.g());
double b = normalize(rgb.bMin(), rgb.bMax(), rgb.b());
double mx = std::max(std::max(r, g), b);
double mn = std::min(std::min(r, g), b);
double h, s, l;
if (mx == mn ) h = 0;
else if(mx == r && g >= b) h = PI/3.0 * (g-b) / (mx-mn);
else if(mx == r && g < b) h = PI/3.0 * (g-b) / (mx-mn) + PI * 2.0;
else if(mx == g ) h = PI/3.0 * (b-r) / (mx-mn) + PI/3.0*2.0;
else h = PI/3.0 * (r-g) / (mx-mn) + PI/3.0*4.0;
l = 0.5 * (mx + mn);
if (l == 0 || mx == mn) s = 0;
else if(l < 0.5 ) s = (mx - mn) / (2.0 * l);
else s = (mx - mn) / (2 - 2.0 * l);
hsl->h(h);
hsl->s(s);
hsl->l(l);
}
template<class HSL_T, class RGB_T>
inline void HSL_to_RGB(HSL<HSL_T> const& hsl, RGB<RGB_T>* rgb){
double h = normalize(hsl.hMin(), hsl.hMax(), hsl.h());
double s = normalize(hsl.sMin(), hsl.sMax(), hsl.s());
double l = normalize(hsl.lMin(), hsl.lMax(), hsl.l());
if(s == 0){
rgb->r(denormalize(rgb->rMin(), rgb->rMax(), l));
rgb->g(denormalize(rgb->gMin(), rgb->gMax(), l));
rgb->b(denormalize(rgb->bMin(), rgb->bMax(), l));
return ;
}
double q = (l < 0.5 ? (l * (1 + s)) : (l + s - (l * s)));
double p = 2 * l - q;
double t_r = h + 1.0 / 3.0;
double t_g = h;
double t_b = h - 1.0 / 3.0;
if(t_r < 0) t_r = t_r + 1.0;
if(t_r > 1) t_r = t_r - 1.0;
if(t_g < 0) t_g = t_g + 1.0;
if(t_g > 1) t_g = t_g - 1.0;
if(t_b < 0) t_b = t_b + 1.0;
if(t_b > 1) t_b = t_b - 1.0;
double r, g, b;
if (t_r < 1.0 / 6.0) r = p + (q - p) * 6 * t_r;
else if(t_r < 0.5 ) r = q;
else if(t_r < 2.0 / 3.0) r = p + (q - p) * 6 * (2.0 / 3.0 - t_r);
else r = p;
if (t_g < 1.0 / 6.0) g = p + (q - p) * 6 * t_g;
else if(t_g < 0.5 ) g = q;
else if(t_g < 2.0 / 3.0) g = p + (q - p) * 6 * (2.0 / 3.0 - t_g);
else g = p;
if (t_b < 1.0 / 6.0) b = p + (q - p) * 6 * t_b;
else if(t_b < 0.5 ) b = q;
else if(t_b < 2.0 / 3.0) b = p + (q - p) * 6 * (2.0 / 3.0 - t_b);
else b = p;
rgb->r(denormalize(rgb->rMin(), rgb->rMax(), r));
rgb->g(denormalize(rgb->gMin(), rgb->gMax(), g));
rgb->b(denormalize(rgb->bMin(), rgb->bMax(), b));
}
template<class YUV_T, class HSL_T>
inline void YUV_to_HSL(YUV<YUV_T> const& yuv, HSL<HSL_T>* hsl){
RGBf tmp;
YUV_to_RGB(yuv, &tmp);
RGB_to_HSL(tmp, hsl);
}
template<class HSL_T, class YUV_T>
inline void HSL_to_YUV(HSL<HSL_T> const& hsl, YUV<YUV_T>* yuv){
RGBf tmp;
HSL_to_RGB(hsl, &tmp);
RGB_to_YUV(tmp, yuv);
}
}
