00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026 #ifndef MLN_VALUE_HSL_HH
00027 # define MLN_VALUE_HSL_HH
00028
00029 #include <mln/value/ops.hh>
00030
00031 #include <mln/value/concept/vectorial.hh>
00032 #include <mln/value/int_u.hh>
00033 #include <mln/algebra/vec.hh>
00034
00035
00036 #include <mln/fun/v2v/rgb_to_hsl.hh>
00037
00038
00039 namespace mln
00040 {
00041
00042
00043 namespace value
00044 {
00045
00046 template <typename H, typename S, typename L>
00047 class hsl_;
00048
00049 }
00050
00051
00052
00053 namespace convert
00054 {
00055
00056 namespace over_load
00057 {
00058
00059
00060 void
00061 from_to_(const value::rgb<16>& from, value::hsl_<float,float,float>& to);
00062
00063
00064 void
00065 from_to_(const value::rgb<8>& from, value::hsl_<float,float,float>& to);
00066
00067 }
00068
00069 }
00070
00071
00072
00073 namespace trait
00074 {
00075
00076 template <typename H, typename S, typename L>
00077 struct set_precise_binary_< op::plus, mln::value::hsl_<H,S,L>, mln::value::hsl_<H,S,L> >
00078 {
00079 typedef mln::value::hsl_<H,S,L> ret;
00080 };
00081
00082 template <typename H, typename S, typename L>
00083 struct set_precise_binary_< op::minus, mln::value::hsl_<H,S,L>, mln::value::hsl_<H,S,L> >
00084 {
00085 typedef mln::value::hsl_<H,S,L> ret;
00086 };
00087
00088 template <typename H, typename S, typename L, typename S2>
00089 struct set_precise_binary_< op::times, mln::value::hsl_<H,S,L>, mln::value::scalar_<S2> >
00090 {
00091 typedef mln::value::hsl_<H,S,L> ret;
00092 };
00093
00094 template <typename H, typename S, typename L, typename S2>
00095 struct set_precise_binary_< op::div, mln::value::hsl_<H,S,L>, mln::value::scalar_<S2> >
00096 {
00097 typedef mln::value::hsl_<H,S,L> ret;
00098 };
00099
00100
00101
00102
00103
00104
00105
00106
00107 template <typename H, typename S, typename L, unsigned m>
00108 struct set_precise_binary_< op::times, mln::value::hsl_<H,S,L>, mln::value::int_u<m> >
00109 {
00110 typedef mln::value::hsl_<H,S,L> ret;
00111 };
00112
00113 template <typename H, typename S, typename L, unsigned m>
00114 struct set_precise_binary_< op::div, mln::value::hsl_<H,S,L>, mln::value::int_u<m> >
00115 {
00116 typedef mln::value::hsl_<H,S,L> ret;
00117 };
00118
00119 template <typename H, typename S, typename L>
00120 struct value_< mln::value::hsl_<H,S,L> >
00121 {
00122 enum {
00123 dim = 3,
00124 nbits = (sizeof (H) + sizeof (S) + sizeof (L)) * 8,
00125 card = mln_value_card_from_(nbits)
00126 };
00127
00128 typedef trait::value::nature::vectorial nature;
00129 typedef trait::value::kind::color kind;
00130 typedef mln_value_quant_from_(card) quant;
00131
00132 typedef void comp;
00133 typedef H comp_0;
00134 typedef S comp_1;
00135 typedef L comp_2;
00136
00137 template <typename V> static comp_0 get_comp_0(const V& v) { return v.hue(); }
00138 template <typename V> static comp_1 get_comp_1(const V& v) { return v.sat(); }
00139 template <typename V> static comp_2 get_comp_2(const V& v) { return v.lum(); }
00140
00141
00142 typedef mln::value::hsl_<H,S,L> sum;
00143 };
00144
00145 }
00146
00147
00148 namespace value
00149 {
00150
00151 template <typename E>
00152 struct HSL : Object<E>
00153 {
00154 };
00155
00156 template <typename H, typename S, typename L>
00157 class hsl_ : public HSL< hsl_<H,S,L> >
00158 {
00159 public:
00160
00161 typedef H h_type;
00162 typedef S s_type;
00163 typedef L l_type;
00164
00166 hsl_()
00167 {
00168 }
00169
00170 hsl_(const literal::zero_t&)
00171 : hue_(0),
00172 sat_(0),
00173 lum_(0)
00174 {
00175 }
00176
00178 hsl_(const H& hue, const S& sat, const L& lum)
00179 : hue_(hue),
00180 sat_(sat),
00181 lum_(lum)
00182 {
00183 }
00184
00186 const H& hue() const;
00187 const S& sat() const;
00188 const L& lum() const;
00189
00191 H& hue();
00192 S& sat();
00193 L& lum();
00194
00195 private:
00196
00197 H hue_;
00198 S sat_;
00199 L lum_;
00200 };
00201
00202 typedef hsl_<float, float, float> hsl_f;
00203
00204 typedef hsl_<double, double, double> hsl_d;
00205
00206
00213 template <typename H, typename S, typename L>
00214 std::ostream& operator<<(std::ostream& ostr, const hsl_<H,S,L>& c);
00215
00216
00219 template <typename H, typename S, typename L>
00220 hsl_<H,S,L>
00221 operator+(const hsl_<H,S,L>& lhs, const hsl_<H,S,L>& rhs);
00223
00226 template <typename H, typename S, typename L>
00227 hsl_<H,S,L>
00228 operator-(const hsl_<H,S,L>& lhs, const hsl_<H,S,L>& rhs);
00230
00233 template <typename H, typename S, typename L, typename S2>
00234 hsl_<H,S,L>
00235 operator*(const hsl_<H,S,L>& lhs, const mln::value::scalar_<S2>& s);
00237
00240 template <typename H, typename S, typename L, typename S2>
00241 hsl_<H,S,L>
00242 operator/(const hsl_<H,S,L>& lhs, const mln::value::scalar_<S2>& s);
00244
00247 template <typename H, typename S, typename L>
00248 bool
00249 operator==(const hsl_<H,S,L>& lhs, const hsl_<H,S,L>& rhs);
00251
00252 }
00253
00254
00255
00256
00257 namespace fun
00258 {
00259 namespace v2v
00260 {
00261
00262 template <typename T_hsl>
00263 struct f_rgb_to_hsl_;
00264
00265 typedef f_rgb_to_hsl_<value::hsl_f> f_rgb_to_hsl_f_t;
00266
00267 extern f_rgb_to_hsl_f_t f_rgb_to_hsl_f;
00268
00269 }
00270
00271 }
00272
00273 # ifndef MLN_INCLUDE_ONLY
00274
00275
00276 namespace value
00277 {
00278
00279 template <typename H, typename S, typename L>
00280 const H&
00281 hsl_<H,S,L>::hue() const
00282 {
00283 return this->hue_;
00284 }
00285
00286 template <typename H, typename S, typename L>
00287 const S&
00288 hsl_<H,S,L>::sat() const
00289 {
00290 return this->sat_;
00291 }
00292
00293 template <typename H, typename S, typename L>
00294 const L&
00295 hsl_<H,S,L>::lum() const
00296 {
00297 return this->lum_;
00298 }
00299
00300 template <typename H, typename S, typename L>
00301 H&
00302 hsl_<H,S,L>::hue()
00303 {
00304 return this->hue_;
00305 }
00306
00307 template <typename H, typename S, typename L>
00308 S&
00309 hsl_<H,S,L>::sat()
00310 {
00311 return this->sat_;
00312 }
00313
00314 template <typename H, typename S, typename L>
00315 L&
00316 hsl_<H,S,L>::lum()
00317 {
00318 return this->lum_;
00319 }
00320
00321
00322 template <typename H, typename S, typename L>
00323 inline
00324 std::ostream& operator<<(std::ostream& ostr, const hsl_<H,S,L>& v)
00325 {
00326 return ostr << '(' << debug::format(v.hue())
00327 << ',' << debug::format(v.sat())
00328 << ',' << debug::format(v.lum())
00329 << ')';
00330 }
00331
00332
00333 template <typename H, typename S, typename L>
00334 hsl_<H,S,L>
00335 operator+(const hsl_<H,S,L>& lhs, const hsl_<H,S,L>& rhs)
00336 {
00337 return hsl_<H,S,L>(lhs.hue() + rhs.hue(),
00338 lhs.sat() + rhs.sat(),
00339 lhs.lum() + rhs.lum());
00340 }
00341
00342
00343 template <typename H, typename S, typename L>
00344 hsl_<H,S,L>
00345 operator-(const hsl_<H,S,L>& lhs, const hsl_<H,S,L>& rhs)
00346 {
00347 return hsl_<H,S,L>(lhs.hue() - rhs.hue(),
00348 lhs.sat() - rhs.sat(),
00349 lhs.lum() - rhs.lum());
00350 }
00351
00352
00353 template <typename H, typename S, typename L, typename S2>
00354 hsl_<H,S,L>
00355 operator*(const hsl_<H,S,L>& lhs, const mln::value::scalar_<S2>& s)
00356 {
00357 return hsl_<H,S,L>(lhs.hue() * s,
00358 lhs.sat() * s,
00359 lhs.lum() * s);
00360 }
00361
00362
00363 template <typename H, typename S, typename L, typename S2>
00364 hsl_<H,S,L>
00365 operator/(const hsl_<H,S,L>& lhs, const mln::value::scalar_<S2>& s)
00366 {
00367 return hsl_<H,S,L>(lhs.hue() / s,
00368 lhs.sat() / s,
00369 lhs.lum() / s);
00370 }
00371
00372 template <typename H, typename S, typename L>
00373 bool
00374 operator==(const hsl_<H,S,L>& lhs, const hsl_<H,S,L>& rhs)
00375 {
00376 return lhs.hue() == rhs.hue()
00377 && lhs.sat() == rhs.sat()
00378 && lhs.lum() == rhs.lum();
00379 }
00380
00381 }
00382
00383
00384 namespace convert
00385 {
00386
00387 namespace over_load
00388 {
00389
00390 inline
00391 void
00392 from_to_(const value::rgb<16>& from, value::hsl_<float,float,float>& to)
00393 {
00394 to = fun::v2v::f_rgb_to_hsl_f(from);
00395 }
00396
00397 inline
00398 void
00399 from_to_(const value::rgb<8>& from, value::hsl_<float,float,float>& to)
00400 {
00401 to = fun::v2v::f_rgb_to_hsl_f(from);
00402 }
00403
00404 }
00405
00406 }
00407
00408
00409 # endif // ! MLN_INCLUDE_ONLY
00410
00411
00412 }
00413
00414 #endif // ! MLN_VALUE_HSL_HH