[ VIGRA Homepage | Class Index | Function Index | File Index | Main Page ]
![]() |
vigra/rgbvalue.hxx | ![]() |
---|
00001 /************************************************************************/ 00002 /* */ 00003 /* Copyright 1998-2002 by Ullrich Koethe */ 00004 /* Cognitive Systems Group, University of Hamburg, Germany */ 00005 /* */ 00006 /* This file is part of the VIGRA computer vision library. */ 00007 /* ( Version 1.3.2, Jan 27 2005 ) */ 00008 /* You may use, modify, and distribute this software according */ 00009 /* to the terms stated in the LICENSE file included in */ 00010 /* the VIGRA distribution. */ 00011 /* */ 00012 /* The VIGRA Website is */ 00013 /* http://kogs-www.informatik.uni-hamburg.de/~koethe/vigra/ */ 00014 /* Please direct questions, bug reports, and contributions to */ 00015 /* koethe@informatik.uni-hamburg.de */ 00016 /* */ 00017 /* THIS SOFTWARE IS PROVIDED AS IS AND WITHOUT ANY EXPRESS OR */ 00018 /* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED */ 00019 /* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. */ 00020 /* */ 00021 /************************************************************************/ 00022 00023 00024 #ifndef VIGRA_RGBVALUE_HXX 00025 #define VIGRA_RGBVALUE_HXX 00026 00027 #include <cmath> // abs(double) 00028 #include <cstdlib> // abs(int) 00029 #include "vigra/config.hxx" 00030 #include "vigra/numerictraits.hxx" 00031 #include "vigra/accessor.hxx" 00032 #include "vigra/tinyvector.hxx" 00033 00034 namespace vigra { 00035 00036 /********************************************************/ 00037 /* */ 00038 /* RGBValue */ 00039 /* */ 00040 /********************************************************/ 00041 00042 /** \brief Class for a single RGB value. 00043 00044 This class contains three values (of the specified type) that represent 00045 red, green, and blue color channels. There are three possibilities 00046 to access these values: accessor functions (\ref red(), \ref green(), 00047 \ref blue()), index operator (operator[](dx), where 0 is red, 00048 1 is green and 2 is blue) and iterator (STL-compatible random access 00049 iterator that references the three colors in turn). The latter two 00050 methods, together with the necessary embedded typedefs, ensure 00051 compatibility of a RGBValue with a STL vector. 00052 00053 \ref RGBValueOperators "Arithmetic operations" are defined as component-wise applications of these 00054 operations. Addition, subtraction, and multiplication of two RGBValues 00055 (+=, -=, *=, +, -, *, unary -), multiplication and division of an 00056 RGBValue with a double, and NumericTraits/PromoteTraits are defined, 00057 so that RGBValue fulfills the requirements of a \ref LinearAlgebra. 00058 00059 A number of \ref RGBValueAccessors "accessors" are provided 00060 that support access to RGBValues as a whole, to a selected 00061 color component, or to the luminance value. 00062 00063 <b>\#include</b> "<a href="rgbvalue_8hxx-source.html">vigra/rgbvalue.hxx</a>"<br> 00064 Namespace: vigra 00065 */ 00066 template <class VALUETYPE> 00067 class RGBValue 00068 : public TinyVector<VALUETYPE, 3> 00069 { 00070 typedef TinyVector<VALUETYPE, 3> Base; 00071 public: 00072 /** STL-compatible definition of valuetype 00073 */ 00074 typedef VALUETYPE value_type; 00075 /** STL-compatible definition of iterator 00076 */ 00077 typedef typename TinyVector<VALUETYPE, 3>::iterator iterator; 00078 /** STL-compatible definition of const iterator 00079 */ 00080 typedef typename TinyVector<VALUETYPE, 3>::const_iterator const_iterator; 00081 00082 /** Construct from explicit color values 00083 */ 00084 RGBValue(value_type red, value_type green, value_type blue) 00085 : Base(red, green, blue) 00086 {} 00087 00088 /** Construct gray value 00089 */ 00090 RGBValue(value_type gray) 00091 : Base(gray, gray, gray) 00092 {} 00093 00094 /** Construct from another sequence (must have length 3!) 00095 */ 00096 template <class Iterator> 00097 RGBValue(Iterator i, Iterator end) 00098 : Base(i[0], i[1], i[2]) 00099 {} 00100 00101 /** Default constructor (sets all components to 0) 00102 */ 00103 RGBValue() 00104 : Base(0, 0, 0) 00105 {} 00106 00107 #if !defined(TEMPLATE_COPY_CONSTRUCTOR_BUG) 00108 00109 RGBValue(RGBValue const & r) 00110 : Base(r) 00111 {} 00112 00113 RGBValue & operator=(RGBValue const & r) 00114 { 00115 Base::operator=(r); 00116 return *this; 00117 } 00118 00119 #endif // TEMPLATE_COPY_CONSTRUCTOR_BUG 00120 00121 00122 /** Copy constructor. 00123 */ 00124 template <class U> 00125 RGBValue(RGBValue<U> const & r) 00126 : Base(r) 00127 {} 00128 00129 /** Copy assignment. 00130 */ 00131 template <class U> 00132 RGBValue & operator=(RGBValue<U> const & r) 00133 { 00134 Base::operator=(r); 00135 return *this; 00136 } 00137 00138 /** construct from TinyVector 00139 */ 00140 RGBValue(TinyVector<value_type, 3> const & r) 00141 : Base(r) 00142 {} 00143 00144 /** assign TinyVector. 00145 */ 00146 RGBValue & operator=(TinyVector<value_type, 3> const & r) 00147 { 00148 Base::operator=(r); 00149 return *this; 00150 } 00151 00152 /** Unary negation (construct RGBValue with negative values) 00153 */ 00154 RGBValue operator-() const 00155 { 00156 return RGBValue(-red(), -green(), -blue()); 00157 } 00158 00159 /** Access red component. 00160 */ 00161 value_type & red() { return (*this)[0]; } 00162 00163 /** Access green component. 00164 */ 00165 value_type & green() { return (*this)[1]; } 00166 00167 /** Access blue component. 00168 */ 00169 value_type & blue() { return (*this)[2]; } 00170 00171 /** Get red component. 00172 */ 00173 value_type const & red() const { return (*this)[0]; } 00174 00175 /** Get green component. 00176 */ 00177 value_type const & green() const { return (*this)[1]; } 00178 00179 /** Get blue component. 00180 */ 00181 value_type const & blue() const { return (*this)[2]; } 00182 00183 /** Calculate luminance. 00184 */ 00185 value_type luminance() const { 00186 return detail::RequiresExplicitCast<value_type>::cast(0.3*red() + 0.59*green() + 0.11*blue()); } 00187 00188 /** Calculate magnitude. 00189 */ 00190 typename NumericTraits<VALUETYPE>::RealPromote 00191 magnitude() const { 00192 return VIGRA_CSTD::sqrt( 00193 (typename NumericTraits<VALUETYPE>::RealPromote)squaredMagnitude()); 00194 } 00195 00196 /** Calculate squared magnitude. 00197 */ 00198 typename NumericTraits<VALUETYPE>::Promote 00199 squaredMagnitude() const { 00200 return red()*red() + green()*green() + blue()*blue(); 00201 } 00202 00203 /** Set red component. The type <TT>V</TT> of the passed 00204 in <TT>value</TT> is automatically converted to <TT>VALUETYPE</TT>. 00205 */ 00206 template <class V> 00207 void setRed(V value) { (*this)[0] = detail::RequiresExplicitCast<value_type>::cast(value); } 00208 00209 /** Set green component.The type <TT>V</TT> of the passed 00210 in <TT>value</TT> is automatically converted to <TT>VALUETYPE</TT>. 00211 */ 00212 template <class V> 00213 void setGreen(V value) { (*this)[1] = detail::RequiresExplicitCast<value_type>::cast(value); } 00214 00215 /** Set blue component.The type <TT>V</TT> of the passed 00216 in <TT>value</TT> is automatically converted to <TT>VALUETYPE</TT>. 00217 */ 00218 template <class V> 00219 void setBlue(V value) { (*this)[2] = detail::RequiresExplicitCast<value_type>::cast(value); } 00220 00221 00222 template <class V> 00223 void setRGB(V r, V g, V b) 00224 { 00225 (*this)[0] = detail::RequiresExplicitCast<value_type>::cast(r); 00226 (*this)[1] = detail::RequiresExplicitCast<value_type>::cast(g); 00227 (*this)[2] = detail::RequiresExplicitCast<value_type>::cast(b); 00228 } 00229 }; 00230 00231 /********************************************************/ 00232 /* */ 00233 /* RGBValue Comparison */ 00234 /* */ 00235 /********************************************************/ 00236 00237 /** \addtogroup RGBValueOperators Functions for RGBValue 00238 00239 \brief <b>\#include</b> "<a href="rgbvalue_8hxx-source.html">vigra/rgbvalue.hxx</a> 00240 00241 These functions fulfill the requirements of a Linear Algebra. 00242 Return types are determined according to \ref RGBValueTraits. 00243 00244 Namespace: vigra 00245 <p> 00246 00247 */ 00248 //@{ 00249 /// component-wise equal 00250 template <class V1, class V2> 00251 inline 00252 bool 00253 operator==(RGBValue<V1> const & l, RGBValue<V2> const & r) 00254 { 00255 return (l.red() == r.red()) && 00256 (l.green() == r.green()) && 00257 (l.blue() == r.blue()); 00258 } 00259 00260 /// component-wise not equal 00261 template <class V1, class V2> 00262 inline 00263 bool 00264 operator!=(RGBValue<V1> const & l, RGBValue<V2> const & r) 00265 { 00266 return (l.red() != r.red()) || 00267 (l.green() != r.green()) || 00268 (l.blue() != r.blue()); 00269 } 00270 00271 00272 //@} 00273 00274 /********************************************************/ 00275 /* */ 00276 /* RGBValue-Traits */ 00277 /* */ 00278 /********************************************************/ 00279 00280 /** \page RGBValueTraits Numeric and Promote Traits of RGBValue 00281 The numeric and promote traits for RGBValues follow 00282 the general specifications for \ref NumericPromotionTraits. 00283 They are implemented in terms of the traits of the basic types by 00284 partial template specialization: 00285 00286 \code 00287 00288 template <class T> 00289 struct NumericTraits<RGBValue<T> > 00290 { 00291 typedef RGBValue<typename NumericTraits<T>::Promote> Promote; 00292 typedef RGBValue<typename NumericTraits<T>::RealPromote> RealPromote; 00293 00294 typedef typename NumericTraits<T>::isIntegral isIntegral; 00295 typedef VigraFalseType isScalar; 00296 00297 // etc. 00298 }; 00299 00300 template <class T1, class T2> 00301 struct PromoteTraits<RGBValue<T1>, RGBValue<T2> > 00302 { 00303 typedef RGBValue<typename PromoteTraits<T1, T2>::Promote> Promote; 00304 }; 00305 \endcode 00306 00307 <b>\#include</b> "<a href="rgbvalue_8hxx-source.html">vigra/rgbvalue.hxx</a>"<br> 00308 Namespace: vigra 00309 00310 */ 00311 00312 #if !defined(NO_PARTIAL_TEMPLATE_SPECIALIZATION) 00313 00314 template <class T> 00315 struct NumericTraits<RGBValue<T> > 00316 { 00317 typedef RGBValue<T> Type; 00318 typedef RGBValue<typename NumericTraits<T>::Promote> Promote; 00319 typedef RGBValue<typename NumericTraits<T>::RealPromote> RealPromote; 00320 typedef RGBValue<typename NumericTraits<T>::ComplexPromote> ComplexPromote; 00321 typedef T ValueType; 00322 00323 typedef typename NumericTraits<T>::isIntegral isIntegral; 00324 typedef VigraFalseType isScalar; 00325 typedef VigraFalseType isOrdered; 00326 typedef VigraFalseType isComplex; 00327 00328 static RGBValue<T> zero() { 00329 return RGBValue<T>(NumericTraits<T>::zero()); 00330 } 00331 static RGBValue<T> one() { 00332 return RGBValue<T>(NumericTraits<T>::one()); 00333 } 00334 static RGBValue<T> nonZero() { 00335 return RGBValue<T>(NumericTraits<T>::nonZero()); 00336 } 00337 00338 static Promote toPromote(RGBValue<T> const & v) { 00339 return Promote(v); 00340 } 00341 static RealPromote toRealPromote(RGBValue<T> const & v) { 00342 return RealPromote(v); 00343 } 00344 static RGBValue<T> fromPromote(Promote const & v) { 00345 return RGBValue<T>(NumericTraits<T>::fromPromote(v.red()), 00346 NumericTraits<T>::fromPromote(v.green()), 00347 NumericTraits<T>::fromPromote(v.blue())); 00348 } 00349 static RGBValue<T> fromRealPromote(RealPromote const & v) { 00350 return RGBValue<T>(NumericTraits<T>::fromRealPromote(v.red()), 00351 NumericTraits<T>::fromRealPromote(v.green()), 00352 NumericTraits<T>::fromRealPromote(v.blue())); 00353 } 00354 }; 00355 00356 template <class T1, class T2> 00357 struct PromoteTraits<RGBValue<T1>, RGBValue<T2> > 00358 { 00359 typedef RGBValue<typename PromoteTraits<T1, T2>::Promote> Promote; 00360 }; 00361 00362 template <class T> 00363 struct PromoteTraits<RGBValue<T>, double > 00364 { 00365 typedef RGBValue<typename NumericTraits<T>::RealPromote> Promote; 00366 }; 00367 00368 template <class T> 00369 struct PromoteTraits<double, RGBValue<T> > 00370 { 00371 typedef RGBValue<typename NumericTraits<T>::RealPromote> Promote; 00372 }; 00373 00374 #else // NO_PARTIAL_TEMPLATE_SPECIALIZATION 00375 00376 #define RGBVALUE_NUMTRAITS(T) \ 00377 template<>\ 00378 struct NumericTraits<RGBValue<T> >\ 00379 {\ 00380 typedef RGBValue<T> Type; \ 00381 typedef RGBValue<NumericTraits<T>::Promote> Promote; \ 00382 typedef RGBValue<NumericTraits<T>::RealPromote> RealPromote; \ 00383 typedef RGBValue<NumericTraits<T>::ComplexPromote> ComplexPromote; \ 00384 typedef T ValueType; \ 00385 \ 00386 typedef NumericTraits<T>::isIntegral isIntegral; \ 00387 typedef VigraFalseType isScalar; \ 00388 typedef VigraFalseType isOrdered; \ 00389 typedef VigraFalseType isComplex; \ 00390 \ 00391 static RGBValue<T> zero() { \ 00392 return RGBValue<T>(NumericTraits<T>::zero()); \ 00393 }\ 00394 static RGBValue<T> one() { \ 00395 return RGBValue<T>(NumericTraits<T>::one()); \ 00396 }\ 00397 static RGBValue<T> nonZero() { \ 00398 return RGBValue<T>(NumericTraits<T>::nonZero()); \ 00399 }\ 00400 \ 00401 static Promote toPromote(RGBValue<T> const & v) { \ 00402 return Promote(v); \ 00403 }\ 00404 static RealPromote toRealPromote(RGBValue<T> const & v) { \ 00405 return RealPromote(v); \ 00406 }\ 00407 static RGBValue<T> fromPromote(Promote const & v) { \ 00408 RGBValue<T> res;\ 00409 RGBValue<T>::iterator d = res.begin();\ 00410 Promote::const_iterator s = v.begin();\ 00411 for(; d != res.end(); ++d, ++s)\ 00412 *d = NumericTraits<T>::fromPromote(*s);\ 00413 return res;\ 00414 }\ 00415 static RGBValue<T> fromRealPromote(RealPromote const & v) {\ 00416 RGBValue<T> res;\ 00417 RGBValue<T>::iterator d = res.begin();\ 00418 RealPromote::const_iterator s = v.begin();\ 00419 for(; d != res.end(); ++d, ++s)\ 00420 *d = NumericTraits<T>::fromRealPromote(*s);\ 00421 return res;\ 00422 }\ 00423 }; 00424 00425 #define RGBVALUE_PROMTRAITS1(type1) \ 00426 template<> \ 00427 struct PromoteTraits<RGBValue<type1>, RGBValue<type1> > \ 00428 { \ 00429 typedef RGBValue<PromoteTraits<type1, type1>::Promote> Promote; \ 00430 static Promote toPromote(RGBValue<type1> const & v) { \ 00431 return static_cast<Promote>(v); } \ 00432 }; 00433 00434 #define RGBVALUE_PROMTRAITS2(type1, type2) \ 00435 template<> \ 00436 struct PromoteTraits<RGBValue<type1>, RGBValue<type2> > \ 00437 { \ 00438 typedef RGBValue<PromoteTraits<type1, type2>::Promote> Promote; \ 00439 static Promote toPromote(RGBValue<type1> const & v) { \ 00440 return static_cast<Promote>(v); } \ 00441 static Promote toPromote(RGBValue<type2> const & v) { \ 00442 return static_cast<Promote>(v); } \ 00443 }; 00444 00445 RGBVALUE_NUMTRAITS(unsigned char) 00446 RGBVALUE_NUMTRAITS(int) 00447 RGBVALUE_NUMTRAITS(float) 00448 RGBVALUE_NUMTRAITS(double) 00449 RGBVALUE_PROMTRAITS1(unsigned char) 00450 RGBVALUE_PROMTRAITS1(int) 00451 RGBVALUE_PROMTRAITS1(float) 00452 RGBVALUE_PROMTRAITS1(double) 00453 RGBVALUE_PROMTRAITS2(float, unsigned char) 00454 RGBVALUE_PROMTRAITS2(unsigned char, float) 00455 RGBVALUE_PROMTRAITS2(int, unsigned char) 00456 RGBVALUE_PROMTRAITS2(unsigned char, int) 00457 RGBVALUE_PROMTRAITS2(int, float) 00458 RGBVALUE_PROMTRAITS2(float, int) 00459 RGBVALUE_PROMTRAITS2(double, unsigned char) 00460 RGBVALUE_PROMTRAITS2(unsigned char, double) 00461 RGBVALUE_PROMTRAITS2(int, double) 00462 RGBVALUE_PROMTRAITS2(double, int) 00463 RGBVALUE_PROMTRAITS2(double, float) 00464 RGBVALUE_PROMTRAITS2(float, double) 00465 00466 #undef RGBVALUE_NUMTRAITS 00467 #undef RGBVALUE_PROMTRAITS1 00468 #undef RGBVALUE_PROMTRAITS2 00469 00470 #endif // NO_PARTIAL_TEMPLATE_SPECIALIZATION 00471 00472 00473 /********************************************************/ 00474 /* */ 00475 /* RGBValue-Arithmetic */ 00476 /* */ 00477 /********************************************************/ 00478 00479 /** \addtogroup RGBValueOperators 00480 */ 00481 //@{ 00482 /// componentwise add-assignment 00483 template <class V1, class V2> 00484 inline 00485 RGBValue<V1> & 00486 operator+=(RGBValue<V1> & l, RGBValue<V2> const & r) 00487 { 00488 l.red() += r.red(); 00489 l.green() += r.green(); 00490 l.blue() += r.blue(); 00491 return l; 00492 } 00493 00494 /// componentwise subtract-assignment 00495 template <class V1, class V2> 00496 inline 00497 RGBValue<V1> & 00498 operator-=(RGBValue<V1> & l, RGBValue<V2> const & r) 00499 { 00500 l.red() -= r.red(); 00501 l.green() -= r.green(); 00502 l.blue() -= r.blue(); 00503 return l; 00504 } 00505 00506 /// componentwise multiply-assignment 00507 template <class V1, class V2> 00508 inline 00509 RGBValue<V1> & 00510 operator*=(RGBValue<V1> & l, RGBValue<V2> const & r) 00511 { 00512 l.red() *= r.red(); 00513 l.green() *= r.green(); 00514 l.blue() *= r.blue(); 00515 return l; 00516 } 00517 00518 /// componentwise scalar multiply-assignment 00519 template <class V> 00520 inline 00521 RGBValue<V> & 00522 operator*=(RGBValue<V> & l, double r) 00523 { 00524 l.red() *= r; 00525 l.green() *= r; 00526 l.blue() *= r; 00527 return l; 00528 } 00529 00530 /// componentwise scalar divide-assignment 00531 template <class V> 00532 inline 00533 RGBValue<V> & 00534 operator/=(RGBValue<V> & l, double r) 00535 { 00536 l.red() /= r; 00537 l.green() /= r; 00538 l.blue() /= r; 00539 return l; 00540 } 00541 00542 using VIGRA_CSTD::abs; 00543 00544 /// component-wise absolute value 00545 template <class T> 00546 inline 00547 RGBValue<T> abs(RGBValue<T> const & v) { 00548 return RGBValue<T>(abs(v.red()), abs(v.green()), abs(v.blue())); 00549 } 00550 00551 00552 00553 /// component-wise addition 00554 template <class V1, class V2> 00555 inline 00556 typename PromoteTraits<RGBValue<V1>, RGBValue<V2> >::Promote 00557 operator+(RGBValue<V1> const & r1, RGBValue<V2> const & r2) 00558 { 00559 typename PromoteTraits<RGBValue<V1>, RGBValue<V2> >::Promote res(r1); 00560 00561 res += r2; 00562 00563 return res; 00564 } 00565 00566 /// component-wise subtraction 00567 template <class V1, class V2> 00568 inline 00569 typename PromoteTraits<RGBValue<V1>, RGBValue<V2> >::Promote 00570 operator-(RGBValue<V1> const & r1, RGBValue<V2> const & r2) 00571 { 00572 typename PromoteTraits<RGBValue<V1>, RGBValue<V2> >::Promote res(r1); 00573 00574 res -= r2; 00575 00576 return res; 00577 } 00578 00579 /// component-wise multiplication 00580 template <class V1, class V2> 00581 inline 00582 typename PromoteTraits<RGBValue<V1>, RGBValue<V2> >::Promote 00583 operator*(RGBValue<V1> const & r1, RGBValue<V2> const & r2) 00584 { 00585 typename PromoteTraits<RGBValue<V1>, RGBValue<V2> >::Promote res(r1); 00586 00587 res *= r2; 00588 00589 return res; 00590 } 00591 00592 /// component-wise left scalar multiplication 00593 template <class V> 00594 inline 00595 typename NumericTraits<RGBValue<V> >::RealPromote 00596 operator*(double v, RGBValue<V> const & r) 00597 { 00598 typename NumericTraits<RGBValue<V> >::RealPromote res(r); 00599 00600 res *= v; 00601 00602 return res; 00603 } 00604 00605 /// component-wise right scalar multiplication 00606 template <class V> 00607 inline 00608 typename NumericTraits<RGBValue<V> >::RealPromote 00609 operator*(RGBValue<V> const & r, double v) 00610 { 00611 typename NumericTraits<RGBValue<V> >::RealPromote res(r); 00612 00613 res *= v; 00614 00615 return res; 00616 } 00617 00618 /// component-wise scalar division 00619 template <class V> 00620 inline 00621 typename NumericTraits<RGBValue<V> >::RealPromote 00622 operator/(RGBValue<V> const & r, double v) 00623 { 00624 typename NumericTraits<RGBValue<V> >::RealPromote res(r); 00625 00626 res /= v; 00627 00628 return res; 00629 } 00630 00631 /// cross product 00632 template <class V1, class V2> 00633 inline 00634 typename PromoteTraits<RGBValue<V1>, RGBValue<V2> >::Promote 00635 cross(RGBValue<V1> const & r1, RGBValue<V2> const & r2) 00636 { 00637 typedef typename PromoteTraits<RGBValue<V1>, RGBValue<V2> >::Promote 00638 Res; 00639 return Res(r1.green()*r2.blue() - r1.blue()*r2.green(), 00640 r1.blue()*r2.red() - r1.red()*r2.blue(), 00641 r1.red()*r2.green() - r1.green()*r2.red()); 00642 } 00643 00644 /// dot product 00645 template <class V1, class V2> 00646 inline 00647 typename PromoteTraits<V1, V2>::Promote 00648 dot(RGBValue<V1> const & r1, RGBValue<V2> const & r2) 00649 { 00650 return r1.red()*r2.red() + r1.green()*r2.green() + r1.blue()*r2.blue(); 00651 } 00652 00653 using VIGRA_CSTD::ceil; 00654 00655 /** Apply ceil() function to each RGB component. 00656 */ 00657 template <class V> 00658 inline 00659 RGBValue<V> 00660 ceil(RGBValue<V> const & r) 00661 { 00662 return RGBValue<V>(ceil(r.red()), 00663 ceil(r.green()), 00664 ceil(r.blue())); 00665 } 00666 00667 using VIGRA_CSTD::floor; 00668 00669 /** Apply floor() function to each RGB component. 00670 */ 00671 template <class V> 00672 inline 00673 RGBValue<V> 00674 floor(RGBValue<V> const & r) 00675 { 00676 return RGBValue<V>(floor(r.red()), 00677 floor(r.green()), 00678 floor(r.blue())); 00679 } 00680 00681 //@} 00682 00683 /********************************************************/ 00684 /* */ 00685 /* RGBValue-Accessors */ 00686 /* */ 00687 /********************************************************/ 00688 00689 /** \addtogroup DataAccessors 00690 */ 00691 //@{ 00692 /** \defgroup RGBValueAccessors Accessors for RGBValue */ 00693 //@{ 00694 /** Encapsulate access to rgb values. 00695 00696 <b>\#include</b> "<a href="rgbvalue_8hxx-source.html">vigra/rgbvalue.hxx</a>"<br> 00697 Namespace: vigra 00698 */ 00699 template <class RGBVALUE> 00700 class RGBAccessor 00701 : public VectorAccessor<RGBVALUE> 00702 { 00703 public: 00704 00705 typedef typename RGBVALUE::value_type component_type; 00706 00707 /** Get value of the red component 00708 */ 00709 template <class RGBIterator> 00710 component_type const & red(RGBIterator const & rgb) const 00711 { 00712 return (*rgb).red(); 00713 } 00714 00715 template <class V, class RGBIterator> 00716 void setRGB(V r, V g, V b, RGBIterator const & rgb) const 00717 { 00718 (*rgb).setRGB( r, g, b ); 00719 } 00720 00721 00722 /** Set value of the red component. The type <TT>V</TT> of the passed 00723 in <TT>value</TT> is automatically converted to <TT>component_type</TT>. 00724 */ 00725 template <class V, class RGBIterator> 00726 void setRed(V value, RGBIterator const & rgb) const 00727 { 00728 (*rgb).setRed(value); 00729 } 00730 00731 /** Get value of the red component at an offset 00732 */ 00733 template <class RGBIterator, class DIFFERENCE> 00734 component_type const & red(RGBIterator const & rgb, DIFFERENCE diff) const 00735 { 00736 return rgb[diff].red(); 00737 } 00738 00739 /** Set value of the red component at an offset. The type <TT>V</TT> of the passed 00740 in <TT>value</TT> is automatically converted to <TT>component_type</TT>. 00741 */ 00742 template <class V, class RGBIterator, class DIFFERENCE> 00743 void setRed(V value, RGBIterator const & rgb, DIFFERENCE diff) const 00744 { 00745 rgb[diff].setRed(value); 00746 } 00747 00748 /** Get value of the green component 00749 */ 00750 template <class RGBIterator> 00751 component_type const & green(RGBIterator const & rgb) const 00752 { 00753 return (*rgb).green(); 00754 } 00755 00756 /** Set value of the green component. The type <TT>V</TT> of the passed 00757 in <TT>value</TT> is automatically converted to <TT>component_type</TT>. 00758 */ 00759 template <class V, class RGBIterator> 00760 void setGreen(V value, RGBIterator const & rgb) const 00761 { 00762 (*rgb).setGreen(value); 00763 } 00764 00765 /** Get value of the green component at an offset 00766 */ 00767 template <class RGBIterator, class DIFFERENCE> 00768 component_type const & green(RGBIterator const & rgb, DIFFERENCE d) const 00769 { 00770 return rgb[d].green(); 00771 } 00772 00773 /** Set value of the green component at an offset. The type <TT>V</TT> of the passed 00774 in <TT>value</TT> is automatically converted to <TT>component_type</TT>. 00775 */ 00776 template <class V, class RGBIterator, class DIFFERENCE> 00777 void setGreen(V value, RGBIterator const & rgb, DIFFERENCE d) const 00778 { 00779 rgb[d].setGreen(value); 00780 } 00781 00782 /** Get value of the blue component 00783 */ 00784 template <class RGBIterator> 00785 component_type const & blue(RGBIterator const & rgb) const 00786 { 00787 return (*rgb).blue(); 00788 } 00789 00790 /** Set value of the blue component. The type <TT>V</TT> of the passed 00791 in <TT>value</TT> is automatically converted to <TT>component_type</TT>. 00792 */ 00793 template <class V, class RGBIterator> 00794 void setBlue(V value, RGBIterator const & rgb) const 00795 { 00796 (*rgb).setBlue(value); 00797 } 00798 00799 /** Get value of the blue component at an offset 00800 */ 00801 template <class RGBIterator, class DIFFERENCE> 00802 component_type const & blue(RGBIterator const & rgb, DIFFERENCE d) const 00803 { 00804 return rgb[d].blue(); 00805 } 00806 00807 /** Set value of the blue component at an offset. The type <TT>V</TT> of the passed 00808 in <TT>value</TT> is automatically converted to <TT>component_type</TT>. 00809 */ 00810 template <class V, class RGBIterator, class DIFFERENCE> 00811 void setBlue(V value, RGBIterator const & rgb, DIFFERENCE d) const 00812 { 00813 rgb[d].setBlue(value); 00814 } 00815 00816 }; 00817 00818 00819 /********************************************************/ 00820 /* */ 00821 /* RedAccessor */ 00822 /* */ 00823 /********************************************************/ 00824 00825 /** Encapsulate access to red band of an rgb value. 00826 00827 <b>\#include</b> "<a href="rgbvalue_8hxx-source.html">vigra/rgbvalue.hxx</a>"<br> 00828 Namespace: vigra 00829 */ 00830 template <class RGBVALUE> 00831 class RedAccessor 00832 { 00833 public: 00834 typedef typename RGBVALUE::value_type value_type; 00835 00836 /** Get value of the red component 00837 */ 00838 template <class ITERATOR> 00839 value_type const & operator()(ITERATOR const & i) const { 00840 return (*i).red(); 00841 } 00842 00843 /** Get value of the red component at an offset 00844 */ 00845 template <class ITERATOR, class DIFFERENCE> 00846 value_type const & operator()(ITERATOR const & i, DIFFERENCE d) const 00847 { 00848 return i[d].red(); 00849 } 00850 00851 /** Set value of the red component. The type <TT>V</TT> of the passed 00852 in <TT>value</TT> is automatically converted to <TT>value_type</TT>. 00853 */ 00854 template <class V, class ITERATOR> 00855 void set(V value, ITERATOR const & i) const { 00856 (*i).setRed(value); 00857 } 00858 00859 00860 /** Set value of the red component at an offset. The type <TT>V</TT> of the passed 00861 in <TT>value</TT> is automatically converted to <TT>value_type</TT>. 00862 */ 00863 template <class V, class ITERATOR, class DIFFERENCE> 00864 void set(V value, ITERATOR const & i, DIFFERENCE d) const 00865 { 00866 i[d].setRed(value); 00867 } 00868 }; 00869 00870 /********************************************************/ 00871 /* */ 00872 /* GreenAccessor */ 00873 /* */ 00874 /********************************************************/ 00875 00876 /** Encapsulate access to green band of an rgb value. 00877 00878 <b>\#include</b> "<a href="rgbvalue_8hxx-source.html">vigra/rgbvalue.hxx</a>"<br> 00879 Namespace: vigra 00880 */ 00881 template <class RGBVALUE> 00882 class GreenAccessor 00883 { 00884 public: 00885 typedef typename RGBVALUE::value_type value_type; 00886 00887 /** Get value of the green component 00888 */ 00889 template <class ITERATOR> 00890 value_type const & operator()(ITERATOR const & i) const { 00891 return (*i).green(); 00892 } 00893 00894 /** Get value of the green component at an offset 00895 */ 00896 template <class ITERATOR, class DIFFERENCE> 00897 value_type const & operator()(ITERATOR const & i, DIFFERENCE d) const 00898 { 00899 return i[d].green(); 00900 } 00901 00902 /** Set value of the green component. The type <TT>V</TT> of the passed 00903 in <TT>value</TT> is automatically converted to <TT>value_type</TT>. 00904 */ 00905 template <class V, class ITERATOR> 00906 void set(V value, ITERATOR const & i) const { 00907 (*i).setGreen(value); 00908 } 00909 00910 00911 /** Set value of the green component at an offset. The type <TT>V</TT> of the passed 00912 in <TT>value</TT> is automatically converted to <TT>value_type</TT>. 00913 */ 00914 template <class V, class ITERATOR, class DIFFERENCE> 00915 void set(V value, ITERATOR const & i, DIFFERENCE d) const 00916 { 00917 i[d].setGreen(value); 00918 } 00919 }; 00920 00921 /********************************************************/ 00922 /* */ 00923 /* BlueAccessor */ 00924 /* */ 00925 /********************************************************/ 00926 00927 /** Encapsulate access to blue band of an rgb value. 00928 00929 <b>\#include</b> "<a href="rgbvalue_8hxx-source.html">vigra/rgbvalue.hxx</a>"<br> 00930 Namespace: vigra 00931 */ 00932 template <class RGBVALUE> 00933 class BlueAccessor 00934 { 00935 public: 00936 typedef typename RGBVALUE::value_type value_type; 00937 00938 /** Get value of the blue component 00939 */ 00940 template <class ITERATOR> 00941 value_type const & operator()(ITERATOR const & i) const { 00942 return (*i).blue(); 00943 } 00944 00945 /** Get value of the blue component at an offset 00946 */ 00947 template <class ITERATOR, class DIFFERENCE> 00948 value_type const & operator()(ITERATOR const & i, DIFFERENCE d) const 00949 { 00950 return i[d].blue(); 00951 } 00952 00953 /** Set value of the blue component. The type <TT>V</TT> of the passed 00954 in <TT>value</TT> is automatically converted to <TT>value_type</TT>. 00955 */ 00956 template <class V, class ITERATOR> 00957 void set(V value, ITERATOR const & i) const { 00958 (*i).setBlue(value); 00959 } 00960 00961 00962 /** Set value of the blue component at an offset. The type <TT>V</TT> of the passed 00963 in <TT>value</TT> is automatically converted to <TT>value_type</TT>. 00964 */ 00965 template <class V, class ITERATOR, class DIFFERENCE> 00966 void set(V value, ITERATOR const & i, DIFFERENCE d) const 00967 { 00968 i[d].setBlue(value); 00969 } 00970 }; 00971 00972 /********************************************************/ 00973 /* */ 00974 /* RGBToGrayAccessor */ 00975 /* */ 00976 /********************************************************/ 00977 00978 /** Encapsulate access to luminance of an rgb value. 00979 00980 <b>\#include</b> "<a href="rgbvalue_8hxx-source.html">vigra/rgbvalue.hxx</a>"<br> 00981 Namespace: vigra 00982 */ 00983 template <class RGBVALUE> 00984 class RGBToGrayAccessor 00985 { 00986 public: 00987 typedef typename RGBVALUE::value_type value_type; 00988 00989 /** Get value of the luminance 00990 */ 00991 template <class ITERATOR> 00992 value_type operator()(ITERATOR const & i) const { 00993 return (*i).luminance(); } 00994 00995 /** Get value of the luminance at an offset 00996 */ 00997 template <class ITERATOR, class DIFFERENCE> 00998 value_type operator()(ITERATOR const & i, DIFFERENCE d) const 00999 { 01000 return i[d].luminance(); 01001 } 01002 }; 01003 01004 01005 /********************************************************/ 01006 /* */ 01007 /* GrayToRGBAccessor */ 01008 /* */ 01009 /********************************************************/ 01010 01011 /** Create an RGB view for a grayscale image by making all three channels 01012 equal. 01013 01014 <b>\#include</b> "<a href="rgbvalue_8hxx-source.html">vigra/rgbvalue.hxx</a>"<br> 01015 Namespace: vigra 01016 */ 01017 template <class VALUETYPE> 01018 class GrayToRGBAccessor 01019 { 01020 public: 01021 typedef typename vigra::RGBValue<VALUETYPE> value_type; 01022 01023 /** Get RGB value for the given pixel. 01024 */ 01025 template <class ITERATOR> 01026 value_type operator()(ITERATOR const & i) const { 01027 return value_type(*i,*i,*i); } 01028 01029 /** Get RGB value at an offset 01030 */ 01031 template <class ITERATOR, class DIFFERENCE> 01032 value_type operator()(ITERATOR const & i, DIFFERENCE d) const 01033 { 01034 return value_type(i[d],i[d],i[d]); 01035 } 01036 }; 01037 01038 01039 //@} 01040 //@} 01041 01042 01043 } // namespace vigra 01044 01045 #endif // VIGRA_RGBVALUE_HXX
© Ullrich Köthe (koethe@informatik.uni-hamburg.de) |
html generated using doxygen and Python
|